Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12696 amit.gupta 705 
 
3376 rajveer 706 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 707 
  """
708 
  service
709 
  """
710 
  def __init__(self, iprot, oprot=None):
3376 rajveer 711 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 712 
 
559 chandransh 713 
  def createAnonymousUser(self, jsessionId):
94 ashish 714 
    """
715 
    Parameters:
559 chandransh 716 
     - jsessionId
94 ashish 717 
    """
559 chandransh 718 
    self.send_createAnonymousUser(jsessionId)
719 
    return self.recv_createAnonymousUser()
94 ashish 720 
 
559 chandransh 721 
  def send_createAnonymousUser(self, jsessionId):
722 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
723 
    args = createAnonymousUser_args()
724 
    args.jsessionId = jsessionId
94 ashish 725 
    args.write(self._oprot)
726 
    self._oprot.writeMessageEnd()
727 
    self._oprot.trans.flush()
728 
 
559 chandransh 729 
  def recv_createAnonymousUser(self, ):
94 ashish 730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
731 
    if mtype == TMessageType.EXCEPTION:
732 
      x = TApplicationException()
733 
      x.read(self._iprot)
734 
      self._iprot.readMessageEnd()
735 
      raise x
559 chandransh 736 
    result = createAnonymousUser_result()
94 ashish 737 
    result.read(self._iprot)
738 
    self._iprot.readMessageEnd()
3431 rajveer 739 
    if result.success is not None:
94 ashish 740 
      return result.success
3431 rajveer 741 
    if result.ucex is not None:
559 chandransh 742 
      raise result.ucex
743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 744 
 
559 chandransh 745 
  def getUserById(self, userId):
94 ashish 746 
    """
747 
    Parameters:
748 
     - userId
749 
    """
559 chandransh 750 
    self.send_getUserById(userId)
751 
    return self.recv_getUserById()
94 ashish 752 
 
559 chandransh 753 
  def send_getUserById(self, userId):
754 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
755 
    args = getUserById_args()
94 ashish 756 
    args.userId = userId
757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
559 chandransh 761 
  def recv_getUserById(self, ):
94 ashish 762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
559 chandransh 768 
    result = getUserById_result()
94 ashish 769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
3431 rajveer 771 
    if result.success is not None:
94 ashish 772 
      return result.success
3431 rajveer 773 
    if result.ucex is not None:
559 chandransh 774 
      raise result.ucex
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 776 
 
5326 rajveer 777 
  def getUserByCartId(self, cartId):
778 
    """
779 
    Parameters:
780 
     - cartId
781 
    """
782 
    self.send_getUserByCartId(cartId)
783 
    return self.recv_getUserByCartId()
784 
 
785 
  def send_getUserByCartId(self, cartId):
786 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
787 
    args = getUserByCartId_args()
788 
    args.cartId = cartId
789 
    args.write(self._oprot)
790 
    self._oprot.writeMessageEnd()
791 
    self._oprot.trans.flush()
792 
 
793 
  def recv_getUserByCartId(self, ):
794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
795 
    if mtype == TMessageType.EXCEPTION:
796 
      x = TApplicationException()
797 
      x.read(self._iprot)
798 
      self._iprot.readMessageEnd()
799 
      raise x
800 
    result = getUserByCartId_result()
801 
    result.read(self._iprot)
802 
    self._iprot.readMessageEnd()
803 
    if result.success is not None:
804 
      return result.success
805 
    if result.ucex is not None:
806 
      raise result.ucex
807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
808 
 
1491 vikas 809 
  def getUserByEmail(self, email):
810 
    """
811 
    Parameters:
812 
     - email
813 
    """
814 
    self.send_getUserByEmail(email)
815 
    return self.recv_getUserByEmail()
816 
 
817 
  def send_getUserByEmail(self, email):
818 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
819 
    args = getUserByEmail_args()
820 
    args.email = email
821 
    args.write(self._oprot)
822 
    self._oprot.writeMessageEnd()
823 
    self._oprot.trans.flush()
824 
 
825 
  def recv_getUserByEmail(self, ):
826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
827 
    if mtype == TMessageType.EXCEPTION:
828 
      x = TApplicationException()
829 
      x.read(self._iprot)
830 
      self._iprot.readMessageEnd()
831 
      raise x
832 
    result = getUserByEmail_result()
833 
    result.read(self._iprot)
834 
    self._iprot.readMessageEnd()
3431 rajveer 835 
    if result.success is not None:
1491 vikas 836 
      return result.success
3431 rajveer 837 
    if result.ucex is not None:
1491 vikas 838 
      raise result.ucex
839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
840 
 
3032 mandeep.dh 841 
  def getUserByMobileNumber(self, mobileNumber):
842 
    """
843 
    Parameters:
844 
     - mobileNumber
845 
    """
846 
    self.send_getUserByMobileNumber(mobileNumber)
847 
    return self.recv_getUserByMobileNumber()
848 
 
849 
  def send_getUserByMobileNumber(self, mobileNumber):
850 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
851 
    args = getUserByMobileNumber_args()
852 
    args.mobileNumber = mobileNumber
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
857 
  def recv_getUserByMobileNumber(self, ):
858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
864 
    result = getUserByMobileNumber_result()
865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
3431 rajveer 867 
    if result.success is not None:
3032 mandeep.dh 868 
      return result.success
3431 rajveer 869 
    if result.ucex is not None:
3032 mandeep.dh 870 
      raise result.ucex
871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
872 
 
559 chandransh 873 
  def createUser(self, user):
94 ashish 874 
    """
875 
    Parameters:
559 chandransh 876 
     - user
94 ashish 877 
    """
559 chandransh 878 
    self.send_createUser(user)
879 
    return self.recv_createUser()
94 ashish 880 
 
559 chandransh 881 
  def send_createUser(self, user):
882 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
883 
    args = createUser_args()
884 
    args.user = user
94 ashish 885 
    args.write(self._oprot)
886 
    self._oprot.writeMessageEnd()
887 
    self._oprot.trans.flush()
888 
 
559 chandransh 889 
  def recv_createUser(self, ):
94 ashish 890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
891 
    if mtype == TMessageType.EXCEPTION:
892 
      x = TApplicationException()
893 
      x.read(self._iprot)
894 
      self._iprot.readMessageEnd()
895 
      raise x
559 chandransh 896 
    result = createUser_result()
94 ashish 897 
    result.read(self._iprot)
898 
    self._iprot.readMessageEnd()
3431 rajveer 899 
    if result.success is not None:
94 ashish 900 
      return result.success
3431 rajveer 901 
    if result.ucex is not None:
559 chandransh 902 
      raise result.ucex
903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 904 
 
559 chandransh 905 
  def updateUser(self, user):
94 ashish 906 
    """
907 
    Parameters:
559 chandransh 908 
     - user
94 ashish 909 
    """
559 chandransh 910 
    self.send_updateUser(user)
911 
    return self.recv_updateUser()
94 ashish 912 
 
559 chandransh 913 
  def send_updateUser(self, user):
914 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
915 
    args = updateUser_args()
916 
    args.user = user
94 ashish 917 
    args.write(self._oprot)
918 
    self._oprot.writeMessageEnd()
919 
    self._oprot.trans.flush()
920 
 
559 chandransh 921 
  def recv_updateUser(self, ):
94 ashish 922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
923 
    if mtype == TMessageType.EXCEPTION:
924 
      x = TApplicationException()
925 
      x.read(self._iprot)
926 
      self._iprot.readMessageEnd()
927 
      raise x
559 chandransh 928 
    result = updateUser_result()
94 ashish 929 
    result.read(self._iprot)
930 
    self._iprot.readMessageEnd()
3431 rajveer 931 
    if result.success is not None:
94 ashish 932 
      return result.success
3431 rajveer 933 
    if result.ucex is not None:
559 chandransh 934 
      raise result.ucex
935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 936 
 
559 chandransh 937 
  def authenticateUser(self, email, password):
94 ashish 938 
    """
939 
    Parameters:
940 
     - email
941 
     - password
942 
    """
559 chandransh 943 
    self.send_authenticateUser(email, password)
122 ashish 944 
    return self.recv_authenticateUser()
945 
 
559 chandransh 946 
  def send_authenticateUser(self, email, password):
122 ashish 947 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
948 
    args = authenticateUser_args()
559 chandransh 949 
    args.email = email
122 ashish 950 
    args.password = password
951 
    args.write(self._oprot)
952 
    self._oprot.writeMessageEnd()
953 
    self._oprot.trans.flush()
954 
 
955 
  def recv_authenticateUser(self, ):
956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
957 
    if mtype == TMessageType.EXCEPTION:
958 
      x = TApplicationException()
959 
      x.read(self._iprot)
960 
      self._iprot.readMessageEnd()
961 
      raise x
962 
    result = authenticateUser_result()
963 
    result.read(self._iprot)
964 
    self._iprot.readMessageEnd()
3431 rajveer 965 
    if result.success is not None:
122 ashish 966 
      return result.success
3431 rajveer 967 
    if result.auex is not None:
559 chandransh 968 
      raise result.auex
122 ashish 969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
970 
 
94 ashish 971 
  def userExists(self, email):
972 
    """
973 
    Parameters:
974 
     - email
975 
    """
976 
    self.send_userExists(email)
977 
    return self.recv_userExists()
978 
 
979 
  def send_userExists(self, email):
980 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
981 
    args = userExists_args()
982 
    args.email = email
983 
    args.write(self._oprot)
984 
    self._oprot.writeMessageEnd()
985 
    self._oprot.trans.flush()
986 
 
987 
  def recv_userExists(self, ):
988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
989 
    if mtype == TMessageType.EXCEPTION:
990 
      x = TApplicationException()
991 
      x.read(self._iprot)
992 
      self._iprot.readMessageEnd()
993 
      raise x
994 
    result = userExists_result()
995 
    result.read(self._iprot)
996 
    self._iprot.readMessageEnd()
3431 rajveer 997 
    if result.success is not None:
94 ashish 998 
      return result.success
3431 rajveer 999 
    if result.ucx is not None:
94 ashish 1000 
      raise result.ucx
1001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1002 
 
567 rajveer 1003 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1004 
    """
1005 
    Parameters:
1006 
     - userId
1007 
     - address
513 rajveer 1008 
     - setDefault
94 ashish 1009 
    """
567 rajveer 1010 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1011 
    return self.recv_addAddressForUser()
1012 
 
567 rajveer 1013 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1014 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1015 
    args = addAddressForUser_args()
559 chandransh 1016 
    args.userId = userId
94 ashish 1017 
    args.address = address
513 rajveer 1018 
    args.setDefault = setDefault
94 ashish 1019 
    args.write(self._oprot)
1020 
    self._oprot.writeMessageEnd()
1021 
    self._oprot.trans.flush()
1022 
 
1023 
  def recv_addAddressForUser(self, ):
1024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1025 
    if mtype == TMessageType.EXCEPTION:
1026 
      x = TApplicationException()
1027 
      x.read(self._iprot)
1028 
      self._iprot.readMessageEnd()
1029 
      raise x
1030 
    result = addAddressForUser_result()
1031 
    result.read(self._iprot)
1032 
    self._iprot.readMessageEnd()
3431 rajveer 1033 
    if result.success is not None:
94 ashish 1034 
      return result.success
3431 rajveer 1035 
    if result.ucx is not None:
94 ashish 1036 
      raise result.ucx
1037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1038 
 
1039 
  def removeAddressForUser(self, userid, addressId):
1040 
    """
1041 
    Parameters:
1042 
     - userid
1043 
     - addressId
1044 
    """
1045 
    self.send_removeAddressForUser(userid, addressId)
1046 
    return self.recv_removeAddressForUser()
1047 
 
1048 
  def send_removeAddressForUser(self, userid, addressId):
1049 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1050 
    args = removeAddressForUser_args()
1051 
    args.userid = userid
1052 
    args.addressId = addressId
1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
1057 
  def recv_removeAddressForUser(self, ):
1058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1059 
    if mtype == TMessageType.EXCEPTION:
1060 
      x = TApplicationException()
1061 
      x.read(self._iprot)
1062 
      self._iprot.readMessageEnd()
1063 
      raise x
1064 
    result = removeAddressForUser_result()
1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
3431 rajveer 1067 
    if result.success is not None:
94 ashish 1068 
      return result.success
3431 rajveer 1069 
    if result.ucx is not None:
94 ashish 1070 
      raise result.ucx
1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1072 
 
1073 
  def setUserAsLoggedIn(self, userId, timestamp):
1074 
    """
1075 
    Parameters:
1076 
     - userId
1077 
     - timestamp
1078 
    """
1079 
    self.send_setUserAsLoggedIn(userId, timestamp)
1080 
    return self.recv_setUserAsLoggedIn()
1081 
 
1082 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1083 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1084 
    args = setUserAsLoggedIn_args()
1085 
    args.userId = userId
1086 
    args.timestamp = timestamp
1087 
    args.write(self._oprot)
1088 
    self._oprot.writeMessageEnd()
1089 
    self._oprot.trans.flush()
1090 
 
1091 
  def recv_setUserAsLoggedIn(self, ):
1092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1093 
    if mtype == TMessageType.EXCEPTION:
1094 
      x = TApplicationException()
1095 
      x.read(self._iprot)
1096 
      self._iprot.readMessageEnd()
1097 
      raise x
1098 
    result = setUserAsLoggedIn_result()
1099 
    result.read(self._iprot)
1100 
    self._iprot.readMessageEnd()
3431 rajveer 1101 
    if result.success is not None:
94 ashish 1102 
      return result.success
3431 rajveer 1103 
    if result.ucx is not None:
94 ashish 1104 
      raise result.ucx
1105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1106 
 
1107 
  def setUserAsLoggedOut(self, userid, timestamp):
1108 
    """
1109 
    Parameters:
1110 
     - userid
1111 
     - timestamp
1112 
    """
1113 
    self.send_setUserAsLoggedOut(userid, timestamp)
1114 
    return self.recv_setUserAsLoggedOut()
1115 
 
1116 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1117 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1118 
    args = setUserAsLoggedOut_args()
1119 
    args.userid = userid
1120 
    args.timestamp = timestamp
1121 
    args.write(self._oprot)
1122 
    self._oprot.writeMessageEnd()
1123 
    self._oprot.trans.flush()
1124 
 
1125 
  def recv_setUserAsLoggedOut(self, ):
1126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1127 
    if mtype == TMessageType.EXCEPTION:
1128 
      x = TApplicationException()
1129 
      x.read(self._iprot)
1130 
      self._iprot.readMessageEnd()
1131 
      raise x
1132 
    result = setUserAsLoggedOut_result()
1133 
    result.read(self._iprot)
1134 
    self._iprot.readMessageEnd()
3431 rajveer 1135 
    if result.success is not None:
94 ashish 1136 
      return result.success
3431 rajveer 1137 
    if result.ucx is not None:
94 ashish 1138 
      raise result.ucx
1139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1140 
 
504 rajveer 1141 
  def setDefaultAddress(self, userid, addressId):
1142 
    """
1143 
    Parameters:
1144 
     - userid
1145 
     - addressId
1146 
    """
1147 
    self.send_setDefaultAddress(userid, addressId)
1148 
    return self.recv_setDefaultAddress()
1149 
 
1150 
  def send_setDefaultAddress(self, userid, addressId):
1151 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1152 
    args = setDefaultAddress_args()
1153 
    args.userid = userid
1154 
    args.addressId = addressId
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_setDefaultAddress(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = setDefaultAddress_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
3431 rajveer 1169 
    if result.success is not None:
504 rajveer 1170 
      return result.success
3431 rajveer 1171 
    if result.ucx is not None:
504 rajveer 1172 
      raise result.ucx
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1174 
 
594 rajveer 1175 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1176 
    """
1177 
    Parameters:
1178 
     - userid
594 rajveer 1179 
     - oldPassword
1180 
     - newPassword
94 ashish 1181 
    """
594 rajveer 1182 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1183 
    return self.recv_updatePassword()
1184 
 
594 rajveer 1185 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1186 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1187 
    args = updatePassword_args()
1188 
    args.userid = userid
594 rajveer 1189 
    args.oldPassword = oldPassword
1190 
    args.newPassword = newPassword
94 ashish 1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_updatePassword(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = updatePassword_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
3431 rajveer 1205 
    if result.success is not None:
94 ashish 1206 
      return result.success
3431 rajveer 1207 
    if result.ucx is not None:
94 ashish 1208 
      raise result.ucx
1209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1210 
 
884 rajveer 1211 
  def forgotPassword(self, email, newPassword):
581 rajveer 1212 
    """
1213 
    Parameters:
1214 
     - email
884 rajveer 1215 
     - newPassword
581 rajveer 1216 
    """
884 rajveer 1217 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1218 
    return self.recv_forgotPassword()
1219 
 
884 rajveer 1220 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1221 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1222 
    args = forgotPassword_args()
1223 
    args.email = email
884 rajveer 1224 
    args.newPassword = newPassword
581 rajveer 1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_forgotPassword(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = forgotPassword_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
3431 rajveer 1239 
    if result.success is not None:
581 rajveer 1240 
      return result.success
3431 rajveer 1241 
    if result.ucx is not None:
581 rajveer 1242 
      raise result.ucx
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1244 
 
594 rajveer 1245 
  def getAllAddressesForUser(self, userId):
1246 
    """
1247 
    Parameters:
1248 
     - userId
1249 
    """
1250 
    self.send_getAllAddressesForUser(userId)
1251 
    return self.recv_getAllAddressesForUser()
1252 
 
1253 
  def send_getAllAddressesForUser(self, userId):
1254 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1255 
    args = getAllAddressesForUser_args()
1256 
    args.userId = userId
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getAllAddressesForUser(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getAllAddressesForUser_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
3431 rajveer 1271 
    if result.success is not None:
594 rajveer 1272 
      return result.success
3431 rajveer 1273 
    if result.ucx is not None:
594 rajveer 1274 
      raise result.ucx
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1276 
 
1894 vikas 1277 
  def getAddressById(self, addressId):
1278 
    """
1279 
    Parameters:
1280 
     - addressId
1281 
    """
1282 
    self.send_getAddressById(addressId)
1283 
    return self.recv_getAddressById()
1284 
 
1285 
  def send_getAddressById(self, addressId):
1286 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1287 
    args = getAddressById_args()
1288 
    args.addressId = addressId
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getAddressById(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getAddressById_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
3431 rajveer 1303 
    if result.success is not None:
1894 vikas 1304 
      return result.success
3431 rajveer 1305 
    if result.ucx is not None:
1894 vikas 1306 
      raise result.ucx
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1308 
 
594 rajveer 1309 
  def getDefaultAddressId(self, userId):
1310 
    """
1311 
    Parameters:
1312 
     - userId
1313 
    """
1314 
    self.send_getDefaultAddressId(userId)
1315 
    return self.recv_getDefaultAddressId()
1316 
 
1317 
  def send_getDefaultAddressId(self, userId):
1318 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1319 
    args = getDefaultAddressId_args()
1320 
    args.userId = userId
1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
1325 
  def recv_getDefaultAddressId(self, ):
1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
1332 
    result = getDefaultAddressId_result()
1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
3431 rajveer 1335 
    if result.success is not None:
594 rajveer 1336 
      return result.success
3431 rajveer 1337 
    if result.ucx is not None:
594 rajveer 1338 
      raise result.ucx
1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1340 
 
785 rajveer 1341 
  def getDefaultPincode(self, userId):
1342 
    """
1343 
    Parameters:
1344 
     - userId
1345 
    """
1346 
    self.send_getDefaultPincode(userId)
1347 
    return self.recv_getDefaultPincode()
1348 
 
1349 
  def send_getDefaultPincode(self, userId):
1350 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1351 
    args = getDefaultPincode_args()
1352 
    args.userId = userId
1353 
    args.write(self._oprot)
1354 
    self._oprot.writeMessageEnd()
1355 
    self._oprot.trans.flush()
1356 
 
1357 
  def recv_getDefaultPincode(self, ):
1358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1359 
    if mtype == TMessageType.EXCEPTION:
1360 
      x = TApplicationException()
1361 
      x.read(self._iprot)
1362 
      self._iprot.readMessageEnd()
1363 
      raise x
1364 
    result = getDefaultPincode_result()
1365 
    result.read(self._iprot)
1366 
    self._iprot.readMessageEnd()
3431 rajveer 1367 
    if result.success is not None:
785 rajveer 1368 
      return result.success
3431 rajveer 1369 
    if result.ucx is not None:
785 rajveer 1370 
      raise result.ucx
1371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1372 
 
1274 varun.gupt 1373 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1374 
    """
1375 
    Parameters:
1376 
     - userId
1377 
     - replyTo
1378 
     - communicationType
1379 
     - orderId
1380 
     - airwaybillNo
1381 
     - productName
1382 
     - subject
1383 
     - message
1384 
    """
1385 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1386 
    return self.recv_saveUserCommunication()
1387 
 
1388 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1389 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1390 
    args = saveUserCommunication_args()
1391 
    args.userId = userId
1392 
    args.replyTo = replyTo
1393 
    args.communicationType = communicationType
1394 
    args.orderId = orderId
1395 
    args.airwaybillNo = airwaybillNo
1396 
    args.productName = productName
1397 
    args.subject = subject
1398 
    args.message = message
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_saveUserCommunication(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = saveUserCommunication_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
1274 varun.gupt 1414 
      return result.success
3431 rajveer 1415 
    if result.ucx is not None:
1274 varun.gupt 1416 
      raise result.ucx
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1418 
 
1590 varun.gupt 1419 
  def getUserCommunicationById(self, id):
1420 
    """
1421 
    Parameters:
1422 
     - id
1423 
    """
1424 
    self.send_getUserCommunicationById(id)
1425 
    return self.recv_getUserCommunicationById()
1426 
 
1427 
  def send_getUserCommunicationById(self, id):
1428 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1429 
    args = getUserCommunicationById_args()
1430 
    args.id = id
1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
1435 
  def recv_getUserCommunicationById(self, ):
1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
1442 
    result = getUserCommunicationById_result()
1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
3431 rajveer 1445 
    if result.success is not None:
1590 varun.gupt 1446 
      return result.success
3431 rajveer 1447 
    if result.ucx is not None:
1590 varun.gupt 1448 
      raise result.ucx
1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1450 
 
1451 
  def getUserCommunicationByUser(self, userId):
1452 
    """
1453 
    Parameters:
1454 
     - userId
1455 
    """
1456 
    self.send_getUserCommunicationByUser(userId)
1457 
    return self.recv_getUserCommunicationByUser()
1458 
 
1459 
  def send_getUserCommunicationByUser(self, userId):
1460 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1461 
    args = getUserCommunicationByUser_args()
1462 
    args.userId = userId
1463 
    args.write(self._oprot)
1464 
    self._oprot.writeMessageEnd()
1465 
    self._oprot.trans.flush()
1466 
 
1467 
  def recv_getUserCommunicationByUser(self, ):
1468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1469 
    if mtype == TMessageType.EXCEPTION:
1470 
      x = TApplicationException()
1471 
      x.read(self._iprot)
1472 
      self._iprot.readMessageEnd()
1473 
      raise x
1474 
    result = getUserCommunicationByUser_result()
1475 
    result.read(self._iprot)
1476 
    self._iprot.readMessageEnd()
3431 rajveer 1477 
    if result.success is not None:
1590 varun.gupt 1478 
      return result.success
3431 rajveer 1479 
    if result.ucx is not None:
1590 varun.gupt 1480 
      raise result.ucx
1481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1482 
 
1483 
  def getAllUserCommunications(self, ):
1484 
    self.send_getAllUserCommunications()
1485 
    return self.recv_getAllUserCommunications()
1486 
 
1487 
  def send_getAllUserCommunications(self, ):
1488 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1489 
    args = getAllUserCommunications_args()
1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
1494 
  def recv_getAllUserCommunications(self, ):
1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
1501 
    result = getAllUserCommunications_result()
1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
3431 rajveer 1504 
    if result.success is not None:
1590 varun.gupt 1505 
      return result.success
3431 rajveer 1506 
    if result.ucx is not None:
1590 varun.gupt 1507 
      raise result.ucx
1508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1509 
 
5407 amar.kumar 1510 
  def removeUserCommunication(self, id):
1511 
    """
1512 
    Parameters:
1513 
     - id
1514 
    """
1515 
    self.send_removeUserCommunication(id)
1516 
    self.recv_removeUserCommunication()
1517 
 
1518 
  def send_removeUserCommunication(self, id):
1519 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1520 
    args = removeUserCommunication_args()
1521 
    args.id = id
1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
1526 
  def recv_removeUserCommunication(self, ):
1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
1533 
    result = removeUserCommunication_result()
1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
1536 
    if result.ucx is not None:
1537 
      raise result.ucx
1538 
    return
1539 
 
1859 vikas 1540 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1541 
    """
1542 
    Parameters:
1543 
     - name
1859 vikas 1544 
     - addedOn
1845 vikas 1545 
    """
1859 vikas 1546 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1547 
    return self.recv_createMasterAffiliate()
1548 
 
1859 vikas 1549 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1550 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1551 
    args = createMasterAffiliate_args()
1552 
    args.name = name
1859 vikas 1553 
    args.addedOn = addedOn
1845 vikas 1554 
    args.write(self._oprot)
1555 
    self._oprot.writeMessageEnd()
1556 
    self._oprot.trans.flush()
1557 
 
1558 
  def recv_createMasterAffiliate(self, ):
1559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1560 
    if mtype == TMessageType.EXCEPTION:
1561 
      x = TApplicationException()
1562 
      x.read(self._iprot)
1563 
      self._iprot.readMessageEnd()
1564 
      raise x
1565 
    result = createMasterAffiliate_result()
1566 
    result.read(self._iprot)
1567 
    self._iprot.readMessageEnd()
3431 rajveer 1568 
    if result.success is not None:
1845 vikas 1569 
      return result.success
3431 rajveer 1570 
    if result.utx is not None:
1845 vikas 1571 
      raise result.utx
1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1573 
 
1899 vikas 1574 
  def getAllMasterAffiliates(self, ):
1575 
    self.send_getAllMasterAffiliates()
1576 
    return self.recv_getAllMasterAffiliates()
1577 
 
1578 
  def send_getAllMasterAffiliates(self, ):
1579 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1580 
    args = getAllMasterAffiliates_args()
1581 
    args.write(self._oprot)
1582 
    self._oprot.writeMessageEnd()
1583 
    self._oprot.trans.flush()
1584 
 
1585 
  def recv_getAllMasterAffiliates(self, ):
1586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1587 
    if mtype == TMessageType.EXCEPTION:
1588 
      x = TApplicationException()
1589 
      x.read(self._iprot)
1590 
      self._iprot.readMessageEnd()
1591 
      raise x
1592 
    result = getAllMasterAffiliates_result()
1593 
    result.read(self._iprot)
1594 
    self._iprot.readMessageEnd()
3431 rajveer 1595 
    if result.success is not None:
1899 vikas 1596 
      return result.success
3431 rajveer 1597 
    if result.utx is not None:
1899 vikas 1598 
      raise result.utx
1599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1600 
 
1845 vikas 1601 
  def getMasterAffiliateById(self, id):
1602 
    """
1603 
    Parameters:
1604 
     - id
1605 
    """
1606 
    self.send_getMasterAffiliateById(id)
1607 
    return self.recv_getMasterAffiliateById()
1608 
 
1609 
  def send_getMasterAffiliateById(self, id):
1610 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1611 
    args = getMasterAffiliateById_args()
1612 
    args.id = id
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getMasterAffiliateById(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getMasterAffiliateById_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
3431 rajveer 1627 
    if result.success is not None:
1845 vikas 1628 
      return result.success
3431 rajveer 1629 
    if result.utx is not None:
1845 vikas 1630 
      raise result.utx
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1632 
 
1633 
  def getMasterAffiliateByName(self, name):
1634 
    """
1635 
    Parameters:
1636 
     - name
1637 
    """
1638 
    self.send_getMasterAffiliateByName(name)
1639 
    return self.recv_getMasterAffiliateByName()
1640 
 
1641 
  def send_getMasterAffiliateByName(self, name):
1642 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1643 
    args = getMasterAffiliateByName_args()
1644 
    args.name = name
1645 
    args.write(self._oprot)
1646 
    self._oprot.writeMessageEnd()
1647 
    self._oprot.trans.flush()
1648 
 
1649 
  def recv_getMasterAffiliateByName(self, ):
1650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1651 
    if mtype == TMessageType.EXCEPTION:
1652 
      x = TApplicationException()
1653 
      x.read(self._iprot)
1654 
      self._iprot.readMessageEnd()
1655 
      raise x
1656 
    result = getMasterAffiliateByName_result()
1657 
    result.read(self._iprot)
1658 
    self._iprot.readMessageEnd()
3431 rajveer 1659 
    if result.success is not None:
1845 vikas 1660 
      return result.success
3431 rajveer 1661 
    if result.utx is not None:
1845 vikas 1662 
      raise result.utx
1663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1664 
 
1859 vikas 1665 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1666 
    """
1667 
    Parameters:
1668 
     - name
1669 
     - url
1670 
     - masterAffiliateId
1859 vikas 1671 
     - addedOn
1845 vikas 1672 
    """
1859 vikas 1673 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1674 
    return self.recv_createAffiliate()
1675 
 
1859 vikas 1676 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1677 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1678 
    args = createAffiliate_args()
1679 
    args.name = name
1680 
    args.url = url
1681 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1682 
    args.addedOn = addedOn
1845 vikas 1683 
    args.write(self._oprot)
1684 
    self._oprot.writeMessageEnd()
1685 
    self._oprot.trans.flush()
1686 
 
1687 
  def recv_createAffiliate(self, ):
1688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1689 
    if mtype == TMessageType.EXCEPTION:
1690 
      x = TApplicationException()
1691 
      x.read(self._iprot)
1692 
      self._iprot.readMessageEnd()
1693 
      raise x
1694 
    result = createAffiliate_result()
1695 
    result.read(self._iprot)
1696 
    self._iprot.readMessageEnd()
3431 rajveer 1697 
    if result.success is not None:
1845 vikas 1698 
      return result.success
3431 rajveer 1699 
    if result.utx is not None:
1845 vikas 1700 
      raise result.utx
1701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1702 
 
1703 
  def getAffiliateById(self, id):
1704 
    """
1705 
    Parameters:
1706 
     - id
1707 
    """
1708 
    self.send_getAffiliateById(id)
1709 
    return self.recv_getAffiliateById()
1710 
 
1711 
  def send_getAffiliateById(self, id):
1712 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1713 
    args = getAffiliateById_args()
1714 
    args.id = id
1715 
    args.write(self._oprot)
1716 
    self._oprot.writeMessageEnd()
1717 
    self._oprot.trans.flush()
1718 
 
1719 
  def recv_getAffiliateById(self, ):
1720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1721 
    if mtype == TMessageType.EXCEPTION:
1722 
      x = TApplicationException()
1723 
      x.read(self._iprot)
1724 
      self._iprot.readMessageEnd()
1725 
      raise x
1726 
    result = getAffiliateById_result()
1727 
    result.read(self._iprot)
1728 
    self._iprot.readMessageEnd()
3431 rajveer 1729 
    if result.success is not None:
1845 vikas 1730 
      return result.success
3431 rajveer 1731 
    if result.utx is not None:
1845 vikas 1732 
      raise result.utx
1733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1734 
 
1735 
  def getAffiliateByName(self, name):
1736 
    """
1737 
    Parameters:
1738 
     - name
1739 
    """
1740 
    self.send_getAffiliateByName(name)
1741 
    return self.recv_getAffiliateByName()
1742 
 
1743 
  def send_getAffiliateByName(self, name):
1744 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1745 
    args = getAffiliateByName_args()
1746 
    args.name = name
1747 
    args.write(self._oprot)
1748 
    self._oprot.writeMessageEnd()
1749 
    self._oprot.trans.flush()
1750 
 
1751 
  def recv_getAffiliateByName(self, ):
1752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1753 
    if mtype == TMessageType.EXCEPTION:
1754 
      x = TApplicationException()
1755 
      x.read(self._iprot)
1756 
      self._iprot.readMessageEnd()
1757 
      raise x
1758 
    result = getAffiliateByName_result()
1759 
    result.read(self._iprot)
1760 
    self._iprot.readMessageEnd()
3431 rajveer 1761 
    if result.success is not None:
1845 vikas 1762 
      return result.success
3431 rajveer 1763 
    if result.utx is not None:
1845 vikas 1764 
      raise result.utx
1765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1766 
 
1996 vikas 1767 
  def getTrackerById(self, id):
1845 vikas 1768 
    """
1769 
    Parameters:
1770 
     - id
1771 
    """
1996 vikas 1772 
    self.send_getTrackerById(id)
1845 vikas 1773 
    return self.recv_getTrackerById()
1774 
 
1996 vikas 1775 
  def send_getTrackerById(self, id):
1845 vikas 1776 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1777 
    args = getTrackerById_args()
1996 vikas 1778 
    args.id = id
1845 vikas 1779 
    args.write(self._oprot)
1780 
    self._oprot.writeMessageEnd()
1781 
    self._oprot.trans.flush()
1782 
 
1783 
  def recv_getTrackerById(self, ):
1784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1785 
    if mtype == TMessageType.EXCEPTION:
1786 
      x = TApplicationException()
1787 
      x.read(self._iprot)
1788 
      self._iprot.readMessageEnd()
1789 
      raise x
1790 
    result = getTrackerById_result()
1791 
    result.read(self._iprot)
1792 
    self._iprot.readMessageEnd()
3431 rajveer 1793 
    if result.success is not None:
1845 vikas 1794 
      return result.success
3431 rajveer 1795 
    if result.utx is not None:
1845 vikas 1796 
      raise result.utx
1797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1798 
 
1996 vikas 1799 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1800 
    """
1801 
    Parameters:
1996 vikas 1802 
     - id
1845 vikas 1803 
    """
1996 vikas 1804 
    self.send_getAffiliatesByMasterAffiliate(id)
1805 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1806 
 
1996 vikas 1807 
  def send_getAffiliatesByMasterAffiliate(self, id):
1808 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1809 
    args = getAffiliatesByMasterAffiliate_args()
1810 
    args.id = id
1845 vikas 1811 
    args.write(self._oprot)
1812 
    self._oprot.writeMessageEnd()
1813 
    self._oprot.trans.flush()
1814 
 
1996 vikas 1815 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1817 
    if mtype == TMessageType.EXCEPTION:
1818 
      x = TApplicationException()
1819 
      x.read(self._iprot)
1820 
      self._iprot.readMessageEnd()
1821 
      raise x
1996 vikas 1822 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1823 
    result.read(self._iprot)
1824 
    self._iprot.readMessageEnd()
3431 rajveer 1825 
    if result.success is not None:
1845 vikas 1826 
      return result.success
3431 rajveer 1827 
    if result.utx is not None:
1845 vikas 1828 
      raise result.utx
1996 vikas 1829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1830 
 
1996 vikas 1831 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1832 
    """
1833 
    Parameters:
1996 vikas 1834 
     - affiliateId
1845 vikas 1835 
     - userId
1836 
     - event
1837 
     - url
1838 
     - data
1859 vikas 1839 
     - addedOn
1845 vikas 1840 
    """
1996 vikas 1841 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1842 
    return self.recv_addTrackLog()
1843 
 
1996 vikas 1844 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1845 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1846 
    args = addTrackLog_args()
1996 vikas 1847 
    args.affiliateId = affiliateId
1845 vikas 1848 
    args.userId = userId
1849 
    args.event = event
1850 
    args.url = url
1851 
    args.data = data
1859 vikas 1852 
    args.addedOn = addedOn
1845 vikas 1853 
    args.write(self._oprot)
1854 
    self._oprot.writeMessageEnd()
1855 
    self._oprot.trans.flush()
1856 
 
1857 
  def recv_addTrackLog(self, ):
1858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1859 
    if mtype == TMessageType.EXCEPTION:
1860 
      x = TApplicationException()
1861 
      x.read(self._iprot)
1862 
      self._iprot.readMessageEnd()
1863 
      raise x
1864 
    result = addTrackLog_result()
1865 
    result.read(self._iprot)
1866 
    self._iprot.readMessageEnd()
3431 rajveer 1867 
    if result.success is not None:
1845 vikas 1868 
      return result.success
3431 rajveer 1869 
    if result.utx is not None:
1845 vikas 1870 
      raise result.utx
1871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1872 
 
1873 
  def getTrackLogById(self, id):
1874 
    """
1875 
    Parameters:
1876 
     - id
1877 
    """
1878 
    self.send_getTrackLogById(id)
1879 
    return self.recv_getTrackLogById()
1880 
 
1881 
  def send_getTrackLogById(self, id):
1882 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1883 
    args = getTrackLogById_args()
1884 
    args.id = id
1885 
    args.write(self._oprot)
1886 
    self._oprot.writeMessageEnd()
1887 
    self._oprot.trans.flush()
1888 
 
1889 
  def recv_getTrackLogById(self, ):
1890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1891 
    if mtype == TMessageType.EXCEPTION:
1892 
      x = TApplicationException()
1893 
      x.read(self._iprot)
1894 
      self._iprot.readMessageEnd()
1895 
      raise x
1896 
    result = getTrackLogById_result()
1897 
    result.read(self._iprot)
1898 
    self._iprot.readMessageEnd()
3431 rajveer 1899 
    if result.success is not None:
1845 vikas 1900 
      return result.success
3431 rajveer 1901 
    if result.utx is not None:
1845 vikas 1902 
      raise result.utx
1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1904 
 
3293 vikas 1905 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1906 
    """
1907 
    Parameters:
1996 vikas 1908 
     - affiliateId
3293 vikas 1909 
     - startDate
1910 
     - endDate
1845 vikas 1911 
    """
3293 vikas 1912 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1913 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1914 
 
3293 vikas 1915 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1916 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1917 
    args = getTrackLogsByAffiliate_args()
1918 
    args.affiliateId = affiliateId
3293 vikas 1919 
    args.startDate = startDate
1920 
    args.endDate = endDate
1845 vikas 1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1996 vikas 1925 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1996 vikas 1932 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
3431 rajveer 1935 
    if result.success is not None:
1845 vikas 1936 
      return result.success
3431 rajveer 1937 
    if result.utx is not None:
1845 vikas 1938 
      raise result.utx
1996 vikas 1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1940 
 
1941 
  def getTrackLogsByUser(self, userId):
1942 
    """
1943 
    Parameters:
1944 
     - userId
1945 
    """
1946 
    self.send_getTrackLogsByUser(userId)
1947 
    return self.recv_getTrackLogsByUser()
1948 
 
1949 
  def send_getTrackLogsByUser(self, userId):
1950 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1951 
    args = getTrackLogsByUser_args()
1952 
    args.userId = userId
1953 
    args.write(self._oprot)
1954 
    self._oprot.writeMessageEnd()
1955 
    self._oprot.trans.flush()
1956 
 
1957 
  def recv_getTrackLogsByUser(self, ):
1958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1959 
    if mtype == TMessageType.EXCEPTION:
1960 
      x = TApplicationException()
1961 
      x.read(self._iprot)
1962 
      self._iprot.readMessageEnd()
1963 
      raise x
1964 
    result = getTrackLogsByUser_result()
1965 
    result.read(self._iprot)
1966 
    self._iprot.readMessageEnd()
3431 rajveer 1967 
    if result.success is not None:
1845 vikas 1968 
      return result.success
3431 rajveer 1969 
    if result.utx is not None:
1845 vikas 1970 
      raise result.utx
1971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1972 
 
1996 vikas 1973 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1974 
    """
1975 
    Parameters:
1976 
     - userId
1977 
     - event
1978 
     - url
1979 
    """
1996 vikas 1980 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1981 
    return self.recv_getTrackLogs()
1982 
 
1996 vikas 1983 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1984 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1985 
    args = getTrackLogs_args()
1986 
    args.userId = userId
1987 
    args.event = event
1988 
    args.url = url
1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
1993 
  def recv_getTrackLogs(self, ):
1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
2000 
    result = getTrackLogs_result()
2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
3431 rajveer 2003 
    if result.success is not None:
1845 vikas 2004 
      return result.success
3431 rajveer 2005 
    if result.utx is not None:
1845 vikas 2006 
      raise result.utx
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2008 
 
559 chandransh 2009 
  def getCurrentCart(self, userId):
94 ashish 2010 
    """
2011 
    Parameters:
559 chandransh 2012 
     - userId
94 ashish 2013 
    """
559 chandransh 2014 
    self.send_getCurrentCart(userId)
2015 
    return self.recv_getCurrentCart()
94 ashish 2016 
 
559 chandransh 2017 
  def send_getCurrentCart(self, userId):
2018 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2019 
    args = getCurrentCart_args()
2020 
    args.userId = userId
94 ashish 2021 
    args.write(self._oprot)
2022 
    self._oprot.writeMessageEnd()
2023 
    self._oprot.trans.flush()
2024 
 
559 chandransh 2025 
  def recv_getCurrentCart(self, ):
94 ashish 2026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2027 
    if mtype == TMessageType.EXCEPTION:
2028 
      x = TApplicationException()
2029 
      x.read(self._iprot)
2030 
      self._iprot.readMessageEnd()
2031 
      raise x
559 chandransh 2032 
    result = getCurrentCart_result()
94 ashish 2033 
    result.read(self._iprot)
2034 
    self._iprot.readMessageEnd()
3431 rajveer 2035 
    if result.success is not None:
94 ashish 2036 
      return result.success
3431 rajveer 2037 
    if result.scx is not None:
559 chandransh 2038 
      raise result.scx
2039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2040 
 
559 chandransh 2041 
  def getCart(self, cartId):
94 ashish 2042 
    """
2043 
    Parameters:
559 chandransh 2044 
     - cartId
94 ashish 2045 
    """
559 chandransh 2046 
    self.send_getCart(cartId)
2047 
    return self.recv_getCart()
94 ashish 2048 
 
559 chandransh 2049 
  def send_getCart(self, cartId):
2050 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2051 
    args = getCart_args()
2052 
    args.cartId = cartId
94 ashish 2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
559 chandransh 2057 
  def recv_getCart(self, ):
94 ashish 2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
559 chandransh 2064 
    result = getCart_result()
94 ashish 2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
3431 rajveer 2067 
    if result.success is not None:
94 ashish 2068 
      return result.success
3431 rajveer 2069 
    if result.scx is not None:
559 chandransh 2070 
      raise result.scx
2071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2072 
 
559 chandransh 2073 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2074 
    """
2075 
    Parameters:
559 chandransh 2076 
     - from_time
2077 
     - to_time
2078 
     - status
94 ashish 2079 
    """
559 chandransh 2080 
    self.send_getCartsByTime(from_time, to_time, status)
2081 
    return self.recv_getCartsByTime()
94 ashish 2082 
 
559 chandransh 2083 
  def send_getCartsByTime(self, from_time, to_time, status):
2084 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2085 
    args = getCartsByTime_args()
2086 
    args.from_time = from_time
2087 
    args.to_time = to_time
2088 
    args.status = status
94 ashish 2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
559 chandransh 2093 
  def recv_getCartsByTime(self, ):
94 ashish 2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
559 chandransh 2100 
    result = getCartsByTime_result()
94 ashish 2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
3431 rajveer 2103 
    if result.success is not None:
94 ashish 2104 
      return result.success
3431 rajveer 2105 
    if result.scx is not None:
559 chandransh 2106 
      raise result.scx
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2108 
 
3557 rajveer 2109 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2110 
    """
2111 
    Parameters:
2112 
     - cartId
2113 
     - itemId
2114 
     - quantity
3557 rajveer 2115 
     - sourceId
559 chandransh 2116 
    """
3557 rajveer 2117 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2118 
    return self.recv_addItemToCart()
559 chandransh 2119 
 
3557 rajveer 2120 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2121 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2122 
    args = addItemToCart_args()
2123 
    args.cartId = cartId
2124 
    args.itemId = itemId
2125 
    args.quantity = quantity
3557 rajveer 2126 
    args.sourceId = sourceId
559 chandransh 2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
2131 
  def recv_addItemToCart(self, ):
2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
2138 
    result = addItemToCart_result()
2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
3431 rajveer 2141 
    if result.success is not None:
2035 rajveer 2142 
      return result.success
3431 rajveer 2143 
    if result.scx is not None:
559 chandransh 2144 
      raise result.scx
2035 rajveer 2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2146 
 
2147 
  def deleteItemFromCart(self, cartId, itemId):
2148 
    """
2149 
    Parameters:
2150 
     - cartId
2151 
     - itemId
2152 
    """
2153 
    self.send_deleteItemFromCart(cartId, itemId)
2154 
    self.recv_deleteItemFromCart()
2155 
 
2156 
  def send_deleteItemFromCart(self, cartId, itemId):
2157 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2158 
    args = deleteItemFromCart_args()
2159 
    args.cartId = cartId
2160 
    args.itemId = itemId
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_deleteItemFromCart(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = deleteItemFromCart_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
3431 rajveer 2175 
    if result.scx is not None:
559 chandransh 2176 
      raise result.scx
2177 
    return
2178 
 
2179 
  def addAddressToCart(self, cartId, addressId):
2180 
    """
2181 
    Parameters:
2182 
     - cartId
2183 
     - addressId
2184 
    """
2185 
    self.send_addAddressToCart(cartId, addressId)
2186 
    self.recv_addAddressToCart()
2187 
 
2188 
  def send_addAddressToCart(self, cartId, addressId):
2189 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2190 
    args = addAddressToCart_args()
2191 
    args.cartId = cartId
2192 
    args.addressId = addressId
2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
2197 
  def recv_addAddressToCart(self, ):
2198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2199 
    if mtype == TMessageType.EXCEPTION:
2200 
      x = TApplicationException()
2201 
      x.read(self._iprot)
2202 
      self._iprot.readMessageEnd()
2203 
      raise x
2204 
    result = addAddressToCart_result()
2205 
    result.read(self._iprot)
2206 
    self._iprot.readMessageEnd()
3431 rajveer 2207 
    if result.scx is not None:
575 chandransh 2208 
      raise result.scx
559 chandransh 2209 
    return
2210 
 
5553 rajveer 2211 
  def addStoreToCart(self, cartId, storeId):
2212 
    """
2213 
    Parameters:
2214 
     - cartId
2215 
     - storeId
2216 
    """
2217 
    self.send_addStoreToCart(cartId, storeId)
2218 
    self.recv_addStoreToCart()
2219 
 
2220 
  def send_addStoreToCart(self, cartId, storeId):
2221 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2222 
    args = addStoreToCart_args()
2223 
    args.cartId = cartId
2224 
    args.storeId = storeId
2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
2229 
  def recv_addStoreToCart(self, ):
2230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2231 
    if mtype == TMessageType.EXCEPTION:
2232 
      x = TApplicationException()
2233 
      x.read(self._iprot)
2234 
      self._iprot.readMessageEnd()
2235 
      raise x
2236 
    result = addStoreToCart_result()
2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
2239 
    if result.scx is not None:
2240 
      raise result.scx
2241 
    return
2242 
 
6922 anupam.sin 2243 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2244 
    """
2245 
    Parameters:
6922 anupam.sin 2246 
     - cart
1976 varun.gupt 2247 
     - couponCode
2248 
    """
6922 anupam.sin 2249 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2250 
    self.recv_applyCouponToCart()
2251 
 
6922 anupam.sin 2252 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2253 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2254 
    args = applyCouponToCart_args()
6922 anupam.sin 2255 
    args.cart = cart
1976 varun.gupt 2256 
    args.couponCode = couponCode
2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
2261 
  def recv_applyCouponToCart(self, ):
2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
2268 
    result = applyCouponToCart_result()
2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.scx is not None:
1976 varun.gupt 2272 
      raise result.scx
2273 
    return
2274 
 
2275 
  def removeCoupon(self, cartId):
2276 
    """
2277 
    Parameters:
2278 
     - cartId
2279 
    """
2280 
    self.send_removeCoupon(cartId)
2281 
    self.recv_removeCoupon()
2282 
 
2283 
  def send_removeCoupon(self, cartId):
2284 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2285 
    args = removeCoupon_args()
2286 
    args.cartId = cartId
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_removeCoupon(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = removeCoupon_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
3431 rajveer 2301 
    if result.scx is not None:
1976 varun.gupt 2302 
      raise result.scx
2303 
    return
2304 
 
3554 varun.gupt 2305 
  def deleteDiscountsFromCart(self, cartId):
2306 
    """
2307 
    Deletes all the discounts associated with the cart
2308 
 
2309 
    Parameters:
2310 
     - cartId
2311 
    """
2312 
    self.send_deleteDiscountsFromCart(cartId)
2313 
    self.recv_deleteDiscountsFromCart()
2314 
 
2315 
  def send_deleteDiscountsFromCart(self, cartId):
2316 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2317 
    args = deleteDiscountsFromCart_args()
2318 
    args.cartId = cartId
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_deleteDiscountsFromCart(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = deleteDiscountsFromCart_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
2333 
    if result.scx is not None:
2334 
      raise result.scx
2335 
    return
2336 
 
2337 
  def saveDiscounts(self, discounts):
2338 
    """
2339 
    Accepts a list of thrift objects of Discount type and saves them
2340 
 
2341 
    Parameters:
2342 
     - discounts
2343 
    """
2344 
    self.send_saveDiscounts(discounts)
2345 
    self.recv_saveDiscounts()
2346 
 
2347 
  def send_saveDiscounts(self, discounts):
2348 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2349 
    args = saveDiscounts_args()
2350 
    args.discounts = discounts
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_saveDiscounts(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = saveDiscounts_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.scx is not None:
2366 
      raise result.scx
2367 
    return
2368 
 
11526 amit.gupta 2369 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2370 
    """
690 chandransh 2371 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2372 
 
559 chandransh 2373 
    Parameters:
2374 
     - cartId
2815 vikas 2375 
     - sessionSource
2376 
     - sessionStartTime
3858 vikas 2377 
     - firstSource
2378 
     - firstSourceTime
5326 rajveer 2379 
     - userId
6389 rajveer 2380 
     - schemeId
11526 amit.gupta 2381 
     - orderSource
559 chandransh 2382 
    """
11526 amit.gupta 2383 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2384 
    return self.recv_createOrders()
559 chandransh 2385 
 
11526 amit.gupta 2386 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2387 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2388 
    args = createOrders_args()
559 chandransh 2389 
    args.cartId = cartId
2815 vikas 2390 
    args.sessionSource = sessionSource
2391 
    args.sessionStartTime = sessionStartTime
3858 vikas 2392 
    args.firstSource = firstSource
2393 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2394 
    args.userId = userId
6389 rajveer 2395 
    args.schemeId = schemeId
11526 amit.gupta 2396 
    args.orderSource = orderSource
559 chandransh 2397 
    args.write(self._oprot)
2398 
    self._oprot.writeMessageEnd()
2399 
    self._oprot.trans.flush()
2400 
 
690 chandransh 2401 
  def recv_createOrders(self, ):
559 chandransh 2402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2403 
    if mtype == TMessageType.EXCEPTION:
2404 
      x = TApplicationException()
2405 
      x.read(self._iprot)
2406 
      self._iprot.readMessageEnd()
2407 
      raise x
690 chandransh 2408 
    result = createOrders_result()
559 chandransh 2409 
    result.read(self._iprot)
2410 
    self._iprot.readMessageEnd()
3431 rajveer 2411 
    if result.success is not None:
130 ashish 2412 
      return result.success
3431 rajveer 2413 
    if result.scx is not None:
559 chandransh 2414 
      raise result.scx
690 chandransh 2415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2416 
 
3557 rajveer 2417 
  def validateCart(self, cartId, sourceId):
130 ashish 2418 
    """
690 chandransh 2419 
    Validates that:
2420 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2421 
    2. All of the lines in the cart are active items.
690 chandransh 2422 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2423 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2424 
 
130 ashish 2425 
    Parameters:
559 chandransh 2426 
     - cartId
3557 rajveer 2427 
     - sourceId
130 ashish 2428 
    """
3557 rajveer 2429 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2430 
    return self.recv_validateCart()
130 ashish 2431 
 
3557 rajveer 2432 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2433 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2434 
    args = validateCart_args()
2435 
    args.cartId = cartId
3557 rajveer 2436 
    args.sourceId = sourceId
130 ashish 2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
559 chandransh 2441 
  def recv_validateCart(self, ):
130 ashish 2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
559 chandransh 2448 
    result = validateCart_result()
130 ashish 2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
3431 rajveer 2451 
    if result.success is not None:
130 ashish 2452 
      return result.success
3431 rajveer 2453 
    if result.scex is not None:
575 chandransh 2454 
      raise result.scex
559 chandransh 2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2456 
 
11980 amit.gupta 2457 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2458 
    """
2459 
    Validates that:
2460 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2461 
    2. All of the lines in the cart are active items.
2462 
    3. The estimate for any of the lines in cart doesn't change.
2463 
    If all three are true, returns empty string; else returns appropriate message.
2464 
 
2465 
    Parameters:
2466 
     - cartId
2467 
     - sourceId
2468 
     - dealCoupon
2469 
    """
2470 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2471 
    return self.recv_validateCartWithDealerCoupon()
2472 
 
2473 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2474 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2475 
    args = validateCartWithDealerCoupon_args()
2476 
    args.cartId = cartId
2477 
    args.sourceId = sourceId
2478 
    args.dealCoupon = dealCoupon
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_validateCartWithDealerCoupon(self, ):
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
2490 
    result = validateCartWithDealerCoupon_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
2493 
    if result.success is not None:
2494 
      return result.success
2495 
    if result.scex is not None:
2496 
      raise result.scex
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2498 
 
690 chandransh 2499 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2500 
    """
690 chandransh 2501 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2502 
 
575 chandransh 2503 
    Parameters:
690 chandransh 2504 
     - fromCartId
2505 
     - toCartId
2506 
    """
2507 
    self.send_mergeCart(fromCartId, toCartId)
2508 
    self.recv_mergeCart()
2509 
 
2510 
  def send_mergeCart(self, fromCartId, toCartId):
2511 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2512 
    args = mergeCart_args()
2513 
    args.fromCartId = fromCartId
2514 
    args.toCartId = toCartId
2515 
    args.write(self._oprot)
2516 
    self._oprot.writeMessageEnd()
2517 
    self._oprot.trans.flush()
2518 
 
2519 
  def recv_mergeCart(self, ):
2520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2521 
    if mtype == TMessageType.EXCEPTION:
2522 
      x = TApplicationException()
2523 
      x.read(self._iprot)
2524 
      self._iprot.readMessageEnd()
2525 
      raise x
2526 
    result = mergeCart_result()
2527 
    result.read(self._iprot)
2528 
    self._iprot.readMessageEnd()
2529 
    return
2530 
 
2531 
  def checkOut(self, cartId):
2532 
    """
2533 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2534 
 
690 chandransh 2535 
    Parameters:
575 chandransh 2536 
     - cartId
2537 
    """
690 chandransh 2538 
    self.send_checkOut(cartId)
2539 
    return self.recv_checkOut()
575 chandransh 2540 
 
690 chandransh 2541 
  def send_checkOut(self, cartId):
2542 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2543 
    args = checkOut_args()
575 chandransh 2544 
    args.cartId = cartId
2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
690 chandransh 2549 
  def recv_checkOut(self, ):
575 chandransh 2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
690 chandransh 2556 
    result = checkOut_result()
575 chandransh 2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
3431 rajveer 2559 
    if result.success is not None:
575 chandransh 2560 
      return result.success
3431 rajveer 2561 
    if result.scex is not None:
575 chandransh 2562 
      raise result.scex
690 chandransh 2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2564 
 
690 chandransh 2565 
  def resetCart(self, cartId, items):
559 chandransh 2566 
    """
690 chandransh 2567 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2568 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2569 
 
559 chandransh 2570 
    Parameters:
690 chandransh 2571 
     - cartId
2572 
     - items
559 chandransh 2573 
    """
690 chandransh 2574 
    self.send_resetCart(cartId, items)
2575 
    return self.recv_resetCart()
130 ashish 2576 
 
690 chandransh 2577 
  def send_resetCart(self, cartId, items):
2578 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2579 
    args = resetCart_args()
2580 
    args.cartId = cartId
2581 
    args.items = items
559 chandransh 2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
690 chandransh 2586 
  def recv_resetCart(self, ):
559 chandransh 2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
690 chandransh 2593 
    result = resetCart_result()
559 chandransh 2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
3431 rajveer 2596 
    if result.success is not None:
690 chandransh 2597 
      return result.success
3431 rajveer 2598 
    if result.scex is not None:
690 chandransh 2599 
      raise result.scex
2600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2601 
 
2981 rajveer 2602 
  def getUserCount(self, userType):
559 chandransh 2603 
    """
2981 rajveer 2604 
    Returns number of registered users.
2605 
    If userType = null, then it returns count of all users, including anonymous
2606 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2607 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2608 
 
559 chandransh 2609 
    Parameters:
2981 rajveer 2610 
     - userType
559 chandransh 2611 
    """
2981 rajveer 2612 
    self.send_getUserCount(userType)
2613 
    return self.recv_getUserCount()
559 chandransh 2614 
 
2981 rajveer 2615 
  def send_getUserCount(self, userType):
2616 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2617 
    args = getUserCount_args()
2618 
    args.userType = userType
559 chandransh 2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2981 rajveer 2623 
  def recv_getUserCount(self, ):
559 chandransh 2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2981 rajveer 2630 
    result = getUserCount_result()
559 chandransh 2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
3431 rajveer 2633 
    if result.success is not None:
559 chandransh 2634 
      return result.success
2981 rajveer 2635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2636 
 
2981 rajveer 2637 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2638 
    """
2981 rajveer 2639 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2640 
    If any of startDate or endDate is -1, then that filter is ignored.
2641 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2642 
 
2643 
 
559 chandransh 2644 
    Parameters:
2981 rajveer 2645 
     - userType
2646 
     - startDate
2647 
     - endDate
559 chandransh 2648 
    """
2981 rajveer 2649 
    self.send_getAllUsers(userType, startDate, endDate)
2650 
    return self.recv_getAllUsers()
559 chandransh 2651 
 
2981 rajveer 2652 
  def send_getAllUsers(self, userType, startDate, endDate):
2653 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2654 
    args = getAllUsers_args()
2655 
    args.userType = userType
2656 
    args.startDate = startDate
2657 
    args.endDate = endDate
559 chandransh 2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2981 rajveer 2662 
  def recv_getAllUsers(self, ):
559 chandransh 2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2981 rajveer 2669 
    result = getAllUsers_result()
559 chandransh 2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
3431 rajveer 2672 
    if result.success is not None:
559 chandransh 2673 
      return result.success
2981 rajveer 2674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2675 
 
2981 rajveer 2676 
  def getMyResearchItems(self, userId):
559 chandransh 2677 
    """
2981 rajveer 2678 
    Returns list of item ids in myresearch for the user
3431 rajveer 2679 
 
559 chandransh 2680 
    Parameters:
772 rajveer 2681 
     - userId
559 chandransh 2682 
    """
2981 rajveer 2683 
    self.send_getMyResearchItems(userId)
2684 
    return self.recv_getMyResearchItems()
559 chandransh 2685 
 
2981 rajveer 2686 
  def send_getMyResearchItems(self, userId):
2687 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2688 
    args = getMyResearchItems_args()
772 rajveer 2689 
    args.userId = userId
559 chandransh 2690 
    args.write(self._oprot)
2691 
    self._oprot.writeMessageEnd()
2692 
    self._oprot.trans.flush()
2693 
 
2981 rajveer 2694 
  def recv_getMyResearchItems(self, ):
559 chandransh 2695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2696 
    if mtype == TMessageType.EXCEPTION:
2697 
      x = TApplicationException()
2698 
      x.read(self._iprot)
2699 
      self._iprot.readMessageEnd()
2700 
      raise x
2981 rajveer 2701 
    result = getMyResearchItems_result()
559 chandransh 2702 
    result.read(self._iprot)
2703 
    self._iprot.readMessageEnd()
3431 rajveer 2704 
    if result.success is not None:
559 chandransh 2705 
      return result.success
3431 rajveer 2706 
    if result.scx is not None:
559 chandransh 2707 
      raise result.scx
2981 rajveer 2708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2709 
 
2981 rajveer 2710 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2711 
    """
2981 rajveer 2712 
    add item to my research for a user
3431 rajveer 2713 
 
559 chandransh 2714 
    Parameters:
2981 rajveer 2715 
     - userId
2716 
     - itemId
559 chandransh 2717 
    """
2981 rajveer 2718 
    self.send_updateMyResearch(userId, itemId)
2719 
    return self.recv_updateMyResearch()
559 chandransh 2720 
 
2981 rajveer 2721 
  def send_updateMyResearch(self, userId, itemId):
2722 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2723 
    args = updateMyResearch_args()
2724 
    args.userId = userId
2725 
    args.itemId = itemId
559 chandransh 2726 
    args.write(self._oprot)
2727 
    self._oprot.writeMessageEnd()
2728 
    self._oprot.trans.flush()
2729 
 
2981 rajveer 2730 
  def recv_updateMyResearch(self, ):
559 chandransh 2731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2732 
    if mtype == TMessageType.EXCEPTION:
2733 
      x = TApplicationException()
2734 
      x.read(self._iprot)
2735 
      self._iprot.readMessageEnd()
2736 
      raise x
2981 rajveer 2737 
    result = updateMyResearch_result()
559 chandransh 2738 
    result.read(self._iprot)
2739 
    self._iprot.readMessageEnd()
3431 rajveer 2740 
    if result.success is not None:
2981 rajveer 2741 
      return result.success
3431 rajveer 2742 
    if result.scx is not None:
2981 rajveer 2743 
      raise result.scx
2744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2745 
 
2981 rajveer 2746 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2747 
    """
2981 rajveer 2748 
    delete item from my research for a user
3431 rajveer 2749 
 
1596 ankur.sing 2750 
    Parameters:
2981 rajveer 2751 
     - userId
2752 
     - itemId
1596 ankur.sing 2753 
    """
2981 rajveer 2754 
    self.send_deleteItemFromMyResearch(userId, itemId)
2755 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2756 
 
2981 rajveer 2757 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2758 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2759 
    args = deleteItemFromMyResearch_args()
2760 
    args.userId = userId
2761 
    args.itemId = itemId
1596 ankur.sing 2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
2981 rajveer 2766 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
2981 rajveer 2773 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
3431 rajveer 2776 
    if result.scx is not None:
2981 rajveer 2777 
      raise result.scx
2778 
    return
1596 ankur.sing 2779 
 
2981 rajveer 2780 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2781 
    """
2981 rajveer 2782 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2783 
 
1673 ankur.sing 2784 
    Parameters:
2981 rajveer 2785 
     - userId
1673 ankur.sing 2786 
    """
2981 rajveer 2787 
    self.send_getBrowseHistoryItems(userId)
2788 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2789 
 
2981 rajveer 2790 
  def send_getBrowseHistoryItems(self, userId):
2791 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2792 
    args = getBrowseHistoryItems_args()
2793 
    args.userId = userId
1673 ankur.sing 2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2981 rajveer 2798 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 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
2981 rajveer 2805 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
3431 rajveer 2808 
    if result.success is not None:
1673 ankur.sing 2809 
      return result.success
3431 rajveer 2810 
    if result.scx is not None:
2981 rajveer 2811 
      raise result.scx
2812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2813 
 
2981 rajveer 2814 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2815 
    """
2981 rajveer 2816 
    add item to browse history for a user
3431 rajveer 2817 
 
2642 varun.gupt 2818 
    Parameters:
2981 rajveer 2819 
     - userId
2820 
     - itemId
2642 varun.gupt 2821 
    """
2981 rajveer 2822 
    self.send_updateBrowseHistory(userId, itemId)
2823 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2824 
 
2981 rajveer 2825 
  def send_updateBrowseHistory(self, userId, itemId):
2826 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2827 
    args = updateBrowseHistory_args()
2828 
    args.userId = userId
2829 
    args.itemId = itemId
2642 varun.gupt 2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2981 rajveer 2834 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2981 rajveer 2841 
    result = updateBrowseHistory_result()
2642 varun.gupt 2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    return
2845 
 
3385 varun.gupt 2846 
  def getCartsWithCouponCount(self, couponCode):
2847 
    """
2848 
    Returns count of Carts with given coupon applied
3431 rajveer 2849 
 
3385 varun.gupt 2850 
    Parameters:
2851 
     - couponCode
2852 
    """
2853 
    self.send_getCartsWithCouponCount(couponCode)
2854 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2855 
 
3385 varun.gupt 2856 
  def send_getCartsWithCouponCount(self, couponCode):
2857 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2858 
    args = getCartsWithCouponCount_args()
2859 
    args.couponCode = couponCode
2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2864 
  def recv_getCartsWithCouponCount(self, ):
2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2871 
    result = getCartsWithCouponCount_result()
2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
3431 rajveer 2874 
    if result.success is not None:
3385 varun.gupt 2875 
      return result.success
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2877 
 
3499 mandeep.dh 2878 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2879 
    """
2880 
    Updates COD trust level of a user
3385 varun.gupt 2881 
 
3499 mandeep.dh 2882 
    Parameters:
2883 
     - userId
2884 
     - trustLevelDelta
2885 
    """
2886 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2887 
 
2888 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2889 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2890 
    args = increaseTrustLevel_args()
2891 
    args.userId = userId
2892 
    args.trustLevelDelta = trustLevelDelta
2893 
    args.write(self._oprot)
2894 
    self._oprot.writeMessageEnd()
2895 
    self._oprot.trans.flush()
5407 amar.kumar 2896 
  def getTrustLevel(self, userId):
2897 
    """
2898 
    Get trust level of a user
2899 
 
2900 
    Parameters:
2901 
     - userId
2902 
    """
2903 
    self.send_getTrustLevel(userId)
2904 
    return self.recv_getTrustLevel()
2905 
 
2906 
  def send_getTrustLevel(self, userId):
2907 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2908 
    args = getTrustLevel_args()
2909 
    args.userId = userId
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_getTrustLevel(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = getTrustLevel_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
2924 
    if result.success is not None:
2925 
      return result.success
2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2927 
 
4668 varun.gupt 2928 
  def showCODOption(self, cartId, sourceId, pincode):
2929 
    """
2930 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2931 
 
4668 varun.gupt 2932 
    Parameters:
2933 
     - cartId
2934 
     - sourceId
2935 
     - pincode
2936 
    """
2937 
    self.send_showCODOption(cartId, sourceId, pincode)
2938 
    return self.recv_showCODOption()
2939 
 
2940 
  def send_showCODOption(self, cartId, sourceId, pincode):
2941 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2942 
    args = showCODOption_args()
2943 
    args.cartId = cartId
2944 
    args.sourceId = sourceId
2945 
    args.pincode = pincode
2946 
    args.write(self._oprot)
2947 
    self._oprot.writeMessageEnd()
2948 
    self._oprot.trans.flush()
2949 
 
2950 
  def recv_showCODOption(self, ):
2951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2952 
    if mtype == TMessageType.EXCEPTION:
2953 
      x = TApplicationException()
2954 
      x.read(self._iprot)
2955 
      self._iprot.readMessageEnd()
2956 
      raise x
2957 
    result = showCODOption_result()
2958 
    result.read(self._iprot)
2959 
    self._iprot.readMessageEnd()
2960 
    if result.success is not None:
2961 
      return result.success
2962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2963 
 
5623 anupam.sin 2964 
  def getUserEmails(self, startDate, endDate):
2965 
    """
2966 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2967 
 
5623 anupam.sin 2968 
    Parameters:
2969 
     - startDate
2970 
     - endDate
2971 
    """
2972 
    self.send_getUserEmails(startDate, endDate)
2973 
    return self.recv_getUserEmails()
2974 
 
2975 
  def send_getUserEmails(self, startDate, endDate):
2976 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
2977 
    args = getUserEmails_args()
2978 
    args.startDate = startDate
2979 
    args.endDate = endDate
2980 
    args.write(self._oprot)
2981 
    self._oprot.writeMessageEnd()
2982 
    self._oprot.trans.flush()
2983 
 
2984 
  def recv_getUserEmails(self, ):
2985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2986 
    if mtype == TMessageType.EXCEPTION:
2987 
      x = TApplicationException()
2988 
      x.read(self._iprot)
2989 
      self._iprot.readMessageEnd()
2990 
      raise x
2991 
    result = getUserEmails_result()
2992 
    result.read(self._iprot)
2993 
    self._iprot.readMessageEnd()
2994 
    if result.success is not None:
2995 
      return result.success
2996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
2997 
 
9299 kshitij.so 2998 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 2999 
    """
3000 
    Mark a cart lineitem as insured. Returns true/false.
3001 
 
3002 
    Parameters:
3003 
     - itemId
3004 
     - cartId
3005 
     - toInsure
9299 kshitij.so 3006 
     - insurerType
6903 anupam.sin 3007 
    """
9299 kshitij.so 3008 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3009 
    return self.recv_insureItem()
3010 
 
9299 kshitij.so 3011 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3012 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3013 
    args = insureItem_args()
3014 
    args.itemId = itemId
3015 
    args.cartId = cartId
3016 
    args.toInsure = toInsure
9299 kshitij.so 3017 
    args.insurerType = insurerType
6903 anupam.sin 3018 
    args.write(self._oprot)
3019 
    self._oprot.writeMessageEnd()
3020 
    self._oprot.trans.flush()
3021 
 
3022 
  def recv_insureItem(self, ):
3023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3024 
    if mtype == TMessageType.EXCEPTION:
3025 
      x = TApplicationException()
3026 
      x.read(self._iprot)
3027 
      self._iprot.readMessageEnd()
3028 
      raise x
3029 
    result = insureItem_result()
3030 
    result.read(self._iprot)
3031 
    self._iprot.readMessageEnd()
3032 
    if result.success is not None:
3033 
      return result.success
3034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3035 
 
3036 
  def cancelInsurance(self, cartId):
3037 
    """
3038 
    Cancel insurance for all items in the cart
3039 
 
3040 
    Parameters:
3041 
     - cartId
3042 
    """
3043 
    self.send_cancelInsurance(cartId)
3044 
    return self.recv_cancelInsurance()
3045 
 
3046 
  def send_cancelInsurance(self, cartId):
3047 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3048 
    args = cancelInsurance_args()
3049 
    args.cartId = cartId
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_cancelInsurance(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = cancelInsurance_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.success is not None:
3065 
      return result.success
3066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3067 
 
3068 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3069 
    """
3070 
    Stores insurance specific details like date of birth and guardianName
3071 
 
3072 
    Parameters:
3073 
     - addressId
3074 
     - dob
3075 
     - guardianName
3076 
    """
3077 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3078 
    return self.recv_storeInsuranceSpecificDetails()
3079 
 
3080 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3081 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3082 
    args = storeInsuranceSpecificDetails_args()
3083 
    args.addressId = addressId
3084 
    args.dob = dob
3085 
    args.guardianName = guardianName
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
3090 
  def recv_storeInsuranceSpecificDetails(self, ):
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
3097 
    result = storeInsuranceSpecificDetails_result()
3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    if result.success is not None:
3101 
      return result.success
3102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3103 
 
3104 
  def isInsuranceDetailPresent(self, addressId):
3105 
    """
3106 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3107 
 
3108 
    Parameters:
3109 
     - addressId
3110 
    """
3111 
    self.send_isInsuranceDetailPresent(addressId)
3112 
    return self.recv_isInsuranceDetailPresent()
3113 
 
3114 
  def send_isInsuranceDetailPresent(self, addressId):
3115 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3116 
    args = isInsuranceDetailPresent_args()
3117 
    args.addressId = addressId
3118 
    args.write(self._oprot)
3119 
    self._oprot.writeMessageEnd()
3120 
    self._oprot.trans.flush()
3121 
 
3122 
  def recv_isInsuranceDetailPresent(self, ):
3123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3124 
    if mtype == TMessageType.EXCEPTION:
3125 
      x = TApplicationException()
3126 
      x.read(self._iprot)
3127 
      self._iprot.readMessageEnd()
3128 
      raise x
3129 
    result = isInsuranceDetailPresent_result()
3130 
    result.read(self._iprot)
3131 
    self._iprot.readMessageEnd()
3132 
    if result.success is not None:
3133 
      return result.success
3134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3135 
 
9791 rajveer 3136 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3137 
    """
9791 rajveer 3138 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3139 
 
6821 amar.kumar 3140 
    Parameters:
3141 
     - startDate
3142 
     - endDate
3143 
    """
9791 rajveer 3144 
    self.send_getProductsAddedToCart(startDate, endDate)
3145 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3146 
 
9791 rajveer 3147 
  def send_getProductsAddedToCart(self, startDate, endDate):
3148 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3149 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3150 
    args.startDate = startDate
3151 
    args.endDate = endDate
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
9791 rajveer 3156 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 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
9791 rajveer 3163 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.success is not None:
3167 
      return result.success
9791 rajveer 3168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3169 
 
11980 amit.gupta 3170 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3171 
    """
3172 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3173 
 
11592 amit.gupta 3174 
    Parameters:
3175 
     - cartId
3176 
     - sourceId
11980 amit.gupta 3177 
     - dealerCoupon
11592 amit.gupta 3178 
    """
11980 amit.gupta 3179 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3180 
    return self.recv_validateCartPlus()
3181 
 
11980 amit.gupta 3182 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3183 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3184 
    args = validateCartPlus_args()
3185 
    args.cartId = cartId
3186 
    args.sourceId = sourceId
11980 amit.gupta 3187 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_validateCartPlus(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = validateCartPlus_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3202 
    if result.success is not None:
3203 
      return result.success
3204 
    if result.scex is not None:
3205 
      raise result.scex
3206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3207 
 
11679 vikram.rag 3208 
  def isPrivateDealUser(self, userId):
3209 
    """
3210 
    Parameters:
3211 
     - userId
3212 
    """
3213 
    self.send_isPrivateDealUser(userId)
3214 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3215 
 
11679 vikram.rag 3216 
  def send_isPrivateDealUser(self, userId):
3217 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3218 
    args = isPrivateDealUser_args()
3219 
    args.userId = userId
3220 
    args.write(self._oprot)
3221 
    self._oprot.writeMessageEnd()
3222 
    self._oprot.trans.flush()
3223 
 
3224 
  def recv_isPrivateDealUser(self, ):
3225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3226 
    if mtype == TMessageType.EXCEPTION:
3227 
      x = TApplicationException()
3228 
      x.read(self._iprot)
3229 
      self._iprot.readMessageEnd()
3230 
      raise x
3231 
    result = isPrivateDealUser_result()
3232 
    result.read(self._iprot)
3233 
    self._iprot.readMessageEnd()
3234 
    if result.success is not None:
3235 
      return result.success
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3237 
 
11890 kshitij.so 3238 
  def addPrivateDealUser(self, userId):
3239 
    """
3240 
    Parameters:
3241 
     - userId
3242 
    """
3243 
    self.send_addPrivateDealUser(userId)
3244 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3245 
 
11890 kshitij.so 3246 
  def send_addPrivateDealUser(self, userId):
3247 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3248 
    args = addPrivateDealUser_args()
3249 
    args.userId = userId
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_addPrivateDealUser(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = addPrivateDealUser_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
3266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3267 
 
3268 
  def changePrivateDealUserStatus(self, userId, isActive):
3269 
    """
3270 
    Parameters:
3271 
     - userId
3272 
     - isActive
3273 
    """
3274 
    self.send_changePrivateDealUserStatus(userId, isActive)
3275 
    return self.recv_changePrivateDealUserStatus()
3276 
 
3277 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3278 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3279 
    args = changePrivateDealUserStatus_args()
3280 
    args.userId = userId
3281 
    args.isActive = isActive
3282 
    args.write(self._oprot)
3283 
    self._oprot.writeMessageEnd()
3284 
    self._oprot.trans.flush()
3285 
 
3286 
  def recv_changePrivateDealUserStatus(self, ):
3287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3288 
    if mtype == TMessageType.EXCEPTION:
3289 
      x = TApplicationException()
3290 
      x.read(self._iprot)
3291 
      self._iprot.readMessageEnd()
3292 
      raise x
3293 
    result = changePrivateDealUserStatus_result()
3294 
    result.read(self._iprot)
3295 
    self._iprot.readMessageEnd()
3296 
    if result.success is not None:
3297 
      return result.success
3298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3299 
 
3300 
  def getPrivateDealUser(self, userId):
3301 
    """
3302 
    Parameters:
3303 
     - userId
3304 
    """
3305 
    self.send_getPrivateDealUser(userId)
3306 
    return self.recv_getPrivateDealUser()
3307 
 
3308 
  def send_getPrivateDealUser(self, userId):
3309 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3310 
    args = getPrivateDealUser_args()
3311 
    args.userId = userId
3312 
    args.write(self._oprot)
3313 
    self._oprot.writeMessageEnd()
3314 
    self._oprot.trans.flush()
3315 
 
3316 
  def recv_getPrivateDealUser(self, ):
3317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3318 
    if mtype == TMessageType.EXCEPTION:
3319 
      x = TApplicationException()
3320 
      x.read(self._iprot)
3321 
      self._iprot.readMessageEnd()
3322 
      raise x
3323 
    result = getPrivateDealUser_result()
3324 
    result.read(self._iprot)
3325 
    self._iprot.readMessageEnd()
3326 
    if result.success is not None:
3327 
      return result.success
3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3329 
 
12696 amit.gupta 3330 
  def registerCounter(self, counter, userId):
3331 
    """
3332 
    Parameters:
3333 
     - counter
3334 
     - userId
3335 
    """
3336 
    self.send_registerCounter(counter, userId)
3337 
    return self.recv_registerCounter()
11890 kshitij.so 3338 
 
12696 amit.gupta 3339 
  def send_registerCounter(self, counter, userId):
3340 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3341 
    args = registerCounter_args()
3342 
    args.counter = counter
3343 
    args.userId = userId
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_registerCounter(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = registerCounter_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3361 
 
3362 
 
3376 rajveer 3363 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3364 
  def __init__(self, handler):
3376 rajveer 3365 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3366 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3367 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3368 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3369 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3370 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3371 
    self._processMap["createUser"] = Processor.process_createUser
3372 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3373 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3374 
    self._processMap["userExists"] = Processor.process_userExists
3375 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3376 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3377 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3378 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3379 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3380 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3381 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3382 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3383 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3384 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3385 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3386 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3387 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3388 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3389 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3390 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3391 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3392 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3393 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3394 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3395 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3396 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3397 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3398 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3399 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3400 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3401 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3402 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3403 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3404 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3405 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3406 
    self._processMap["getCart"] = Processor.process_getCart
3407 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3408 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3409 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3410 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3411 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3412 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3413 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3414 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3415 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3416 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3417 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3418 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3419 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3420 
    self._processMap["checkOut"] = Processor.process_checkOut
3421 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3422 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3423 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3424 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3425 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3426 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3427 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3428 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3429 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3430 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3431 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3432 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3433 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3434 
    self._processMap["insureItem"] = Processor.process_insureItem
3435 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3436 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3437 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3438 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3439 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3440 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3441 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3442 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3443 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3444 
    self._processMap["registerCounter"] = Processor.process_registerCounter
94 ashish 3445 
 
3446 
  def process(self, iprot, oprot):
3447 
    (name, type, seqid) = iprot.readMessageBegin()
3448 
    if name not in self._processMap:
3449 
      iprot.skip(TType.STRUCT)
3450 
      iprot.readMessageEnd()
3451 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3452 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3453 
      x.write(oprot)
3454 
      oprot.writeMessageEnd()
3455 
      oprot.trans.flush()
3456 
      return
3457 
    else:
3458 
      self._processMap[name](self, seqid, iprot, oprot)
3459 
    return True
3460 
 
559 chandransh 3461 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3462 
    args = createAnonymousUser_args()
94 ashish 3463 
    args.read(iprot)
3464 
    iprot.readMessageEnd()
559 chandransh 3465 
    result = createAnonymousUser_result()
94 ashish 3466 
    try:
559 chandransh 3467 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3468 
    except UserContextException, ucex:
3469 
      result.ucex = ucex
3470 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3471 
    result.write(oprot)
3472 
    oprot.writeMessageEnd()
3473 
    oprot.trans.flush()
3474 
 
559 chandransh 3475 
  def process_getUserById(self, seqid, iprot, oprot):
3476 
    args = getUserById_args()
94 ashish 3477 
    args.read(iprot)
3478 
    iprot.readMessageEnd()
559 chandransh 3479 
    result = getUserById_result()
94 ashish 3480 
    try:
559 chandransh 3481 
      result.success = self._handler.getUserById(args.userId)
3482 
    except UserContextException, ucex:
3483 
      result.ucex = ucex
3484 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3485 
    result.write(oprot)
3486 
    oprot.writeMessageEnd()
3487 
    oprot.trans.flush()
3488 
 
5326 rajveer 3489 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3490 
    args = getUserByCartId_args()
3491 
    args.read(iprot)
3492 
    iprot.readMessageEnd()
3493 
    result = getUserByCartId_result()
3494 
    try:
3495 
      result.success = self._handler.getUserByCartId(args.cartId)
3496 
    except UserContextException, ucex:
3497 
      result.ucex = ucex
3498 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3499 
    result.write(oprot)
3500 
    oprot.writeMessageEnd()
3501 
    oprot.trans.flush()
3502 
 
1491 vikas 3503 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3504 
    args = getUserByEmail_args()
3505 
    args.read(iprot)
3506 
    iprot.readMessageEnd()
3507 
    result = getUserByEmail_result()
3508 
    try:
3509 
      result.success = self._handler.getUserByEmail(args.email)
3510 
    except UserContextException, ucex:
3511 
      result.ucex = ucex
3512 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3513 
    result.write(oprot)
3514 
    oprot.writeMessageEnd()
3515 
    oprot.trans.flush()
3516 
 
3032 mandeep.dh 3517 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3518 
    args = getUserByMobileNumber_args()
3519 
    args.read(iprot)
3520 
    iprot.readMessageEnd()
3521 
    result = getUserByMobileNumber_result()
3522 
    try:
3523 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3524 
    except UserContextException, ucex:
3525 
      result.ucex = ucex
3526 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3527 
    result.write(oprot)
3528 
    oprot.writeMessageEnd()
3529 
    oprot.trans.flush()
3530 
 
559 chandransh 3531 
  def process_createUser(self, seqid, iprot, oprot):
3532 
    args = createUser_args()
94 ashish 3533 
    args.read(iprot)
3534 
    iprot.readMessageEnd()
559 chandransh 3535 
    result = createUser_result()
94 ashish 3536 
    try:
559 chandransh 3537 
      result.success = self._handler.createUser(args.user)
3538 
    except UserContextException, ucex:
3539 
      result.ucex = ucex
3540 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3541 
    result.write(oprot)
3542 
    oprot.writeMessageEnd()
3543 
    oprot.trans.flush()
3544 
 
559 chandransh 3545 
  def process_updateUser(self, seqid, iprot, oprot):
3546 
    args = updateUser_args()
94 ashish 3547 
    args.read(iprot)
3548 
    iprot.readMessageEnd()
559 chandransh 3549 
    result = updateUser_result()
94 ashish 3550 
    try:
559 chandransh 3551 
      result.success = self._handler.updateUser(args.user)
3552 
    except UserContextException, ucex:
3553 
      result.ucex = ucex
3554 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3555 
    result.write(oprot)
3556 
    oprot.writeMessageEnd()
3557 
    oprot.trans.flush()
3558 
 
122 ashish 3559 
  def process_authenticateUser(self, seqid, iprot, oprot):
3560 
    args = authenticateUser_args()
3561 
    args.read(iprot)
3562 
    iprot.readMessageEnd()
3563 
    result = authenticateUser_result()
3564 
    try:
559 chandransh 3565 
      result.success = self._handler.authenticateUser(args.email, args.password)
3566 
    except AuthenticationException, auex:
3567 
      result.auex = auex
122 ashish 3568 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3569 
    result.write(oprot)
3570 
    oprot.writeMessageEnd()
3571 
    oprot.trans.flush()
3572 
 
94 ashish 3573 
  def process_userExists(self, seqid, iprot, oprot):
3574 
    args = userExists_args()
3575 
    args.read(iprot)
3576 
    iprot.readMessageEnd()
3577 
    result = userExists_result()
3578 
    try:
3579 
      result.success = self._handler.userExists(args.email)
3580 
    except UserContextException, ucx:
3581 
      result.ucx = ucx
3582 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3583 
    result.write(oprot)
3584 
    oprot.writeMessageEnd()
3585 
    oprot.trans.flush()
3586 
 
3587 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3588 
    args = addAddressForUser_args()
3589 
    args.read(iprot)
3590 
    iprot.readMessageEnd()
3591 
    result = addAddressForUser_result()
3592 
    try:
567 rajveer 3593 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3594 
    except UserContextException, ucx:
3595 
      result.ucx = ucx
3596 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3597 
    result.write(oprot)
3598 
    oprot.writeMessageEnd()
3599 
    oprot.trans.flush()
3600 
 
3601 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3602 
    args = removeAddressForUser_args()
3603 
    args.read(iprot)
3604 
    iprot.readMessageEnd()
3605 
    result = removeAddressForUser_result()
3606 
    try:
3607 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3608 
    except UserContextException, ucx:
3609 
      result.ucx = ucx
3610 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3611 
    result.write(oprot)
3612 
    oprot.writeMessageEnd()
3613 
    oprot.trans.flush()
3614 
 
3615 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3616 
    args = setUserAsLoggedIn_args()
3617 
    args.read(iprot)
3618 
    iprot.readMessageEnd()
3619 
    result = setUserAsLoggedIn_result()
3620 
    try:
3621 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3622 
    except UserContextException, ucx:
3623 
      result.ucx = ucx
3624 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3625 
    result.write(oprot)
3626 
    oprot.writeMessageEnd()
3627 
    oprot.trans.flush()
3628 
 
3629 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3630 
    args = setUserAsLoggedOut_args()
3631 
    args.read(iprot)
3632 
    iprot.readMessageEnd()
3633 
    result = setUserAsLoggedOut_result()
3634 
    try:
3635 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3636 
    except UserContextException, ucx:
3637 
      result.ucx = ucx
3638 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3639 
    result.write(oprot)
3640 
    oprot.writeMessageEnd()
3641 
    oprot.trans.flush()
3642 
 
504 rajveer 3643 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3644 
    args = setDefaultAddress_args()
3645 
    args.read(iprot)
3646 
    iprot.readMessageEnd()
3647 
    result = setDefaultAddress_result()
3648 
    try:
3649 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3650 
    except UserContextException, ucx:
3651 
      result.ucx = ucx
3652 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3653 
    result.write(oprot)
3654 
    oprot.writeMessageEnd()
3655 
    oprot.trans.flush()
3656 
 
94 ashish 3657 
  def process_updatePassword(self, seqid, iprot, oprot):
3658 
    args = updatePassword_args()
3659 
    args.read(iprot)
3660 
    iprot.readMessageEnd()
3661 
    result = updatePassword_result()
3662 
    try:
594 rajveer 3663 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3664 
    except UserContextException, ucx:
3665 
      result.ucx = ucx
3666 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3667 
    result.write(oprot)
3668 
    oprot.writeMessageEnd()
3669 
    oprot.trans.flush()
3670 
 
581 rajveer 3671 
  def process_forgotPassword(self, seqid, iprot, oprot):
3672 
    args = forgotPassword_args()
3673 
    args.read(iprot)
3674 
    iprot.readMessageEnd()
3675 
    result = forgotPassword_result()
3676 
    try:
884 rajveer 3677 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3678 
    except UserContextException, ucx:
3679 
      result.ucx = ucx
3680 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3681 
    result.write(oprot)
3682 
    oprot.writeMessageEnd()
3683 
    oprot.trans.flush()
3684 
 
594 rajveer 3685 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3686 
    args = getAllAddressesForUser_args()
3687 
    args.read(iprot)
3688 
    iprot.readMessageEnd()
3689 
    result = getAllAddressesForUser_result()
3690 
    try:
3691 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3692 
    except UserContextException, ucx:
3693 
      result.ucx = ucx
3694 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3695 
    result.write(oprot)
3696 
    oprot.writeMessageEnd()
3697 
    oprot.trans.flush()
3698 
 
1894 vikas 3699 
  def process_getAddressById(self, seqid, iprot, oprot):
3700 
    args = getAddressById_args()
3701 
    args.read(iprot)
3702 
    iprot.readMessageEnd()
3703 
    result = getAddressById_result()
3704 
    try:
3705 
      result.success = self._handler.getAddressById(args.addressId)
3706 
    except UserContextException, ucx:
3707 
      result.ucx = ucx
3708 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3709 
    result.write(oprot)
3710 
    oprot.writeMessageEnd()
3711 
    oprot.trans.flush()
3712 
 
594 rajveer 3713 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3714 
    args = getDefaultAddressId_args()
3715 
    args.read(iprot)
3716 
    iprot.readMessageEnd()
3717 
    result = getDefaultAddressId_result()
3718 
    try:
3719 
      result.success = self._handler.getDefaultAddressId(args.userId)
3720 
    except UserContextException, ucx:
3721 
      result.ucx = ucx
3722 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3723 
    result.write(oprot)
3724 
    oprot.writeMessageEnd()
3725 
    oprot.trans.flush()
3726 
 
785 rajveer 3727 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3728 
    args = getDefaultPincode_args()
3729 
    args.read(iprot)
3730 
    iprot.readMessageEnd()
3731 
    result = getDefaultPincode_result()
3732 
    try:
3733 
      result.success = self._handler.getDefaultPincode(args.userId)
3734 
    except UserContextException, ucx:
3735 
      result.ucx = ucx
3736 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3737 
    result.write(oprot)
3738 
    oprot.writeMessageEnd()
3739 
    oprot.trans.flush()
3740 
 
1274 varun.gupt 3741 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3742 
    args = saveUserCommunication_args()
3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
3745 
    result = saveUserCommunication_result()
3746 
    try:
3747 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3748 
    except UserCommunicationException, ucx:
3749 
      result.ucx = ucx
3750 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
3754 
 
1590 varun.gupt 3755 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3756 
    args = getUserCommunicationById_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = getUserCommunicationById_result()
3760 
    try:
3761 
      result.success = self._handler.getUserCommunicationById(args.id)
3762 
    except UserCommunicationException, ucx:
3763 
      result.ucx = ucx
3764 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3765 
    result.write(oprot)
3766 
    oprot.writeMessageEnd()
3767 
    oprot.trans.flush()
3768 
 
3769 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3770 
    args = getUserCommunicationByUser_args()
3771 
    args.read(iprot)
3772 
    iprot.readMessageEnd()
3773 
    result = getUserCommunicationByUser_result()
3774 
    try:
3775 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3776 
    except UserCommunicationException, ucx:
3777 
      result.ucx = ucx
3778 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3779 
    result.write(oprot)
3780 
    oprot.writeMessageEnd()
3781 
    oprot.trans.flush()
3782 
 
3783 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3784 
    args = getAllUserCommunications_args()
3785 
    args.read(iprot)
3786 
    iprot.readMessageEnd()
3787 
    result = getAllUserCommunications_result()
3788 
    try:
3789 
      result.success = self._handler.getAllUserCommunications()
3790 
    except UserCommunicationException, ucx:
3791 
      result.ucx = ucx
3792 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3793 
    result.write(oprot)
3794 
    oprot.writeMessageEnd()
3795 
    oprot.trans.flush()
3796 
 
5407 amar.kumar 3797 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3798 
    args = removeUserCommunication_args()
3799 
    args.read(iprot)
3800 
    iprot.readMessageEnd()
3801 
    result = removeUserCommunication_result()
3802 
    try:
3803 
      self._handler.removeUserCommunication(args.id)
3804 
    except UserCommunicationException, ucx:
3805 
      result.ucx = ucx
3806 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3807 
    result.write(oprot)
3808 
    oprot.writeMessageEnd()
3809 
    oprot.trans.flush()
3810 
 
1845 vikas 3811 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3812 
    args = createMasterAffiliate_args()
3813 
    args.read(iprot)
3814 
    iprot.readMessageEnd()
3815 
    result = createMasterAffiliate_result()
3816 
    try:
1859 vikas 3817 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3818 
    except UserAffiliateException, utx:
1845 vikas 3819 
      result.utx = utx
3820 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3821 
    result.write(oprot)
3822 
    oprot.writeMessageEnd()
3823 
    oprot.trans.flush()
3824 
 
1899 vikas 3825 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3826 
    args = getAllMasterAffiliates_args()
3827 
    args.read(iprot)
3828 
    iprot.readMessageEnd()
3829 
    result = getAllMasterAffiliates_result()
3830 
    try:
3831 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3832 
    except UserAffiliateException, utx:
1899 vikas 3833 
      result.utx = utx
3834 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3835 
    result.write(oprot)
3836 
    oprot.writeMessageEnd()
3837 
    oprot.trans.flush()
3838 
 
1845 vikas 3839 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3840 
    args = getMasterAffiliateById_args()
3841 
    args.read(iprot)
3842 
    iprot.readMessageEnd()
3843 
    result = getMasterAffiliateById_result()
3844 
    try:
3845 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3846 
    except UserAffiliateException, utx:
1845 vikas 3847 
      result.utx = utx
3848 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3849 
    result.write(oprot)
3850 
    oprot.writeMessageEnd()
3851 
    oprot.trans.flush()
3852 
 
3853 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3854 
    args = getMasterAffiliateByName_args()
3855 
    args.read(iprot)
3856 
    iprot.readMessageEnd()
3857 
    result = getMasterAffiliateByName_result()
3858 
    try:
3859 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3860 
    except UserAffiliateException, utx:
1845 vikas 3861 
      result.utx = utx
3862 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3863 
    result.write(oprot)
3864 
    oprot.writeMessageEnd()
3865 
    oprot.trans.flush()
3866 
 
3867 
  def process_createAffiliate(self, seqid, iprot, oprot):
3868 
    args = createAffiliate_args()
3869 
    args.read(iprot)
3870 
    iprot.readMessageEnd()
3871 
    result = createAffiliate_result()
3872 
    try:
1859 vikas 3873 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3874 
    except UserAffiliateException, utx:
1845 vikas 3875 
      result.utx = utx
3876 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3877 
    result.write(oprot)
3878 
    oprot.writeMessageEnd()
3879 
    oprot.trans.flush()
3880 
 
3881 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3882 
    args = getAffiliateById_args()
3883 
    args.read(iprot)
3884 
    iprot.readMessageEnd()
3885 
    result = getAffiliateById_result()
3886 
    try:
3887 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3888 
    except UserAffiliateException, utx:
1845 vikas 3889 
      result.utx = utx
3890 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3891 
    result.write(oprot)
3892 
    oprot.writeMessageEnd()
3893 
    oprot.trans.flush()
3894 
 
3895 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3896 
    args = getAffiliateByName_args()
3897 
    args.read(iprot)
3898 
    iprot.readMessageEnd()
3899 
    result = getAffiliateByName_result()
3900 
    try:
3901 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3902 
    except UserAffiliateException, utx:
1845 vikas 3903 
      result.utx = utx
3904 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3905 
    result.write(oprot)
3906 
    oprot.writeMessageEnd()
3907 
    oprot.trans.flush()
3908 
 
3909 
  def process_getTrackerById(self, seqid, iprot, oprot):
3910 
    args = getTrackerById_args()
3911 
    args.read(iprot)
3912 
    iprot.readMessageEnd()
3913 
    result = getTrackerById_result()
3914 
    try:
1996 vikas 3915 
      result.success = self._handler.getTrackerById(args.id)
3916 
    except UserAffiliateException, utx:
1845 vikas 3917 
      result.utx = utx
3918 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3919 
    result.write(oprot)
3920 
    oprot.writeMessageEnd()
3921 
    oprot.trans.flush()
3922 
 
1996 vikas 3923 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3924 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3925 
    args.read(iprot)
3926 
    iprot.readMessageEnd()
1996 vikas 3927 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3928 
    try:
1996 vikas 3929 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3930 
    except UserAffiliateException, utx:
1845 vikas 3931 
      result.utx = utx
1996 vikas 3932 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3933 
    result.write(oprot)
3934 
    oprot.writeMessageEnd()
3935 
    oprot.trans.flush()
3936 
 
3937 
  def process_addTrackLog(self, seqid, iprot, oprot):
3938 
    args = addTrackLog_args()
3939 
    args.read(iprot)
3940 
    iprot.readMessageEnd()
3941 
    result = addTrackLog_result()
3942 
    try:
1996 vikas 3943 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3944 
    except UserAffiliateException, utx:
1845 vikas 3945 
      result.utx = utx
3946 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3947 
    result.write(oprot)
3948 
    oprot.writeMessageEnd()
3949 
    oprot.trans.flush()
3950 
 
3951 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3952 
    args = getTrackLogById_args()
3953 
    args.read(iprot)
3954 
    iprot.readMessageEnd()
3955 
    result = getTrackLogById_result()
3956 
    try:
3957 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3958 
    except UserAffiliateException, utx:
1845 vikas 3959 
      result.utx = utx
3960 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3961 
    result.write(oprot)
3962 
    oprot.writeMessageEnd()
3963 
    oprot.trans.flush()
3964 
 
1996 vikas 3965 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3966 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3967 
    args.read(iprot)
3968 
    iprot.readMessageEnd()
1996 vikas 3969 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3970 
    try:
3293 vikas 3971 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3972 
    except UserAffiliateException, utx:
1845 vikas 3973 
      result.utx = utx
1996 vikas 3974 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3975 
    result.write(oprot)
3976 
    oprot.writeMessageEnd()
3977 
    oprot.trans.flush()
3978 
 
3979 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3980 
    args = getTrackLogsByUser_args()
3981 
    args.read(iprot)
3982 
    iprot.readMessageEnd()
3983 
    result = getTrackLogsByUser_result()
3984 
    try:
3985 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3986 
    except UserAffiliateException, utx:
1845 vikas 3987 
      result.utx = utx
3988 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3989 
    result.write(oprot)
3990 
    oprot.writeMessageEnd()
3991 
    oprot.trans.flush()
3992 
 
3993 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3994 
    args = getTrackLogs_args()
3995 
    args.read(iprot)
3996 
    iprot.readMessageEnd()
3997 
    result = getTrackLogs_result()
3998 
    try:
1996 vikas 3999 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4000 
    except UserAffiliateException, utx:
1845 vikas 4001 
      result.utx = utx
4002 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4003 
    result.write(oprot)
4004 
    oprot.writeMessageEnd()
4005 
    oprot.trans.flush()
4006 
 
559 chandransh 4007 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4008 
    args = getCurrentCart_args()
94 ashish 4009 
    args.read(iprot)
4010 
    iprot.readMessageEnd()
559 chandransh 4011 
    result = getCurrentCart_result()
94 ashish 4012 
    try:
559 chandransh 4013 
      result.success = self._handler.getCurrentCart(args.userId)
4014 
    except ShoppingCartException, scx:
4015 
      result.scx = scx
4016 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4017 
    result.write(oprot)
4018 
    oprot.writeMessageEnd()
4019 
    oprot.trans.flush()
4020 
 
559 chandransh 4021 
  def process_getCart(self, seqid, iprot, oprot):
4022 
    args = getCart_args()
94 ashish 4023 
    args.read(iprot)
4024 
    iprot.readMessageEnd()
559 chandransh 4025 
    result = getCart_result()
94 ashish 4026 
    try:
559 chandransh 4027 
      result.success = self._handler.getCart(args.cartId)
4028 
    except ShoppingCartException, scx:
4029 
      result.scx = scx
4030 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4031 
    result.write(oprot)
4032 
    oprot.writeMessageEnd()
4033 
    oprot.trans.flush()
4034 
 
559 chandransh 4035 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4036 
    args = getCartsByTime_args()
94 ashish 4037 
    args.read(iprot)
4038 
    iprot.readMessageEnd()
559 chandransh 4039 
    result = getCartsByTime_result()
94 ashish 4040 
    try:
559 chandransh 4041 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4042 
    except ShoppingCartException, scx:
4043 
      result.scx = scx
4044 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4045 
    result.write(oprot)
4046 
    oprot.writeMessageEnd()
4047 
    oprot.trans.flush()
4048 
 
559 chandransh 4049 
  def process_addItemToCart(self, seqid, iprot, oprot):
4050 
    args = addItemToCart_args()
130 ashish 4051 
    args.read(iprot)
4052 
    iprot.readMessageEnd()
559 chandransh 4053 
    result = addItemToCart_result()
130 ashish 4054 
    try:
3557 rajveer 4055 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4056 
    except ShoppingCartException, scx:
4057 
      result.scx = scx
4058 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4059 
    result.write(oprot)
4060 
    oprot.writeMessageEnd()
4061 
    oprot.trans.flush()
4062 
 
559 chandransh 4063 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4064 
    args = deleteItemFromCart_args()
4065 
    args.read(iprot)
4066 
    iprot.readMessageEnd()
4067 
    result = deleteItemFromCart_result()
4068 
    try:
4069 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4070 
    except ShoppingCartException, scx:
4071 
      result.scx = scx
4072 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4073 
    result.write(oprot)
4074 
    oprot.writeMessageEnd()
4075 
    oprot.trans.flush()
130 ashish 4076 
 
559 chandransh 4077 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4078 
    args = addAddressToCart_args()
4079 
    args.read(iprot)
4080 
    iprot.readMessageEnd()
4081 
    result = addAddressToCart_result()
575 chandransh 4082 
    try:
4083 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4084 
    except ShoppingCartException, scx:
4085 
      result.scx = scx
559 chandransh 4086 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4087 
    result.write(oprot)
4088 
    oprot.writeMessageEnd()
4089 
    oprot.trans.flush()
4090 
 
5553 rajveer 4091 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4092 
    args = addStoreToCart_args()
4093 
    args.read(iprot)
4094 
    iprot.readMessageEnd()
4095 
    result = addStoreToCart_result()
4096 
    try:
4097 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4098 
    except ShoppingCartException, scx:
4099 
      result.scx = scx
4100 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4101 
    result.write(oprot)
4102 
    oprot.writeMessageEnd()
4103 
    oprot.trans.flush()
4104 
 
1976 varun.gupt 4105 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4106 
    args = applyCouponToCart_args()
4107 
    args.read(iprot)
4108 
    iprot.readMessageEnd()
4109 
    result = applyCouponToCart_result()
4110 
    try:
6922 anupam.sin 4111 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4112 
    except ShoppingCartException, scx:
4113 
      result.scx = scx
4114 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4115 
    result.write(oprot)
4116 
    oprot.writeMessageEnd()
4117 
    oprot.trans.flush()
4118 
 
4119 
  def process_removeCoupon(self, seqid, iprot, oprot):
4120 
    args = removeCoupon_args()
4121 
    args.read(iprot)
4122 
    iprot.readMessageEnd()
4123 
    result = removeCoupon_result()
4124 
    try:
4125 
      self._handler.removeCoupon(args.cartId)
4126 
    except ShoppingCartException, scx:
4127 
      result.scx = scx
4128 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
3554 varun.gupt 4133 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4134 
    args = deleteDiscountsFromCart_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = deleteDiscountsFromCart_result()
4138 
    try:
4139 
      self._handler.deleteDiscountsFromCart(args.cartId)
4140 
    except ShoppingCartException, scx:
4141 
      result.scx = scx
4142 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4143 
    result.write(oprot)
4144 
    oprot.writeMessageEnd()
4145 
    oprot.trans.flush()
4146 
 
4147 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4148 
    args = saveDiscounts_args()
4149 
    args.read(iprot)
4150 
    iprot.readMessageEnd()
4151 
    result = saveDiscounts_result()
4152 
    try:
4153 
      self._handler.saveDiscounts(args.discounts)
4154 
    except ShoppingCartException, scx:
4155 
      result.scx = scx
4156 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4157 
    result.write(oprot)
4158 
    oprot.writeMessageEnd()
4159 
    oprot.trans.flush()
4160 
 
690 chandransh 4161 
  def process_createOrders(self, seqid, iprot, oprot):
4162 
    args = createOrders_args()
559 chandransh 4163 
    args.read(iprot)
4164 
    iprot.readMessageEnd()
690 chandransh 4165 
    result = createOrders_result()
559 chandransh 4166 
    try:
11526 amit.gupta 4167 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4168 
    except ShoppingCartException, scx:
4169 
      result.scx = scx
690 chandransh 4170 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4171 
    result.write(oprot)
4172 
    oprot.writeMessageEnd()
4173 
    oprot.trans.flush()
4174 
 
4175 
  def process_validateCart(self, seqid, iprot, oprot):
4176 
    args = validateCart_args()
4177 
    args.read(iprot)
4178 
    iprot.readMessageEnd()
4179 
    result = validateCart_result()
575 chandransh 4180 
    try:
3557 rajveer 4181 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4182 
    except ShoppingCartException, scex:
4183 
      result.scex = scex
559 chandransh 4184 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4185 
    result.write(oprot)
4186 
    oprot.writeMessageEnd()
4187 
    oprot.trans.flush()
4188 
 
11980 amit.gupta 4189 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4190 
    args = validateCartWithDealerCoupon_args()
4191 
    args.read(iprot)
4192 
    iprot.readMessageEnd()
4193 
    result = validateCartWithDealerCoupon_result()
4194 
    try:
4195 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4196 
    except ShoppingCartException, scex:
4197 
      result.scex = scex
4198 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4199 
    result.write(oprot)
4200 
    oprot.writeMessageEnd()
4201 
    oprot.trans.flush()
4202 
 
690 chandransh 4203 
  def process_mergeCart(self, seqid, iprot, oprot):
4204 
    args = mergeCart_args()
575 chandransh 4205 
    args.read(iprot)
4206 
    iprot.readMessageEnd()
690 chandransh 4207 
    result = mergeCart_result()
4208 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4209 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4210 
    result.write(oprot)
4211 
    oprot.writeMessageEnd()
4212 
    oprot.trans.flush()
4213 
 
4214 
  def process_checkOut(self, seqid, iprot, oprot):
4215 
    args = checkOut_args()
4216 
    args.read(iprot)
4217 
    iprot.readMessageEnd()
4218 
    result = checkOut_result()
575 chandransh 4219 
    try:
690 chandransh 4220 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4221 
    except ShoppingCartException, scex:
4222 
      result.scex = scex
690 chandransh 4223 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4224 
    result.write(oprot)
4225 
    oprot.writeMessageEnd()
4226 
    oprot.trans.flush()
4227 
 
690 chandransh 4228 
  def process_resetCart(self, seqid, iprot, oprot):
4229 
    args = resetCart_args()
559 chandransh 4230 
    args.read(iprot)
4231 
    iprot.readMessageEnd()
690 chandransh 4232 
    result = resetCart_result()
4233 
    try:
4234 
      result.success = self._handler.resetCart(args.cartId, args.items)
4235 
    except ShoppingCartException, scex:
4236 
      result.scex = scex
4237 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4238 
    result.write(oprot)
4239 
    oprot.writeMessageEnd()
4240 
    oprot.trans.flush()
4241 
 
2981 rajveer 4242 
  def process_getUserCount(self, seqid, iprot, oprot):
4243 
    args = getUserCount_args()
559 chandransh 4244 
    args.read(iprot)
4245 
    iprot.readMessageEnd()
2981 rajveer 4246 
    result = getUserCount_result()
4247 
    result.success = self._handler.getUserCount(args.userType)
4248 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
2981 rajveer 4253 
  def process_getAllUsers(self, seqid, iprot, oprot):
4254 
    args = getAllUsers_args()
559 chandransh 4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
2981 rajveer 4257 
    result = getAllUsers_result()
4258 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4259 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4260 
    result.write(oprot)
4261 
    oprot.writeMessageEnd()
4262 
    oprot.trans.flush()
4263 
 
2981 rajveer 4264 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4265 
    args = getMyResearchItems_args()
559 chandransh 4266 
    args.read(iprot)
4267 
    iprot.readMessageEnd()
2981 rajveer 4268 
    result = getMyResearchItems_result()
559 chandransh 4269 
    try:
2981 rajveer 4270 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4271 
    except WidgetException, scx:
4272 
      result.scx = scx
2981 rajveer 4273 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
4277 
 
2981 rajveer 4278 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4279 
    args = updateMyResearch_args()
772 rajveer 4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
2981 rajveer 4282 
    result = updateMyResearch_result()
4283 
    try:
4284 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4285 
    except WidgetException, scx:
4286 
      result.scx = scx
4287 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4288 
    result.write(oprot)
4289 
    oprot.writeMessageEnd()
4290 
    oprot.trans.flush()
559 chandransh 4291 
 
2981 rajveer 4292 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4293 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4294 
    args.read(iprot)
4295 
    iprot.readMessageEnd()
2981 rajveer 4296 
    result = deleteItemFromMyResearch_result()
4297 
    try:
4298 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4299 
    except WidgetException, scx:
4300 
      result.scx = scx
4301 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
772 rajveer 4305 
 
2981 rajveer 4306 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4307 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
2981 rajveer 4310 
    result = getBrowseHistoryItems_result()
4311 
    try:
4312 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4313 
    except WidgetException, scx:
4314 
      result.scx = scx
4315 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
1596 ankur.sing 4319 
 
2981 rajveer 4320 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4321 
    args = updateBrowseHistory_args()
2642 varun.gupt 4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
2981 rajveer 4324 
    result = updateBrowseHistory_result()
4325 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4326 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
1673 ankur.sing 4330 
 
3385 varun.gupt 4331 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4332 
    args = getCartsWithCouponCount_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = getCartsWithCouponCount_result()
4336 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4337 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
2642 varun.gupt 4341 
 
3499 mandeep.dh 4342 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4343 
    args = increaseTrustLevel_args()
4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
4346 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4347 
    return
3385 varun.gupt 4348 
 
5407 amar.kumar 4349 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4350 
    args = getTrustLevel_args()
4351 
    args.read(iprot)
4352 
    iprot.readMessageEnd()
4353 
    result = getTrustLevel_result()
4354 
    result.success = self._handler.getTrustLevel(args.userId)
4355 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
4668 varun.gupt 4360 
  def process_showCODOption(self, seqid, iprot, oprot):
4361 
    args = showCODOption_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = showCODOption_result()
4365 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4366 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
3499 mandeep.dh 4370 
 
5623 anupam.sin 4371 
  def process_getUserEmails(self, seqid, iprot, oprot):
4372 
    args = getUserEmails_args()
4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
4375 
    result = getUserEmails_result()
4376 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4377 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4378 
    result.write(oprot)
4379 
    oprot.writeMessageEnd()
4380 
    oprot.trans.flush()
4668 varun.gupt 4381 
 
6903 anupam.sin 4382 
  def process_insureItem(self, seqid, iprot, oprot):
4383 
    args = insureItem_args()
4384 
    args.read(iprot)
4385 
    iprot.readMessageEnd()
4386 
    result = insureItem_result()
9299 kshitij.so 4387 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4388 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4389 
    result.write(oprot)
4390 
    oprot.writeMessageEnd()
4391 
    oprot.trans.flush()
4392 
 
4393 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4394 
    args = cancelInsurance_args()
4395 
    args.read(iprot)
4396 
    iprot.readMessageEnd()
4397 
    result = cancelInsurance_result()
4398 
    result.success = self._handler.cancelInsurance(args.cartId)
4399 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4400 
    result.write(oprot)
4401 
    oprot.writeMessageEnd()
4402 
    oprot.trans.flush()
4403 
 
4404 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4405 
    args = storeInsuranceSpecificDetails_args()
4406 
    args.read(iprot)
4407 
    iprot.readMessageEnd()
4408 
    result = storeInsuranceSpecificDetails_result()
4409 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4410 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4411 
    result.write(oprot)
4412 
    oprot.writeMessageEnd()
4413 
    oprot.trans.flush()
4414 
 
4415 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4416 
    args = isInsuranceDetailPresent_args()
4417 
    args.read(iprot)
4418 
    iprot.readMessageEnd()
4419 
    result = isInsuranceDetailPresent_result()
4420 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4421 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4422 
    result.write(oprot)
4423 
    oprot.writeMessageEnd()
4424 
    oprot.trans.flush()
4425 
 
9791 rajveer 4426 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4427 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4428 
    args.read(iprot)
4429 
    iprot.readMessageEnd()
9791 rajveer 4430 
    result = getProductsAddedToCart_result()
4431 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4432 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4433 
    result.write(oprot)
4434 
    oprot.writeMessageEnd()
4435 
    oprot.trans.flush()
5623 anupam.sin 4436 
 
11592 amit.gupta 4437 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4438 
    args = validateCartPlus_args()
4439 
    args.read(iprot)
4440 
    iprot.readMessageEnd()
4441 
    result = validateCartPlus_result()
4442 
    try:
11980 amit.gupta 4443 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4444 
    except ShoppingCartException, scex:
4445 
      result.scex = scex
4446 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
6821 amar.kumar 4450 
 
11679 vikram.rag 4451 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4452 
    args = isPrivateDealUser_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = isPrivateDealUser_result()
4456 
    result.success = self._handler.isPrivateDealUser(args.userId)
4457 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4458 
    result.write(oprot)
4459 
    oprot.writeMessageEnd()
4460 
    oprot.trans.flush()
11592 amit.gupta 4461 
 
11890 kshitij.so 4462 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4463 
    args = addPrivateDealUser_args()
4464 
    args.read(iprot)
4465 
    iprot.readMessageEnd()
4466 
    result = addPrivateDealUser_result()
4467 
    result.success = self._handler.addPrivateDealUser(args.userId)
4468 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4469 
    result.write(oprot)
4470 
    oprot.writeMessageEnd()
4471 
    oprot.trans.flush()
11679 vikram.rag 4472 
 
11890 kshitij.so 4473 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4474 
    args = changePrivateDealUserStatus_args()
4475 
    args.read(iprot)
4476 
    iprot.readMessageEnd()
4477 
    result = changePrivateDealUserStatus_result()
4478 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4479 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4480 
    result.write(oprot)
4481 
    oprot.writeMessageEnd()
4482 
    oprot.trans.flush()
4483 
 
4484 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4485 
    args = getPrivateDealUser_args()
4486 
    args.read(iprot)
4487 
    iprot.readMessageEnd()
4488 
    result = getPrivateDealUser_result()
4489 
    result.success = self._handler.getPrivateDealUser(args.userId)
4490 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4491 
    result.write(oprot)
4492 
    oprot.writeMessageEnd()
4493 
    oprot.trans.flush()
4494 
 
12696 amit.gupta 4495 
  def process_registerCounter(self, seqid, iprot, oprot):
4496 
    args = registerCounter_args()
4497 
    args.read(iprot)
4498 
    iprot.readMessageEnd()
4499 
    result = registerCounter_result()
4500 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4501 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4502 
    result.write(oprot)
4503 
    oprot.writeMessageEnd()
4504 
    oprot.trans.flush()
11890 kshitij.so 4505 
 
12696 amit.gupta 4506 
 
94 ashish 4507 
# HELPER FUNCTIONS AND STRUCTURES
4508 
 
559 chandransh 4509 
class createAnonymousUser_args:
94 ashish 4510 
  """
4511 
  Attributes:
559 chandransh 4512 
   - jsessionId
94 ashish 4513 
  """
4514 
 
4515 
  thrift_spec = (
4516 
    None, # 0
559 chandransh 4517 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4518 
  )
4519 
 
559 chandransh 4520 
  def __init__(self, jsessionId=None,):
4521 
    self.jsessionId = jsessionId
94 ashish 4522 
 
4523 
  def read(self, iprot):
4524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4526 
      return
4527 
    iprot.readStructBegin()
4528 
    while True:
4529 
      (fname, ftype, fid) = iprot.readFieldBegin()
4530 
      if ftype == TType.STOP:
4531 
        break
4532 
      if fid == 1:
559 chandransh 4533 
        if ftype == TType.STRING:
4534 
          self.jsessionId = iprot.readString();
94 ashish 4535 
        else:
4536 
          iprot.skip(ftype)
4537 
      else:
4538 
        iprot.skip(ftype)
4539 
      iprot.readFieldEnd()
4540 
    iprot.readStructEnd()
4541 
 
4542 
  def write(self, oprot):
4543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4545 
      return
559 chandransh 4546 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4547 
    if self.jsessionId is not None:
559 chandransh 4548 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4549 
      oprot.writeString(self.jsessionId)
94 ashish 4550 
      oprot.writeFieldEnd()
4551 
    oprot.writeFieldStop()
4552 
    oprot.writeStructEnd()
4553 
 
3431 rajveer 4554 
  def validate(self):
4555 
    return
4556 
 
4557 
 
94 ashish 4558 
  def __repr__(self):
4559 
    L = ['%s=%r' % (key, value)
4560 
      for key, value in self.__dict__.iteritems()]
4561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4562 
 
4563 
  def __eq__(self, other):
4564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4565 
 
4566 
  def __ne__(self, other):
4567 
    return not (self == other)
4568 
 
559 chandransh 4569 
class createAnonymousUser_result:
94 ashish 4570 
  """
4571 
  Attributes:
4572 
   - success
559 chandransh 4573 
   - ucex
94 ashish 4574 
  """
4575 
 
4576 
  thrift_spec = (
559 chandransh 4577 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4578 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4579 
  )
4580 
 
559 chandransh 4581 
  def __init__(self, success=None, ucex=None,):
94 ashish 4582 
    self.success = success
559 chandransh 4583 
    self.ucex = ucex
94 ashish 4584 
 
4585 
  def read(self, iprot):
4586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4588 
      return
4589 
    iprot.readStructBegin()
4590 
    while True:
4591 
      (fname, ftype, fid) = iprot.readFieldBegin()
4592 
      if ftype == TType.STOP:
4593 
        break
4594 
      if fid == 0:
4595 
        if ftype == TType.STRUCT:
559 chandransh 4596 
          self.success = User()
94 ashish 4597 
          self.success.read(iprot)
4598 
        else:
4599 
          iprot.skip(ftype)
4600 
      elif fid == 1:
4601 
        if ftype == TType.STRUCT:
559 chandransh 4602 
          self.ucex = UserContextException()
4603 
          self.ucex.read(iprot)
94 ashish 4604 
        else:
4605 
          iprot.skip(ftype)
4606 
      else:
4607 
        iprot.skip(ftype)
4608 
      iprot.readFieldEnd()
4609 
    iprot.readStructEnd()
4610 
 
4611 
  def write(self, oprot):
4612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4614 
      return
559 chandransh 4615 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4616 
    if self.success is not None:
94 ashish 4617 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4618 
      self.success.write(oprot)
4619 
      oprot.writeFieldEnd()
3431 rajveer 4620 
    if self.ucex is not None:
559 chandransh 4621 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4622 
      self.ucex.write(oprot)
94 ashish 4623 
      oprot.writeFieldEnd()
4624 
    oprot.writeFieldStop()
4625 
    oprot.writeStructEnd()
4626 
 
3431 rajveer 4627 
  def validate(self):
4628 
    return
4629 
 
4630 
 
94 ashish 4631 
  def __repr__(self):
4632 
    L = ['%s=%r' % (key, value)
4633 
      for key, value in self.__dict__.iteritems()]
4634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4635 
 
4636 
  def __eq__(self, other):
4637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4638 
 
4639 
  def __ne__(self, other):
4640 
    return not (self == other)
4641 
 
559 chandransh 4642 
class getUserById_args:
94 ashish 4643 
  """
4644 
  Attributes:
4645 
   - userId
4646 
  """
4647 
 
4648 
  thrift_spec = (
4649 
    None, # 0
4650 
    (1, TType.I64, 'userId', None, None, ), # 1
4651 
  )
4652 
 
559 chandransh 4653 
  def __init__(self, userId=None,):
94 ashish 4654 
    self.userId = userId
4655 
 
4656 
  def read(self, iprot):
4657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4659 
      return
4660 
    iprot.readStructBegin()
4661 
    while True:
4662 
      (fname, ftype, fid) = iprot.readFieldBegin()
4663 
      if ftype == TType.STOP:
4664 
        break
4665 
      if fid == 1:
4666 
        if ftype == TType.I64:
4667 
          self.userId = iprot.readI64();
4668 
        else:
4669 
          iprot.skip(ftype)
4670 
      else:
4671 
        iprot.skip(ftype)
4672 
      iprot.readFieldEnd()
4673 
    iprot.readStructEnd()
4674 
 
4675 
  def write(self, oprot):
4676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4678 
      return
559 chandransh 4679 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4680 
    if self.userId is not None:
94 ashish 4681 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4682 
      oprot.writeI64(self.userId)
4683 
      oprot.writeFieldEnd()
4684 
    oprot.writeFieldStop()
4685 
    oprot.writeStructEnd()
4686 
 
3431 rajveer 4687 
  def validate(self):
4688 
    return
4689 
 
4690 
 
94 ashish 4691 
  def __repr__(self):
4692 
    L = ['%s=%r' % (key, value)
4693 
      for key, value in self.__dict__.iteritems()]
4694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4695 
 
4696 
  def __eq__(self, other):
4697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4698 
 
4699 
  def __ne__(self, other):
4700 
    return not (self == other)
4701 
 
559 chandransh 4702 
class getUserById_result:
94 ashish 4703 
  """
4704 
  Attributes:
4705 
   - success
559 chandransh 4706 
   - ucex
94 ashish 4707 
  """
4708 
 
4709 
  thrift_spec = (
559 chandransh 4710 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4711 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4712 
  )
4713 
 
559 chandransh 4714 
  def __init__(self, success=None, ucex=None,):
94 ashish 4715 
    self.success = success
559 chandransh 4716 
    self.ucex = ucex
94 ashish 4717 
 
4718 
  def read(self, iprot):
4719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4721 
      return
4722 
    iprot.readStructBegin()
4723 
    while True:
4724 
      (fname, ftype, fid) = iprot.readFieldBegin()
4725 
      if ftype == TType.STOP:
4726 
        break
4727 
      if fid == 0:
4728 
        if ftype == TType.STRUCT:
559 chandransh 4729 
          self.success = User()
94 ashish 4730 
          self.success.read(iprot)
4731 
        else:
4732 
          iprot.skip(ftype)
4733 
      elif fid == 1:
4734 
        if ftype == TType.STRUCT:
559 chandransh 4735 
          self.ucex = UserContextException()
4736 
          self.ucex.read(iprot)
94 ashish 4737 
        else:
4738 
          iprot.skip(ftype)
4739 
      else:
4740 
        iprot.skip(ftype)
4741 
      iprot.readFieldEnd()
4742 
    iprot.readStructEnd()
4743 
 
4744 
  def write(self, oprot):
4745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4747 
      return
559 chandransh 4748 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4749 
    if self.success is not None:
94 ashish 4750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4751 
      self.success.write(oprot)
4752 
      oprot.writeFieldEnd()
3431 rajveer 4753 
    if self.ucex is not None:
559 chandransh 4754 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4755 
      self.ucex.write(oprot)
94 ashish 4756 
      oprot.writeFieldEnd()
4757 
    oprot.writeFieldStop()
4758 
    oprot.writeStructEnd()
4759 
 
3431 rajveer 4760 
  def validate(self):
4761 
    return
4762 
 
4763 
 
94 ashish 4764 
  def __repr__(self):
4765 
    L = ['%s=%r' % (key, value)
4766 
      for key, value in self.__dict__.iteritems()]
4767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4768 
 
4769 
  def __eq__(self, other):
4770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4771 
 
4772 
  def __ne__(self, other):
4773 
    return not (self == other)
4774 
 
5326 rajveer 4775 
class getUserByCartId_args:
1491 vikas 4776 
  """
4777 
  Attributes:
5326 rajveer 4778 
   - cartId
1491 vikas 4779 
  """
4780 
 
4781 
  thrift_spec = (
4782 
    None, # 0
5326 rajveer 4783 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4784 
  )
4785 
 
5326 rajveer 4786 
  def __init__(self, cartId=None,):
4787 
    self.cartId = cartId
1491 vikas 4788 
 
4789 
  def read(self, iprot):
4790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4792 
      return
4793 
    iprot.readStructBegin()
4794 
    while True:
4795 
      (fname, ftype, fid) = iprot.readFieldBegin()
4796 
      if ftype == TType.STOP:
4797 
        break
4798 
      if fid == 1:
5326 rajveer 4799 
        if ftype == TType.I64:
4800 
          self.cartId = iprot.readI64();
1491 vikas 4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      else:
4804 
        iprot.skip(ftype)
4805 
      iprot.readFieldEnd()
4806 
    iprot.readStructEnd()
4807 
 
4808 
  def write(self, oprot):
4809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4811 
      return
5326 rajveer 4812 
    oprot.writeStructBegin('getUserByCartId_args')
4813 
    if self.cartId is not None:
4814 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4815 
      oprot.writeI64(self.cartId)
1491 vikas 4816 
      oprot.writeFieldEnd()
4817 
    oprot.writeFieldStop()
4818 
    oprot.writeStructEnd()
4819 
 
3431 rajveer 4820 
  def validate(self):
4821 
    return
4822 
 
4823 
 
1491 vikas 4824 
  def __repr__(self):
4825 
    L = ['%s=%r' % (key, value)
4826 
      for key, value in self.__dict__.iteritems()]
4827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4828 
 
4829 
  def __eq__(self, other):
4830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4831 
 
4832 
  def __ne__(self, other):
4833 
    return not (self == other)
4834 
 
5326 rajveer 4835 
class getUserByCartId_result:
1491 vikas 4836 
  """
4837 
  Attributes:
4838 
   - success
4839 
   - ucex
4840 
  """
4841 
 
4842 
  thrift_spec = (
4843 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4844 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4845 
  )
4846 
 
4847 
  def __init__(self, success=None, ucex=None,):
4848 
    self.success = success
4849 
    self.ucex = ucex
4850 
 
4851 
  def read(self, iprot):
4852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4854 
      return
4855 
    iprot.readStructBegin()
4856 
    while True:
4857 
      (fname, ftype, fid) = iprot.readFieldBegin()
4858 
      if ftype == TType.STOP:
4859 
        break
4860 
      if fid == 0:
4861 
        if ftype == TType.STRUCT:
4862 
          self.success = User()
4863 
          self.success.read(iprot)
4864 
        else:
4865 
          iprot.skip(ftype)
4866 
      elif fid == 1:
4867 
        if ftype == TType.STRUCT:
4868 
          self.ucex = UserContextException()
4869 
          self.ucex.read(iprot)
4870 
        else:
4871 
          iprot.skip(ftype)
4872 
      else:
4873 
        iprot.skip(ftype)
4874 
      iprot.readFieldEnd()
4875 
    iprot.readStructEnd()
4876 
 
4877 
  def write(self, oprot):
4878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4880 
      return
5326 rajveer 4881 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 4882 
    if self.success is not None:
1491 vikas 4883 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4884 
      self.success.write(oprot)
4885 
      oprot.writeFieldEnd()
3431 rajveer 4886 
    if self.ucex is not None:
1491 vikas 4887 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4888 
      self.ucex.write(oprot)
4889 
      oprot.writeFieldEnd()
4890 
    oprot.writeFieldStop()
4891 
    oprot.writeStructEnd()
4892 
 
3431 rajveer 4893 
  def validate(self):
4894 
    return
4895 
 
4896 
 
1491 vikas 4897 
  def __repr__(self):
4898 
    L = ['%s=%r' % (key, value)
4899 
      for key, value in self.__dict__.iteritems()]
4900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4901 
 
4902 
  def __eq__(self, other):
4903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4904 
 
4905 
  def __ne__(self, other):
4906 
    return not (self == other)
4907 
 
5326 rajveer 4908 
class getUserByEmail_args:
3032 mandeep.dh 4909 
  """
4910 
  Attributes:
5326 rajveer 4911 
   - email
3032 mandeep.dh 4912 
  """
4913 
 
4914 
  thrift_spec = (
4915 
    None, # 0
5326 rajveer 4916 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 4917 
  )
4918 
 
5326 rajveer 4919 
  def __init__(self, email=None,):
4920 
    self.email = email
3032 mandeep.dh 4921 
 
4922 
  def read(self, iprot):
4923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4925 
      return
4926 
    iprot.readStructBegin()
4927 
    while True:
4928 
      (fname, ftype, fid) = iprot.readFieldBegin()
4929 
      if ftype == TType.STOP:
4930 
        break
4931 
      if fid == 1:
5326 rajveer 4932 
        if ftype == TType.STRING:
4933 
          self.email = iprot.readString();
3032 mandeep.dh 4934 
        else:
4935 
          iprot.skip(ftype)
4936 
      else:
4937 
        iprot.skip(ftype)
4938 
      iprot.readFieldEnd()
4939 
    iprot.readStructEnd()
4940 
 
4941 
  def write(self, oprot):
4942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4944 
      return
5326 rajveer 4945 
    oprot.writeStructBegin('getUserByEmail_args')
4946 
    if self.email is not None:
4947 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4948 
      oprot.writeString(self.email)
3032 mandeep.dh 4949 
      oprot.writeFieldEnd()
4950 
    oprot.writeFieldStop()
4951 
    oprot.writeStructEnd()
4952 
 
3431 rajveer 4953 
  def validate(self):
4954 
    return
4955 
 
4956 
 
3032 mandeep.dh 4957 
  def __repr__(self):
4958 
    L = ['%s=%r' % (key, value)
4959 
      for key, value in self.__dict__.iteritems()]
4960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4961 
 
4962 
  def __eq__(self, other):
4963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4964 
 
4965 
  def __ne__(self, other):
4966 
    return not (self == other)
4967 
 
5326 rajveer 4968 
class getUserByEmail_result:
3032 mandeep.dh 4969 
  """
4970 
  Attributes:
4971 
   - success
4972 
   - ucex
4973 
  """
4974 
 
4975 
  thrift_spec = (
4976 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4977 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4978 
  )
4979 
 
4980 
  def __init__(self, success=None, ucex=None,):
4981 
    self.success = success
4982 
    self.ucex = ucex
4983 
 
4984 
  def read(self, iprot):
4985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4987 
      return
4988 
    iprot.readStructBegin()
4989 
    while True:
4990 
      (fname, ftype, fid) = iprot.readFieldBegin()
4991 
      if ftype == TType.STOP:
4992 
        break
4993 
      if fid == 0:
4994 
        if ftype == TType.STRUCT:
4995 
          self.success = User()
4996 
          self.success.read(iprot)
4997 
        else:
4998 
          iprot.skip(ftype)
4999 
      elif fid == 1:
5000 
        if ftype == TType.STRUCT:
5001 
          self.ucex = UserContextException()
5002 
          self.ucex.read(iprot)
5003 
        else:
5004 
          iprot.skip(ftype)
5005 
      else:
5006 
        iprot.skip(ftype)
5007 
      iprot.readFieldEnd()
5008 
    iprot.readStructEnd()
5009 
 
5010 
  def write(self, oprot):
5011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5013 
      return
5326 rajveer 5014 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5015 
    if self.success is not None:
3032 mandeep.dh 5016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5017 
      self.success.write(oprot)
5018 
      oprot.writeFieldEnd()
3431 rajveer 5019 
    if self.ucex is not None:
3032 mandeep.dh 5020 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5021 
      self.ucex.write(oprot)
5022 
      oprot.writeFieldEnd()
5023 
    oprot.writeFieldStop()
5024 
    oprot.writeStructEnd()
5025 
 
3431 rajveer 5026 
  def validate(self):
5027 
    return
5028 
 
5029 
 
3032 mandeep.dh 5030 
  def __repr__(self):
5031 
    L = ['%s=%r' % (key, value)
5032 
      for key, value in self.__dict__.iteritems()]
5033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5034 
 
5035 
  def __eq__(self, other):
5036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5037 
 
5038 
  def __ne__(self, other):
5039 
    return not (self == other)
5040 
 
5326 rajveer 5041 
class getUserByMobileNumber_args:
94 ashish 5042 
  """
5043 
  Attributes:
5326 rajveer 5044 
   - mobileNumber
94 ashish 5045 
  """
5046 
 
5047 
  thrift_spec = (
5048 
    None, # 0
5326 rajveer 5049 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5050 
  )
5051 
 
5326 rajveer 5052 
  def __init__(self, mobileNumber=None,):
5053 
    self.mobileNumber = mobileNumber
94 ashish 5054 
 
5055 
  def read(self, iprot):
5056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5058 
      return
5059 
    iprot.readStructBegin()
5060 
    while True:
5061 
      (fname, ftype, fid) = iprot.readFieldBegin()
5062 
      if ftype == TType.STOP:
5063 
        break
5064 
      if fid == 1:
5326 rajveer 5065 
        if ftype == TType.I64:
5066 
          self.mobileNumber = iprot.readI64();
94 ashish 5067 
        else:
5068 
          iprot.skip(ftype)
5069 
      else:
5070 
        iprot.skip(ftype)
5071 
      iprot.readFieldEnd()
5072 
    iprot.readStructEnd()
5073 
 
5074 
  def write(self, oprot):
5075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5077 
      return
5326 rajveer 5078 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5079 
    if self.mobileNumber is not None:
5080 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5081 
      oprot.writeI64(self.mobileNumber)
94 ashish 5082 
      oprot.writeFieldEnd()
5083 
    oprot.writeFieldStop()
5084 
    oprot.writeStructEnd()
5085 
 
3431 rajveer 5086 
  def validate(self):
5087 
    return
5088 
 
5089 
 
94 ashish 5090 
  def __repr__(self):
5091 
    L = ['%s=%r' % (key, value)
5092 
      for key, value in self.__dict__.iteritems()]
5093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5094 
 
5095 
  def __eq__(self, other):
5096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5097 
 
5098 
  def __ne__(self, other):
5099 
    return not (self == other)
5100 
 
5326 rajveer 5101 
class getUserByMobileNumber_result:
94 ashish 5102 
  """
5103 
  Attributes:
5104 
   - success
559 chandransh 5105 
   - ucex
94 ashish 5106 
  """
5107 
 
5108 
  thrift_spec = (
559 chandransh 5109 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5110 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5111 
  )
5112 
 
559 chandransh 5113 
  def __init__(self, success=None, ucex=None,):
94 ashish 5114 
    self.success = success
559 chandransh 5115 
    self.ucex = ucex
94 ashish 5116 
 
5117 
  def read(self, iprot):
5118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5120 
      return
5121 
    iprot.readStructBegin()
5122 
    while True:
5123 
      (fname, ftype, fid) = iprot.readFieldBegin()
5124 
      if ftype == TType.STOP:
5125 
        break
5126 
      if fid == 0:
5127 
        if ftype == TType.STRUCT:
559 chandransh 5128 
          self.success = User()
94 ashish 5129 
          self.success.read(iprot)
5130 
        else:
5131 
          iprot.skip(ftype)
5132 
      elif fid == 1:
5133 
        if ftype == TType.STRUCT:
559 chandransh 5134 
          self.ucex = UserContextException()
5135 
          self.ucex.read(iprot)
94 ashish 5136 
        else:
5137 
          iprot.skip(ftype)
5138 
      else:
5139 
        iprot.skip(ftype)
5140 
      iprot.readFieldEnd()
5141 
    iprot.readStructEnd()
5142 
 
5143 
  def write(self, oprot):
5144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5146 
      return
5326 rajveer 5147 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5148 
    if self.success is not None:
94 ashish 5149 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5150 
      self.success.write(oprot)
5151 
      oprot.writeFieldEnd()
3431 rajveer 5152 
    if self.ucex is not None:
559 chandransh 5153 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5154 
      self.ucex.write(oprot)
94 ashish 5155 
      oprot.writeFieldEnd()
5156 
    oprot.writeFieldStop()
5157 
    oprot.writeStructEnd()
5158 
 
3431 rajveer 5159 
  def validate(self):
5160 
    return
5161 
 
5162 
 
94 ashish 5163 
  def __repr__(self):
5164 
    L = ['%s=%r' % (key, value)
5165 
      for key, value in self.__dict__.iteritems()]
5166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5167 
 
5168 
  def __eq__(self, other):
5169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5170 
 
5171 
  def __ne__(self, other):
5172 
    return not (self == other)
5173 
 
5326 rajveer 5174 
class createUser_args:
94 ashish 5175 
  """
5176 
  Attributes:
559 chandransh 5177 
   - user
94 ashish 5178 
  """
5179 
 
5180 
  thrift_spec = (
5181 
    None, # 0
559 chandransh 5182 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5183 
  )
5184 
 
559 chandransh 5185 
  def __init__(self, user=None,):
5186 
    self.user = user
94 ashish 5187 
 
5188 
  def read(self, iprot):
5189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5191 
      return
5192 
    iprot.readStructBegin()
5193 
    while True:
5194 
      (fname, ftype, fid) = iprot.readFieldBegin()
5195 
      if ftype == TType.STOP:
5196 
        break
5197 
      if fid == 1:
559 chandransh 5198 
        if ftype == TType.STRUCT:
5199 
          self.user = User()
5200 
          self.user.read(iprot)
94 ashish 5201 
        else:
5202 
          iprot.skip(ftype)
5203 
      else:
5204 
        iprot.skip(ftype)
5205 
      iprot.readFieldEnd()
5206 
    iprot.readStructEnd()
5207 
 
5208 
  def write(self, oprot):
5209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5211 
      return
5326 rajveer 5212 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5213 
    if self.user is not None:
559 chandransh 5214 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5215 
      self.user.write(oprot)
94 ashish 5216 
      oprot.writeFieldEnd()
5217 
    oprot.writeFieldStop()
5218 
    oprot.writeStructEnd()
5219 
 
3431 rajveer 5220 
  def validate(self):
5221 
    return
5222 
 
5223 
 
94 ashish 5224 
  def __repr__(self):
5225 
    L = ['%s=%r' % (key, value)
5226 
      for key, value in self.__dict__.iteritems()]
5227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5228 
 
5229 
  def __eq__(self, other):
5230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5231 
 
5232 
  def __ne__(self, other):
5233 
    return not (self == other)
5234 
 
5326 rajveer 5235 
class createUser_result:
94 ashish 5236 
  """
5237 
  Attributes:
5238 
   - success
559 chandransh 5239 
   - ucex
94 ashish 5240 
  """
5241 
 
5242 
  thrift_spec = (
559 chandransh 5243 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5244 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5245 
  )
5246 
 
559 chandransh 5247 
  def __init__(self, success=None, ucex=None,):
94 ashish 5248 
    self.success = success
559 chandransh 5249 
    self.ucex = ucex
94 ashish 5250 
 
5251 
  def read(self, iprot):
5252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5254 
      return
5255 
    iprot.readStructBegin()
5256 
    while True:
5257 
      (fname, ftype, fid) = iprot.readFieldBegin()
5258 
      if ftype == TType.STOP:
5259 
        break
5260 
      if fid == 0:
5261 
        if ftype == TType.STRUCT:
559 chandransh 5262 
          self.success = User()
94 ashish 5263 
          self.success.read(iprot)
5264 
        else:
5265 
          iprot.skip(ftype)
5266 
      elif fid == 1:
5267 
        if ftype == TType.STRUCT:
559 chandransh 5268 
          self.ucex = UserContextException()
5269 
          self.ucex.read(iprot)
94 ashish 5270 
        else:
5271 
          iprot.skip(ftype)
5272 
      else:
5273 
        iprot.skip(ftype)
5274 
      iprot.readFieldEnd()
5275 
    iprot.readStructEnd()
5276 
 
5277 
  def write(self, oprot):
5278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5280 
      return
5326 rajveer 5281 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5282 
    if self.success is not None:
94 ashish 5283 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5284 
      self.success.write(oprot)
5285 
      oprot.writeFieldEnd()
3431 rajveer 5286 
    if self.ucex is not None:
559 chandransh 5287 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5288 
      self.ucex.write(oprot)
94 ashish 5289 
      oprot.writeFieldEnd()
5290 
    oprot.writeFieldStop()
5291 
    oprot.writeStructEnd()
5292 
 
3431 rajveer 5293 
  def validate(self):
5294 
    return
5295 
 
5296 
 
94 ashish 5297 
  def __repr__(self):
5298 
    L = ['%s=%r' % (key, value)
5299 
      for key, value in self.__dict__.iteritems()]
5300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5301 
 
5302 
  def __eq__(self, other):
5303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5304 
 
5305 
  def __ne__(self, other):
5306 
    return not (self == other)
5307 
 
5326 rajveer 5308 
class updateUser_args:
94 ashish 5309 
  """
5310 
  Attributes:
5326 rajveer 5311 
   - user
94 ashish 5312 
  """
5313 
 
5314 
  thrift_spec = (
5315 
    None, # 0
5326 rajveer 5316 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5317 
  )
5318 
 
5326 rajveer 5319 
  def __init__(self, user=None,):
5320 
    self.user = user
94 ashish 5321 
 
5322 
  def read(self, iprot):
5323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5325 
      return
5326 
    iprot.readStructBegin()
5327 
    while True:
5328 
      (fname, ftype, fid) = iprot.readFieldBegin()
5329 
      if ftype == TType.STOP:
5330 
        break
5331 
      if fid == 1:
5326 rajveer 5332 
        if ftype == TType.STRUCT:
5333 
          self.user = User()
5334 
          self.user.read(iprot)
94 ashish 5335 
        else:
5336 
          iprot.skip(ftype)
5337 
      else:
5338 
        iprot.skip(ftype)
5339 
      iprot.readFieldEnd()
5340 
    iprot.readStructEnd()
5341 
 
5342 
  def write(self, oprot):
5343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5345 
      return
5326 rajveer 5346 
    oprot.writeStructBegin('updateUser_args')
5347 
    if self.user is not None:
5348 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5349 
      self.user.write(oprot)
94 ashish 5350 
      oprot.writeFieldEnd()
5351 
    oprot.writeFieldStop()
5352 
    oprot.writeStructEnd()
5353 
 
3431 rajveer 5354 
  def validate(self):
5355 
    return
5356 
 
5357 
 
94 ashish 5358 
  def __repr__(self):
5359 
    L = ['%s=%r' % (key, value)
5360 
      for key, value in self.__dict__.iteritems()]
5361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5362 
 
5363 
  def __eq__(self, other):
5364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5365 
 
5366 
  def __ne__(self, other):
5367 
    return not (self == other)
5368 
 
5326 rajveer 5369 
class updateUser_result:
94 ashish 5370 
  """
5371 
  Attributes:
5372 
   - success
559 chandransh 5373 
   - ucex
94 ashish 5374 
  """
5375 
 
5376 
  thrift_spec = (
5326 rajveer 5377 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5378 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5379 
  )
5380 
 
559 chandransh 5381 
  def __init__(self, success=None, ucex=None,):
94 ashish 5382 
    self.success = success
559 chandransh 5383 
    self.ucex = ucex
94 ashish 5384 
 
5385 
  def read(self, iprot):
5386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5388 
      return
5389 
    iprot.readStructBegin()
5390 
    while True:
5391 
      (fname, ftype, fid) = iprot.readFieldBegin()
5392 
      if ftype == TType.STOP:
5393 
        break
5394 
      if fid == 0:
5326 rajveer 5395 
        if ftype == TType.STRUCT:
5396 
          self.success = User()
5397 
          self.success.read(iprot)
94 ashish 5398 
        else:
5399 
          iprot.skip(ftype)
5400 
      elif fid == 1:
5401 
        if ftype == TType.STRUCT:
559 chandransh 5402 
          self.ucex = UserContextException()
5403 
          self.ucex.read(iprot)
94 ashish 5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      else:
5407 
        iprot.skip(ftype)
5408 
      iprot.readFieldEnd()
5409 
    iprot.readStructEnd()
5410 
 
5411 
  def write(self, oprot):
5412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5414 
      return
5326 rajveer 5415 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5416 
    if self.success is not None:
5326 rajveer 5417 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5418 
      self.success.write(oprot)
94 ashish 5419 
      oprot.writeFieldEnd()
3431 rajveer 5420 
    if self.ucex is not None:
559 chandransh 5421 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5422 
      self.ucex.write(oprot)
94 ashish 5423 
      oprot.writeFieldEnd()
5424 
    oprot.writeFieldStop()
5425 
    oprot.writeStructEnd()
5426 
 
3431 rajveer 5427 
  def validate(self):
5428 
    return
5429 
 
5430 
 
94 ashish 5431 
  def __repr__(self):
5432 
    L = ['%s=%r' % (key, value)
5433 
      for key, value in self.__dict__.iteritems()]
5434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5435 
 
5436 
  def __eq__(self, other):
5437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5438 
 
5439 
  def __ne__(self, other):
5440 
    return not (self == other)
5441 
 
559 chandransh 5442 
class authenticateUser_args:
94 ashish 5443 
  """
5444 
  Attributes:
5445 
   - email
5446 
   - password
5447 
  """
5448 
 
5449 
  thrift_spec = (
5450 
    None, # 0
5451 
    (1, TType.STRING, 'email', None, None, ), # 1
5452 
    (2, TType.STRING, 'password', None, None, ), # 2
5453 
  )
5454 
 
5455 
  def __init__(self, email=None, password=None,):
5456 
    self.email = email
5457 
    self.password = password
5458 
 
5459 
  def read(self, iprot):
5460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5462 
      return
5463 
    iprot.readStructBegin()
5464 
    while True:
5465 
      (fname, ftype, fid) = iprot.readFieldBegin()
5466 
      if ftype == TType.STOP:
5467 
        break
5468 
      if fid == 1:
5469 
        if ftype == TType.STRING:
5470 
          self.email = iprot.readString();
5471 
        else:
5472 
          iprot.skip(ftype)
5473 
      elif fid == 2:
5474 
        if ftype == TType.STRING:
5475 
          self.password = iprot.readString();
5476 
        else:
5477 
          iprot.skip(ftype)
5478 
      else:
5479 
        iprot.skip(ftype)
5480 
      iprot.readFieldEnd()
5481 
    iprot.readStructEnd()
5482 
 
5483 
  def write(self, oprot):
5484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5486 
      return
559 chandransh 5487 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5488 
    if self.email is not None:
94 ashish 5489 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5490 
      oprot.writeString(self.email)
5491 
      oprot.writeFieldEnd()
3431 rajveer 5492 
    if self.password is not None:
94 ashish 5493 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5494 
      oprot.writeString(self.password)
5495 
      oprot.writeFieldEnd()
5496 
    oprot.writeFieldStop()
5497 
    oprot.writeStructEnd()
5498 
 
3431 rajveer 5499 
  def validate(self):
5500 
    return
5501 
 
5502 
 
94 ashish 5503 
  def __repr__(self):
5504 
    L = ['%s=%r' % (key, value)
5505 
      for key, value in self.__dict__.iteritems()]
5506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5507 
 
5508 
  def __eq__(self, other):
5509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5510 
 
5511 
  def __ne__(self, other):
5512 
    return not (self == other)
5513 
 
559 chandransh 5514 
class authenticateUser_result:
94 ashish 5515 
  """
5516 
  Attributes:
5517 
   - success
559 chandransh 5518 
   - auex
94 ashish 5519 
  """
5520 
 
5521 
  thrift_spec = (
559 chandransh 5522 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5523 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5524 
  )
5525 
 
559 chandransh 5526 
  def __init__(self, success=None, auex=None,):
94 ashish 5527 
    self.success = success
559 chandransh 5528 
    self.auex = auex
94 ashish 5529 
 
5530 
  def read(self, iprot):
5531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5533 
      return
5534 
    iprot.readStructBegin()
5535 
    while True:
5536 
      (fname, ftype, fid) = iprot.readFieldBegin()
5537 
      if ftype == TType.STOP:
5538 
        break
5539 
      if fid == 0:
5540 
        if ftype == TType.STRUCT:
559 chandransh 5541 
          self.success = User()
94 ashish 5542 
          self.success.read(iprot)
5543 
        else:
5544 
          iprot.skip(ftype)
5545 
      elif fid == 1:
5546 
        if ftype == TType.STRUCT:
559 chandransh 5547 
          self.auex = AuthenticationException()
5548 
          self.auex.read(iprot)
94 ashish 5549 
        else:
5550 
          iprot.skip(ftype)
5551 
      else:
5552 
        iprot.skip(ftype)
5553 
      iprot.readFieldEnd()
5554 
    iprot.readStructEnd()
5555 
 
5556 
  def write(self, oprot):
5557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5559 
      return
559 chandransh 5560 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5561 
    if self.success is not None:
94 ashish 5562 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5563 
      self.success.write(oprot)
5564 
      oprot.writeFieldEnd()
3431 rajveer 5565 
    if self.auex is not None:
559 chandransh 5566 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5567 
      self.auex.write(oprot)
94 ashish 5568 
      oprot.writeFieldEnd()
5569 
    oprot.writeFieldStop()
5570 
    oprot.writeStructEnd()
5571 
 
3431 rajveer 5572 
  def validate(self):
5573 
    return
5574 
 
5575 
 
94 ashish 5576 
  def __repr__(self):
5577 
    L = ['%s=%r' % (key, value)
5578 
      for key, value in self.__dict__.iteritems()]
5579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5580 
 
5581 
  def __eq__(self, other):
5582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5583 
 
5584 
  def __ne__(self, other):
5585 
    return not (self == other)
5586 
 
559 chandransh 5587 
class userExists_args:
122 ashish 5588 
  """
5589 
  Attributes:
559 chandransh 5590 
   - email
122 ashish 5591 
  """
5592 
 
5593 
  thrift_spec = (
5594 
    None, # 0
559 chandransh 5595 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5596 
  )
5597 
 
559 chandransh 5598 
  def __init__(self, email=None,):
5599 
    self.email = email
122 ashish 5600 
 
5601 
  def read(self, iprot):
5602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5604 
      return
5605 
    iprot.readStructBegin()
5606 
    while True:
5607 
      (fname, ftype, fid) = iprot.readFieldBegin()
5608 
      if ftype == TType.STOP:
5609 
        break
5610 
      if fid == 1:
5611 
        if ftype == TType.STRING:
559 chandransh 5612 
          self.email = iprot.readString();
122 ashish 5613 
        else:
5614 
          iprot.skip(ftype)
559 chandransh 5615 
      else:
5616 
        iprot.skip(ftype)
5617 
      iprot.readFieldEnd()
5618 
    iprot.readStructEnd()
5619 
 
5620 
  def write(self, oprot):
5621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5623 
      return
5624 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5625 
    if self.email is not None:
559 chandransh 5626 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5627 
      oprot.writeString(self.email)
5628 
      oprot.writeFieldEnd()
5629 
    oprot.writeFieldStop()
5630 
    oprot.writeStructEnd()
5631 
 
3431 rajveer 5632 
  def validate(self):
5633 
    return
5634 
 
5635 
 
559 chandransh 5636 
  def __repr__(self):
5637 
    L = ['%s=%r' % (key, value)
5638 
      for key, value in self.__dict__.iteritems()]
5639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5640 
 
5641 
  def __eq__(self, other):
5642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5643 
 
5644 
  def __ne__(self, other):
5645 
    return not (self == other)
5646 
 
5647 
class userExists_result:
5648 
  """
5649 
  Attributes:
5650 
   - success
5651 
   - ucx
5652 
  """
5653 
 
5654 
  thrift_spec = (
5655 
    (0, TType.BOOL, 'success', None, None, ), # 0
5656 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5657 
  )
5658 
 
5659 
  def __init__(self, success=None, ucx=None,):
5660 
    self.success = success
5661 
    self.ucx = ucx
5662 
 
5663 
  def read(self, iprot):
5664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5666 
      return
5667 
    iprot.readStructBegin()
5668 
    while True:
5669 
      (fname, ftype, fid) = iprot.readFieldBegin()
5670 
      if ftype == TType.STOP:
5671 
        break
5672 
      if fid == 0:
5673 
        if ftype == TType.BOOL:
5674 
          self.success = iprot.readBool();
5675 
        else:
5676 
          iprot.skip(ftype)
5677 
      elif fid == 1:
5678 
        if ftype == TType.STRUCT:
5679 
          self.ucx = UserContextException()
5680 
          self.ucx.read(iprot)
5681 
        else:
5682 
          iprot.skip(ftype)
5683 
      else:
5684 
        iprot.skip(ftype)
5685 
      iprot.readFieldEnd()
5686 
    iprot.readStructEnd()
5687 
 
5688 
  def write(self, oprot):
5689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5691 
      return
5692 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5693 
    if self.success is not None:
559 chandransh 5694 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5695 
      oprot.writeBool(self.success)
5696 
      oprot.writeFieldEnd()
3431 rajveer 5697 
    if self.ucx is not None:
559 chandransh 5698 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5699 
      self.ucx.write(oprot)
5700 
      oprot.writeFieldEnd()
5701 
    oprot.writeFieldStop()
5702 
    oprot.writeStructEnd()
5703 
 
3431 rajveer 5704 
  def validate(self):
5705 
    return
5706 
 
5707 
 
559 chandransh 5708 
  def __repr__(self):
5709 
    L = ['%s=%r' % (key, value)
5710 
      for key, value in self.__dict__.iteritems()]
5711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5712 
 
5713 
  def __eq__(self, other):
5714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5715 
 
5716 
  def __ne__(self, other):
5717 
    return not (self == other)
5718 
 
5719 
class addAddressForUser_args:
5720 
  """
5721 
  Attributes:
5722 
   - userId
5723 
   - address
5724 
   - setDefault
5725 
  """
5726 
 
5727 
  thrift_spec = (
5728 
    None, # 0
5729 
    (1, TType.I64, 'userId', None, None, ), # 1
5730 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5731 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5732 
  )
5733 
 
567 rajveer 5734 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5735 
    self.userId = userId
5736 
    self.address = address
5737 
    self.setDefault = setDefault
5738 
 
5739 
  def read(self, iprot):
5740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5742 
      return
5743 
    iprot.readStructBegin()
5744 
    while True:
5745 
      (fname, ftype, fid) = iprot.readFieldBegin()
5746 
      if ftype == TType.STOP:
5747 
        break
5748 
      if fid == 1:
5749 
        if ftype == TType.I64:
5750 
          self.userId = iprot.readI64();
5751 
        else:
5752 
          iprot.skip(ftype)
122 ashish 5753 
      elif fid == 2:
559 chandransh 5754 
        if ftype == TType.STRUCT:
5755 
          self.address = Address()
5756 
          self.address.read(iprot)
122 ashish 5757 
        else:
5758 
          iprot.skip(ftype)
5759 
      elif fid == 3:
5760 
        if ftype == TType.BOOL:
559 chandransh 5761 
          self.setDefault = iprot.readBool();
122 ashish 5762 
        else:
5763 
          iprot.skip(ftype)
5764 
      else:
5765 
        iprot.skip(ftype)
5766 
      iprot.readFieldEnd()
5767 
    iprot.readStructEnd()
5768 
 
5769 
  def write(self, oprot):
5770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5772 
      return
559 chandransh 5773 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5774 
    if self.userId is not None:
559 chandransh 5775 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5776 
      oprot.writeI64(self.userId)
122 ashish 5777 
      oprot.writeFieldEnd()
3431 rajveer 5778 
    if self.address is not None:
559 chandransh 5779 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5780 
      self.address.write(oprot)
122 ashish 5781 
      oprot.writeFieldEnd()
3431 rajveer 5782 
    if self.setDefault is not None:
567 rajveer 5783 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5784 
      oprot.writeBool(self.setDefault)
5785 
      oprot.writeFieldEnd()
122 ashish 5786 
    oprot.writeFieldStop()
5787 
    oprot.writeStructEnd()
5788 
 
3431 rajveer 5789 
  def validate(self):
5790 
    return
5791 
 
5792 
 
122 ashish 5793 
  def __repr__(self):
5794 
    L = ['%s=%r' % (key, value)
5795 
      for key, value in self.__dict__.iteritems()]
5796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5797 
 
5798 
  def __eq__(self, other):
5799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5800 
 
5801 
  def __ne__(self, other):
5802 
    return not (self == other)
5803 
 
559 chandransh 5804 
class addAddressForUser_result:
122 ashish 5805 
  """
5806 
  Attributes:
5807 
   - success
559 chandransh 5808 
   - ucx
122 ashish 5809 
  """
5810 
 
5811 
  thrift_spec = (
567 rajveer 5812 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5813 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5814 
  )
5815 
 
559 chandransh 5816 
  def __init__(self, success=None, ucx=None,):
122 ashish 5817 
    self.success = success
559 chandransh 5818 
    self.ucx = ucx
122 ashish 5819 
 
5820 
  def read(self, iprot):
5821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5823 
      return
5824 
    iprot.readStructBegin()
5825 
    while True:
5826 
      (fname, ftype, fid) = iprot.readFieldBegin()
5827 
      if ftype == TType.STOP:
5828 
        break
5829 
      if fid == 0:
567 rajveer 5830 
        if ftype == TType.I64:
5831 
          self.success = iprot.readI64();
122 ashish 5832 
        else:
5833 
          iprot.skip(ftype)
5834 
      elif fid == 1:
5835 
        if ftype == TType.STRUCT:
559 chandransh 5836 
          self.ucx = UserContextException()
5837 
          self.ucx.read(iprot)
122 ashish 5838 
        else:
5839 
          iprot.skip(ftype)
5840 
      else:
5841 
        iprot.skip(ftype)
5842 
      iprot.readFieldEnd()
5843 
    iprot.readStructEnd()
5844 
 
5845 
  def write(self, oprot):
5846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5848 
      return
559 chandransh 5849 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 5850 
    if self.success is not None:
567 rajveer 5851 
      oprot.writeFieldBegin('success', TType.I64, 0)
5852 
      oprot.writeI64(self.success)
122 ashish 5853 
      oprot.writeFieldEnd()
3431 rajveer 5854 
    if self.ucx is not None:
559 chandransh 5855 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5856 
      self.ucx.write(oprot)
122 ashish 5857 
      oprot.writeFieldEnd()
5858 
    oprot.writeFieldStop()
5859 
    oprot.writeStructEnd()
5860 
 
3431 rajveer 5861 
  def validate(self):
5862 
    return
5863 
 
5864 
 
122 ashish 5865 
  def __repr__(self):
5866 
    L = ['%s=%r' % (key, value)
5867 
      for key, value in self.__dict__.iteritems()]
5868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5869 
 
5870 
  def __eq__(self, other):
5871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5872 
 
5873 
  def __ne__(self, other):
5874 
    return not (self == other)
5875 
 
559 chandransh 5876 
class removeAddressForUser_args:
94 ashish 5877 
  """
5878 
  Attributes:
559 chandransh 5879 
   - userid
5880 
   - addressId
94 ashish 5881 
  """
5882 
 
5883 
  thrift_spec = (
5884 
    None, # 0
559 chandransh 5885 
    (1, TType.I64, 'userid', None, None, ), # 1
5886 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5887 
  )
5888 
 
559 chandransh 5889 
  def __init__(self, userid=None, addressId=None,):
5890 
    self.userid = userid
5891 
    self.addressId = addressId
94 ashish 5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 1:
559 chandransh 5903 
        if ftype == TType.I64:
5904 
          self.userid = iprot.readI64();
94 ashish 5905 
        else:
5906 
          iprot.skip(ftype)
559 chandransh 5907 
      elif fid == 2:
5908 
        if ftype == TType.I64:
5909 
          self.addressId = iprot.readI64();
5910 
        else:
5911 
          iprot.skip(ftype)
94 ashish 5912 
      else:
5913 
        iprot.skip(ftype)
5914 
      iprot.readFieldEnd()
5915 
    iprot.readStructEnd()
5916 
 
5917 
  def write(self, oprot):
5918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5920 
      return
559 chandransh 5921 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 5922 
    if self.userid is not None:
559 chandransh 5923 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5924 
      oprot.writeI64(self.userid)
94 ashish 5925 
      oprot.writeFieldEnd()
3431 rajveer 5926 
    if self.addressId is not None:
559 chandransh 5927 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5928 
      oprot.writeI64(self.addressId)
5929 
      oprot.writeFieldEnd()
94 ashish 5930 
    oprot.writeFieldStop()
5931 
    oprot.writeStructEnd()
5932 
 
3431 rajveer 5933 
  def validate(self):
5934 
    return
5935 
 
5936 
 
94 ashish 5937 
  def __repr__(self):
5938 
    L = ['%s=%r' % (key, value)
5939 
      for key, value in self.__dict__.iteritems()]
5940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5941 
 
5942 
  def __eq__(self, other):
5943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5944 
 
5945 
  def __ne__(self, other):
5946 
    return not (self == other)
5947 
 
559 chandransh 5948 
class removeAddressForUser_result:
94 ashish 5949 
  """
5950 
  Attributes:
5951 
   - success
5952 
   - ucx
5953 
  """
5954 
 
5955 
  thrift_spec = (
5956 
    (0, TType.BOOL, 'success', None, None, ), # 0
5957 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5958 
  )
5959 
 
5960 
  def __init__(self, success=None, ucx=None,):
5961 
    self.success = success
5962 
    self.ucx = ucx
5963 
 
5964 
  def read(self, iprot):
5965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5967 
      return
5968 
    iprot.readStructBegin()
5969 
    while True:
5970 
      (fname, ftype, fid) = iprot.readFieldBegin()
5971 
      if ftype == TType.STOP:
5972 
        break
5973 
      if fid == 0:
5974 
        if ftype == TType.BOOL:
5975 
          self.success = iprot.readBool();
5976 
        else:
5977 
          iprot.skip(ftype)
5978 
      elif fid == 1:
5979 
        if ftype == TType.STRUCT:
5980 
          self.ucx = UserContextException()
5981 
          self.ucx.read(iprot)
5982 
        else:
5983 
          iprot.skip(ftype)
5984 
      else:
5985 
        iprot.skip(ftype)
5986 
      iprot.readFieldEnd()
5987 
    iprot.readStructEnd()
5988 
 
5989 
  def write(self, oprot):
5990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5992 
      return
559 chandransh 5993 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 5994 
    if self.success is not None:
94 ashish 5995 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5996 
      oprot.writeBool(self.success)
5997 
      oprot.writeFieldEnd()
3431 rajveer 5998 
    if self.ucx is not None:
94 ashish 5999 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6000 
      self.ucx.write(oprot)
6001 
      oprot.writeFieldEnd()
6002 
    oprot.writeFieldStop()
6003 
    oprot.writeStructEnd()
6004 
 
3431 rajveer 6005 
  def validate(self):
6006 
    return
6007 
 
6008 
 
94 ashish 6009 
  def __repr__(self):
6010 
    L = ['%s=%r' % (key, value)
6011 
      for key, value in self.__dict__.iteritems()]
6012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6013 
 
6014 
  def __eq__(self, other):
6015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6016 
 
6017 
  def __ne__(self, other):
6018 
    return not (self == other)
6019 
 
559 chandransh 6020 
class setUserAsLoggedIn_args:
94 ashish 6021 
  """
6022 
  Attributes:
559 chandransh 6023 
   - userId
94 ashish 6024 
   - timestamp
6025 
  """
6026 
 
6027 
  thrift_spec = (
6028 
    None, # 0
559 chandransh 6029 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6030 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6031 
  )
6032 
 
559 chandransh 6033 
  def __init__(self, userId=None, timestamp=None,):
6034 
    self.userId = userId
94 ashish 6035 
    self.timestamp = timestamp
6036 
 
6037 
  def read(self, iprot):
6038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6040 
      return
6041 
    iprot.readStructBegin()
6042 
    while True:
6043 
      (fname, ftype, fid) = iprot.readFieldBegin()
6044 
      if ftype == TType.STOP:
6045 
        break
6046 
      if fid == 1:
559 chandransh 6047 
        if ftype == TType.I64:
6048 
          self.userId = iprot.readI64();
94 ashish 6049 
        else:
6050 
          iprot.skip(ftype)
6051 
      elif fid == 2:
6052 
        if ftype == TType.I64:
6053 
          self.timestamp = iprot.readI64();
6054 
        else:
6055 
          iprot.skip(ftype)
6056 
      else:
6057 
        iprot.skip(ftype)
6058 
      iprot.readFieldEnd()
6059 
    iprot.readStructEnd()
6060 
 
6061 
  def write(self, oprot):
6062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6064 
      return
559 chandransh 6065 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6066 
    if self.userId is not None:
559 chandransh 6067 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6068 
      oprot.writeI64(self.userId)
94 ashish 6069 
      oprot.writeFieldEnd()
3431 rajveer 6070 
    if self.timestamp is not None:
94 ashish 6071 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6072 
      oprot.writeI64(self.timestamp)
6073 
      oprot.writeFieldEnd()
6074 
    oprot.writeFieldStop()
6075 
    oprot.writeStructEnd()
6076 
 
3431 rajveer 6077 
  def validate(self):
6078 
    return
6079 
 
6080 
 
94 ashish 6081 
  def __repr__(self):
6082 
    L = ['%s=%r' % (key, value)
6083 
      for key, value in self.__dict__.iteritems()]
6084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6085 
 
6086 
  def __eq__(self, other):
6087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6088 
 
6089 
  def __ne__(self, other):
6090 
    return not (self == other)
6091 
 
559 chandransh 6092 
class setUserAsLoggedIn_result:
94 ashish 6093 
  """
6094 
  Attributes:
6095 
   - success
6096 
   - ucx
6097 
  """
6098 
 
6099 
  thrift_spec = (
6100 
    (0, TType.BOOL, 'success', None, None, ), # 0
6101 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6102 
  )
6103 
 
6104 
  def __init__(self, success=None, ucx=None,):
6105 
    self.success = success
6106 
    self.ucx = ucx
6107 
 
6108 
  def read(self, iprot):
6109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6111 
      return
6112 
    iprot.readStructBegin()
6113 
    while True:
6114 
      (fname, ftype, fid) = iprot.readFieldBegin()
6115 
      if ftype == TType.STOP:
6116 
        break
6117 
      if fid == 0:
6118 
        if ftype == TType.BOOL:
6119 
          self.success = iprot.readBool();
6120 
        else:
6121 
          iprot.skip(ftype)
6122 
      elif fid == 1:
6123 
        if ftype == TType.STRUCT:
6124 
          self.ucx = UserContextException()
6125 
          self.ucx.read(iprot)
6126 
        else:
6127 
          iprot.skip(ftype)
6128 
      else:
6129 
        iprot.skip(ftype)
6130 
      iprot.readFieldEnd()
6131 
    iprot.readStructEnd()
6132 
 
6133 
  def write(self, oprot):
6134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6136 
      return
559 chandransh 6137 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6138 
    if self.success is not None:
94 ashish 6139 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6140 
      oprot.writeBool(self.success)
6141 
      oprot.writeFieldEnd()
3431 rajveer 6142 
    if self.ucx is not None:
94 ashish 6143 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6144 
      self.ucx.write(oprot)
6145 
      oprot.writeFieldEnd()
6146 
    oprot.writeFieldStop()
6147 
    oprot.writeStructEnd()
6148 
 
3431 rajveer 6149 
  def validate(self):
6150 
    return
6151 
 
6152 
 
94 ashish 6153 
  def __repr__(self):
6154 
    L = ['%s=%r' % (key, value)
6155 
      for key, value in self.__dict__.iteritems()]
6156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6157 
 
6158 
  def __eq__(self, other):
6159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6160 
 
6161 
  def __ne__(self, other):
6162 
    return not (self == other)
6163 
 
559 chandransh 6164 
class setUserAsLoggedOut_args:
94 ashish 6165 
  """
6166 
  Attributes:
6167 
   - userid
6168 
   - timestamp
6169 
  """
6170 
 
6171 
  thrift_spec = (
6172 
    None, # 0
559 chandransh 6173 
    (1, TType.I64, 'userid', None, None, ), # 1
6174 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6175 
  )
6176 
 
559 chandransh 6177 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6178 
    self.userid = userid
6179 
    self.timestamp = timestamp
6180 
 
6181 
  def read(self, iprot):
6182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6184 
      return
6185 
    iprot.readStructBegin()
6186 
    while True:
6187 
      (fname, ftype, fid) = iprot.readFieldBegin()
6188 
      if ftype == TType.STOP:
6189 
        break
6190 
      if fid == 1:
6191 
        if ftype == TType.I64:
6192 
          self.userid = iprot.readI64();
6193 
        else:
6194 
          iprot.skip(ftype)
559 chandransh 6195 
      elif fid == 2:
94 ashish 6196 
        if ftype == TType.I64:
6197 
          self.timestamp = iprot.readI64();
6198 
        else:
6199 
          iprot.skip(ftype)
6200 
      else:
6201 
        iprot.skip(ftype)
6202 
      iprot.readFieldEnd()
6203 
    iprot.readStructEnd()
6204 
 
6205 
  def write(self, oprot):
6206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6208 
      return
559 chandransh 6209 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6210 
    if self.userid is not None:
559 chandransh 6211 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6212 
      oprot.writeI64(self.userid)
6213 
      oprot.writeFieldEnd()
3431 rajveer 6214 
    if self.timestamp is not None:
559 chandransh 6215 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6216 
      oprot.writeI64(self.timestamp)
6217 
      oprot.writeFieldEnd()
6218 
    oprot.writeFieldStop()
6219 
    oprot.writeStructEnd()
6220 
 
3431 rajveer 6221 
  def validate(self):
6222 
    return
6223 
 
6224 
 
94 ashish 6225 
  def __repr__(self):
6226 
    L = ['%s=%r' % (key, value)
6227 
      for key, value in self.__dict__.iteritems()]
6228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6229 
 
6230 
  def __eq__(self, other):
6231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6232 
 
6233 
  def __ne__(self, other):
6234 
    return not (self == other)
6235 
 
559 chandransh 6236 
class setUserAsLoggedOut_result:
94 ashish 6237 
  """
6238 
  Attributes:
6239 
   - success
6240 
   - ucx
6241 
  """
6242 
 
6243 
  thrift_spec = (
6244 
    (0, TType.BOOL, 'success', None, None, ), # 0
6245 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6246 
  )
6247 
 
6248 
  def __init__(self, success=None, ucx=None,):
6249 
    self.success = success
6250 
    self.ucx = ucx
6251 
 
6252 
  def read(self, iprot):
6253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6255 
      return
6256 
    iprot.readStructBegin()
6257 
    while True:
6258 
      (fname, ftype, fid) = iprot.readFieldBegin()
6259 
      if ftype == TType.STOP:
6260 
        break
6261 
      if fid == 0:
6262 
        if ftype == TType.BOOL:
6263 
          self.success = iprot.readBool();
6264 
        else:
6265 
          iprot.skip(ftype)
6266 
      elif fid == 1:
6267 
        if ftype == TType.STRUCT:
6268 
          self.ucx = UserContextException()
6269 
          self.ucx.read(iprot)
6270 
        else:
6271 
          iprot.skip(ftype)
6272 
      else:
6273 
        iprot.skip(ftype)
6274 
      iprot.readFieldEnd()
6275 
    iprot.readStructEnd()
6276 
 
6277 
  def write(self, oprot):
6278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6280 
      return
559 chandransh 6281 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6282 
    if self.success is not None:
94 ashish 6283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6284 
      oprot.writeBool(self.success)
6285 
      oprot.writeFieldEnd()
3431 rajveer 6286 
    if self.ucx is not None:
94 ashish 6287 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6288 
      self.ucx.write(oprot)
6289 
      oprot.writeFieldEnd()
6290 
    oprot.writeFieldStop()
6291 
    oprot.writeStructEnd()
6292 
 
3431 rajveer 6293 
  def validate(self):
6294 
    return
6295 
 
6296 
 
94 ashish 6297 
  def __repr__(self):
6298 
    L = ['%s=%r' % (key, value)
6299 
      for key, value in self.__dict__.iteritems()]
6300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6301 
 
6302 
  def __eq__(self, other):
6303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6304 
 
6305 
  def __ne__(self, other):
6306 
    return not (self == other)
6307 
 
559 chandransh 6308 
class setDefaultAddress_args:
94 ashish 6309 
  """
6310 
  Attributes:
6311 
   - userid
6312 
   - addressId
6313 
  """
6314 
 
6315 
  thrift_spec = (
6316 
    None, # 0
6317 
    (1, TType.I64, 'userid', None, None, ), # 1
6318 
    (2, TType.I64, 'addressId', None, None, ), # 2
6319 
  )
6320 
 
6321 
  def __init__(self, userid=None, addressId=None,):
6322 
    self.userid = userid
6323 
    self.addressId = addressId
6324 
 
6325 
  def read(self, iprot):
6326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6328 
      return
6329 
    iprot.readStructBegin()
6330 
    while True:
6331 
      (fname, ftype, fid) = iprot.readFieldBegin()
6332 
      if ftype == TType.STOP:
6333 
        break
6334 
      if fid == 1:
6335 
        if ftype == TType.I64:
6336 
          self.userid = iprot.readI64();
6337 
        else:
6338 
          iprot.skip(ftype)
6339 
      elif fid == 2:
6340 
        if ftype == TType.I64:
6341 
          self.addressId = iprot.readI64();
6342 
        else:
6343 
          iprot.skip(ftype)
6344 
      else:
6345 
        iprot.skip(ftype)
6346 
      iprot.readFieldEnd()
6347 
    iprot.readStructEnd()
6348 
 
6349 
  def write(self, oprot):
6350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6352 
      return
559 chandransh 6353 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6354 
    if self.userid is not None:
94 ashish 6355 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6356 
      oprot.writeI64(self.userid)
6357 
      oprot.writeFieldEnd()
3431 rajveer 6358 
    if self.addressId is not None:
94 ashish 6359 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6360 
      oprot.writeI64(self.addressId)
6361 
      oprot.writeFieldEnd()
6362 
    oprot.writeFieldStop()
6363 
    oprot.writeStructEnd()
6364 
 
3431 rajveer 6365 
  def validate(self):
6366 
    return
6367 
 
6368 
 
94 ashish 6369 
  def __repr__(self):
6370 
    L = ['%s=%r' % (key, value)
6371 
      for key, value in self.__dict__.iteritems()]
6372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6373 
 
6374 
  def __eq__(self, other):
6375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6376 
 
6377 
  def __ne__(self, other):
6378 
    return not (self == other)
6379 
 
559 chandransh 6380 
class setDefaultAddress_result:
94 ashish 6381 
  """
6382 
  Attributes:
6383 
   - success
6384 
   - ucx
6385 
  """
6386 
 
6387 
  thrift_spec = (
6388 
    (0, TType.BOOL, 'success', None, None, ), # 0
6389 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6390 
  )
6391 
 
6392 
  def __init__(self, success=None, ucx=None,):
6393 
    self.success = success
6394 
    self.ucx = ucx
6395 
 
6396 
  def read(self, iprot):
6397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6399 
      return
6400 
    iprot.readStructBegin()
6401 
    while True:
6402 
      (fname, ftype, fid) = iprot.readFieldBegin()
6403 
      if ftype == TType.STOP:
6404 
        break
6405 
      if fid == 0:
6406 
        if ftype == TType.BOOL:
6407 
          self.success = iprot.readBool();
6408 
        else:
6409 
          iprot.skip(ftype)
6410 
      elif fid == 1:
6411 
        if ftype == TType.STRUCT:
6412 
          self.ucx = UserContextException()
6413 
          self.ucx.read(iprot)
6414 
        else:
6415 
          iprot.skip(ftype)
6416 
      else:
6417 
        iprot.skip(ftype)
6418 
      iprot.readFieldEnd()
6419 
    iprot.readStructEnd()
6420 
 
6421 
  def write(self, oprot):
6422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6424 
      return
559 chandransh 6425 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6426 
    if self.success is not None:
94 ashish 6427 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6428 
      oprot.writeBool(self.success)
6429 
      oprot.writeFieldEnd()
3431 rajveer 6430 
    if self.ucx is not None:
94 ashish 6431 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6432 
      self.ucx.write(oprot)
6433 
      oprot.writeFieldEnd()
6434 
    oprot.writeFieldStop()
6435 
    oprot.writeStructEnd()
6436 
 
3431 rajveer 6437 
  def validate(self):
6438 
    return
6439 
 
6440 
 
94 ashish 6441 
  def __repr__(self):
6442 
    L = ['%s=%r' % (key, value)
6443 
      for key, value in self.__dict__.iteritems()]
6444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6445 
 
6446 
  def __eq__(self, other):
6447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6448 
 
6449 
  def __ne__(self, other):
6450 
    return not (self == other)
6451 
 
559 chandransh 6452 
class updatePassword_args:
94 ashish 6453 
  """
6454 
  Attributes:
559 chandransh 6455 
   - userid
594 rajveer 6456 
   - oldPassword
6457 
   - newPassword
94 ashish 6458 
  """
6459 
 
6460 
  thrift_spec = (
6461 
    None, # 0
559 chandransh 6462 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6463 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6464 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6465 
  )
6466 
 
594 rajveer 6467 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6468 
    self.userid = userid
594 rajveer 6469 
    self.oldPassword = oldPassword
6470 
    self.newPassword = newPassword
94 ashish 6471 
 
6472 
  def read(self, iprot):
6473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6475 
      return
6476 
    iprot.readStructBegin()
6477 
    while True:
6478 
      (fname, ftype, fid) = iprot.readFieldBegin()
6479 
      if ftype == TType.STOP:
6480 
        break
6481 
      if fid == 1:
6482 
        if ftype == TType.I64:
559 chandransh 6483 
          self.userid = iprot.readI64();
94 ashish 6484 
        else:
6485 
          iprot.skip(ftype)
6486 
      elif fid == 2:
559 chandransh 6487 
        if ftype == TType.STRING:
594 rajveer 6488 
          self.oldPassword = iprot.readString();
94 ashish 6489 
        else:
6490 
          iprot.skip(ftype)
594 rajveer 6491 
      elif fid == 3:
6492 
        if ftype == TType.STRING:
6493 
          self.newPassword = iprot.readString();
6494 
        else:
6495 
          iprot.skip(ftype)
94 ashish 6496 
      else:
6497 
        iprot.skip(ftype)
6498 
      iprot.readFieldEnd()
6499 
    iprot.readStructEnd()
6500 
 
6501 
  def write(self, oprot):
6502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6504 
      return
559 chandransh 6505 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6506 
    if self.userid is not None:
559 chandransh 6507 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6508 
      oprot.writeI64(self.userid)
94 ashish 6509 
      oprot.writeFieldEnd()
3431 rajveer 6510 
    if self.oldPassword is not None:
594 rajveer 6511 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6512 
      oprot.writeString(self.oldPassword)
94 ashish 6513 
      oprot.writeFieldEnd()
3431 rajveer 6514 
    if self.newPassword is not None:
594 rajveer 6515 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6516 
      oprot.writeString(self.newPassword)
6517 
      oprot.writeFieldEnd()
94 ashish 6518 
    oprot.writeFieldStop()
6519 
    oprot.writeStructEnd()
6520 
 
3431 rajveer 6521 
  def validate(self):
6522 
    return
6523 
 
6524 
 
94 ashish 6525 
  def __repr__(self):
6526 
    L = ['%s=%r' % (key, value)
6527 
      for key, value in self.__dict__.iteritems()]
6528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6529 
 
6530 
  def __eq__(self, other):
6531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6532 
 
6533 
  def __ne__(self, other):
6534 
    return not (self == other)
6535 
 
559 chandransh 6536 
class updatePassword_result:
94 ashish 6537 
  """
6538 
  Attributes:
6539 
   - success
6540 
   - ucx
6541 
  """
6542 
 
6543 
  thrift_spec = (
6544 
    (0, TType.BOOL, 'success', None, None, ), # 0
6545 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6546 
  )
6547 
 
6548 
  def __init__(self, success=None, ucx=None,):
6549 
    self.success = success
6550 
    self.ucx = ucx
6551 
 
6552 
  def read(self, iprot):
6553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6555 
      return
6556 
    iprot.readStructBegin()
6557 
    while True:
6558 
      (fname, ftype, fid) = iprot.readFieldBegin()
6559 
      if ftype == TType.STOP:
6560 
        break
6561 
      if fid == 0:
6562 
        if ftype == TType.BOOL:
6563 
          self.success = iprot.readBool();
6564 
        else:
6565 
          iprot.skip(ftype)
6566 
      elif fid == 1:
6567 
        if ftype == TType.STRUCT:
6568 
          self.ucx = UserContextException()
6569 
          self.ucx.read(iprot)
6570 
        else:
6571 
          iprot.skip(ftype)
6572 
      else:
6573 
        iprot.skip(ftype)
6574 
      iprot.readFieldEnd()
6575 
    iprot.readStructEnd()
6576 
 
6577 
  def write(self, oprot):
6578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6580 
      return
559 chandransh 6581 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6582 
    if self.success is not None:
94 ashish 6583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6584 
      oprot.writeBool(self.success)
6585 
      oprot.writeFieldEnd()
3431 rajveer 6586 
    if self.ucx is not None:
94 ashish 6587 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6588 
      self.ucx.write(oprot)
6589 
      oprot.writeFieldEnd()
6590 
    oprot.writeFieldStop()
6591 
    oprot.writeStructEnd()
6592 
 
3431 rajveer 6593 
  def validate(self):
6594 
    return
6595 
 
6596 
 
94 ashish 6597 
  def __repr__(self):
6598 
    L = ['%s=%r' % (key, value)
6599 
      for key, value in self.__dict__.iteritems()]
6600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6601 
 
6602 
  def __eq__(self, other):
6603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6604 
 
6605 
  def __ne__(self, other):
6606 
    return not (self == other)
6607 
 
581 rajveer 6608 
class forgotPassword_args:
6609 
  """
6610 
  Attributes:
6611 
   - email
884 rajveer 6612 
   - newPassword
581 rajveer 6613 
  """
6614 
 
6615 
  thrift_spec = (
6616 
    None, # 0
6617 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6618 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6619 
  )
6620 
 
884 rajveer 6621 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6622 
    self.email = email
884 rajveer 6623 
    self.newPassword = newPassword
581 rajveer 6624 
 
6625 
  def read(self, iprot):
6626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6628 
      return
6629 
    iprot.readStructBegin()
6630 
    while True:
6631 
      (fname, ftype, fid) = iprot.readFieldBegin()
6632 
      if ftype == TType.STOP:
6633 
        break
6634 
      if fid == 1:
6635 
        if ftype == TType.STRING:
6636 
          self.email = iprot.readString();
6637 
        else:
6638 
          iprot.skip(ftype)
884 rajveer 6639 
      elif fid == 2:
6640 
        if ftype == TType.STRING:
6641 
          self.newPassword = iprot.readString();
6642 
        else:
6643 
          iprot.skip(ftype)
581 rajveer 6644 
      else:
6645 
        iprot.skip(ftype)
6646 
      iprot.readFieldEnd()
6647 
    iprot.readStructEnd()
6648 
 
6649 
  def write(self, oprot):
6650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6652 
      return
6653 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6654 
    if self.email is not None:
581 rajveer 6655 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6656 
      oprot.writeString(self.email)
6657 
      oprot.writeFieldEnd()
3431 rajveer 6658 
    if self.newPassword is not None:
884 rajveer 6659 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6660 
      oprot.writeString(self.newPassword)
6661 
      oprot.writeFieldEnd()
581 rajveer 6662 
    oprot.writeFieldStop()
6663 
    oprot.writeStructEnd()
6664 
 
3431 rajveer 6665 
  def validate(self):
6666 
    return
6667 
 
6668 
 
581 rajveer 6669 
  def __repr__(self):
6670 
    L = ['%s=%r' % (key, value)
6671 
      for key, value in self.__dict__.iteritems()]
6672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6673 
 
6674 
  def __eq__(self, other):
6675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6676 
 
6677 
  def __ne__(self, other):
6678 
    return not (self == other)
6679 
 
6680 
class forgotPassword_result:
6681 
  """
6682 
  Attributes:
6683 
   - success
6684 
   - ucx
6685 
  """
6686 
 
6687 
  thrift_spec = (
6688 
    (0, TType.BOOL, 'success', None, None, ), # 0
6689 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6690 
  )
6691 
 
6692 
  def __init__(self, success=None, ucx=None,):
6693 
    self.success = success
6694 
    self.ucx = ucx
6695 
 
6696 
  def read(self, iprot):
6697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6699 
      return
6700 
    iprot.readStructBegin()
6701 
    while True:
6702 
      (fname, ftype, fid) = iprot.readFieldBegin()
6703 
      if ftype == TType.STOP:
6704 
        break
6705 
      if fid == 0:
6706 
        if ftype == TType.BOOL:
6707 
          self.success = iprot.readBool();
6708 
        else:
6709 
          iprot.skip(ftype)
6710 
      elif fid == 1:
6711 
        if ftype == TType.STRUCT:
6712 
          self.ucx = UserContextException()
6713 
          self.ucx.read(iprot)
6714 
        else:
6715 
          iprot.skip(ftype)
6716 
      else:
6717 
        iprot.skip(ftype)
6718 
      iprot.readFieldEnd()
6719 
    iprot.readStructEnd()
6720 
 
6721 
  def write(self, oprot):
6722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6724 
      return
6725 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6726 
    if self.success is not None:
581 rajveer 6727 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6728 
      oprot.writeBool(self.success)
6729 
      oprot.writeFieldEnd()
3431 rajveer 6730 
    if self.ucx is not None:
581 rajveer 6731 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6732 
      self.ucx.write(oprot)
6733 
      oprot.writeFieldEnd()
6734 
    oprot.writeFieldStop()
6735 
    oprot.writeStructEnd()
6736 
 
3431 rajveer 6737 
  def validate(self):
6738 
    return
6739 
 
6740 
 
581 rajveer 6741 
  def __repr__(self):
6742 
    L = ['%s=%r' % (key, value)
6743 
      for key, value in self.__dict__.iteritems()]
6744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6745 
 
6746 
  def __eq__(self, other):
6747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6748 
 
6749 
  def __ne__(self, other):
6750 
    return not (self == other)
6751 
 
594 rajveer 6752 
class getAllAddressesForUser_args:
6753 
  """
6754 
  Attributes:
6755 
   - userId
6756 
  """
6757 
 
6758 
  thrift_spec = (
6759 
    None, # 0
6760 
    (1, TType.I64, 'userId', None, None, ), # 1
6761 
  )
6762 
 
6763 
  def __init__(self, userId=None,):
6764 
    self.userId = userId
6765 
 
6766 
  def read(self, iprot):
6767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6769 
      return
6770 
    iprot.readStructBegin()
6771 
    while True:
6772 
      (fname, ftype, fid) = iprot.readFieldBegin()
6773 
      if ftype == TType.STOP:
6774 
        break
6775 
      if fid == 1:
6776 
        if ftype == TType.I64:
6777 
          self.userId = iprot.readI64();
6778 
        else:
6779 
          iprot.skip(ftype)
6780 
      else:
6781 
        iprot.skip(ftype)
6782 
      iprot.readFieldEnd()
6783 
    iprot.readStructEnd()
6784 
 
6785 
  def write(self, oprot):
6786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6788 
      return
6789 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6790 
    if self.userId is not None:
594 rajveer 6791 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6792 
      oprot.writeI64(self.userId)
6793 
      oprot.writeFieldEnd()
6794 
    oprot.writeFieldStop()
6795 
    oprot.writeStructEnd()
6796 
 
3431 rajveer 6797 
  def validate(self):
6798 
    return
6799 
 
6800 
 
594 rajveer 6801 
  def __repr__(self):
6802 
    L = ['%s=%r' % (key, value)
6803 
      for key, value in self.__dict__.iteritems()]
6804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6805 
 
6806 
  def __eq__(self, other):
6807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6808 
 
6809 
  def __ne__(self, other):
6810 
    return not (self == other)
6811 
 
6812 
class getAllAddressesForUser_result:
6813 
  """
6814 
  Attributes:
6815 
   - success
6816 
   - ucx
6817 
  """
6818 
 
6819 
  thrift_spec = (
6820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6821 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6822 
  )
6823 
 
6824 
  def __init__(self, success=None, ucx=None,):
6825 
    self.success = success
6826 
    self.ucx = ucx
6827 
 
6828 
  def read(self, iprot):
6829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6831 
      return
6832 
    iprot.readStructBegin()
6833 
    while True:
6834 
      (fname, ftype, fid) = iprot.readFieldBegin()
6835 
      if ftype == TType.STOP:
6836 
        break
6837 
      if fid == 0:
6838 
        if ftype == TType.LIST:
6839 
          self.success = []
11592 amit.gupta 6840 
          (_etype100, _size97) = iprot.readListBegin()
6841 
          for _i101 in xrange(_size97):
6842 
            _elem102 = Address()
6843 
            _elem102.read(iprot)
6844 
            self.success.append(_elem102)
594 rajveer 6845 
          iprot.readListEnd()
6846 
        else:
6847 
          iprot.skip(ftype)
6848 
      elif fid == 1:
6849 
        if ftype == TType.STRUCT:
6850 
          self.ucx = UserContextException()
6851 
          self.ucx.read(iprot)
6852 
        else:
6853 
          iprot.skip(ftype)
6854 
      else:
6855 
        iprot.skip(ftype)
6856 
      iprot.readFieldEnd()
6857 
    iprot.readStructEnd()
6858 
 
6859 
  def write(self, oprot):
6860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6862 
      return
6863 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 6864 
    if self.success is not None:
594 rajveer 6865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 6867 
      for iter103 in self.success:
6868 
        iter103.write(oprot)
594 rajveer 6869 
      oprot.writeListEnd()
6870 
      oprot.writeFieldEnd()
3431 rajveer 6871 
    if self.ucx is not None:
594 rajveer 6872 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6873 
      self.ucx.write(oprot)
6874 
      oprot.writeFieldEnd()
6875 
    oprot.writeFieldStop()
6876 
    oprot.writeStructEnd()
6877 
 
3431 rajveer 6878 
  def validate(self):
6879 
    return
6880 
 
6881 
 
594 rajveer 6882 
  def __repr__(self):
6883 
    L = ['%s=%r' % (key, value)
6884 
      for key, value in self.__dict__.iteritems()]
6885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6886 
 
6887 
  def __eq__(self, other):
6888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6889 
 
6890 
  def __ne__(self, other):
6891 
    return not (self == other)
6892 
 
1894 vikas 6893 
class getAddressById_args:
6894 
  """
6895 
  Attributes:
6896 
   - addressId
6897 
  """
6898 
 
6899 
  thrift_spec = (
6900 
    None, # 0
6901 
    (1, TType.I64, 'addressId', None, None, ), # 1
6902 
  )
6903 
 
6904 
  def __init__(self, addressId=None,):
6905 
    self.addressId = addressId
6906 
 
6907 
  def read(self, iprot):
6908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6910 
      return
6911 
    iprot.readStructBegin()
6912 
    while True:
6913 
      (fname, ftype, fid) = iprot.readFieldBegin()
6914 
      if ftype == TType.STOP:
6915 
        break
6916 
      if fid == 1:
6917 
        if ftype == TType.I64:
6918 
          self.addressId = iprot.readI64();
6919 
        else:
6920 
          iprot.skip(ftype)
6921 
      else:
6922 
        iprot.skip(ftype)
6923 
      iprot.readFieldEnd()
6924 
    iprot.readStructEnd()
6925 
 
6926 
  def write(self, oprot):
6927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6929 
      return
6930 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 6931 
    if self.addressId is not None:
1894 vikas 6932 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6933 
      oprot.writeI64(self.addressId)
6934 
      oprot.writeFieldEnd()
6935 
    oprot.writeFieldStop()
6936 
    oprot.writeStructEnd()
6937 
 
3431 rajveer 6938 
  def validate(self):
6939 
    return
6940 
 
6941 
 
1894 vikas 6942 
  def __repr__(self):
6943 
    L = ['%s=%r' % (key, value)
6944 
      for key, value in self.__dict__.iteritems()]
6945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6946 
 
6947 
  def __eq__(self, other):
6948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6949 
 
6950 
  def __ne__(self, other):
6951 
    return not (self == other)
6952 
 
6953 
class getAddressById_result:
6954 
  """
6955 
  Attributes:
6956 
   - success
6957 
   - ucx
6958 
  """
6959 
 
6960 
  thrift_spec = (
6961 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6962 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6963 
  )
6964 
 
6965 
  def __init__(self, success=None, ucx=None,):
6966 
    self.success = success
6967 
    self.ucx = ucx
6968 
 
6969 
  def read(self, iprot):
6970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6972 
      return
6973 
    iprot.readStructBegin()
6974 
    while True:
6975 
      (fname, ftype, fid) = iprot.readFieldBegin()
6976 
      if ftype == TType.STOP:
6977 
        break
6978 
      if fid == 0:
6979 
        if ftype == TType.STRUCT:
6980 
          self.success = Address()
6981 
          self.success.read(iprot)
6982 
        else:
6983 
          iprot.skip(ftype)
6984 
      elif fid == 1:
6985 
        if ftype == TType.STRUCT:
6986 
          self.ucx = UserContextException()
6987 
          self.ucx.read(iprot)
6988 
        else:
6989 
          iprot.skip(ftype)
6990 
      else:
6991 
        iprot.skip(ftype)
6992 
      iprot.readFieldEnd()
6993 
    iprot.readStructEnd()
6994 
 
6995 
  def write(self, oprot):
6996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6998 
      return
6999 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7000 
    if self.success is not None:
1894 vikas 7001 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7002 
      self.success.write(oprot)
7003 
      oprot.writeFieldEnd()
3431 rajveer 7004 
    if self.ucx is not None:
1894 vikas 7005 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7006 
      self.ucx.write(oprot)
7007 
      oprot.writeFieldEnd()
7008 
    oprot.writeFieldStop()
7009 
    oprot.writeStructEnd()
7010 
 
3431 rajveer 7011 
  def validate(self):
7012 
    return
7013 
 
7014 
 
1894 vikas 7015 
  def __repr__(self):
7016 
    L = ['%s=%r' % (key, value)
7017 
      for key, value in self.__dict__.iteritems()]
7018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7019 
 
7020 
  def __eq__(self, other):
7021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7022 
 
7023 
  def __ne__(self, other):
7024 
    return not (self == other)
7025 
 
594 rajveer 7026 
class getDefaultAddressId_args:
7027 
  """
7028 
  Attributes:
7029 
   - userId
7030 
  """
7031 
 
7032 
  thrift_spec = (
7033 
    None, # 0
7034 
    (1, TType.I64, 'userId', None, None, ), # 1
7035 
  )
7036 
 
7037 
  def __init__(self, userId=None,):
7038 
    self.userId = userId
7039 
 
7040 
  def read(self, iprot):
7041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7043 
      return
7044 
    iprot.readStructBegin()
7045 
    while True:
7046 
      (fname, ftype, fid) = iprot.readFieldBegin()
7047 
      if ftype == TType.STOP:
7048 
        break
7049 
      if fid == 1:
7050 
        if ftype == TType.I64:
7051 
          self.userId = iprot.readI64();
7052 
        else:
7053 
          iprot.skip(ftype)
7054 
      else:
7055 
        iprot.skip(ftype)
7056 
      iprot.readFieldEnd()
7057 
    iprot.readStructEnd()
7058 
 
7059 
  def write(self, oprot):
7060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7062 
      return
7063 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7064 
    if self.userId is not None:
594 rajveer 7065 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7066 
      oprot.writeI64(self.userId)
7067 
      oprot.writeFieldEnd()
7068 
    oprot.writeFieldStop()
7069 
    oprot.writeStructEnd()
7070 
 
3431 rajveer 7071 
  def validate(self):
7072 
    return
7073 
 
7074 
 
594 rajveer 7075 
  def __repr__(self):
7076 
    L = ['%s=%r' % (key, value)
7077 
      for key, value in self.__dict__.iteritems()]
7078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7079 
 
7080 
  def __eq__(self, other):
7081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7082 
 
7083 
  def __ne__(self, other):
7084 
    return not (self == other)
7085 
 
7086 
class getDefaultAddressId_result:
7087 
  """
7088 
  Attributes:
7089 
   - success
7090 
   - ucx
7091 
  """
7092 
 
7093 
  thrift_spec = (
7094 
    (0, TType.I64, 'success', None, None, ), # 0
7095 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7096 
  )
7097 
 
7098 
  def __init__(self, success=None, ucx=None,):
7099 
    self.success = success
7100 
    self.ucx = ucx
7101 
 
7102 
  def read(self, iprot):
7103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7105 
      return
7106 
    iprot.readStructBegin()
7107 
    while True:
7108 
      (fname, ftype, fid) = iprot.readFieldBegin()
7109 
      if ftype == TType.STOP:
7110 
        break
7111 
      if fid == 0:
7112 
        if ftype == TType.I64:
7113 
          self.success = iprot.readI64();
7114 
        else:
7115 
          iprot.skip(ftype)
7116 
      elif fid == 1:
7117 
        if ftype == TType.STRUCT:
7118 
          self.ucx = UserContextException()
7119 
          self.ucx.read(iprot)
7120 
        else:
7121 
          iprot.skip(ftype)
7122 
      else:
7123 
        iprot.skip(ftype)
7124 
      iprot.readFieldEnd()
7125 
    iprot.readStructEnd()
7126 
 
7127 
  def write(self, oprot):
7128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7130 
      return
7131 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7132 
    if self.success is not None:
594 rajveer 7133 
      oprot.writeFieldBegin('success', TType.I64, 0)
7134 
      oprot.writeI64(self.success)
7135 
      oprot.writeFieldEnd()
3431 rajveer 7136 
    if self.ucx is not None:
594 rajveer 7137 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7138 
      self.ucx.write(oprot)
7139 
      oprot.writeFieldEnd()
7140 
    oprot.writeFieldStop()
7141 
    oprot.writeStructEnd()
7142 
 
3431 rajveer 7143 
  def validate(self):
7144 
    return
7145 
 
7146 
 
594 rajveer 7147 
  def __repr__(self):
7148 
    L = ['%s=%r' % (key, value)
7149 
      for key, value in self.__dict__.iteritems()]
7150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7151 
 
7152 
  def __eq__(self, other):
7153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7154 
 
7155 
  def __ne__(self, other):
7156 
    return not (self == other)
7157 
 
785 rajveer 7158 
class getDefaultPincode_args:
7159 
  """
7160 
  Attributes:
7161 
   - userId
7162 
  """
7163 
 
7164 
  thrift_spec = (
7165 
    None, # 0
7166 
    (1, TType.I64, 'userId', None, None, ), # 1
7167 
  )
7168 
 
7169 
  def __init__(self, userId=None,):
7170 
    self.userId = userId
7171 
 
7172 
  def read(self, iprot):
7173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7175 
      return
7176 
    iprot.readStructBegin()
7177 
    while True:
7178 
      (fname, ftype, fid) = iprot.readFieldBegin()
7179 
      if ftype == TType.STOP:
7180 
        break
7181 
      if fid == 1:
7182 
        if ftype == TType.I64:
7183 
          self.userId = iprot.readI64();
7184 
        else:
7185 
          iprot.skip(ftype)
7186 
      else:
7187 
        iprot.skip(ftype)
7188 
      iprot.readFieldEnd()
7189 
    iprot.readStructEnd()
7190 
 
7191 
  def write(self, oprot):
7192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7194 
      return
7195 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7196 
    if self.userId is not None:
785 rajveer 7197 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7198 
      oprot.writeI64(self.userId)
7199 
      oprot.writeFieldEnd()
7200 
    oprot.writeFieldStop()
7201 
    oprot.writeStructEnd()
7202 
 
3431 rajveer 7203 
  def validate(self):
7204 
    return
7205 
 
7206 
 
785 rajveer 7207 
  def __repr__(self):
7208 
    L = ['%s=%r' % (key, value)
7209 
      for key, value in self.__dict__.iteritems()]
7210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7211 
 
7212 
  def __eq__(self, other):
7213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7214 
 
7215 
  def __ne__(self, other):
7216 
    return not (self == other)
7217 
 
7218 
class getDefaultPincode_result:
7219 
  """
7220 
  Attributes:
7221 
   - success
7222 
   - ucx
7223 
  """
7224 
 
7225 
  thrift_spec = (
7226 
    (0, TType.STRING, 'success', None, None, ), # 0
7227 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7228 
  )
7229 
 
7230 
  def __init__(self, success=None, ucx=None,):
7231 
    self.success = success
7232 
    self.ucx = ucx
7233 
 
7234 
  def read(self, iprot):
7235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7237 
      return
7238 
    iprot.readStructBegin()
7239 
    while True:
7240 
      (fname, ftype, fid) = iprot.readFieldBegin()
7241 
      if ftype == TType.STOP:
7242 
        break
7243 
      if fid == 0:
7244 
        if ftype == TType.STRING:
7245 
          self.success = iprot.readString();
7246 
        else:
7247 
          iprot.skip(ftype)
7248 
      elif fid == 1:
7249 
        if ftype == TType.STRUCT:
7250 
          self.ucx = UserContextException()
7251 
          self.ucx.read(iprot)
7252 
        else:
7253 
          iprot.skip(ftype)
7254 
      else:
7255 
        iprot.skip(ftype)
7256 
      iprot.readFieldEnd()
7257 
    iprot.readStructEnd()
7258 
 
7259 
  def write(self, oprot):
7260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7262 
      return
7263 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7264 
    if self.success is not None:
785 rajveer 7265 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7266 
      oprot.writeString(self.success)
7267 
      oprot.writeFieldEnd()
3431 rajveer 7268 
    if self.ucx is not None:
785 rajveer 7269 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7270 
      self.ucx.write(oprot)
7271 
      oprot.writeFieldEnd()
7272 
    oprot.writeFieldStop()
7273 
    oprot.writeStructEnd()
7274 
 
3431 rajveer 7275 
  def validate(self):
7276 
    return
7277 
 
7278 
 
785 rajveer 7279 
  def __repr__(self):
7280 
    L = ['%s=%r' % (key, value)
7281 
      for key, value in self.__dict__.iteritems()]
7282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7283 
 
7284 
  def __eq__(self, other):
7285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7286 
 
7287 
  def __ne__(self, other):
7288 
    return not (self == other)
7289 
 
1274 varun.gupt 7290 
class saveUserCommunication_args:
7291 
  """
7292 
  Attributes:
7293 
   - userId
7294 
   - replyTo
7295 
   - communicationType
7296 
   - orderId
7297 
   - airwaybillNo
7298 
   - productName
7299 
   - subject
7300 
   - message
7301 
  """
7302 
 
7303 
  thrift_spec = (
7304 
    None, # 0
7305 
    (1, TType.I64, 'userId', None, None, ), # 1
7306 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7307 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7308 
    (4, TType.I64, 'orderId', None, None, ), # 4
7309 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7310 
    (6, TType.STRING, 'productName', None, None, ), # 6
7311 
    (7, TType.STRING, 'subject', None, None, ), # 7
7312 
    (8, TType.STRING, 'message', None, None, ), # 8
7313 
  )
7314 
 
7315 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7316 
    self.userId = userId
7317 
    self.replyTo = replyTo
7318 
    self.communicationType = communicationType
7319 
    self.orderId = orderId
7320 
    self.airwaybillNo = airwaybillNo
7321 
    self.productName = productName
7322 
    self.subject = subject
7323 
    self.message = message
7324 
 
7325 
  def read(self, iprot):
7326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7328 
      return
7329 
    iprot.readStructBegin()
7330 
    while True:
7331 
      (fname, ftype, fid) = iprot.readFieldBegin()
7332 
      if ftype == TType.STOP:
7333 
        break
7334 
      if fid == 1:
7335 
        if ftype == TType.I64:
7336 
          self.userId = iprot.readI64();
7337 
        else:
7338 
          iprot.skip(ftype)
7339 
      elif fid == 2:
7340 
        if ftype == TType.STRING:
7341 
          self.replyTo = iprot.readString();
7342 
        else:
7343 
          iprot.skip(ftype)
7344 
      elif fid == 3:
7345 
        if ftype == TType.I64:
7346 
          self.communicationType = iprot.readI64();
7347 
        else:
7348 
          iprot.skip(ftype)
7349 
      elif fid == 4:
7350 
        if ftype == TType.I64:
7351 
          self.orderId = iprot.readI64();
7352 
        else:
7353 
          iprot.skip(ftype)
7354 
      elif fid == 5:
7355 
        if ftype == TType.STRING:
7356 
          self.airwaybillNo = iprot.readString();
7357 
        else:
7358 
          iprot.skip(ftype)
7359 
      elif fid == 6:
7360 
        if ftype == TType.STRING:
7361 
          self.productName = iprot.readString();
7362 
        else:
7363 
          iprot.skip(ftype)
7364 
      elif fid == 7:
7365 
        if ftype == TType.STRING:
7366 
          self.subject = iprot.readString();
7367 
        else:
7368 
          iprot.skip(ftype)
7369 
      elif fid == 8:
7370 
        if ftype == TType.STRING:
7371 
          self.message = iprot.readString();
7372 
        else:
7373 
          iprot.skip(ftype)
7374 
      else:
7375 
        iprot.skip(ftype)
7376 
      iprot.readFieldEnd()
7377 
    iprot.readStructEnd()
7378 
 
7379 
  def write(self, oprot):
7380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7382 
      return
7383 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7384 
    if self.userId is not None:
1274 varun.gupt 7385 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7386 
      oprot.writeI64(self.userId)
7387 
      oprot.writeFieldEnd()
3431 rajveer 7388 
    if self.replyTo is not None:
1274 varun.gupt 7389 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7390 
      oprot.writeString(self.replyTo)
7391 
      oprot.writeFieldEnd()
3431 rajveer 7392 
    if self.communicationType is not None:
1274 varun.gupt 7393 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7394 
      oprot.writeI64(self.communicationType)
7395 
      oprot.writeFieldEnd()
3431 rajveer 7396 
    if self.orderId is not None:
1274 varun.gupt 7397 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7398 
      oprot.writeI64(self.orderId)
7399 
      oprot.writeFieldEnd()
3431 rajveer 7400 
    if self.airwaybillNo is not None:
1274 varun.gupt 7401 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7402 
      oprot.writeString(self.airwaybillNo)
7403 
      oprot.writeFieldEnd()
3431 rajveer 7404 
    if self.productName is not None:
1274 varun.gupt 7405 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7406 
      oprot.writeString(self.productName)
7407 
      oprot.writeFieldEnd()
3431 rajveer 7408 
    if self.subject is not None:
1274 varun.gupt 7409 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7410 
      oprot.writeString(self.subject)
7411 
      oprot.writeFieldEnd()
3431 rajveer 7412 
    if self.message is not None:
1274 varun.gupt 7413 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7414 
      oprot.writeString(self.message)
7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
3431 rajveer 7419 
  def validate(self):
7420 
    return
7421 
 
7422 
 
1274 varun.gupt 7423 
  def __repr__(self):
7424 
    L = ['%s=%r' % (key, value)
7425 
      for key, value in self.__dict__.iteritems()]
7426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7427 
 
7428 
  def __eq__(self, other):
7429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7430 
 
7431 
  def __ne__(self, other):
7432 
    return not (self == other)
7433 
 
7434 
class saveUserCommunication_result:
7435 
  """
7436 
  Attributes:
7437 
   - success
7438 
   - ucx
7439 
  """
7440 
 
7441 
  thrift_spec = (
7442 
    (0, TType.BOOL, 'success', None, None, ), # 0
7443 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7444 
  )
7445 
 
7446 
  def __init__(self, success=None, ucx=None,):
7447 
    self.success = success
7448 
    self.ucx = ucx
7449 
 
7450 
  def read(self, iprot):
7451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7453 
      return
7454 
    iprot.readStructBegin()
7455 
    while True:
7456 
      (fname, ftype, fid) = iprot.readFieldBegin()
7457 
      if ftype == TType.STOP:
7458 
        break
7459 
      if fid == 0:
7460 
        if ftype == TType.BOOL:
7461 
          self.success = iprot.readBool();
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      elif fid == 1:
7465 
        if ftype == TType.STRUCT:
7466 
          self.ucx = UserCommunicationException()
7467 
          self.ucx.read(iprot)
7468 
        else:
7469 
          iprot.skip(ftype)
7470 
      else:
7471 
        iprot.skip(ftype)
7472 
      iprot.readFieldEnd()
7473 
    iprot.readStructEnd()
7474 
 
7475 
  def write(self, oprot):
7476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7478 
      return
7479 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7480 
    if self.success is not None:
1274 varun.gupt 7481 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7482 
      oprot.writeBool(self.success)
7483 
      oprot.writeFieldEnd()
3431 rajveer 7484 
    if self.ucx is not None:
1274 varun.gupt 7485 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7486 
      self.ucx.write(oprot)
7487 
      oprot.writeFieldEnd()
7488 
    oprot.writeFieldStop()
7489 
    oprot.writeStructEnd()
7490 
 
3431 rajveer 7491 
  def validate(self):
7492 
    return
7493 
 
7494 
 
1274 varun.gupt 7495 
  def __repr__(self):
7496 
    L = ['%s=%r' % (key, value)
7497 
      for key, value in self.__dict__.iteritems()]
7498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7499 
 
7500 
  def __eq__(self, other):
7501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7502 
 
7503 
  def __ne__(self, other):
7504 
    return not (self == other)
7505 
 
1590 varun.gupt 7506 
class getUserCommunicationById_args:
7507 
  """
7508 
  Attributes:
7509 
   - id
7510 
  """
7511 
 
7512 
  thrift_spec = (
7513 
    None, # 0
7514 
    (1, TType.I64, 'id', None, None, ), # 1
7515 
  )
7516 
 
7517 
  def __init__(self, id=None,):
7518 
    self.id = id
7519 
 
7520 
  def read(self, iprot):
7521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7523 
      return
7524 
    iprot.readStructBegin()
7525 
    while True:
7526 
      (fname, ftype, fid) = iprot.readFieldBegin()
7527 
      if ftype == TType.STOP:
7528 
        break
7529 
      if fid == 1:
7530 
        if ftype == TType.I64:
7531 
          self.id = iprot.readI64();
7532 
        else:
7533 
          iprot.skip(ftype)
7534 
      else:
7535 
        iprot.skip(ftype)
7536 
      iprot.readFieldEnd()
7537 
    iprot.readStructEnd()
7538 
 
7539 
  def write(self, oprot):
7540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7542 
      return
7543 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7544 
    if self.id is not None:
1590 varun.gupt 7545 
      oprot.writeFieldBegin('id', TType.I64, 1)
7546 
      oprot.writeI64(self.id)
7547 
      oprot.writeFieldEnd()
7548 
    oprot.writeFieldStop()
7549 
    oprot.writeStructEnd()
7550 
 
3431 rajveer 7551 
  def validate(self):
7552 
    return
7553 
 
7554 
 
1590 varun.gupt 7555 
  def __repr__(self):
7556 
    L = ['%s=%r' % (key, value)
7557 
      for key, value in self.__dict__.iteritems()]
7558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7559 
 
7560 
  def __eq__(self, other):
7561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7562 
 
7563 
  def __ne__(self, other):
7564 
    return not (self == other)
7565 
 
7566 
class getUserCommunicationById_result:
7567 
  """
7568 
  Attributes:
7569 
   - success
7570 
   - ucx
7571 
  """
7572 
 
7573 
  thrift_spec = (
7574 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7575 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7576 
  )
7577 
 
7578 
  def __init__(self, success=None, ucx=None,):
7579 
    self.success = success
7580 
    self.ucx = ucx
7581 
 
7582 
  def read(self, iprot):
7583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7585 
      return
7586 
    iprot.readStructBegin()
7587 
    while True:
7588 
      (fname, ftype, fid) = iprot.readFieldBegin()
7589 
      if ftype == TType.STOP:
7590 
        break
7591 
      if fid == 0:
7592 
        if ftype == TType.STRUCT:
7593 
          self.success = UserCommunication()
7594 
          self.success.read(iprot)
7595 
        else:
7596 
          iprot.skip(ftype)
7597 
      elif fid == 1:
7598 
        if ftype == TType.STRUCT:
7599 
          self.ucx = UserCommunicationException()
7600 
          self.ucx.read(iprot)
7601 
        else:
7602 
          iprot.skip(ftype)
7603 
      else:
7604 
        iprot.skip(ftype)
7605 
      iprot.readFieldEnd()
7606 
    iprot.readStructEnd()
7607 
 
7608 
  def write(self, oprot):
7609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7611 
      return
7612 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7613 
    if self.success is not None:
1590 varun.gupt 7614 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7615 
      self.success.write(oprot)
7616 
      oprot.writeFieldEnd()
3431 rajveer 7617 
    if self.ucx is not None:
1590 varun.gupt 7618 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7619 
      self.ucx.write(oprot)
7620 
      oprot.writeFieldEnd()
7621 
    oprot.writeFieldStop()
7622 
    oprot.writeStructEnd()
7623 
 
3431 rajveer 7624 
  def validate(self):
7625 
    return
7626 
 
7627 
 
1590 varun.gupt 7628 
  def __repr__(self):
7629 
    L = ['%s=%r' % (key, value)
7630 
      for key, value in self.__dict__.iteritems()]
7631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7632 
 
7633 
  def __eq__(self, other):
7634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7635 
 
7636 
  def __ne__(self, other):
7637 
    return not (self == other)
7638 
 
7639 
class getUserCommunicationByUser_args:
7640 
  """
7641 
  Attributes:
7642 
   - userId
7643 
  """
7644 
 
7645 
  thrift_spec = (
7646 
    None, # 0
7647 
    (1, TType.I64, 'userId', None, None, ), # 1
7648 
  )
7649 
 
7650 
  def __init__(self, userId=None,):
7651 
    self.userId = userId
7652 
 
7653 
  def read(self, iprot):
7654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7656 
      return
7657 
    iprot.readStructBegin()
7658 
    while True:
7659 
      (fname, ftype, fid) = iprot.readFieldBegin()
7660 
      if ftype == TType.STOP:
7661 
        break
7662 
      if fid == 1:
7663 
        if ftype == TType.I64:
7664 
          self.userId = iprot.readI64();
7665 
        else:
7666 
          iprot.skip(ftype)
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('getUserCommunicationByUser_args')
3431 rajveer 7677 
    if self.userId is not None:
1590 varun.gupt 7678 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7679 
      oprot.writeI64(self.userId)
7680 
      oprot.writeFieldEnd()
7681 
    oprot.writeFieldStop()
7682 
    oprot.writeStructEnd()
7683 
 
3431 rajveer 7684 
  def validate(self):
7685 
    return
7686 
 
7687 
 
1590 varun.gupt 7688 
  def __repr__(self):
7689 
    L = ['%s=%r' % (key, value)
7690 
      for key, value in self.__dict__.iteritems()]
7691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7692 
 
7693 
  def __eq__(self, other):
7694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7695 
 
7696 
  def __ne__(self, other):
7697 
    return not (self == other)
7698 
 
7699 
class getUserCommunicationByUser_result:
7700 
  """
7701 
  Attributes:
7702 
   - success
7703 
   - ucx
7704 
  """
7705 
 
7706 
  thrift_spec = (
7707 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7708 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7709 
  )
7710 
 
7711 
  def __init__(self, success=None, ucx=None,):
7712 
    self.success = success
7713 
    self.ucx = ucx
7714 
 
7715 
  def read(self, iprot):
7716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7718 
      return
7719 
    iprot.readStructBegin()
7720 
    while True:
7721 
      (fname, ftype, fid) = iprot.readFieldBegin()
7722 
      if ftype == TType.STOP:
7723 
        break
7724 
      if fid == 0:
7725 
        if ftype == TType.LIST:
7726 
          self.success = []
11592 amit.gupta 7727 
          (_etype107, _size104) = iprot.readListBegin()
7728 
          for _i108 in xrange(_size104):
7729 
            _elem109 = UserCommunication()
7730 
            _elem109.read(iprot)
7731 
            self.success.append(_elem109)
1590 varun.gupt 7732 
          iprot.readListEnd()
7733 
        else:
7734 
          iprot.skip(ftype)
7735 
      elif fid == 1:
7736 
        if ftype == TType.STRUCT:
7737 
          self.ucx = UserCommunicationException()
7738 
          self.ucx.read(iprot)
7739 
        else:
7740 
          iprot.skip(ftype)
7741 
      else:
7742 
        iprot.skip(ftype)
7743 
      iprot.readFieldEnd()
7744 
    iprot.readStructEnd()
7745 
 
7746 
  def write(self, oprot):
7747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7749 
      return
7750 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7751 
    if self.success is not None:
1590 varun.gupt 7752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7754 
      for iter110 in self.success:
7755 
        iter110.write(oprot)
1590 varun.gupt 7756 
      oprot.writeListEnd()
7757 
      oprot.writeFieldEnd()
3431 rajveer 7758 
    if self.ucx is not None:
1590 varun.gupt 7759 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7760 
      self.ucx.write(oprot)
7761 
      oprot.writeFieldEnd()
7762 
    oprot.writeFieldStop()
7763 
    oprot.writeStructEnd()
7764 
 
3431 rajveer 7765 
  def validate(self):
7766 
    return
7767 
 
7768 
 
1590 varun.gupt 7769 
  def __repr__(self):
7770 
    L = ['%s=%r' % (key, value)
7771 
      for key, value in self.__dict__.iteritems()]
7772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7773 
 
7774 
  def __eq__(self, other):
7775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7776 
 
7777 
  def __ne__(self, other):
7778 
    return not (self == other)
7779 
 
7780 
class getAllUserCommunications_args:
7781 
 
7782 
  thrift_spec = (
7783 
  )
7784 
 
7785 
  def read(self, iprot):
7786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7788 
      return
7789 
    iprot.readStructBegin()
7790 
    while True:
7791 
      (fname, ftype, fid) = iprot.readFieldBegin()
7792 
      if ftype == TType.STOP:
7793 
        break
7794 
      else:
7795 
        iprot.skip(ftype)
7796 
      iprot.readFieldEnd()
7797 
    iprot.readStructEnd()
7798 
 
7799 
  def write(self, oprot):
7800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7802 
      return
7803 
    oprot.writeStructBegin('getAllUserCommunications_args')
7804 
    oprot.writeFieldStop()
7805 
    oprot.writeStructEnd()
7806 
 
3431 rajveer 7807 
  def validate(self):
7808 
    return
7809 
 
7810 
 
1590 varun.gupt 7811 
  def __repr__(self):
7812 
    L = ['%s=%r' % (key, value)
7813 
      for key, value in self.__dict__.iteritems()]
7814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7815 
 
7816 
  def __eq__(self, other):
7817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7818 
 
7819 
  def __ne__(self, other):
7820 
    return not (self == other)
7821 
 
7822 
class getAllUserCommunications_result:
7823 
  """
7824 
  Attributes:
7825 
   - success
7826 
   - ucx
7827 
  """
7828 
 
7829 
  thrift_spec = (
7830 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7831 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7832 
  )
7833 
 
7834 
  def __init__(self, success=None, ucx=None,):
7835 
    self.success = success
7836 
    self.ucx = ucx
7837 
 
7838 
  def read(self, iprot):
7839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7841 
      return
7842 
    iprot.readStructBegin()
7843 
    while True:
7844 
      (fname, ftype, fid) = iprot.readFieldBegin()
7845 
      if ftype == TType.STOP:
7846 
        break
7847 
      if fid == 0:
7848 
        if ftype == TType.LIST:
7849 
          self.success = []
11592 amit.gupta 7850 
          (_etype114, _size111) = iprot.readListBegin()
7851 
          for _i115 in xrange(_size111):
7852 
            _elem116 = UserCommunication()
7853 
            _elem116.read(iprot)
7854 
            self.success.append(_elem116)
1590 varun.gupt 7855 
          iprot.readListEnd()
7856 
        else:
7857 
          iprot.skip(ftype)
7858 
      elif fid == 1:
7859 
        if ftype == TType.STRUCT:
7860 
          self.ucx = UserCommunicationException()
7861 
          self.ucx.read(iprot)
7862 
        else:
7863 
          iprot.skip(ftype)
7864 
      else:
7865 
        iprot.skip(ftype)
7866 
      iprot.readFieldEnd()
7867 
    iprot.readStructEnd()
7868 
 
7869 
  def write(self, oprot):
7870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7872 
      return
7873 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 7874 
    if self.success is not None:
1590 varun.gupt 7875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7877 
      for iter117 in self.success:
7878 
        iter117.write(oprot)
1590 varun.gupt 7879 
      oprot.writeListEnd()
7880 
      oprot.writeFieldEnd()
3431 rajveer 7881 
    if self.ucx is not None:
1590 varun.gupt 7882 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7883 
      self.ucx.write(oprot)
7884 
      oprot.writeFieldEnd()
7885 
    oprot.writeFieldStop()
7886 
    oprot.writeStructEnd()
7887 
 
3431 rajveer 7888 
  def validate(self):
7889 
    return
7890 
 
7891 
 
1590 varun.gupt 7892 
  def __repr__(self):
7893 
    L = ['%s=%r' % (key, value)
7894 
      for key, value in self.__dict__.iteritems()]
7895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7896 
 
7897 
  def __eq__(self, other):
7898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7899 
 
7900 
  def __ne__(self, other):
7901 
    return not (self == other)
7902 
 
5407 amar.kumar 7903 
class removeUserCommunication_args:
7904 
  """
7905 
  Attributes:
7906 
   - id
7907 
  """
7908 
 
7909 
  thrift_spec = (
7910 
    None, # 0
7911 
    (1, TType.I64, 'id', None, None, ), # 1
7912 
  )
7913 
 
7914 
  def __init__(self, id=None,):
7915 
    self.id = id
7916 
 
7917 
  def read(self, iprot):
7918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7920 
      return
7921 
    iprot.readStructBegin()
7922 
    while True:
7923 
      (fname, ftype, fid) = iprot.readFieldBegin()
7924 
      if ftype == TType.STOP:
7925 
        break
7926 
      if fid == 1:
7927 
        if ftype == TType.I64:
7928 
          self.id = iprot.readI64();
7929 
        else:
7930 
          iprot.skip(ftype)
7931 
      else:
7932 
        iprot.skip(ftype)
7933 
      iprot.readFieldEnd()
7934 
    iprot.readStructEnd()
7935 
 
7936 
  def write(self, oprot):
7937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7939 
      return
7940 
    oprot.writeStructBegin('removeUserCommunication_args')
7941 
    if self.id is not None:
7942 
      oprot.writeFieldBegin('id', TType.I64, 1)
7943 
      oprot.writeI64(self.id)
7944 
      oprot.writeFieldEnd()
7945 
    oprot.writeFieldStop()
7946 
    oprot.writeStructEnd()
7947 
 
7948 
  def validate(self):
7949 
    return
7950 
 
7951 
 
7952 
  def __repr__(self):
7953 
    L = ['%s=%r' % (key, value)
7954 
      for key, value in self.__dict__.iteritems()]
7955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7956 
 
7957 
  def __eq__(self, other):
7958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7959 
 
7960 
  def __ne__(self, other):
7961 
    return not (self == other)
7962 
 
7963 
class removeUserCommunication_result:
7964 
  """
7965 
  Attributes:
7966 
   - ucx
7967 
  """
7968 
 
7969 
  thrift_spec = (
7970 
    None, # 0
7971 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7972 
  )
7973 
 
7974 
  def __init__(self, ucx=None,):
7975 
    self.ucx = ucx
7976 
 
7977 
  def read(self, iprot):
7978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7980 
      return
7981 
    iprot.readStructBegin()
7982 
    while True:
7983 
      (fname, ftype, fid) = iprot.readFieldBegin()
7984 
      if ftype == TType.STOP:
7985 
        break
7986 
      if fid == 1:
7987 
        if ftype == TType.STRUCT:
7988 
          self.ucx = UserCommunicationException()
7989 
          self.ucx.read(iprot)
7990 
        else:
7991 
          iprot.skip(ftype)
7992 
      else:
7993 
        iprot.skip(ftype)
7994 
      iprot.readFieldEnd()
7995 
    iprot.readStructEnd()
7996 
 
7997 
  def write(self, oprot):
7998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8000 
      return
8001 
    oprot.writeStructBegin('removeUserCommunication_result')
8002 
    if self.ucx is not None:
8003 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8004 
      self.ucx.write(oprot)
8005 
      oprot.writeFieldEnd()
8006 
    oprot.writeFieldStop()
8007 
    oprot.writeStructEnd()
8008 
 
8009 
  def validate(self):
8010 
    return
8011 
 
8012 
 
8013 
  def __repr__(self):
8014 
    L = ['%s=%r' % (key, value)
8015 
      for key, value in self.__dict__.iteritems()]
8016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8017 
 
8018 
  def __eq__(self, other):
8019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8020 
 
8021 
  def __ne__(self, other):
8022 
    return not (self == other)
8023 
 
1845 vikas 8024 
class createMasterAffiliate_args:
8025 
  """
8026 
  Attributes:
8027 
   - name
1859 vikas 8028 
   - addedOn
1845 vikas 8029 
  """
8030 
 
8031 
  thrift_spec = (
8032 
    None, # 0
8033 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8034 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8035 
  )
8036 
 
1859 vikas 8037 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8038 
    self.name = name
1859 vikas 8039 
    self.addedOn = addedOn
1845 vikas 8040 
 
8041 
  def read(self, iprot):
8042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8044 
      return
8045 
    iprot.readStructBegin()
8046 
    while True:
8047 
      (fname, ftype, fid) = iprot.readFieldBegin()
8048 
      if ftype == TType.STOP:
8049 
        break
8050 
      if fid == 1:
8051 
        if ftype == TType.STRING:
8052 
          self.name = iprot.readString();
8053 
        else:
8054 
          iprot.skip(ftype)
1859 vikas 8055 
      elif fid == 2:
8056 
        if ftype == TType.I64:
8057 
          self.addedOn = iprot.readI64();
8058 
        else:
8059 
          iprot.skip(ftype)
1845 vikas 8060 
      else:
8061 
        iprot.skip(ftype)
8062 
      iprot.readFieldEnd()
8063 
    iprot.readStructEnd()
8064 
 
8065 
  def write(self, oprot):
8066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8068 
      return
8069 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8070 
    if self.name is not None:
1845 vikas 8071 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8072 
      oprot.writeString(self.name)
8073 
      oprot.writeFieldEnd()
3431 rajveer 8074 
    if self.addedOn is not None:
1859 vikas 8075 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8076 
      oprot.writeI64(self.addedOn)
8077 
      oprot.writeFieldEnd()
1845 vikas 8078 
    oprot.writeFieldStop()
8079 
    oprot.writeStructEnd()
8080 
 
3431 rajveer 8081 
  def validate(self):
8082 
    return
8083 
 
8084 
 
1845 vikas 8085 
  def __repr__(self):
8086 
    L = ['%s=%r' % (key, value)
8087 
      for key, value in self.__dict__.iteritems()]
8088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8089 
 
8090 
  def __eq__(self, other):
8091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8092 
 
8093 
  def __ne__(self, other):
8094 
    return not (self == other)
8095 
 
8096 
class createMasterAffiliate_result:
8097 
  """
8098 
  Attributes:
8099 
   - success
8100 
   - utx
8101 
  """
8102 
 
8103 
  thrift_spec = (
8104 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8105 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8106 
  )
8107 
 
8108 
  def __init__(self, success=None, utx=None,):
8109 
    self.success = success
8110 
    self.utx = utx
8111 
 
8112 
  def read(self, iprot):
8113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8115 
      return
8116 
    iprot.readStructBegin()
8117 
    while True:
8118 
      (fname, ftype, fid) = iprot.readFieldBegin()
8119 
      if ftype == TType.STOP:
8120 
        break
8121 
      if fid == 0:
8122 
        if ftype == TType.STRUCT:
8123 
          self.success = MasterAffiliate()
8124 
          self.success.read(iprot)
8125 
        else:
8126 
          iprot.skip(ftype)
8127 
      elif fid == 1:
8128 
        if ftype == TType.STRUCT:
1996 vikas 8129 
          self.utx = UserAffiliateException()
1845 vikas 8130 
          self.utx.read(iprot)
8131 
        else:
8132 
          iprot.skip(ftype)
8133 
      else:
8134 
        iprot.skip(ftype)
8135 
      iprot.readFieldEnd()
8136 
    iprot.readStructEnd()
8137 
 
8138 
  def write(self, oprot):
8139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8141 
      return
8142 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8143 
    if self.success is not None:
1845 vikas 8144 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8145 
      self.success.write(oprot)
8146 
      oprot.writeFieldEnd()
3431 rajveer 8147 
    if self.utx is not None:
1845 vikas 8148 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8149 
      self.utx.write(oprot)
8150 
      oprot.writeFieldEnd()
8151 
    oprot.writeFieldStop()
8152 
    oprot.writeStructEnd()
8153 
 
3431 rajveer 8154 
  def validate(self):
8155 
    return
8156 
 
8157 
 
1845 vikas 8158 
  def __repr__(self):
8159 
    L = ['%s=%r' % (key, value)
8160 
      for key, value in self.__dict__.iteritems()]
8161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8162 
 
8163 
  def __eq__(self, other):
8164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8165 
 
8166 
  def __ne__(self, other):
8167 
    return not (self == other)
8168 
 
1899 vikas 8169 
class getAllMasterAffiliates_args:
8170 
 
8171 
  thrift_spec = (
8172 
  )
8173 
 
8174 
  def read(self, iprot):
8175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8177 
      return
8178 
    iprot.readStructBegin()
8179 
    while True:
8180 
      (fname, ftype, fid) = iprot.readFieldBegin()
8181 
      if ftype == TType.STOP:
8182 
        break
8183 
      else:
8184 
        iprot.skip(ftype)
8185 
      iprot.readFieldEnd()
8186 
    iprot.readStructEnd()
8187 
 
8188 
  def write(self, oprot):
8189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8191 
      return
8192 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8193 
    oprot.writeFieldStop()
8194 
    oprot.writeStructEnd()
8195 
 
3431 rajveer 8196 
  def validate(self):
8197 
    return
8198 
 
8199 
 
1899 vikas 8200 
  def __repr__(self):
8201 
    L = ['%s=%r' % (key, value)
8202 
      for key, value in self.__dict__.iteritems()]
8203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8204 
 
8205 
  def __eq__(self, other):
8206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8207 
 
8208 
  def __ne__(self, other):
8209 
    return not (self == other)
8210 
 
8211 
class getAllMasterAffiliates_result:
8212 
  """
8213 
  Attributes:
8214 
   - success
8215 
   - utx
8216 
  """
8217 
 
8218 
  thrift_spec = (
8219 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8220 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8221 
  )
8222 
 
8223 
  def __init__(self, success=None, utx=None,):
8224 
    self.success = success
8225 
    self.utx = utx
8226 
 
8227 
  def read(self, iprot):
8228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8230 
      return
8231 
    iprot.readStructBegin()
8232 
    while True:
8233 
      (fname, ftype, fid) = iprot.readFieldBegin()
8234 
      if ftype == TType.STOP:
8235 
        break
8236 
      if fid == 0:
8237 
        if ftype == TType.LIST:
8238 
          self.success = []
11592 amit.gupta 8239 
          (_etype121, _size118) = iprot.readListBegin()
8240 
          for _i122 in xrange(_size118):
8241 
            _elem123 = MasterAffiliate()
8242 
            _elem123.read(iprot)
8243 
            self.success.append(_elem123)
1899 vikas 8244 
          iprot.readListEnd()
8245 
        else:
8246 
          iprot.skip(ftype)
8247 
      elif fid == 1:
8248 
        if ftype == TType.STRUCT:
1996 vikas 8249 
          self.utx = UserAffiliateException()
1899 vikas 8250 
          self.utx.read(iprot)
8251 
        else:
8252 
          iprot.skip(ftype)
8253 
      else:
8254 
        iprot.skip(ftype)
8255 
      iprot.readFieldEnd()
8256 
    iprot.readStructEnd()
8257 
 
8258 
  def write(self, oprot):
8259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8261 
      return
8262 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8263 
    if self.success is not None:
1899 vikas 8264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8266 
      for iter124 in self.success:
8267 
        iter124.write(oprot)
1899 vikas 8268 
      oprot.writeListEnd()
8269 
      oprot.writeFieldEnd()
3431 rajveer 8270 
    if self.utx is not None:
1899 vikas 8271 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8272 
      self.utx.write(oprot)
8273 
      oprot.writeFieldEnd()
8274 
    oprot.writeFieldStop()
8275 
    oprot.writeStructEnd()
8276 
 
3431 rajveer 8277 
  def validate(self):
8278 
    return
8279 
 
8280 
 
1899 vikas 8281 
  def __repr__(self):
8282 
    L = ['%s=%r' % (key, value)
8283 
      for key, value in self.__dict__.iteritems()]
8284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8285 
 
8286 
  def __eq__(self, other):
8287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8288 
 
8289 
  def __ne__(self, other):
8290 
    return not (self == other)
8291 
 
1845 vikas 8292 
class getMasterAffiliateById_args:
8293 
  """
8294 
  Attributes:
8295 
   - id
8296 
  """
8297 
 
8298 
  thrift_spec = (
8299 
    None, # 0
8300 
    (1, TType.I64, 'id', None, None, ), # 1
8301 
  )
8302 
 
8303 
  def __init__(self, id=None,):
8304 
    self.id = id
8305 
 
8306 
  def read(self, iprot):
8307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8309 
      return
8310 
    iprot.readStructBegin()
8311 
    while True:
8312 
      (fname, ftype, fid) = iprot.readFieldBegin()
8313 
      if ftype == TType.STOP:
8314 
        break
8315 
      if fid == 1:
8316 
        if ftype == TType.I64:
8317 
          self.id = iprot.readI64();
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
8329 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8330 
    if self.id is not None:
1845 vikas 8331 
      oprot.writeFieldBegin('id', TType.I64, 1)
8332 
      oprot.writeI64(self.id)
8333 
      oprot.writeFieldEnd()
8334 
    oprot.writeFieldStop()
8335 
    oprot.writeStructEnd()
8336 
 
3431 rajveer 8337 
  def validate(self):
8338 
    return
8339 
 
8340 
 
1845 vikas 8341 
  def __repr__(self):
8342 
    L = ['%s=%r' % (key, value)
8343 
      for key, value in self.__dict__.iteritems()]
8344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8345 
 
8346 
  def __eq__(self, other):
8347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8348 
 
8349 
  def __ne__(self, other):
8350 
    return not (self == other)
8351 
 
8352 
class getMasterAffiliateById_result:
8353 
  """
8354 
  Attributes:
8355 
   - success
8356 
   - utx
8357 
  """
8358 
 
8359 
  thrift_spec = (
8360 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8361 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8362 
  )
8363 
 
8364 
  def __init__(self, success=None, utx=None,):
8365 
    self.success = success
8366 
    self.utx = utx
8367 
 
8368 
  def read(self, iprot):
8369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8371 
      return
8372 
    iprot.readStructBegin()
8373 
    while True:
8374 
      (fname, ftype, fid) = iprot.readFieldBegin()
8375 
      if ftype == TType.STOP:
8376 
        break
8377 
      if fid == 0:
8378 
        if ftype == TType.STRUCT:
8379 
          self.success = MasterAffiliate()
8380 
          self.success.read(iprot)
8381 
        else:
8382 
          iprot.skip(ftype)
8383 
      elif fid == 1:
8384 
        if ftype == TType.STRUCT:
1996 vikas 8385 
          self.utx = UserAffiliateException()
1845 vikas 8386 
          self.utx.read(iprot)
8387 
        else:
8388 
          iprot.skip(ftype)
8389 
      else:
8390 
        iprot.skip(ftype)
8391 
      iprot.readFieldEnd()
8392 
    iprot.readStructEnd()
8393 
 
8394 
  def write(self, oprot):
8395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8397 
      return
8398 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8399 
    if self.success is not None:
1845 vikas 8400 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8401 
      self.success.write(oprot)
8402 
      oprot.writeFieldEnd()
3431 rajveer 8403 
    if self.utx is not None:
1845 vikas 8404 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8405 
      self.utx.write(oprot)
8406 
      oprot.writeFieldEnd()
8407 
    oprot.writeFieldStop()
8408 
    oprot.writeStructEnd()
8409 
 
3431 rajveer 8410 
  def validate(self):
8411 
    return
8412 
 
8413 
 
1845 vikas 8414 
  def __repr__(self):
8415 
    L = ['%s=%r' % (key, value)
8416 
      for key, value in self.__dict__.iteritems()]
8417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8418 
 
8419 
  def __eq__(self, other):
8420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8421 
 
8422 
  def __ne__(self, other):
8423 
    return not (self == other)
8424 
 
8425 
class getMasterAffiliateByName_args:
8426 
  """
8427 
  Attributes:
8428 
   - name
8429 
  """
8430 
 
8431 
  thrift_spec = (
8432 
    None, # 0
8433 
    (1, TType.STRING, 'name', None, None, ), # 1
8434 
  )
8435 
 
8436 
  def __init__(self, name=None,):
8437 
    self.name = name
8438 
 
8439 
  def read(self, iprot):
8440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8442 
      return
8443 
    iprot.readStructBegin()
8444 
    while True:
8445 
      (fname, ftype, fid) = iprot.readFieldBegin()
8446 
      if ftype == TType.STOP:
8447 
        break
8448 
      if fid == 1:
8449 
        if ftype == TType.STRING:
8450 
          self.name = iprot.readString();
8451 
        else:
8452 
          iprot.skip(ftype)
8453 
      else:
8454 
        iprot.skip(ftype)
8455 
      iprot.readFieldEnd()
8456 
    iprot.readStructEnd()
8457 
 
8458 
  def write(self, oprot):
8459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8461 
      return
8462 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8463 
    if self.name is not None:
1845 vikas 8464 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8465 
      oprot.writeString(self.name)
8466 
      oprot.writeFieldEnd()
8467 
    oprot.writeFieldStop()
8468 
    oprot.writeStructEnd()
8469 
 
3431 rajveer 8470 
  def validate(self):
8471 
    return
8472 
 
8473 
 
1845 vikas 8474 
  def __repr__(self):
8475 
    L = ['%s=%r' % (key, value)
8476 
      for key, value in self.__dict__.iteritems()]
8477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8478 
 
8479 
  def __eq__(self, other):
8480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8481 
 
8482 
  def __ne__(self, other):
8483 
    return not (self == other)
8484 
 
8485 
class getMasterAffiliateByName_result:
8486 
  """
8487 
  Attributes:
8488 
   - success
8489 
   - utx
8490 
  """
8491 
 
8492 
  thrift_spec = (
8493 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8494 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8495 
  )
8496 
 
8497 
  def __init__(self, success=None, utx=None,):
8498 
    self.success = success
8499 
    self.utx = utx
8500 
 
8501 
  def read(self, iprot):
8502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8504 
      return
8505 
    iprot.readStructBegin()
8506 
    while True:
8507 
      (fname, ftype, fid) = iprot.readFieldBegin()
8508 
      if ftype == TType.STOP:
8509 
        break
8510 
      if fid == 0:
8511 
        if ftype == TType.STRUCT:
8512 
          self.success = MasterAffiliate()
8513 
          self.success.read(iprot)
8514 
        else:
8515 
          iprot.skip(ftype)
8516 
      elif fid == 1:
8517 
        if ftype == TType.STRUCT:
1996 vikas 8518 
          self.utx = UserAffiliateException()
1845 vikas 8519 
          self.utx.read(iprot)
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8532 
    if self.success is not None:
1845 vikas 8533 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8534 
      self.success.write(oprot)
8535 
      oprot.writeFieldEnd()
3431 rajveer 8536 
    if self.utx is not None:
1845 vikas 8537 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8538 
      self.utx.write(oprot)
8539 
      oprot.writeFieldEnd()
8540 
    oprot.writeFieldStop()
8541 
    oprot.writeStructEnd()
8542 
 
3431 rajveer 8543 
  def validate(self):
8544 
    return
8545 
 
8546 
 
1845 vikas 8547 
  def __repr__(self):
8548 
    L = ['%s=%r' % (key, value)
8549 
      for key, value in self.__dict__.iteritems()]
8550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8551 
 
8552 
  def __eq__(self, other):
8553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8554 
 
8555 
  def __ne__(self, other):
8556 
    return not (self == other)
8557 
 
8558 
class createAffiliate_args:
8559 
  """
8560 
  Attributes:
8561 
   - name
8562 
   - url
8563 
   - masterAffiliateId
1859 vikas 8564 
   - addedOn
1845 vikas 8565 
  """
8566 
 
8567 
  thrift_spec = (
8568 
    None, # 0
8569 
    (1, TType.STRING, 'name', None, None, ), # 1
8570 
    (2, TType.STRING, 'url', None, None, ), # 2
8571 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8572 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8573 
  )
8574 
 
1859 vikas 8575 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8576 
    self.name = name
8577 
    self.url = url
8578 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8579 
    self.addedOn = addedOn
1845 vikas 8580 
 
8581 
  def read(self, iprot):
8582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8584 
      return
8585 
    iprot.readStructBegin()
8586 
    while True:
8587 
      (fname, ftype, fid) = iprot.readFieldBegin()
8588 
      if ftype == TType.STOP:
8589 
        break
8590 
      if fid == 1:
8591 
        if ftype == TType.STRING:
8592 
          self.name = iprot.readString();
8593 
        else:
8594 
          iprot.skip(ftype)
8595 
      elif fid == 2:
8596 
        if ftype == TType.STRING:
8597 
          self.url = iprot.readString();
8598 
        else:
8599 
          iprot.skip(ftype)
8600 
      elif fid == 3:
8601 
        if ftype == TType.I64:
8602 
          self.masterAffiliateId = iprot.readI64();
8603 
        else:
8604 
          iprot.skip(ftype)
1859 vikas 8605 
      elif fid == 4:
8606 
        if ftype == TType.I64:
8607 
          self.addedOn = iprot.readI64();
8608 
        else:
8609 
          iprot.skip(ftype)
1845 vikas 8610 
      else:
8611 
        iprot.skip(ftype)
8612 
      iprot.readFieldEnd()
8613 
    iprot.readStructEnd()
8614 
 
8615 
  def write(self, oprot):
8616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8618 
      return
8619 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8620 
    if self.name is not None:
1845 vikas 8621 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8622 
      oprot.writeString(self.name)
8623 
      oprot.writeFieldEnd()
3431 rajveer 8624 
    if self.url is not None:
1845 vikas 8625 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8626 
      oprot.writeString(self.url)
8627 
      oprot.writeFieldEnd()
3431 rajveer 8628 
    if self.masterAffiliateId is not None:
1845 vikas 8629 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8630 
      oprot.writeI64(self.masterAffiliateId)
8631 
      oprot.writeFieldEnd()
3431 rajveer 8632 
    if self.addedOn is not None:
1859 vikas 8633 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8634 
      oprot.writeI64(self.addedOn)
8635 
      oprot.writeFieldEnd()
1845 vikas 8636 
    oprot.writeFieldStop()
8637 
    oprot.writeStructEnd()
8638 
 
3431 rajveer 8639 
  def validate(self):
8640 
    return
8641 
 
8642 
 
1845 vikas 8643 
  def __repr__(self):
8644 
    L = ['%s=%r' % (key, value)
8645 
      for key, value in self.__dict__.iteritems()]
8646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8647 
 
8648 
  def __eq__(self, other):
8649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8650 
 
8651 
  def __ne__(self, other):
8652 
    return not (self == other)
8653 
 
8654 
class createAffiliate_result:
8655 
  """
8656 
  Attributes:
8657 
   - success
8658 
   - utx
8659 
  """
8660 
 
8661 
  thrift_spec = (
8662 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8663 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8664 
  )
8665 
 
8666 
  def __init__(self, success=None, utx=None,):
8667 
    self.success = success
8668 
    self.utx = utx
8669 
 
8670 
  def read(self, iprot):
8671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8673 
      return
8674 
    iprot.readStructBegin()
8675 
    while True:
8676 
      (fname, ftype, fid) = iprot.readFieldBegin()
8677 
      if ftype == TType.STOP:
8678 
        break
8679 
      if fid == 0:
8680 
        if ftype == TType.STRUCT:
8681 
          self.success = Affiliate()
8682 
          self.success.read(iprot)
8683 
        else:
8684 
          iprot.skip(ftype)
8685 
      elif fid == 1:
8686 
        if ftype == TType.STRUCT:
1996 vikas 8687 
          self.utx = UserAffiliateException()
1845 vikas 8688 
          self.utx.read(iprot)
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      else:
8692 
        iprot.skip(ftype)
8693 
      iprot.readFieldEnd()
8694 
    iprot.readStructEnd()
8695 
 
8696 
  def write(self, oprot):
8697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8699 
      return
8700 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8701 
    if self.success is not None:
1845 vikas 8702 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8703 
      self.success.write(oprot)
8704 
      oprot.writeFieldEnd()
3431 rajveer 8705 
    if self.utx is not None:
1845 vikas 8706 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8707 
      self.utx.write(oprot)
8708 
      oprot.writeFieldEnd()
8709 
    oprot.writeFieldStop()
8710 
    oprot.writeStructEnd()
8711 
 
3431 rajveer 8712 
  def validate(self):
8713 
    return
8714 
 
8715 
 
1845 vikas 8716 
  def __repr__(self):
8717 
    L = ['%s=%r' % (key, value)
8718 
      for key, value in self.__dict__.iteritems()]
8719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8720 
 
8721 
  def __eq__(self, other):
8722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8723 
 
8724 
  def __ne__(self, other):
8725 
    return not (self == other)
8726 
 
8727 
class getAffiliateById_args:
8728 
  """
8729 
  Attributes:
8730 
   - id
8731 
  """
8732 
 
8733 
  thrift_spec = (
8734 
    None, # 0
8735 
    (1, TType.I64, 'id', None, None, ), # 1
8736 
  )
8737 
 
8738 
  def __init__(self, id=None,):
8739 
    self.id = id
8740 
 
8741 
  def read(self, iprot):
8742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8744 
      return
8745 
    iprot.readStructBegin()
8746 
    while True:
8747 
      (fname, ftype, fid) = iprot.readFieldBegin()
8748 
      if ftype == TType.STOP:
8749 
        break
8750 
      if fid == 1:
8751 
        if ftype == TType.I64:
8752 
          self.id = iprot.readI64();
8753 
        else:
8754 
          iprot.skip(ftype)
8755 
      else:
8756 
        iprot.skip(ftype)
8757 
      iprot.readFieldEnd()
8758 
    iprot.readStructEnd()
8759 
 
8760 
  def write(self, oprot):
8761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8763 
      return
8764 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8765 
    if self.id is not None:
1845 vikas 8766 
      oprot.writeFieldBegin('id', TType.I64, 1)
8767 
      oprot.writeI64(self.id)
8768 
      oprot.writeFieldEnd()
8769 
    oprot.writeFieldStop()
8770 
    oprot.writeStructEnd()
8771 
 
3431 rajveer 8772 
  def validate(self):
8773 
    return
8774 
 
8775 
 
1845 vikas 8776 
  def __repr__(self):
8777 
    L = ['%s=%r' % (key, value)
8778 
      for key, value in self.__dict__.iteritems()]
8779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8780 
 
8781 
  def __eq__(self, other):
8782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8783 
 
8784 
  def __ne__(self, other):
8785 
    return not (self == other)
8786 
 
8787 
class getAffiliateById_result:
8788 
  """
8789 
  Attributes:
8790 
   - success
8791 
   - utx
8792 
  """
8793 
 
8794 
  thrift_spec = (
8795 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8796 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8797 
  )
8798 
 
8799 
  def __init__(self, success=None, utx=None,):
8800 
    self.success = success
8801 
    self.utx = utx
8802 
 
8803 
  def read(self, iprot):
8804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8806 
      return
8807 
    iprot.readStructBegin()
8808 
    while True:
8809 
      (fname, ftype, fid) = iprot.readFieldBegin()
8810 
      if ftype == TType.STOP:
8811 
        break
8812 
      if fid == 0:
8813 
        if ftype == TType.STRUCT:
8814 
          self.success = Affiliate()
8815 
          self.success.read(iprot)
8816 
        else:
8817 
          iprot.skip(ftype)
8818 
      elif fid == 1:
8819 
        if ftype == TType.STRUCT:
1996 vikas 8820 
          self.utx = UserAffiliateException()
1845 vikas 8821 
          self.utx.read(iprot)
8822 
        else:
8823 
          iprot.skip(ftype)
8824 
      else:
8825 
        iprot.skip(ftype)
8826 
      iprot.readFieldEnd()
8827 
    iprot.readStructEnd()
8828 
 
8829 
  def write(self, oprot):
8830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8832 
      return
8833 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 8834 
    if self.success is not None:
1845 vikas 8835 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8836 
      self.success.write(oprot)
8837 
      oprot.writeFieldEnd()
3431 rajveer 8838 
    if self.utx is not None:
1845 vikas 8839 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8840 
      self.utx.write(oprot)
8841 
      oprot.writeFieldEnd()
8842 
    oprot.writeFieldStop()
8843 
    oprot.writeStructEnd()
8844 
 
3431 rajveer 8845 
  def validate(self):
8846 
    return
8847 
 
8848 
 
1845 vikas 8849 
  def __repr__(self):
8850 
    L = ['%s=%r' % (key, value)
8851 
      for key, value in self.__dict__.iteritems()]
8852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8853 
 
8854 
  def __eq__(self, other):
8855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8856 
 
8857 
  def __ne__(self, other):
8858 
    return not (self == other)
8859 
 
8860 
class getAffiliateByName_args:
8861 
  """
8862 
  Attributes:
8863 
   - name
8864 
  """
8865 
 
8866 
  thrift_spec = (
8867 
    None, # 0
8868 
    (1, TType.STRING, 'name', None, None, ), # 1
8869 
  )
8870 
 
8871 
  def __init__(self, name=None,):
8872 
    self.name = name
8873 
 
8874 
  def read(self, iprot):
8875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8877 
      return
8878 
    iprot.readStructBegin()
8879 
    while True:
8880 
      (fname, ftype, fid) = iprot.readFieldBegin()
8881 
      if ftype == TType.STOP:
8882 
        break
8883 
      if fid == 1:
8884 
        if ftype == TType.STRING:
8885 
          self.name = iprot.readString();
8886 
        else:
8887 
          iprot.skip(ftype)
8888 
      else:
8889 
        iprot.skip(ftype)
8890 
      iprot.readFieldEnd()
8891 
    iprot.readStructEnd()
8892 
 
8893 
  def write(self, oprot):
8894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8896 
      return
8897 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 8898 
    if self.name is not None:
1845 vikas 8899 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8900 
      oprot.writeString(self.name)
8901 
      oprot.writeFieldEnd()
8902 
    oprot.writeFieldStop()
8903 
    oprot.writeStructEnd()
8904 
 
3431 rajveer 8905 
  def validate(self):
8906 
    return
8907 
 
8908 
 
1845 vikas 8909 
  def __repr__(self):
8910 
    L = ['%s=%r' % (key, value)
8911 
      for key, value in self.__dict__.iteritems()]
8912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8913 
 
8914 
  def __eq__(self, other):
8915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8916 
 
8917 
  def __ne__(self, other):
8918 
    return not (self == other)
8919 
 
8920 
class getAffiliateByName_result:
8921 
  """
8922 
  Attributes:
8923 
   - success
8924 
   - utx
8925 
  """
8926 
 
8927 
  thrift_spec = (
8928 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8929 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8930 
  )
8931 
 
8932 
  def __init__(self, success=None, utx=None,):
8933 
    self.success = success
8934 
    self.utx = utx
8935 
 
8936 
  def read(self, iprot):
8937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8939 
      return
8940 
    iprot.readStructBegin()
8941 
    while True:
8942 
      (fname, ftype, fid) = iprot.readFieldBegin()
8943 
      if ftype == TType.STOP:
8944 
        break
8945 
      if fid == 0:
8946 
        if ftype == TType.STRUCT:
8947 
          self.success = Affiliate()
8948 
          self.success.read(iprot)
8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      elif fid == 1:
8952 
        if ftype == TType.STRUCT:
1996 vikas 8953 
          self.utx = UserAffiliateException()
1845 vikas 8954 
          self.utx.read(iprot)
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      else:
8958 
        iprot.skip(ftype)
8959 
      iprot.readFieldEnd()
8960 
    iprot.readStructEnd()
8961 
 
8962 
  def write(self, oprot):
8963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8965 
      return
8966 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 8967 
    if self.success is not None:
1845 vikas 8968 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8969 
      self.success.write(oprot)
8970 
      oprot.writeFieldEnd()
3431 rajveer 8971 
    if self.utx is not None:
1845 vikas 8972 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8973 
      self.utx.write(oprot)
8974 
      oprot.writeFieldEnd()
8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
3431 rajveer 8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
1845 vikas 8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
1996 vikas 8993 
class getTrackerById_args:
1845 vikas 8994 
  """
8995 
  Attributes:
8996 
   - id
8997 
  """
8998 
 
8999 
  thrift_spec = (
9000 
    None, # 0
9001 
    (1, TType.I64, 'id', None, None, ), # 1
9002 
  )
9003 
 
9004 
  def __init__(self, id=None,):
9005 
    self.id = id
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      if fid == 1:
9017 
        if ftype == TType.I64:
9018 
          self.id = iprot.readI64();
9019 
        else:
9020 
          iprot.skip(ftype)
9021 
      else:
9022 
        iprot.skip(ftype)
9023 
      iprot.readFieldEnd()
9024 
    iprot.readStructEnd()
9025 
 
9026 
  def write(self, oprot):
9027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9029 
      return
1996 vikas 9030 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9031 
    if self.id is not None:
1845 vikas 9032 
      oprot.writeFieldBegin('id', TType.I64, 1)
9033 
      oprot.writeI64(self.id)
9034 
      oprot.writeFieldEnd()
9035 
    oprot.writeFieldStop()
9036 
    oprot.writeStructEnd()
9037 
 
3431 rajveer 9038 
  def validate(self):
9039 
    return
9040 
 
9041 
 
1845 vikas 9042 
  def __repr__(self):
9043 
    L = ['%s=%r' % (key, value)
9044 
      for key, value in self.__dict__.iteritems()]
9045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9046 
 
9047 
  def __eq__(self, other):
9048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9049 
 
9050 
  def __ne__(self, other):
9051 
    return not (self == other)
9052 
 
9053 
class getTrackerById_result:
9054 
  """
9055 
  Attributes:
9056 
   - success
9057 
   - utx
9058 
  """
9059 
 
9060 
  thrift_spec = (
9061 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9062 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9063 
  )
9064 
 
9065 
  def __init__(self, success=None, utx=None,):
9066 
    self.success = success
9067 
    self.utx = utx
9068 
 
9069 
  def read(self, iprot):
9070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9072 
      return
9073 
    iprot.readStructBegin()
9074 
    while True:
9075 
      (fname, ftype, fid) = iprot.readFieldBegin()
9076 
      if ftype == TType.STOP:
9077 
        break
9078 
      if fid == 0:
9079 
        if ftype == TType.STRUCT:
9080 
          self.success = Tracker()
9081 
          self.success.read(iprot)
9082 
        else:
9083 
          iprot.skip(ftype)
9084 
      elif fid == 1:
9085 
        if ftype == TType.STRUCT:
1996 vikas 9086 
          self.utx = UserAffiliateException()
1845 vikas 9087 
          self.utx.read(iprot)
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
9099 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9100 
    if self.success is not None:
1845 vikas 9101 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9102 
      self.success.write(oprot)
9103 
      oprot.writeFieldEnd()
3431 rajveer 9104 
    if self.utx is not None:
1845 vikas 9105 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9106 
      self.utx.write(oprot)
9107 
      oprot.writeFieldEnd()
9108 
    oprot.writeFieldStop()
9109 
    oprot.writeStructEnd()
9110 
 
3431 rajveer 9111 
  def validate(self):
9112 
    return
9113 
 
9114 
 
1845 vikas 9115 
  def __repr__(self):
9116 
    L = ['%s=%r' % (key, value)
9117 
      for key, value in self.__dict__.iteritems()]
9118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9119 
 
9120 
  def __eq__(self, other):
9121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9122 
 
9123 
  def __ne__(self, other):
9124 
    return not (self == other)
9125 
 
1996 vikas 9126 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9127 
  """
9128 
  Attributes:
1996 vikas 9129 
   - id
1845 vikas 9130 
  """
9131 
 
9132 
  thrift_spec = (
9133 
    None, # 0
1996 vikas 9134 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9135 
  )
9136 
 
1996 vikas 9137 
  def __init__(self, id=None,):
9138 
    self.id = id
1845 vikas 9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 1:
9150 
        if ftype == TType.I64:
1996 vikas 9151 
          self.id = iprot.readI64();
1845 vikas 9152 
        else:
9153 
          iprot.skip(ftype)
9154 
      else:
9155 
        iprot.skip(ftype)
9156 
      iprot.readFieldEnd()
9157 
    iprot.readStructEnd()
9158 
 
9159 
  def write(self, oprot):
9160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9162 
      return
1996 vikas 9163 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9164 
    if self.id is not None:
1996 vikas 9165 
      oprot.writeFieldBegin('id', TType.I64, 1)
9166 
      oprot.writeI64(self.id)
1845 vikas 9167 
      oprot.writeFieldEnd()
9168 
    oprot.writeFieldStop()
9169 
    oprot.writeStructEnd()
9170 
 
3431 rajveer 9171 
  def validate(self):
9172 
    return
9173 
 
9174 
 
1845 vikas 9175 
  def __repr__(self):
9176 
    L = ['%s=%r' % (key, value)
9177 
      for key, value in self.__dict__.iteritems()]
9178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9179 
 
9180 
  def __eq__(self, other):
9181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9182 
 
9183 
  def __ne__(self, other):
9184 
    return not (self == other)
9185 
 
1996 vikas 9186 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9187 
  """
9188 
  Attributes:
9189 
   - success
9190 
   - utx
9191 
  """
9192 
 
9193 
  thrift_spec = (
1996 vikas 9194 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9195 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9196 
  )
9197 
 
9198 
  def __init__(self, success=None, utx=None,):
9199 
    self.success = success
9200 
    self.utx = utx
9201 
 
9202 
  def read(self, iprot):
9203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9205 
      return
9206 
    iprot.readStructBegin()
9207 
    while True:
9208 
      (fname, ftype, fid) = iprot.readFieldBegin()
9209 
      if ftype == TType.STOP:
9210 
        break
9211 
      if fid == 0:
9212 
        if ftype == TType.LIST:
9213 
          self.success = []
11592 amit.gupta 9214 
          (_etype128, _size125) = iprot.readListBegin()
9215 
          for _i129 in xrange(_size125):
9216 
            _elem130 = Affiliate()
9217 
            _elem130.read(iprot)
9218 
            self.success.append(_elem130)
1845 vikas 9219 
          iprot.readListEnd()
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      elif fid == 1:
9223 
        if ftype == TType.STRUCT:
1996 vikas 9224 
          self.utx = UserAffiliateException()
1845 vikas 9225 
          self.utx.read(iprot)
9226 
        else:
9227 
          iprot.skip(ftype)
9228 
      else:
9229 
        iprot.skip(ftype)
9230 
      iprot.readFieldEnd()
9231 
    iprot.readStructEnd()
9232 
 
9233 
  def write(self, oprot):
9234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9236 
      return
1996 vikas 9237 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9238 
    if self.success is not None:
1845 vikas 9239 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9240 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9241 
      for iter131 in self.success:
9242 
        iter131.write(oprot)
1845 vikas 9243 
      oprot.writeListEnd()
9244 
      oprot.writeFieldEnd()
3431 rajveer 9245 
    if self.utx is not None:
1845 vikas 9246 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9247 
      self.utx.write(oprot)
9248 
      oprot.writeFieldEnd()
9249 
    oprot.writeFieldStop()
9250 
    oprot.writeStructEnd()
9251 
 
3431 rajveer 9252 
  def validate(self):
9253 
    return
9254 
 
9255 
 
1845 vikas 9256 
  def __repr__(self):
9257 
    L = ['%s=%r' % (key, value)
9258 
      for key, value in self.__dict__.iteritems()]
9259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9260 
 
9261 
  def __eq__(self, other):
9262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9263 
 
9264 
  def __ne__(self, other):
9265 
    return not (self == other)
9266 
 
9267 
class addTrackLog_args:
9268 
  """
9269 
  Attributes:
1996 vikas 9270 
   - affiliateId
1845 vikas 9271 
   - userId
9272 
   - event
9273 
   - url
9274 
   - data
1859 vikas 9275 
   - addedOn
1845 vikas 9276 
  """
9277 
 
9278 
  thrift_spec = (
9279 
    None, # 0
1996 vikas 9280 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9281 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9282 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9283 
    (4, TType.STRING, 'url', None, None, ), # 4
9284 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9285 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9286 
  )
9287 
 
1996 vikas 9288 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9289 
    self.affiliateId = affiliateId
1845 vikas 9290 
    self.userId = userId
9291 
    self.event = event
9292 
    self.url = url
9293 
    self.data = data
1859 vikas 9294 
    self.addedOn = addedOn
1845 vikas 9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 1:
9306 
        if ftype == TType.I64:
1996 vikas 9307 
          self.affiliateId = iprot.readI64();
1845 vikas 9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 2:
9311 
        if ftype == TType.I64:
9312 
          self.userId = iprot.readI64();
9313 
        else:
9314 
          iprot.skip(ftype)
9315 
      elif fid == 3:
3378 vikas 9316 
        if ftype == TType.I32:
9317 
          self.event = iprot.readI32();
1845 vikas 9318 
        else:
9319 
          iprot.skip(ftype)
9320 
      elif fid == 4:
9321 
        if ftype == TType.STRING:
9322 
          self.url = iprot.readString();
9323 
        else:
9324 
          iprot.skip(ftype)
9325 
      elif fid == 5:
9326 
        if ftype == TType.STRING:
9327 
          self.data = iprot.readString();
9328 
        else:
9329 
          iprot.skip(ftype)
1859 vikas 9330 
      elif fid == 6:
9331 
        if ftype == TType.I64:
9332 
          self.addedOn = iprot.readI64();
9333 
        else:
9334 
          iprot.skip(ftype)
1845 vikas 9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
9344 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9345 
    if self.affiliateId is not None:
1996 vikas 9346 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9347 
      oprot.writeI64(self.affiliateId)
1845 vikas 9348 
      oprot.writeFieldEnd()
3431 rajveer 9349 
    if self.userId is not None:
1845 vikas 9350 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9351 
      oprot.writeI64(self.userId)
9352 
      oprot.writeFieldEnd()
3431 rajveer 9353 
    if self.event is not None:
3378 vikas 9354 
      oprot.writeFieldBegin('event', TType.I32, 3)
9355 
      oprot.writeI32(self.event)
1845 vikas 9356 
      oprot.writeFieldEnd()
3431 rajveer 9357 
    if self.url is not None:
1845 vikas 9358 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9359 
      oprot.writeString(self.url)
9360 
      oprot.writeFieldEnd()
3431 rajveer 9361 
    if self.data is not None:
1845 vikas 9362 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9363 
      oprot.writeString(self.data)
9364 
      oprot.writeFieldEnd()
3431 rajveer 9365 
    if self.addedOn is not None:
1859 vikas 9366 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9367 
      oprot.writeI64(self.addedOn)
9368 
      oprot.writeFieldEnd()
1845 vikas 9369 
    oprot.writeFieldStop()
9370 
    oprot.writeStructEnd()
9371 
 
3431 rajveer 9372 
  def validate(self):
9373 
    return
9374 
 
9375 
 
1845 vikas 9376 
  def __repr__(self):
9377 
    L = ['%s=%r' % (key, value)
9378 
      for key, value in self.__dict__.iteritems()]
9379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9380 
 
9381 
  def __eq__(self, other):
9382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9383 
 
9384 
  def __ne__(self, other):
9385 
    return not (self == other)
9386 
 
9387 
class addTrackLog_result:
9388 
  """
9389 
  Attributes:
9390 
   - success
9391 
   - utx
9392 
  """
9393 
 
9394 
  thrift_spec = (
9395 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9396 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9397 
  )
9398 
 
9399 
  def __init__(self, success=None, utx=None,):
9400 
    self.success = success
9401 
    self.utx = utx
9402 
 
9403 
  def read(self, iprot):
9404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9406 
      return
9407 
    iprot.readStructBegin()
9408 
    while True:
9409 
      (fname, ftype, fid) = iprot.readFieldBegin()
9410 
      if ftype == TType.STOP:
9411 
        break
9412 
      if fid == 0:
9413 
        if ftype == TType.I64:
9414 
          self.success = iprot.readI64();
9415 
        else:
9416 
          iprot.skip(ftype)
9417 
      elif fid == 1:
9418 
        if ftype == TType.STRUCT:
1996 vikas 9419 
          self.utx = UserAffiliateException()
1845 vikas 9420 
          self.utx.read(iprot)
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      else:
9424 
        iprot.skip(ftype)
9425 
      iprot.readFieldEnd()
9426 
    iprot.readStructEnd()
9427 
 
9428 
  def write(self, oprot):
9429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9431 
      return
9432 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9433 
    if self.success is not None:
1845 vikas 9434 
      oprot.writeFieldBegin('success', TType.I64, 0)
9435 
      oprot.writeI64(self.success)
9436 
      oprot.writeFieldEnd()
3431 rajveer 9437 
    if self.utx is not None:
1845 vikas 9438 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9439 
      self.utx.write(oprot)
9440 
      oprot.writeFieldEnd()
9441 
    oprot.writeFieldStop()
9442 
    oprot.writeStructEnd()
9443 
 
3431 rajveer 9444 
  def validate(self):
9445 
    return
9446 
 
9447 
 
1845 vikas 9448 
  def __repr__(self):
9449 
    L = ['%s=%r' % (key, value)
9450 
      for key, value in self.__dict__.iteritems()]
9451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9452 
 
9453 
  def __eq__(self, other):
9454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9455 
 
9456 
  def __ne__(self, other):
9457 
    return not (self == other)
9458 
 
9459 
class getTrackLogById_args:
9460 
  """
9461 
  Attributes:
9462 
   - id
9463 
  """
9464 
 
9465 
  thrift_spec = (
9466 
    None, # 0
9467 
    (1, TType.I64, 'id', None, None, ), # 1
9468 
  )
9469 
 
9470 
  def __init__(self, id=None,):
9471 
    self.id = id
9472 
 
9473 
  def read(self, iprot):
9474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9476 
      return
9477 
    iprot.readStructBegin()
9478 
    while True:
9479 
      (fname, ftype, fid) = iprot.readFieldBegin()
9480 
      if ftype == TType.STOP:
9481 
        break
9482 
      if fid == 1:
9483 
        if ftype == TType.I64:
9484 
          self.id = iprot.readI64();
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      else:
9488 
        iprot.skip(ftype)
9489 
      iprot.readFieldEnd()
9490 
    iprot.readStructEnd()
9491 
 
9492 
  def write(self, oprot):
9493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9495 
      return
9496 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9497 
    if self.id is not None:
1845 vikas 9498 
      oprot.writeFieldBegin('id', TType.I64, 1)
9499 
      oprot.writeI64(self.id)
9500 
      oprot.writeFieldEnd()
9501 
    oprot.writeFieldStop()
9502 
    oprot.writeStructEnd()
9503 
 
3431 rajveer 9504 
  def validate(self):
9505 
    return
9506 
 
9507 
 
1845 vikas 9508 
  def __repr__(self):
9509 
    L = ['%s=%r' % (key, value)
9510 
      for key, value in self.__dict__.iteritems()]
9511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9512 
 
9513 
  def __eq__(self, other):
9514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9515 
 
9516 
  def __ne__(self, other):
9517 
    return not (self == other)
9518 
 
9519 
class getTrackLogById_result:
9520 
  """
9521 
  Attributes:
9522 
   - success
9523 
   - utx
9524 
  """
9525 
 
9526 
  thrift_spec = (
9527 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9528 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9529 
  )
9530 
 
9531 
  def __init__(self, success=None, utx=None,):
9532 
    self.success = success
9533 
    self.utx = utx
9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      if fid == 0:
9545 
        if ftype == TType.STRUCT:
9546 
          self.success = TrackLog()
9547 
          self.success.read(iprot)
9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      elif fid == 1:
9551 
        if ftype == TType.STRUCT:
1996 vikas 9552 
          self.utx = UserAffiliateException()
1845 vikas 9553 
          self.utx.read(iprot)
9554 
        else:
9555 
          iprot.skip(ftype)
9556 
      else:
9557 
        iprot.skip(ftype)
9558 
      iprot.readFieldEnd()
9559 
    iprot.readStructEnd()
9560 
 
9561 
  def write(self, oprot):
9562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9564 
      return
9565 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9566 
    if self.success is not None:
1845 vikas 9567 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9568 
      self.success.write(oprot)
9569 
      oprot.writeFieldEnd()
3431 rajveer 9570 
    if self.utx is not None:
1845 vikas 9571 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9572 
      self.utx.write(oprot)
9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
3431 rajveer 9577 
  def validate(self):
9578 
    return
9579 
 
9580 
 
1845 vikas 9581 
  def __repr__(self):
9582 
    L = ['%s=%r' % (key, value)
9583 
      for key, value in self.__dict__.iteritems()]
9584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9585 
 
9586 
  def __eq__(self, other):
9587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9588 
 
9589 
  def __ne__(self, other):
9590 
    return not (self == other)
9591 
 
1996 vikas 9592 
class getTrackLogsByAffiliate_args:
1845 vikas 9593 
  """
9594 
  Attributes:
1996 vikas 9595 
   - affiliateId
3293 vikas 9596 
   - startDate
9597 
   - endDate
1845 vikas 9598 
  """
9599 
 
9600 
  thrift_spec = (
9601 
    None, # 0
1996 vikas 9602 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9603 
    (2, TType.I64, 'startDate', None, None, ), # 2
9604 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9605 
  )
9606 
 
3293 vikas 9607 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9608 
    self.affiliateId = affiliateId
3293 vikas 9609 
    self.startDate = startDate
9610 
    self.endDate = endDate
1845 vikas 9611 
 
9612 
  def read(self, iprot):
9613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9615 
      return
9616 
    iprot.readStructBegin()
9617 
    while True:
9618 
      (fname, ftype, fid) = iprot.readFieldBegin()
9619 
      if ftype == TType.STOP:
9620 
        break
9621 
      if fid == 1:
9622 
        if ftype == TType.I64:
1996 vikas 9623 
          self.affiliateId = iprot.readI64();
1845 vikas 9624 
        else:
9625 
          iprot.skip(ftype)
3293 vikas 9626 
      elif fid == 2:
9627 
        if ftype == TType.I64:
9628 
          self.startDate = iprot.readI64();
9629 
        else:
9630 
          iprot.skip(ftype)
9631 
      elif fid == 3:
9632 
        if ftype == TType.I64:
9633 
          self.endDate = iprot.readI64();
9634 
        else:
9635 
          iprot.skip(ftype)
1845 vikas 9636 
      else:
9637 
        iprot.skip(ftype)
9638 
      iprot.readFieldEnd()
9639 
    iprot.readStructEnd()
9640 
 
9641 
  def write(self, oprot):
9642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9644 
      return
1996 vikas 9645 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9646 
    if self.affiliateId is not None:
1996 vikas 9647 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9648 
      oprot.writeI64(self.affiliateId)
1845 vikas 9649 
      oprot.writeFieldEnd()
3431 rajveer 9650 
    if self.startDate is not None:
3293 vikas 9651 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9652 
      oprot.writeI64(self.startDate)
9653 
      oprot.writeFieldEnd()
3431 rajveer 9654 
    if self.endDate is not None:
3293 vikas 9655 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9656 
      oprot.writeI64(self.endDate)
9657 
      oprot.writeFieldEnd()
1845 vikas 9658 
    oprot.writeFieldStop()
9659 
    oprot.writeStructEnd()
9660 
 
3431 rajveer 9661 
  def validate(self):
9662 
    return
9663 
 
9664 
 
1845 vikas 9665 
  def __repr__(self):
9666 
    L = ['%s=%r' % (key, value)
9667 
      for key, value in self.__dict__.iteritems()]
9668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9669 
 
9670 
  def __eq__(self, other):
9671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9672 
 
9673 
  def __ne__(self, other):
9674 
    return not (self == other)
9675 
 
1996 vikas 9676 
class getTrackLogsByAffiliate_result:
1845 vikas 9677 
  """
9678 
  Attributes:
9679 
   - success
9680 
   - utx
9681 
  """
9682 
 
9683 
  thrift_spec = (
9684 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9685 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9686 
  )
9687 
 
9688 
  def __init__(self, success=None, utx=None,):
9689 
    self.success = success
9690 
    self.utx = utx
9691 
 
9692 
  def read(self, iprot):
9693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9695 
      return
9696 
    iprot.readStructBegin()
9697 
    while True:
9698 
      (fname, ftype, fid) = iprot.readFieldBegin()
9699 
      if ftype == TType.STOP:
9700 
        break
9701 
      if fid == 0:
9702 
        if ftype == TType.LIST:
9703 
          self.success = []
11592 amit.gupta 9704 
          (_etype135, _size132) = iprot.readListBegin()
9705 
          for _i136 in xrange(_size132):
9706 
            _elem137 = TrackLog()
9707 
            _elem137.read(iprot)
9708 
            self.success.append(_elem137)
1845 vikas 9709 
          iprot.readListEnd()
9710 
        else:
9711 
          iprot.skip(ftype)
9712 
      elif fid == 1:
9713 
        if ftype == TType.STRUCT:
1996 vikas 9714 
          self.utx = UserAffiliateException()
1845 vikas 9715 
          self.utx.read(iprot)
9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
1996 vikas 9727 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9728 
    if self.success is not None:
1845 vikas 9729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9731 
      for iter138 in self.success:
9732 
        iter138.write(oprot)
1845 vikas 9733 
      oprot.writeListEnd()
9734 
      oprot.writeFieldEnd()
3431 rajveer 9735 
    if self.utx is not None:
1845 vikas 9736 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9737 
      self.utx.write(oprot)
9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
3431 rajveer 9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
1845 vikas 9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
9757 
class getTrackLogsByUser_args:
9758 
  """
9759 
  Attributes:
9760 
   - userId
9761 
  """
9762 
 
9763 
  thrift_spec = (
9764 
    None, # 0
9765 
    (1, TType.I64, 'userId', None, None, ), # 1
9766 
  )
9767 
 
9768 
  def __init__(self, userId=None,):
9769 
    self.userId = userId
9770 
 
9771 
  def read(self, iprot):
9772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9774 
      return
9775 
    iprot.readStructBegin()
9776 
    while True:
9777 
      (fname, ftype, fid) = iprot.readFieldBegin()
9778 
      if ftype == TType.STOP:
9779 
        break
9780 
      if fid == 1:
9781 
        if ftype == TType.I64:
9782 
          self.userId = iprot.readI64();
9783 
        else:
9784 
          iprot.skip(ftype)
9785 
      else:
9786 
        iprot.skip(ftype)
9787 
      iprot.readFieldEnd()
9788 
    iprot.readStructEnd()
9789 
 
9790 
  def write(self, oprot):
9791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9793 
      return
9794 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9795 
    if self.userId is not None:
1845 vikas 9796 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9797 
      oprot.writeI64(self.userId)
9798 
      oprot.writeFieldEnd()
9799 
    oprot.writeFieldStop()
9800 
    oprot.writeStructEnd()
9801 
 
3431 rajveer 9802 
  def validate(self):
9803 
    return
9804 
 
9805 
 
1845 vikas 9806 
  def __repr__(self):
9807 
    L = ['%s=%r' % (key, value)
9808 
      for key, value in self.__dict__.iteritems()]
9809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9810 
 
9811 
  def __eq__(self, other):
9812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9813 
 
9814 
  def __ne__(self, other):
9815 
    return not (self == other)
9816 
 
9817 
class getTrackLogsByUser_result:
9818 
  """
9819 
  Attributes:
9820 
   - success
9821 
   - utx
9822 
  """
9823 
 
9824 
  thrift_spec = (
9825 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9826 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9827 
  )
9828 
 
9829 
  def __init__(self, success=None, utx=None,):
9830 
    self.success = success
9831 
    self.utx = utx
9832 
 
9833 
  def read(self, iprot):
9834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9836 
      return
9837 
    iprot.readStructBegin()
9838 
    while True:
9839 
      (fname, ftype, fid) = iprot.readFieldBegin()
9840 
      if ftype == TType.STOP:
9841 
        break
9842 
      if fid == 0:
9843 
        if ftype == TType.LIST:
9844 
          self.success = []
11592 amit.gupta 9845 
          (_etype142, _size139) = iprot.readListBegin()
9846 
          for _i143 in xrange(_size139):
9847 
            _elem144 = TrackLog()
9848 
            _elem144.read(iprot)
9849 
            self.success.append(_elem144)
1845 vikas 9850 
          iprot.readListEnd()
9851 
        else:
9852 
          iprot.skip(ftype)
9853 
      elif fid == 1:
9854 
        if ftype == TType.STRUCT:
1996 vikas 9855 
          self.utx = UserAffiliateException()
1845 vikas 9856 
          self.utx.read(iprot)
9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      else:
9860 
        iprot.skip(ftype)
9861 
      iprot.readFieldEnd()
9862 
    iprot.readStructEnd()
9863 
 
9864 
  def write(self, oprot):
9865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9867 
      return
9868 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 9869 
    if self.success is not None:
1845 vikas 9870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9872 
      for iter145 in self.success:
9873 
        iter145.write(oprot)
1845 vikas 9874 
      oprot.writeListEnd()
9875 
      oprot.writeFieldEnd()
3431 rajveer 9876 
    if self.utx is not None:
1845 vikas 9877 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9878 
      self.utx.write(oprot)
9879 
      oprot.writeFieldEnd()
9880 
    oprot.writeFieldStop()
9881 
    oprot.writeStructEnd()
9882 
 
3431 rajveer 9883 
  def validate(self):
9884 
    return
9885 
 
9886 
 
1845 vikas 9887 
  def __repr__(self):
9888 
    L = ['%s=%r' % (key, value)
9889 
      for key, value in self.__dict__.iteritems()]
9890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9891 
 
9892 
  def __eq__(self, other):
9893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9894 
 
9895 
  def __ne__(self, other):
9896 
    return not (self == other)
9897 
 
9898 
class getTrackLogs_args:
9899 
  """
9900 
  Attributes:
9901 
   - userId
9902 
   - event
9903 
   - url
9904 
  """
9905 
 
9906 
  thrift_spec = (
9907 
    None, # 0
1996 vikas 9908 
    (1, TType.I64, 'userId', None, None, ), # 1
9909 
    (2, TType.STRING, 'event', None, None, ), # 2
9910 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9911 
  )
9912 
 
1996 vikas 9913 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9914 
    self.userId = userId
9915 
    self.event = event
9916 
    self.url = url
9917 
 
9918 
  def read(self, iprot):
9919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9921 
      return
9922 
    iprot.readStructBegin()
9923 
    while True:
9924 
      (fname, ftype, fid) = iprot.readFieldBegin()
9925 
      if ftype == TType.STOP:
9926 
        break
9927 
      if fid == 1:
9928 
        if ftype == TType.I64:
1996 vikas 9929 
          self.userId = iprot.readI64();
1845 vikas 9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      elif fid == 2:
9933 
        if ftype == TType.STRING:
9934 
          self.event = iprot.readString();
9935 
        else:
9936 
          iprot.skip(ftype)
1996 vikas 9937 
      elif fid == 3:
1845 vikas 9938 
        if ftype == TType.STRING:
9939 
          self.url = iprot.readString();
9940 
        else:
9941 
          iprot.skip(ftype)
9942 
      else:
9943 
        iprot.skip(ftype)
9944 
      iprot.readFieldEnd()
9945 
    iprot.readStructEnd()
9946 
 
9947 
  def write(self, oprot):
9948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9950 
      return
9951 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 9952 
    if self.userId is not None:
1996 vikas 9953 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9954 
      oprot.writeI64(self.userId)
9955 
      oprot.writeFieldEnd()
3431 rajveer 9956 
    if self.event is not None:
1996 vikas 9957 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9958 
      oprot.writeString(self.event)
9959 
      oprot.writeFieldEnd()
3431 rajveer 9960 
    if self.url is not None:
1996 vikas 9961 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9962 
      oprot.writeString(self.url)
9963 
      oprot.writeFieldEnd()
9964 
    oprot.writeFieldStop()
9965 
    oprot.writeStructEnd()
9966 
 
3431 rajveer 9967 
  def validate(self):
9968 
    return
9969 
 
9970 
 
1845 vikas 9971 
  def __repr__(self):
9972 
    L = ['%s=%r' % (key, value)
9973 
      for key, value in self.__dict__.iteritems()]
9974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9975 
 
9976 
  def __eq__(self, other):
9977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9978 
 
9979 
  def __ne__(self, other):
9980 
    return not (self == other)
9981 
 
9982 
class getTrackLogs_result:
9983 
  """
9984 
  Attributes:
9985 
   - success
9986 
   - utx
9987 
  """
9988 
 
9989 
  thrift_spec = (
9990 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9991 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9992 
  )
9993 
 
9994 
  def __init__(self, success=None, utx=None,):
9995 
    self.success = success
9996 
    self.utx = utx
9997 
 
9998 
  def read(self, iprot):
9999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10001 
      return
10002 
    iprot.readStructBegin()
10003 
    while True:
10004 
      (fname, ftype, fid) = iprot.readFieldBegin()
10005 
      if ftype == TType.STOP:
10006 
        break
10007 
      if fid == 0:
10008 
        if ftype == TType.LIST:
10009 
          self.success = []
11592 amit.gupta 10010 
          (_etype149, _size146) = iprot.readListBegin()
10011 
          for _i150 in xrange(_size146):
10012 
            _elem151 = TrackLog()
10013 
            _elem151.read(iprot)
10014 
            self.success.append(_elem151)
1845 vikas 10015 
          iprot.readListEnd()
10016 
        else:
10017 
          iprot.skip(ftype)
10018 
      elif fid == 1:
10019 
        if ftype == TType.STRUCT:
1996 vikas 10020 
          self.utx = UserAffiliateException()
1845 vikas 10021 
          self.utx.read(iprot)
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      else:
10025 
        iprot.skip(ftype)
10026 
      iprot.readFieldEnd()
10027 
    iprot.readStructEnd()
10028 
 
10029 
  def write(self, oprot):
10030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10032 
      return
10033 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10034 
    if self.success is not None:
1845 vikas 10035 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10036 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10037 
      for iter152 in self.success:
10038 
        iter152.write(oprot)
1845 vikas 10039 
      oprot.writeListEnd()
10040 
      oprot.writeFieldEnd()
3431 rajveer 10041 
    if self.utx is not None:
1845 vikas 10042 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10043 
      self.utx.write(oprot)
10044 
      oprot.writeFieldEnd()
10045 
    oprot.writeFieldStop()
10046 
    oprot.writeStructEnd()
10047 
 
3431 rajveer 10048 
  def validate(self):
10049 
    return
10050 
 
10051 
 
1845 vikas 10052 
  def __repr__(self):
10053 
    L = ['%s=%r' % (key, value)
10054 
      for key, value in self.__dict__.iteritems()]
10055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10056 
 
10057 
  def __eq__(self, other):
10058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10059 
 
10060 
  def __ne__(self, other):
10061 
    return not (self == other)
10062 
 
559 chandransh 10063 
class getCurrentCart_args:
94 ashish 10064 
  """
10065 
  Attributes:
559 chandransh 10066 
   - userId
10067 
  """
10068 
 
10069 
  thrift_spec = (
10070 
    None, # 0
10071 
    (1, TType.I64, 'userId', None, None, ), # 1
10072 
  )
10073 
 
10074 
  def __init__(self, userId=None,):
10075 
    self.userId = userId
10076 
 
10077 
  def read(self, iprot):
10078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10080 
      return
10081 
    iprot.readStructBegin()
10082 
    while True:
10083 
      (fname, ftype, fid) = iprot.readFieldBegin()
10084 
      if ftype == TType.STOP:
10085 
        break
10086 
      if fid == 1:
10087 
        if ftype == TType.I64:
10088 
          self.userId = iprot.readI64();
10089 
        else:
10090 
          iprot.skip(ftype)
10091 
      else:
10092 
        iprot.skip(ftype)
10093 
      iprot.readFieldEnd()
10094 
    iprot.readStructEnd()
10095 
 
10096 
  def write(self, oprot):
10097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10099 
      return
10100 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10101 
    if self.userId is not None:
559 chandransh 10102 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10103 
      oprot.writeI64(self.userId)
10104 
      oprot.writeFieldEnd()
10105 
    oprot.writeFieldStop()
10106 
    oprot.writeStructEnd()
10107 
 
3431 rajveer 10108 
  def validate(self):
10109 
    return
10110 
 
10111 
 
559 chandransh 10112 
  def __repr__(self):
10113 
    L = ['%s=%r' % (key, value)
10114 
      for key, value in self.__dict__.iteritems()]
10115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10116 
 
10117 
  def __eq__(self, other):
10118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10119 
 
10120 
  def __ne__(self, other):
10121 
    return not (self == other)
10122 
 
10123 
class getCurrentCart_result:
10124 
  """
10125 
  Attributes:
94 ashish 10126 
   - success
559 chandransh 10127 
   - scx
94 ashish 10128 
  """
10129 
 
10130 
  thrift_spec = (
559 chandransh 10131 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10132 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10133 
  )
10134 
 
559 chandransh 10135 
  def __init__(self, success=None, scx=None,):
94 ashish 10136 
    self.success = success
559 chandransh 10137 
    self.scx = scx
94 ashish 10138 
 
10139 
  def read(self, iprot):
10140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10142 
      return
10143 
    iprot.readStructBegin()
10144 
    while True:
10145 
      (fname, ftype, fid) = iprot.readFieldBegin()
10146 
      if ftype == TType.STOP:
10147 
        break
10148 
      if fid == 0:
559 chandransh 10149 
        if ftype == TType.STRUCT:
10150 
          self.success = Cart()
10151 
          self.success.read(iprot)
94 ashish 10152 
        else:
10153 
          iprot.skip(ftype)
10154 
      elif fid == 1:
10155 
        if ftype == TType.STRUCT:
559 chandransh 10156 
          self.scx = ShoppingCartException()
10157 
          self.scx.read(iprot)
94 ashish 10158 
        else:
10159 
          iprot.skip(ftype)
10160 
      else:
10161 
        iprot.skip(ftype)
10162 
      iprot.readFieldEnd()
10163 
    iprot.readStructEnd()
10164 
 
10165 
  def write(self, oprot):
10166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10168 
      return
559 chandransh 10169 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10170 
    if self.success is not None:
559 chandransh 10171 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10172 
      self.success.write(oprot)
94 ashish 10173 
      oprot.writeFieldEnd()
3431 rajveer 10174 
    if self.scx is not None:
559 chandransh 10175 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10176 
      self.scx.write(oprot)
94 ashish 10177 
      oprot.writeFieldEnd()
10178 
    oprot.writeFieldStop()
10179 
    oprot.writeStructEnd()
10180 
 
3431 rajveer 10181 
  def validate(self):
10182 
    return
10183 
 
10184 
 
94 ashish 10185 
  def __repr__(self):
10186 
    L = ['%s=%r' % (key, value)
10187 
      for key, value in self.__dict__.iteritems()]
10188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10189 
 
10190 
  def __eq__(self, other):
10191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10192 
 
10193 
  def __ne__(self, other):
10194 
    return not (self == other)
10195 
 
559 chandransh 10196 
class getCart_args:
504 rajveer 10197 
  """
10198 
  Attributes:
559 chandransh 10199 
   - cartId
504 rajveer 10200 
  """
10201 
 
10202 
  thrift_spec = (
10203 
    None, # 0
559 chandransh 10204 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10205 
  )
10206 
 
559 chandransh 10207 
  def __init__(self, cartId=None,):
10208 
    self.cartId = cartId
504 rajveer 10209 
 
10210 
  def read(self, iprot):
10211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10213 
      return
10214 
    iprot.readStructBegin()
10215 
    while True:
10216 
      (fname, ftype, fid) = iprot.readFieldBegin()
10217 
      if ftype == TType.STOP:
10218 
        break
10219 
      if fid == 1:
10220 
        if ftype == TType.I64:
559 chandransh 10221 
          self.cartId = iprot.readI64();
504 rajveer 10222 
        else:
10223 
          iprot.skip(ftype)
10224 
      else:
10225 
        iprot.skip(ftype)
10226 
      iprot.readFieldEnd()
10227 
    iprot.readStructEnd()
10228 
 
10229 
  def write(self, oprot):
10230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10232 
      return
559 chandransh 10233 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10234 
    if self.cartId is not None:
559 chandransh 10235 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10236 
      oprot.writeI64(self.cartId)
504 rajveer 10237 
      oprot.writeFieldEnd()
10238 
    oprot.writeFieldStop()
10239 
    oprot.writeStructEnd()
10240 
 
3431 rajveer 10241 
  def validate(self):
10242 
    return
10243 
 
10244 
 
504 rajveer 10245 
  def __repr__(self):
10246 
    L = ['%s=%r' % (key, value)
10247 
      for key, value in self.__dict__.iteritems()]
10248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10249 
 
10250 
  def __eq__(self, other):
10251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10252 
 
10253 
  def __ne__(self, other):
10254 
    return not (self == other)
10255 
 
559 chandransh 10256 
class getCart_result:
504 rajveer 10257 
  """
10258 
  Attributes:
10259 
   - success
559 chandransh 10260 
   - scx
504 rajveer 10261 
  """
10262 
 
10263 
  thrift_spec = (
559 chandransh 10264 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10265 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10266 
  )
10267 
 
559 chandransh 10268 
  def __init__(self, success=None, scx=None,):
504 rajveer 10269 
    self.success = success
559 chandransh 10270 
    self.scx = scx
504 rajveer 10271 
 
10272 
  def read(self, iprot):
10273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10275 
      return
10276 
    iprot.readStructBegin()
10277 
    while True:
10278 
      (fname, ftype, fid) = iprot.readFieldBegin()
10279 
      if ftype == TType.STOP:
10280 
        break
10281 
      if fid == 0:
559 chandransh 10282 
        if ftype == TType.STRUCT:
10283 
          self.success = Cart()
10284 
          self.success.read(iprot)
504 rajveer 10285 
        else:
10286 
          iprot.skip(ftype)
10287 
      elif fid == 1:
10288 
        if ftype == TType.STRUCT:
559 chandransh 10289 
          self.scx = ShoppingCartException()
10290 
          self.scx.read(iprot)
504 rajveer 10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      else:
10294 
        iprot.skip(ftype)
10295 
      iprot.readFieldEnd()
10296 
    iprot.readStructEnd()
10297 
 
10298 
  def write(self, oprot):
10299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10301 
      return
559 chandransh 10302 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10303 
    if self.success is not None:
559 chandransh 10304 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10305 
      self.success.write(oprot)
504 rajveer 10306 
      oprot.writeFieldEnd()
3431 rajveer 10307 
    if self.scx is not None:
559 chandransh 10308 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10309 
      self.scx.write(oprot)
504 rajveer 10310 
      oprot.writeFieldEnd()
10311 
    oprot.writeFieldStop()
10312 
    oprot.writeStructEnd()
10313 
 
3431 rajveer 10314 
  def validate(self):
10315 
    return
10316 
 
10317 
 
504 rajveer 10318 
  def __repr__(self):
10319 
    L = ['%s=%r' % (key, value)
10320 
      for key, value in self.__dict__.iteritems()]
10321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10322 
 
10323 
  def __eq__(self, other):
10324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10325 
 
10326 
  def __ne__(self, other):
10327 
    return not (self == other)
10328 
 
559 chandransh 10329 
class getCartsByTime_args:
10330 
  """
10331 
  Attributes:
10332 
   - from_time
10333 
   - to_time
10334 
   - status
10335 
  """
10336 
 
10337 
  thrift_spec = (
10338 
    None, # 0
10339 
    (1, TType.I64, 'from_time', None, None, ), # 1
10340 
    (2, TType.I64, 'to_time', None, None, ), # 2
10341 
    (3, TType.I32, 'status', None, None, ), # 3
10342 
  )
10343 
 
10344 
  def __init__(self, from_time=None, to_time=None, status=None,):
10345 
    self.from_time = from_time
10346 
    self.to_time = to_time
10347 
    self.status = status
10348 
 
10349 
  def read(self, iprot):
10350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10352 
      return
10353 
    iprot.readStructBegin()
10354 
    while True:
10355 
      (fname, ftype, fid) = iprot.readFieldBegin()
10356 
      if ftype == TType.STOP:
10357 
        break
10358 
      if fid == 1:
94 ashish 10359 
        if ftype == TType.I64:
559 chandransh 10360 
          self.from_time = iprot.readI64();
94 ashish 10361 
        else:
10362 
          iprot.skip(ftype)
122 ashish 10363 
      elif fid == 2:
559 chandransh 10364 
        if ftype == TType.I64:
10365 
          self.to_time = iprot.readI64();
122 ashish 10366 
        else:
10367 
          iprot.skip(ftype)
559 chandransh 10368 
      elif fid == 3:
10369 
        if ftype == TType.I32:
10370 
          self.status = iprot.readI32();
10371 
        else:
10372 
          iprot.skip(ftype)
94 ashish 10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
559 chandransh 10382 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10383 
    if self.from_time is not None:
559 chandransh 10384 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10385 
      oprot.writeI64(self.from_time)
94 ashish 10386 
      oprot.writeFieldEnd()
3431 rajveer 10387 
    if self.to_time is not None:
559 chandransh 10388 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10389 
      oprot.writeI64(self.to_time)
122 ashish 10390 
      oprot.writeFieldEnd()
3431 rajveer 10391 
    if self.status is not None:
559 chandransh 10392 
      oprot.writeFieldBegin('status', TType.I32, 3)
10393 
      oprot.writeI32(self.status)
10394 
      oprot.writeFieldEnd()
94 ashish 10395 
    oprot.writeFieldStop()
10396 
    oprot.writeStructEnd()
10397 
 
3431 rajveer 10398 
  def validate(self):
10399 
    return
10400 
 
10401 
 
94 ashish 10402 
  def __repr__(self):
10403 
    L = ['%s=%r' % (key, value)
10404 
      for key, value in self.__dict__.iteritems()]
10405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10406 
 
10407 
  def __eq__(self, other):
10408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10409 
 
10410 
  def __ne__(self, other):
10411 
    return not (self == other)
10412 
 
559 chandransh 10413 
class getCartsByTime_result:
94 ashish 10414 
  """
10415 
  Attributes:
10416 
   - success
559 chandransh 10417 
   - scx
94 ashish 10418 
  """
10419 
 
10420 
  thrift_spec = (
559 chandransh 10421 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10422 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10423 
  )
10424 
 
559 chandransh 10425 
  def __init__(self, success=None, scx=None,):
94 ashish 10426 
    self.success = success
559 chandransh 10427 
    self.scx = scx
94 ashish 10428 
 
10429 
  def read(self, iprot):
10430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10432 
      return
10433 
    iprot.readStructBegin()
10434 
    while True:
10435 
      (fname, ftype, fid) = iprot.readFieldBegin()
10436 
      if ftype == TType.STOP:
10437 
        break
10438 
      if fid == 0:
559 chandransh 10439 
        if ftype == TType.LIST:
10440 
          self.success = []
11592 amit.gupta 10441 
          (_etype156, _size153) = iprot.readListBegin()
10442 
          for _i157 in xrange(_size153):
10443 
            _elem158 = Cart()
10444 
            _elem158.read(iprot)
10445 
            self.success.append(_elem158)
559 chandransh 10446 
          iprot.readListEnd()
94 ashish 10447 
        else:
10448 
          iprot.skip(ftype)
10449 
      elif fid == 1:
10450 
        if ftype == TType.STRUCT:
559 chandransh 10451 
          self.scx = ShoppingCartException()
10452 
          self.scx.read(iprot)
94 ashish 10453 
        else:
10454 
          iprot.skip(ftype)
10455 
      else:
10456 
        iprot.skip(ftype)
10457 
      iprot.readFieldEnd()
10458 
    iprot.readStructEnd()
10459 
 
10460 
  def write(self, oprot):
10461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10463 
      return
559 chandransh 10464 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10465 
    if self.success is not None:
559 chandransh 10466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10468 
      for iter159 in self.success:
10469 
        iter159.write(oprot)
559 chandransh 10470 
      oprot.writeListEnd()
94 ashish 10471 
      oprot.writeFieldEnd()
3431 rajveer 10472 
    if self.scx is not None:
559 chandransh 10473 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10474 
      self.scx.write(oprot)
94 ashish 10475 
      oprot.writeFieldEnd()
10476 
    oprot.writeFieldStop()
10477 
    oprot.writeStructEnd()
10478 
 
3431 rajveer 10479 
  def validate(self):
10480 
    return
10481 
 
10482 
 
94 ashish 10483 
  def __repr__(self):
10484 
    L = ['%s=%r' % (key, value)
10485 
      for key, value in self.__dict__.iteritems()]
10486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10487 
 
10488 
  def __eq__(self, other):
10489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10490 
 
10491 
  def __ne__(self, other):
10492 
    return not (self == other)
10493 
 
559 chandransh 10494 
class addItemToCart_args:
10495 
  """
10496 
  Attributes:
10497 
   - cartId
10498 
   - itemId
10499 
   - quantity
3557 rajveer 10500 
   - sourceId
559 chandransh 10501 
  """
10502 
 
10503 
  thrift_spec = (
10504 
    None, # 0
10505 
    (1, TType.I64, 'cartId', None, None, ), # 1
10506 
    (2, TType.I64, 'itemId', None, None, ), # 2
10507 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10508 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10509 
  )
10510 
 
3557 rajveer 10511 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10512 
    self.cartId = cartId
10513 
    self.itemId = itemId
10514 
    self.quantity = quantity
3557 rajveer 10515 
    self.sourceId = sourceId
559 chandransh 10516 
 
10517 
  def read(self, iprot):
10518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10520 
      return
10521 
    iprot.readStructBegin()
10522 
    while True:
10523 
      (fname, ftype, fid) = iprot.readFieldBegin()
10524 
      if ftype == TType.STOP:
10525 
        break
10526 
      if fid == 1:
10527 
        if ftype == TType.I64:
10528 
          self.cartId = iprot.readI64();
10529 
        else:
10530 
          iprot.skip(ftype)
10531 
      elif fid == 2:
10532 
        if ftype == TType.I64:
10533 
          self.itemId = iprot.readI64();
10534 
        else:
10535 
          iprot.skip(ftype)
10536 
      elif fid == 3:
10537 
        if ftype == TType.I64:
10538 
          self.quantity = iprot.readI64();
10539 
        else:
10540 
          iprot.skip(ftype)
3557 rajveer 10541 
      elif fid == 4:
10542 
        if ftype == TType.I64:
10543 
          self.sourceId = iprot.readI64();
10544 
        else:
10545 
          iprot.skip(ftype)
559 chandransh 10546 
      else:
10547 
        iprot.skip(ftype)
10548 
      iprot.readFieldEnd()
10549 
    iprot.readStructEnd()
10550 
 
10551 
  def write(self, oprot):
10552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10554 
      return
10555 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10556 
    if self.cartId is not None:
559 chandransh 10557 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10558 
      oprot.writeI64(self.cartId)
10559 
      oprot.writeFieldEnd()
3431 rajveer 10560 
    if self.itemId is not None:
559 chandransh 10561 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10562 
      oprot.writeI64(self.itemId)
10563 
      oprot.writeFieldEnd()
3431 rajveer 10564 
    if self.quantity is not None:
559 chandransh 10565 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10566 
      oprot.writeI64(self.quantity)
10567 
      oprot.writeFieldEnd()
3557 rajveer 10568 
    if self.sourceId is not None:
10569 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10570 
      oprot.writeI64(self.sourceId)
10571 
      oprot.writeFieldEnd()
559 chandransh 10572 
    oprot.writeFieldStop()
10573 
    oprot.writeStructEnd()
10574 
 
3431 rajveer 10575 
  def validate(self):
10576 
    return
10577 
 
10578 
 
559 chandransh 10579 
  def __repr__(self):
10580 
    L = ['%s=%r' % (key, value)
10581 
      for key, value in self.__dict__.iteritems()]
10582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10583 
 
10584 
  def __eq__(self, other):
10585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10586 
 
10587 
  def __ne__(self, other):
10588 
    return not (self == other)
10589 
 
10590 
class addItemToCart_result:
10591 
  """
10592 
  Attributes:
2035 rajveer 10593 
   - success
559 chandransh 10594 
   - scx
10595 
  """
10596 
 
10597 
  thrift_spec = (
2035 rajveer 10598 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10599 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10600 
  )
10601 
 
2035 rajveer 10602 
  def __init__(self, success=None, scx=None,):
10603 
    self.success = success
559 chandransh 10604 
    self.scx = scx
10605 
 
10606 
  def read(self, iprot):
10607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10609 
      return
10610 
    iprot.readStructBegin()
10611 
    while True:
10612 
      (fname, ftype, fid) = iprot.readFieldBegin()
10613 
      if ftype == TType.STOP:
10614 
        break
2035 rajveer 10615 
      if fid == 0:
10616 
        if ftype == TType.STRING:
10617 
          self.success = iprot.readString();
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      elif fid == 1:
559 chandransh 10621 
        if ftype == TType.STRUCT:
10622 
          self.scx = ShoppingCartException()
10623 
          self.scx.read(iprot)
10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      else:
10627 
        iprot.skip(ftype)
10628 
      iprot.readFieldEnd()
10629 
    iprot.readStructEnd()
10630 
 
10631 
  def write(self, oprot):
10632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10634 
      return
10635 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10636 
    if self.success is not None:
2035 rajveer 10637 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10638 
      oprot.writeString(self.success)
10639 
      oprot.writeFieldEnd()
3431 rajveer 10640 
    if self.scx is not None:
559 chandransh 10641 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10642 
      self.scx.write(oprot)
10643 
      oprot.writeFieldEnd()
10644 
    oprot.writeFieldStop()
10645 
    oprot.writeStructEnd()
10646 
 
3431 rajveer 10647 
  def validate(self):
10648 
    return
10649 
 
10650 
 
559 chandransh 10651 
  def __repr__(self):
10652 
    L = ['%s=%r' % (key, value)
10653 
      for key, value in self.__dict__.iteritems()]
10654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10655 
 
10656 
  def __eq__(self, other):
10657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10658 
 
10659 
  def __ne__(self, other):
10660 
    return not (self == other)
10661 
 
10662 
class deleteItemFromCart_args:
10663 
  """
10664 
  Attributes:
10665 
   - cartId
10666 
   - itemId
10667 
  """
10668 
 
10669 
  thrift_spec = (
10670 
    None, # 0
10671 
    (1, TType.I64, 'cartId', None, None, ), # 1
10672 
    (2, TType.I64, 'itemId', None, None, ), # 2
10673 
  )
10674 
 
10675 
  def __init__(self, cartId=None, itemId=None,):
10676 
    self.cartId = cartId
10677 
    self.itemId = itemId
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 1:
10689 
        if ftype == TType.I64:
10690 
          self.cartId = iprot.readI64();
10691 
        else:
10692 
          iprot.skip(ftype)
10693 
      elif fid == 2:
10694 
        if ftype == TType.I64:
10695 
          self.itemId = iprot.readI64();
10696 
        else:
10697 
          iprot.skip(ftype)
10698 
      else:
10699 
        iprot.skip(ftype)
10700 
      iprot.readFieldEnd()
10701 
    iprot.readStructEnd()
10702 
 
10703 
  def write(self, oprot):
10704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10706 
      return
10707 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10708 
    if self.cartId is not None:
559 chandransh 10709 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10710 
      oprot.writeI64(self.cartId)
10711 
      oprot.writeFieldEnd()
3431 rajveer 10712 
    if self.itemId is not None:
559 chandransh 10713 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10714 
      oprot.writeI64(self.itemId)
10715 
      oprot.writeFieldEnd()
10716 
    oprot.writeFieldStop()
10717 
    oprot.writeStructEnd()
10718 
 
3431 rajveer 10719 
  def validate(self):
10720 
    return
10721 
 
10722 
 
559 chandransh 10723 
  def __repr__(self):
10724 
    L = ['%s=%r' % (key, value)
10725 
      for key, value in self.__dict__.iteritems()]
10726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10727 
 
10728 
  def __eq__(self, other):
10729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10730 
 
10731 
  def __ne__(self, other):
10732 
    return not (self == other)
10733 
 
10734 
class deleteItemFromCart_result:
10735 
  """
10736 
  Attributes:
10737 
   - scx
10738 
  """
10739 
 
10740 
  thrift_spec = (
10741 
    None, # 0
10742 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10743 
  )
10744 
 
10745 
  def __init__(self, scx=None,):
10746 
    self.scx = scx
10747 
 
10748 
  def read(self, iprot):
10749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10751 
      return
10752 
    iprot.readStructBegin()
10753 
    while True:
10754 
      (fname, ftype, fid) = iprot.readFieldBegin()
10755 
      if ftype == TType.STOP:
10756 
        break
10757 
      if fid == 1:
10758 
        if ftype == TType.STRUCT:
10759 
          self.scx = ShoppingCartException()
10760 
          self.scx.read(iprot)
10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      else:
10764 
        iprot.skip(ftype)
10765 
      iprot.readFieldEnd()
10766 
    iprot.readStructEnd()
10767 
 
10768 
  def write(self, oprot):
10769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10771 
      return
10772 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10773 
    if self.scx is not None:
559 chandransh 10774 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10775 
      self.scx.write(oprot)
10776 
      oprot.writeFieldEnd()
10777 
    oprot.writeFieldStop()
10778 
    oprot.writeStructEnd()
10779 
 
3431 rajveer 10780 
  def validate(self):
10781 
    return
10782 
 
10783 
 
559 chandransh 10784 
  def __repr__(self):
10785 
    L = ['%s=%r' % (key, value)
10786 
      for key, value in self.__dict__.iteritems()]
10787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10788 
 
10789 
  def __eq__(self, other):
10790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10791 
 
10792 
  def __ne__(self, other):
10793 
    return not (self == other)
10794 
 
10795 
class addAddressToCart_args:
10796 
  """
10797 
  Attributes:
10798 
   - cartId
10799 
   - addressId
10800 
  """
10801 
 
10802 
  thrift_spec = (
10803 
    None, # 0
10804 
    (1, TType.I64, 'cartId', None, None, ), # 1
10805 
    (2, TType.I64, 'addressId', None, None, ), # 2
10806 
  )
10807 
 
10808 
  def __init__(self, cartId=None, addressId=None,):
10809 
    self.cartId = cartId
10810 
    self.addressId = addressId
10811 
 
10812 
  def read(self, iprot):
10813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10815 
      return
10816 
    iprot.readStructBegin()
10817 
    while True:
10818 
      (fname, ftype, fid) = iprot.readFieldBegin()
10819 
      if ftype == TType.STOP:
10820 
        break
10821 
      if fid == 1:
10822 
        if ftype == TType.I64:
10823 
          self.cartId = iprot.readI64();
10824 
        else:
10825 
          iprot.skip(ftype)
10826 
      elif fid == 2:
10827 
        if ftype == TType.I64:
10828 
          self.addressId = iprot.readI64();
10829 
        else:
10830 
          iprot.skip(ftype)
10831 
      else:
10832 
        iprot.skip(ftype)
10833 
      iprot.readFieldEnd()
10834 
    iprot.readStructEnd()
10835 
 
10836 
  def write(self, oprot):
10837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10839 
      return
10840 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 10841 
    if self.cartId is not None:
559 chandransh 10842 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10843 
      oprot.writeI64(self.cartId)
10844 
      oprot.writeFieldEnd()
3431 rajveer 10845 
    if self.addressId is not None:
559 chandransh 10846 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10847 
      oprot.writeI64(self.addressId)
10848 
      oprot.writeFieldEnd()
10849 
    oprot.writeFieldStop()
10850 
    oprot.writeStructEnd()
10851 
 
3431 rajveer 10852 
  def validate(self):
10853 
    return
10854 
 
10855 
 
559 chandransh 10856 
  def __repr__(self):
10857 
    L = ['%s=%r' % (key, value)
10858 
      for key, value in self.__dict__.iteritems()]
10859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10860 
 
10861 
  def __eq__(self, other):
10862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10863 
 
10864 
  def __ne__(self, other):
10865 
    return not (self == other)
10866 
 
10867 
class addAddressToCart_result:
575 chandransh 10868 
  """
10869 
  Attributes:
10870 
   - scx
10871 
  """
559 chandransh 10872 
 
10873 
  thrift_spec = (
575 chandransh 10874 
    None, # 0
10875 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10876 
  )
10877 
 
575 chandransh 10878 
  def __init__(self, scx=None,):
10879 
    self.scx = scx
10880 
 
559 chandransh 10881 
  def read(self, iprot):
10882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10884 
      return
10885 
    iprot.readStructBegin()
10886 
    while True:
10887 
      (fname, ftype, fid) = iprot.readFieldBegin()
10888 
      if ftype == TType.STOP:
10889 
        break
575 chandransh 10890 
      if fid == 1:
10891 
        if ftype == TType.STRUCT:
10892 
          self.scx = ShoppingCartException()
10893 
          self.scx.read(iprot)
10894 
        else:
10895 
          iprot.skip(ftype)
559 chandransh 10896 
      else:
10897 
        iprot.skip(ftype)
10898 
      iprot.readFieldEnd()
10899 
    iprot.readStructEnd()
10900 
 
10901 
  def write(self, oprot):
10902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10904 
      return
10905 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 10906 
    if self.scx is not None:
575 chandransh 10907 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10908 
      self.scx.write(oprot)
10909 
      oprot.writeFieldEnd()
559 chandransh 10910 
    oprot.writeFieldStop()
10911 
    oprot.writeStructEnd()
10912 
 
3431 rajveer 10913 
  def validate(self):
10914 
    return
10915 
 
10916 
 
559 chandransh 10917 
  def __repr__(self):
10918 
    L = ['%s=%r' % (key, value)
10919 
      for key, value in self.__dict__.iteritems()]
10920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10921 
 
10922 
  def __eq__(self, other):
10923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10924 
 
10925 
  def __ne__(self, other):
10926 
    return not (self == other)
10927 
 
5553 rajveer 10928 
class addStoreToCart_args:
10929 
  """
10930 
  Attributes:
10931 
   - cartId
10932 
   - storeId
10933 
  """
10934 
 
10935 
  thrift_spec = (
10936 
    None, # 0
10937 
    (1, TType.I64, 'cartId', None, None, ), # 1
10938 
    (2, TType.I64, 'storeId', None, None, ), # 2
10939 
  )
10940 
 
10941 
  def __init__(self, cartId=None, storeId=None,):
10942 
    self.cartId = cartId
10943 
    self.storeId = storeId
10944 
 
10945 
  def read(self, iprot):
10946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10948 
      return
10949 
    iprot.readStructBegin()
10950 
    while True:
10951 
      (fname, ftype, fid) = iprot.readFieldBegin()
10952 
      if ftype == TType.STOP:
10953 
        break
10954 
      if fid == 1:
10955 
        if ftype == TType.I64:
10956 
          self.cartId = iprot.readI64();
10957 
        else:
10958 
          iprot.skip(ftype)
10959 
      elif fid == 2:
10960 
        if ftype == TType.I64:
10961 
          self.storeId = iprot.readI64();
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      else:
10965 
        iprot.skip(ftype)
10966 
      iprot.readFieldEnd()
10967 
    iprot.readStructEnd()
10968 
 
10969 
  def write(self, oprot):
10970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10972 
      return
10973 
    oprot.writeStructBegin('addStoreToCart_args')
10974 
    if self.cartId is not None:
10975 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10976 
      oprot.writeI64(self.cartId)
10977 
      oprot.writeFieldEnd()
10978 
    if self.storeId is not None:
10979 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
10980 
      oprot.writeI64(self.storeId)
10981 
      oprot.writeFieldEnd()
10982 
    oprot.writeFieldStop()
10983 
    oprot.writeStructEnd()
10984 
 
10985 
  def validate(self):
10986 
    return
10987 
 
10988 
 
10989 
  def __repr__(self):
10990 
    L = ['%s=%r' % (key, value)
10991 
      for key, value in self.__dict__.iteritems()]
10992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10993 
 
10994 
  def __eq__(self, other):
10995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10996 
 
10997 
  def __ne__(self, other):
10998 
    return not (self == other)
10999 
 
11000 
class addStoreToCart_result:
11001 
  """
11002 
  Attributes:
11003 
   - scx
11004 
  """
11005 
 
11006 
  thrift_spec = (
11007 
    None, # 0
11008 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11009 
  )
11010 
 
11011 
  def __init__(self, scx=None,):
11012 
    self.scx = scx
11013 
 
11014 
  def read(self, iprot):
11015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11017 
      return
11018 
    iprot.readStructBegin()
11019 
    while True:
11020 
      (fname, ftype, fid) = iprot.readFieldBegin()
11021 
      if ftype == TType.STOP:
11022 
        break
11023 
      if fid == 1:
11024 
        if ftype == TType.STRUCT:
11025 
          self.scx = ShoppingCartException()
11026 
          self.scx.read(iprot)
11027 
        else:
11028 
          iprot.skip(ftype)
11029 
      else:
11030 
        iprot.skip(ftype)
11031 
      iprot.readFieldEnd()
11032 
    iprot.readStructEnd()
11033 
 
11034 
  def write(self, oprot):
11035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11037 
      return
11038 
    oprot.writeStructBegin('addStoreToCart_result')
11039 
    if self.scx is not None:
11040 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11041 
      self.scx.write(oprot)
11042 
      oprot.writeFieldEnd()
11043 
    oprot.writeFieldStop()
11044 
    oprot.writeStructEnd()
11045 
 
11046 
  def validate(self):
11047 
    return
11048 
 
11049 
 
11050 
  def __repr__(self):
11051 
    L = ['%s=%r' % (key, value)
11052 
      for key, value in self.__dict__.iteritems()]
11053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11054 
 
11055 
  def __eq__(self, other):
11056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11057 
 
11058 
  def __ne__(self, other):
11059 
    return not (self == other)
11060 
 
1976 varun.gupt 11061 
class applyCouponToCart_args:
11062 
  """
11063 
  Attributes:
6922 anupam.sin 11064 
   - cart
1976 varun.gupt 11065 
   - couponCode
11066 
  """
11067 
 
11068 
  thrift_spec = (
11069 
    None, # 0
6922 anupam.sin 11070 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11071 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11072 
  )
11073 
 
6922 anupam.sin 11074 
  def __init__(self, cart=None, couponCode=None,):
11075 
    self.cart = cart
1976 varun.gupt 11076 
    self.couponCode = couponCode
11077 
 
11078 
  def read(self, iprot):
11079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11081 
      return
11082 
    iprot.readStructBegin()
11083 
    while True:
11084 
      (fname, ftype, fid) = iprot.readFieldBegin()
11085 
      if ftype == TType.STOP:
11086 
        break
11087 
      if fid == 1:
6922 anupam.sin 11088 
        if ftype == TType.STRUCT:
11089 
          self.cart = Cart()
11090 
          self.cart.read(iprot)
1976 varun.gupt 11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      elif fid == 2:
11094 
        if ftype == TType.STRING:
11095 
          self.couponCode = iprot.readString();
11096 
        else:
11097 
          iprot.skip(ftype)
11098 
      else:
11099 
        iprot.skip(ftype)
11100 
      iprot.readFieldEnd()
11101 
    iprot.readStructEnd()
11102 
 
11103 
  def write(self, oprot):
11104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11106 
      return
11107 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11108 
    if self.cart is not None:
11109 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11110 
      self.cart.write(oprot)
1976 varun.gupt 11111 
      oprot.writeFieldEnd()
3431 rajveer 11112 
    if self.couponCode is not None:
1976 varun.gupt 11113 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11114 
      oprot.writeString(self.couponCode)
11115 
      oprot.writeFieldEnd()
11116 
    oprot.writeFieldStop()
11117 
    oprot.writeStructEnd()
11118 
 
3431 rajveer 11119 
  def validate(self):
11120 
    return
11121 
 
11122 
 
1976 varun.gupt 11123 
  def __repr__(self):
11124 
    L = ['%s=%r' % (key, value)
11125 
      for key, value in self.__dict__.iteritems()]
11126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11127 
 
11128 
  def __eq__(self, other):
11129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11130 
 
11131 
  def __ne__(self, other):
11132 
    return not (self == other)
11133 
 
11134 
class applyCouponToCart_result:
11135 
  """
11136 
  Attributes:
11137 
   - scx
11138 
  """
11139 
 
11140 
  thrift_spec = (
11141 
    None, # 0
11142 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11143 
  )
11144 
 
11145 
  def __init__(self, scx=None,):
11146 
    self.scx = scx
11147 
 
11148 
  def read(self, iprot):
11149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11151 
      return
11152 
    iprot.readStructBegin()
11153 
    while True:
11154 
      (fname, ftype, fid) = iprot.readFieldBegin()
11155 
      if ftype == TType.STOP:
11156 
        break
11157 
      if fid == 1:
11158 
        if ftype == TType.STRUCT:
11159 
          self.scx = ShoppingCartException()
11160 
          self.scx.read(iprot)
11161 
        else:
11162 
          iprot.skip(ftype)
11163 
      else:
11164 
        iprot.skip(ftype)
11165 
      iprot.readFieldEnd()
11166 
    iprot.readStructEnd()
11167 
 
11168 
  def write(self, oprot):
11169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11171 
      return
11172 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11173 
    if self.scx is not None:
1976 varun.gupt 11174 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11175 
      self.scx.write(oprot)
11176 
      oprot.writeFieldEnd()
11177 
    oprot.writeFieldStop()
11178 
    oprot.writeStructEnd()
11179 
 
3431 rajveer 11180 
  def validate(self):
11181 
    return
11182 
 
11183 
 
1976 varun.gupt 11184 
  def __repr__(self):
11185 
    L = ['%s=%r' % (key, value)
11186 
      for key, value in self.__dict__.iteritems()]
11187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11188 
 
11189 
  def __eq__(self, other):
11190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11191 
 
11192 
  def __ne__(self, other):
11193 
    return not (self == other)
11194 
 
11195 
class removeCoupon_args:
11196 
  """
11197 
  Attributes:
11198 
   - cartId
11199 
  """
11200 
 
11201 
  thrift_spec = (
11202 
    None, # 0
11203 
    (1, TType.I64, 'cartId', None, None, ), # 1
11204 
  )
11205 
 
11206 
  def __init__(self, cartId=None,):
11207 
    self.cartId = cartId
11208 
 
11209 
  def read(self, iprot):
11210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11212 
      return
11213 
    iprot.readStructBegin()
11214 
    while True:
11215 
      (fname, ftype, fid) = iprot.readFieldBegin()
11216 
      if ftype == TType.STOP:
11217 
        break
11218 
      if fid == 1:
11219 
        if ftype == TType.I64:
11220 
          self.cartId = iprot.readI64();
11221 
        else:
11222 
          iprot.skip(ftype)
11223 
      else:
11224 
        iprot.skip(ftype)
11225 
      iprot.readFieldEnd()
11226 
    iprot.readStructEnd()
11227 
 
11228 
  def write(self, oprot):
11229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11231 
      return
11232 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11233 
    if self.cartId is not None:
1976 varun.gupt 11234 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11235 
      oprot.writeI64(self.cartId)
11236 
      oprot.writeFieldEnd()
11237 
    oprot.writeFieldStop()
11238 
    oprot.writeStructEnd()
11239 
 
3431 rajveer 11240 
  def validate(self):
11241 
    return
11242 
 
11243 
 
1976 varun.gupt 11244 
  def __repr__(self):
11245 
    L = ['%s=%r' % (key, value)
11246 
      for key, value in self.__dict__.iteritems()]
11247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11248 
 
11249 
  def __eq__(self, other):
11250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11251 
 
11252 
  def __ne__(self, other):
11253 
    return not (self == other)
11254 
 
11255 
class removeCoupon_result:
11256 
  """
11257 
  Attributes:
11258 
   - scx
11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    None, # 0
11263 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11264 
  )
11265 
 
11266 
  def __init__(self, scx=None,):
11267 
    self.scx = scx
11268 
 
11269 
  def read(self, iprot):
11270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11272 
      return
11273 
    iprot.readStructBegin()
11274 
    while True:
11275 
      (fname, ftype, fid) = iprot.readFieldBegin()
11276 
      if ftype == TType.STOP:
11277 
        break
11278 
      if fid == 1:
11279 
        if ftype == TType.STRUCT:
11280 
          self.scx = ShoppingCartException()
11281 
          self.scx.read(iprot)
11282 
        else:
11283 
          iprot.skip(ftype)
11284 
      else:
11285 
        iprot.skip(ftype)
11286 
      iprot.readFieldEnd()
11287 
    iprot.readStructEnd()
11288 
 
11289 
  def write(self, oprot):
11290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11292 
      return
11293 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11294 
    if self.scx is not None:
1976 varun.gupt 11295 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11296 
      self.scx.write(oprot)
11297 
      oprot.writeFieldEnd()
11298 
    oprot.writeFieldStop()
11299 
    oprot.writeStructEnd()
11300 
 
3431 rajveer 11301 
  def validate(self):
11302 
    return
11303 
 
11304 
 
1976 varun.gupt 11305 
  def __repr__(self):
11306 
    L = ['%s=%r' % (key, value)
11307 
      for key, value in self.__dict__.iteritems()]
11308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11309 
 
11310 
  def __eq__(self, other):
11311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11312 
 
11313 
  def __ne__(self, other):
11314 
    return not (self == other)
11315 
 
3554 varun.gupt 11316 
class deleteDiscountsFromCart_args:
11317 
  """
11318 
  Attributes:
11319 
   - cartId
11320 
  """
11321 
 
11322 
  thrift_spec = (
11323 
    None, # 0
11324 
    (1, TType.I64, 'cartId', None, None, ), # 1
11325 
  )
11326 
 
11327 
  def __init__(self, cartId=None,):
11328 
    self.cartId = cartId
11329 
 
11330 
  def read(self, iprot):
11331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11333 
      return
11334 
    iprot.readStructBegin()
11335 
    while True:
11336 
      (fname, ftype, fid) = iprot.readFieldBegin()
11337 
      if ftype == TType.STOP:
11338 
        break
11339 
      if fid == 1:
11340 
        if ftype == TType.I64:
11341 
          self.cartId = iprot.readI64();
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('deleteDiscountsFromCart_args')
11354 
    if self.cartId is not None:
11355 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11356 
      oprot.writeI64(self.cartId)
11357 
      oprot.writeFieldEnd()
11358 
    oprot.writeFieldStop()
11359 
    oprot.writeStructEnd()
11360 
 
11361 
  def validate(self):
11362 
    return
11363 
 
11364 
 
11365 
  def __repr__(self):
11366 
    L = ['%s=%r' % (key, value)
11367 
      for key, value in self.__dict__.iteritems()]
11368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11369 
 
11370 
  def __eq__(self, other):
11371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11372 
 
11373 
  def __ne__(self, other):
11374 
    return not (self == other)
11375 
 
11376 
class deleteDiscountsFromCart_result:
11377 
  """
11378 
  Attributes:
11379 
   - scx
11380 
  """
11381 
 
11382 
  thrift_spec = (
11383 
    None, # 0
11384 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11385 
  )
11386 
 
11387 
  def __init__(self, scx=None,):
11388 
    self.scx = scx
11389 
 
11390 
  def read(self, iprot):
11391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11393 
      return
11394 
    iprot.readStructBegin()
11395 
    while True:
11396 
      (fname, ftype, fid) = iprot.readFieldBegin()
11397 
      if ftype == TType.STOP:
11398 
        break
11399 
      if fid == 1:
11400 
        if ftype == TType.STRUCT:
11401 
          self.scx = ShoppingCartException()
11402 
          self.scx.read(iprot)
11403 
        else:
11404 
          iprot.skip(ftype)
11405 
      else:
11406 
        iprot.skip(ftype)
11407 
      iprot.readFieldEnd()
11408 
    iprot.readStructEnd()
11409 
 
11410 
  def write(self, oprot):
11411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11413 
      return
11414 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11415 
    if self.scx is not None:
11416 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11417 
      self.scx.write(oprot)
11418 
      oprot.writeFieldEnd()
11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
11422 
  def validate(self):
11423 
    return
11424 
 
11425 
 
11426 
  def __repr__(self):
11427 
    L = ['%s=%r' % (key, value)
11428 
      for key, value in self.__dict__.iteritems()]
11429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11430 
 
11431 
  def __eq__(self, other):
11432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11433 
 
11434 
  def __ne__(self, other):
11435 
    return not (self == other)
11436 
 
11437 
class saveDiscounts_args:
11438 
  """
11439 
  Attributes:
11440 
   - discounts
11441 
  """
11442 
 
11443 
  thrift_spec = (
11444 
    None, # 0
11445 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11446 
  )
11447 
 
11448 
  def __init__(self, discounts=None,):
11449 
    self.discounts = discounts
11450 
 
11451 
  def read(self, iprot):
11452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11454 
      return
11455 
    iprot.readStructBegin()
11456 
    while True:
11457 
      (fname, ftype, fid) = iprot.readFieldBegin()
11458 
      if ftype == TType.STOP:
11459 
        break
11460 
      if fid == 1:
11461 
        if ftype == TType.LIST:
11462 
          self.discounts = []
11592 amit.gupta 11463 
          (_etype163, _size160) = iprot.readListBegin()
11464 
          for _i164 in xrange(_size160):
11465 
            _elem165 = Discount()
11466 
            _elem165.read(iprot)
11467 
            self.discounts.append(_elem165)
3554 varun.gupt 11468 
          iprot.readListEnd()
11469 
        else:
11470 
          iprot.skip(ftype)
11471 
      else:
11472 
        iprot.skip(ftype)
11473 
      iprot.readFieldEnd()
11474 
    iprot.readStructEnd()
11475 
 
11476 
  def write(self, oprot):
11477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11479 
      return
11480 
    oprot.writeStructBegin('saveDiscounts_args')
11481 
    if self.discounts is not None:
11482 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11483 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11484 
      for iter166 in self.discounts:
11485 
        iter166.write(oprot)
3554 varun.gupt 11486 
      oprot.writeListEnd()
11487 
      oprot.writeFieldEnd()
11488 
    oprot.writeFieldStop()
11489 
    oprot.writeStructEnd()
11490 
 
11491 
  def validate(self):
11492 
    return
11493 
 
11494 
 
11495 
  def __repr__(self):
11496 
    L = ['%s=%r' % (key, value)
11497 
      for key, value in self.__dict__.iteritems()]
11498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11499 
 
11500 
  def __eq__(self, other):
11501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11502 
 
11503 
  def __ne__(self, other):
11504 
    return not (self == other)
11505 
 
11506 
class saveDiscounts_result:
11507 
  """
11508 
  Attributes:
11509 
   - scx
11510 
  """
11511 
 
11512 
  thrift_spec = (
11513 
    None, # 0
11514 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11515 
  )
11516 
 
11517 
  def __init__(self, scx=None,):
11518 
    self.scx = scx
11519 
 
11520 
  def read(self, iprot):
11521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11523 
      return
11524 
    iprot.readStructBegin()
11525 
    while True:
11526 
      (fname, ftype, fid) = iprot.readFieldBegin()
11527 
      if ftype == TType.STOP:
11528 
        break
11529 
      if fid == 1:
11530 
        if ftype == TType.STRUCT:
11531 
          self.scx = ShoppingCartException()
11532 
          self.scx.read(iprot)
11533 
        else:
11534 
          iprot.skip(ftype)
11535 
      else:
11536 
        iprot.skip(ftype)
11537 
      iprot.readFieldEnd()
11538 
    iprot.readStructEnd()
11539 
 
11540 
  def write(self, oprot):
11541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11543 
      return
11544 
    oprot.writeStructBegin('saveDiscounts_result')
11545 
    if self.scx is not None:
11546 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11547 
      self.scx.write(oprot)
11548 
      oprot.writeFieldEnd()
11549 
    oprot.writeFieldStop()
11550 
    oprot.writeStructEnd()
11551 
 
11552 
  def validate(self):
11553 
    return
11554 
 
11555 
 
11556 
  def __repr__(self):
11557 
    L = ['%s=%r' % (key, value)
11558 
      for key, value in self.__dict__.iteritems()]
11559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11560 
 
11561 
  def __eq__(self, other):
11562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11563 
 
11564 
  def __ne__(self, other):
11565 
    return not (self == other)
11566 
 
690 chandransh 11567 
class createOrders_args:
559 chandransh 11568 
  """
11569 
  Attributes:
11570 
   - cartId
2815 vikas 11571 
   - sessionSource
11572 
   - sessionStartTime
3858 vikas 11573 
   - firstSource
11574 
   - firstSourceTime
5326 rajveer 11575 
   - userId
6389 rajveer 11576 
   - schemeId
11526 amit.gupta 11577 
   - orderSource
559 chandransh 11578 
  """
11579 
 
11580 
  thrift_spec = (
11581 
    None, # 0
11582 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11583 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11584 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11585 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11586 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11587 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11588 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11589 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11590 
  )
11591 
 
11526 amit.gupta 11592 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11593 
    self.cartId = cartId
2815 vikas 11594 
    self.sessionSource = sessionSource
11595 
    self.sessionStartTime = sessionStartTime
3858 vikas 11596 
    self.firstSource = firstSource
11597 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11598 
    self.userId = userId
6389 rajveer 11599 
    self.schemeId = schemeId
11526 amit.gupta 11600 
    self.orderSource = orderSource
559 chandransh 11601 
 
11602 
  def read(self, iprot):
11603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11605 
      return
11606 
    iprot.readStructBegin()
11607 
    while True:
11608 
      (fname, ftype, fid) = iprot.readFieldBegin()
11609 
      if ftype == TType.STOP:
11610 
        break
11611 
      if fid == 1:
11612 
        if ftype == TType.I64:
11613 
          self.cartId = iprot.readI64();
11614 
        else:
11615 
          iprot.skip(ftype)
2815 vikas 11616 
      elif fid == 2:
11617 
        if ftype == TType.STRING:
11618 
          self.sessionSource = iprot.readString();
11619 
        else:
11620 
          iprot.skip(ftype)
11621 
      elif fid == 3:
11622 
        if ftype == TType.I64:
11623 
          self.sessionStartTime = iprot.readI64();
11624 
        else:
11625 
          iprot.skip(ftype)
3858 vikas 11626 
      elif fid == 4:
11627 
        if ftype == TType.STRING:
11628 
          self.firstSource = iprot.readString();
11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      elif fid == 5:
11632 
        if ftype == TType.I64:
11633 
          self.firstSourceTime = iprot.readI64();
11634 
        else:
11635 
          iprot.skip(ftype)
5326 rajveer 11636 
      elif fid == 6:
11637 
        if ftype == TType.I64:
11638 
          self.userId = iprot.readI64();
11639 
        else:
11640 
          iprot.skip(ftype)
6389 rajveer 11641 
      elif fid == 7:
11642 
        if ftype == TType.I64:
11643 
          self.schemeId = iprot.readI64();
11644 
        else:
11645 
          iprot.skip(ftype)
11526 amit.gupta 11646 
      elif fid == 8:
11647 
        if ftype == TType.I64:
11648 
          self.orderSource = iprot.readI64();
11649 
        else:
11650 
          iprot.skip(ftype)
559 chandransh 11651 
      else:
11652 
        iprot.skip(ftype)
11653 
      iprot.readFieldEnd()
11654 
    iprot.readStructEnd()
11655 
 
11656 
  def write(self, oprot):
11657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11659 
      return
690 chandransh 11660 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11661 
    if self.cartId is not None:
559 chandransh 11662 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11663 
      oprot.writeI64(self.cartId)
11664 
      oprot.writeFieldEnd()
3431 rajveer 11665 
    if self.sessionSource is not None:
2815 vikas 11666 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11667 
      oprot.writeString(self.sessionSource)
11668 
      oprot.writeFieldEnd()
3431 rajveer 11669 
    if self.sessionStartTime is not None:
2815 vikas 11670 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11671 
      oprot.writeI64(self.sessionStartTime)
11672 
      oprot.writeFieldEnd()
3858 vikas 11673 
    if self.firstSource is not None:
11674 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11675 
      oprot.writeString(self.firstSource)
11676 
      oprot.writeFieldEnd()
11677 
    if self.firstSourceTime is not None:
11678 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11679 
      oprot.writeI64(self.firstSourceTime)
11680 
      oprot.writeFieldEnd()
5326 rajveer 11681 
    if self.userId is not None:
11682 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11683 
      oprot.writeI64(self.userId)
11684 
      oprot.writeFieldEnd()
6389 rajveer 11685 
    if self.schemeId is not None:
11686 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11687 
      oprot.writeI64(self.schemeId)
11688 
      oprot.writeFieldEnd()
11526 amit.gupta 11689 
    if self.orderSource is not None:
11690 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11691 
      oprot.writeI64(self.orderSource)
11692 
      oprot.writeFieldEnd()
559 chandransh 11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
3431 rajveer 11696 
  def validate(self):
11697 
    return
11698 
 
11699 
 
559 chandransh 11700 
  def __repr__(self):
11701 
    L = ['%s=%r' % (key, value)
11702 
      for key, value in self.__dict__.iteritems()]
11703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11704 
 
11705 
  def __eq__(self, other):
11706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11707 
 
11708 
  def __ne__(self, other):
11709 
    return not (self == other)
11710 
 
690 chandransh 11711 
class createOrders_result:
559 chandransh 11712 
  """
11713 
  Attributes:
94 ashish 11714 
   - success
559 chandransh 11715 
   - scx
94 ashish 11716 
  """
11717 
 
11718 
  thrift_spec = (
575 chandransh 11719 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11720 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11721 
  )
11722 
 
559 chandransh 11723 
  def __init__(self, success=None, scx=None,):
94 ashish 11724 
    self.success = success
559 chandransh 11725 
    self.scx = scx
94 ashish 11726 
 
11727 
  def read(self, iprot):
11728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11730 
      return
11731 
    iprot.readStructBegin()
11732 
    while True:
11733 
      (fname, ftype, fid) = iprot.readFieldBegin()
11734 
      if ftype == TType.STOP:
11735 
        break
11736 
      if fid == 0:
575 chandransh 11737 
        if ftype == TType.I64:
11738 
          self.success = iprot.readI64();
94 ashish 11739 
        else:
11740 
          iprot.skip(ftype)
11741 
      elif fid == 1:
11742 
        if ftype == TType.STRUCT:
559 chandransh 11743 
          self.scx = ShoppingCartException()
11744 
          self.scx.read(iprot)
94 ashish 11745 
        else:
11746 
          iprot.skip(ftype)
11747 
      else:
11748 
        iprot.skip(ftype)
11749 
      iprot.readFieldEnd()
11750 
    iprot.readStructEnd()
11751 
 
11752 
  def write(self, oprot):
11753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11755 
      return
690 chandransh 11756 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11757 
    if self.success is not None:
575 chandransh 11758 
      oprot.writeFieldBegin('success', TType.I64, 0)
11759 
      oprot.writeI64(self.success)
94 ashish 11760 
      oprot.writeFieldEnd()
3431 rajveer 11761 
    if self.scx is not None:
559 chandransh 11762 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11763 
      self.scx.write(oprot)
94 ashish 11764 
      oprot.writeFieldEnd()
11765 
    oprot.writeFieldStop()
11766 
    oprot.writeStructEnd()
11767 
 
3431 rajveer 11768 
  def validate(self):
11769 
    return
11770 
 
11771 
 
94 ashish 11772 
  def __repr__(self):
11773 
    L = ['%s=%r' % (key, value)
11774 
      for key, value in self.__dict__.iteritems()]
11775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11776 
 
11777 
  def __eq__(self, other):
11778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11779 
 
11780 
  def __ne__(self, other):
11781 
    return not (self == other)
11782 
 
559 chandransh 11783 
class validateCart_args:
94 ashish 11784 
  """
11785 
  Attributes:
559 chandransh 11786 
   - cartId
3557 rajveer 11787 
   - sourceId
94 ashish 11788 
  """
11789 
 
11790 
  thrift_spec = (
11791 
    None, # 0
559 chandransh 11792 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11793 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11794 
  )
11795 
 
3557 rajveer 11796 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11797 
    self.cartId = cartId
3557 rajveer 11798 
    self.sourceId = sourceId
94 ashish 11799 
 
11800 
  def read(self, iprot):
11801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11803 
      return
11804 
    iprot.readStructBegin()
11805 
    while True:
11806 
      (fname, ftype, fid) = iprot.readFieldBegin()
11807 
      if ftype == TType.STOP:
11808 
        break
11809 
      if fid == 1:
11810 
        if ftype == TType.I64:
559 chandransh 11811 
          self.cartId = iprot.readI64();
94 ashish 11812 
        else:
11813 
          iprot.skip(ftype)
3557 rajveer 11814 
      elif fid == 2:
11815 
        if ftype == TType.I64:
11816 
          self.sourceId = iprot.readI64();
11817 
        else:
11818 
          iprot.skip(ftype)
94 ashish 11819 
      else:
11820 
        iprot.skip(ftype)
11821 
      iprot.readFieldEnd()
11822 
    iprot.readStructEnd()
11823 
 
11824 
  def write(self, oprot):
11825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11827 
      return
559 chandransh 11828 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 11829 
    if self.cartId is not None:
559 chandransh 11830 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11831 
      oprot.writeI64(self.cartId)
94 ashish 11832 
      oprot.writeFieldEnd()
3557 rajveer 11833 
    if self.sourceId is not None:
11834 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11835 
      oprot.writeI64(self.sourceId)
11836 
      oprot.writeFieldEnd()
94 ashish 11837 
    oprot.writeFieldStop()
11838 
    oprot.writeStructEnd()
11839 
 
3431 rajveer 11840 
  def validate(self):
11841 
    return
11842 
 
11843 
 
94 ashish 11844 
  def __repr__(self):
11845 
    L = ['%s=%r' % (key, value)
11846 
      for key, value in self.__dict__.iteritems()]
11847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11848 
 
11849 
  def __eq__(self, other):
11850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11851 
 
11852 
  def __ne__(self, other):
11853 
    return not (self == other)
11854 
 
559 chandransh 11855 
class validateCart_result:
94 ashish 11856 
  """
11857 
  Attributes:
11858 
   - success
575 chandransh 11859 
   - scex
94 ashish 11860 
  """
11861 
 
11862 
  thrift_spec = (
6736 amit.gupta 11863 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 11864 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11865 
  )
11866 
 
575 chandransh 11867 
  def __init__(self, success=None, scex=None,):
94 ashish 11868 
    self.success = success
575 chandransh 11869 
    self.scex = scex
94 ashish 11870 
 
11871 
  def read(self, iprot):
11872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11874 
      return
11875 
    iprot.readStructBegin()
11876 
    while True:
11877 
      (fname, ftype, fid) = iprot.readFieldBegin()
11878 
      if ftype == TType.STOP:
11879 
        break
11880 
      if fid == 0:
6736 amit.gupta 11881 
        if ftype == TType.LIST:
11882 
          self.success = []
11592 amit.gupta 11883 
          (_etype170, _size167) = iprot.readListBegin()
11884 
          for _i171 in xrange(_size167):
11885 
            _elem172 = iprot.readString();
11886 
            self.success.append(_elem172)
6736 amit.gupta 11887 
          iprot.readListEnd()
94 ashish 11888 
        else:
11889 
          iprot.skip(ftype)
575 chandransh 11890 
      elif fid == 1:
11891 
        if ftype == TType.STRUCT:
11892 
          self.scex = ShoppingCartException()
11893 
          self.scex.read(iprot)
11894 
        else:
11895 
          iprot.skip(ftype)
94 ashish 11896 
      else:
11897 
        iprot.skip(ftype)
11898 
      iprot.readFieldEnd()
11899 
    iprot.readStructEnd()
11900 
 
11901 
  def write(self, oprot):
11902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11904 
      return
559 chandransh 11905 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 11906 
    if self.success is not None:
6736 amit.gupta 11907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11908 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 11909 
      for iter173 in self.success:
11910 
        oprot.writeString(iter173)
6736 amit.gupta 11911 
      oprot.writeListEnd()
94 ashish 11912 
      oprot.writeFieldEnd()
3431 rajveer 11913 
    if self.scex is not None:
575 chandransh 11914 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11915 
      self.scex.write(oprot)
11916 
      oprot.writeFieldEnd()
559 chandransh 11917 
    oprot.writeFieldStop()
11918 
    oprot.writeStructEnd()
11919 
 
3431 rajveer 11920 
  def validate(self):
11921 
    return
11922 
 
11923 
 
559 chandransh 11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
11934 
 
11980 amit.gupta 11935 
class validateCartWithDealerCoupon_args:
11936 
  """
11937 
  Attributes:
11938 
   - cartId
11939 
   - sourceId
11940 
   - dealCoupon
11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    None, # 0
11945 
    (1, TType.I64, 'cartId', None, None, ), # 1
11946 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11947 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
11948 
  )
11949 
 
11950 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
11951 
    self.cartId = cartId
11952 
    self.sourceId = sourceId
11953 
    self.dealCoupon = dealCoupon
11954 
 
11955 
  def read(self, iprot):
11956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11958 
      return
11959 
    iprot.readStructBegin()
11960 
    while True:
11961 
      (fname, ftype, fid) = iprot.readFieldBegin()
11962 
      if ftype == TType.STOP:
11963 
        break
11964 
      if fid == 1:
11965 
        if ftype == TType.I64:
11966 
          self.cartId = iprot.readI64();
11967 
        else:
11968 
          iprot.skip(ftype)
11969 
      elif fid == 2:
11970 
        if ftype == TType.I64:
11971 
          self.sourceId = iprot.readI64();
11972 
        else:
11973 
          iprot.skip(ftype)
11974 
      elif fid == 3:
11975 
        if ftype == TType.STRING:
11976 
          self.dealCoupon = iprot.readString();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      else:
11980 
        iprot.skip(ftype)
11981 
      iprot.readFieldEnd()
11982 
    iprot.readStructEnd()
11983 
 
11984 
  def write(self, oprot):
11985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11987 
      return
11988 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
11989 
    if self.cartId is not None:
11990 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11991 
      oprot.writeI64(self.cartId)
11992 
      oprot.writeFieldEnd()
11993 
    if self.sourceId is not None:
11994 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
11995 
      oprot.writeI64(self.sourceId)
11996 
      oprot.writeFieldEnd()
11997 
    if self.dealCoupon is not None:
11998 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
11999 
      oprot.writeString(self.dealCoupon)
12000 
      oprot.writeFieldEnd()
12001 
    oprot.writeFieldStop()
12002 
    oprot.writeStructEnd()
12003 
 
12004 
  def validate(self):
12005 
    return
12006 
 
12007 
 
12008 
  def __repr__(self):
12009 
    L = ['%s=%r' % (key, value)
12010 
      for key, value in self.__dict__.iteritems()]
12011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12012 
 
12013 
  def __eq__(self, other):
12014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12015 
 
12016 
  def __ne__(self, other):
12017 
    return not (self == other)
12018 
 
12019 
class validateCartWithDealerCoupon_result:
12020 
  """
12021 
  Attributes:
12022 
   - success
12023 
   - scex
12024 
  """
12025 
 
12026 
  thrift_spec = (
12027 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12028 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12029 
  )
12030 
 
12031 
  def __init__(self, success=None, scex=None,):
12032 
    self.success = success
12033 
    self.scex = scex
12034 
 
12035 
  def read(self, iprot):
12036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12038 
      return
12039 
    iprot.readStructBegin()
12040 
    while True:
12041 
      (fname, ftype, fid) = iprot.readFieldBegin()
12042 
      if ftype == TType.STOP:
12043 
        break
12044 
      if fid == 0:
12045 
        if ftype == TType.LIST:
12046 
          self.success = []
12047 
          (_etype177, _size174) = iprot.readListBegin()
12048 
          for _i178 in xrange(_size174):
12049 
            _elem179 = iprot.readString();
12050 
            self.success.append(_elem179)
12051 
          iprot.readListEnd()
12052 
        else:
12053 
          iprot.skip(ftype)
12054 
      elif fid == 1:
12055 
        if ftype == TType.STRUCT:
12056 
          self.scex = ShoppingCartException()
12057 
          self.scex.read(iprot)
12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
12069 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12070 
    if self.success is not None:
12071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12072 
      oprot.writeListBegin(TType.STRING, len(self.success))
12073 
      for iter180 in self.success:
12074 
        oprot.writeString(iter180)
12075 
      oprot.writeListEnd()
12076 
      oprot.writeFieldEnd()
12077 
    if self.scex is not None:
12078 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12079 
      self.scex.write(oprot)
12080 
      oprot.writeFieldEnd()
12081 
    oprot.writeFieldStop()
12082 
    oprot.writeStructEnd()
12083 
 
12084 
  def validate(self):
12085 
    return
12086 
 
12087 
 
12088 
  def __repr__(self):
12089 
    L = ['%s=%r' % (key, value)
12090 
      for key, value in self.__dict__.iteritems()]
12091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12092 
 
12093 
  def __eq__(self, other):
12094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12095 
 
12096 
  def __ne__(self, other):
12097 
    return not (self == other)
12098 
 
690 chandransh 12099 
class mergeCart_args:
575 chandransh 12100 
  """
12101 
  Attributes:
690 chandransh 12102 
   - fromCartId
12103 
   - toCartId
12104 
  """
12105 
 
12106 
  thrift_spec = (
12107 
    None, # 0
12108 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12109 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12110 
  )
12111 
 
12112 
  def __init__(self, fromCartId=None, toCartId=None,):
12113 
    self.fromCartId = fromCartId
12114 
    self.toCartId = toCartId
12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 1:
12126 
        if ftype == TType.I64:
12127 
          self.fromCartId = iprot.readI64();
12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      elif fid == 2:
12131 
        if ftype == TType.I64:
12132 
          self.toCartId = iprot.readI64();
12133 
        else:
12134 
          iprot.skip(ftype)
12135 
      else:
12136 
        iprot.skip(ftype)
12137 
      iprot.readFieldEnd()
12138 
    iprot.readStructEnd()
12139 
 
12140 
  def write(self, oprot):
12141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12143 
      return
12144 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12145 
    if self.fromCartId is not None:
690 chandransh 12146 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12147 
      oprot.writeI64(self.fromCartId)
12148 
      oprot.writeFieldEnd()
3431 rajveer 12149 
    if self.toCartId is not None:
690 chandransh 12150 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12151 
      oprot.writeI64(self.toCartId)
12152 
      oprot.writeFieldEnd()
12153 
    oprot.writeFieldStop()
12154 
    oprot.writeStructEnd()
12155 
 
3431 rajveer 12156 
  def validate(self):
12157 
    return
12158 
 
12159 
 
690 chandransh 12160 
  def __repr__(self):
12161 
    L = ['%s=%r' % (key, value)
12162 
      for key, value in self.__dict__.iteritems()]
12163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12164 
 
12165 
  def __eq__(self, other):
12166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12167 
 
12168 
  def __ne__(self, other):
12169 
    return not (self == other)
12170 
 
12171 
class mergeCart_result:
12172 
 
12173 
  thrift_spec = (
12174 
  )
12175 
 
12176 
  def read(self, iprot):
12177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12179 
      return
12180 
    iprot.readStructBegin()
12181 
    while True:
12182 
      (fname, ftype, fid) = iprot.readFieldBegin()
12183 
      if ftype == TType.STOP:
12184 
        break
12185 
      else:
12186 
        iprot.skip(ftype)
12187 
      iprot.readFieldEnd()
12188 
    iprot.readStructEnd()
12189 
 
12190 
  def write(self, oprot):
12191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12193 
      return
12194 
    oprot.writeStructBegin('mergeCart_result')
12195 
    oprot.writeFieldStop()
12196 
    oprot.writeStructEnd()
12197 
 
3431 rajveer 12198 
  def validate(self):
12199 
    return
12200 
 
12201 
 
690 chandransh 12202 
  def __repr__(self):
12203 
    L = ['%s=%r' % (key, value)
12204 
      for key, value in self.__dict__.iteritems()]
12205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12206 
 
12207 
  def __eq__(self, other):
12208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12209 
 
12210 
  def __ne__(self, other):
12211 
    return not (self == other)
12212 
 
12213 
class checkOut_args:
12214 
  """
12215 
  Attributes:
575 chandransh 12216 
   - cartId
12217 
  """
12218 
 
12219 
  thrift_spec = (
12220 
    None, # 0
12221 
    (1, TType.I64, 'cartId', None, None, ), # 1
12222 
  )
12223 
 
12224 
  def __init__(self, cartId=None,):
12225 
    self.cartId = cartId
12226 
 
12227 
  def read(self, iprot):
12228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12230 
      return
12231 
    iprot.readStructBegin()
12232 
    while True:
12233 
      (fname, ftype, fid) = iprot.readFieldBegin()
12234 
      if ftype == TType.STOP:
12235 
        break
12236 
      if fid == 1:
12237 
        if ftype == TType.I64:
12238 
          self.cartId = iprot.readI64();
12239 
        else:
12240 
          iprot.skip(ftype)
12241 
      else:
12242 
        iprot.skip(ftype)
12243 
      iprot.readFieldEnd()
12244 
    iprot.readStructEnd()
12245 
 
12246 
  def write(self, oprot):
12247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12249 
      return
690 chandransh 12250 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12251 
    if self.cartId is not None:
575 chandransh 12252 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12253 
      oprot.writeI64(self.cartId)
12254 
      oprot.writeFieldEnd()
12255 
    oprot.writeFieldStop()
12256 
    oprot.writeStructEnd()
12257 
 
3431 rajveer 12258 
  def validate(self):
12259 
    return
12260 
 
12261 
 
575 chandransh 12262 
  def __repr__(self):
12263 
    L = ['%s=%r' % (key, value)
12264 
      for key, value in self.__dict__.iteritems()]
12265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12266 
 
12267 
  def __eq__(self, other):
12268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12269 
 
12270 
  def __ne__(self, other):
12271 
    return not (self == other)
12272 
 
690 chandransh 12273 
class checkOut_result:
575 chandransh 12274 
  """
12275 
  Attributes:
12276 
   - success
12277 
   - scex
12278 
  """
12279 
 
12280 
  thrift_spec = (
12281 
    (0, TType.BOOL, 'success', None, None, ), # 0
12282 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12283 
  )
12284 
 
12285 
  def __init__(self, success=None, scex=None,):
12286 
    self.success = success
12287 
    self.scex = scex
12288 
 
12289 
  def read(self, iprot):
12290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12292 
      return
12293 
    iprot.readStructBegin()
12294 
    while True:
12295 
      (fname, ftype, fid) = iprot.readFieldBegin()
12296 
      if ftype == TType.STOP:
12297 
        break
12298 
      if fid == 0:
12299 
        if ftype == TType.BOOL:
12300 
          self.success = iprot.readBool();
12301 
        else:
12302 
          iprot.skip(ftype)
12303 
      elif fid == 1:
12304 
        if ftype == TType.STRUCT:
12305 
          self.scex = ShoppingCartException()
12306 
          self.scex.read(iprot)
12307 
        else:
12308 
          iprot.skip(ftype)
12309 
      else:
12310 
        iprot.skip(ftype)
12311 
      iprot.readFieldEnd()
12312 
    iprot.readStructEnd()
12313 
 
12314 
  def write(self, oprot):
12315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12317 
      return
690 chandransh 12318 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12319 
    if self.success is not None:
575 chandransh 12320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12321 
      oprot.writeBool(self.success)
12322 
      oprot.writeFieldEnd()
3431 rajveer 12323 
    if self.scex is not None:
575 chandransh 12324 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12325 
      self.scex.write(oprot)
12326 
      oprot.writeFieldEnd()
12327 
    oprot.writeFieldStop()
12328 
    oprot.writeStructEnd()
12329 
 
3431 rajveer 12330 
  def validate(self):
12331 
    return
12332 
 
12333 
 
575 chandransh 12334 
  def __repr__(self):
12335 
    L = ['%s=%r' % (key, value)
12336 
      for key, value in self.__dict__.iteritems()]
12337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12338 
 
12339 
  def __eq__(self, other):
12340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12341 
 
12342 
  def __ne__(self, other):
12343 
    return not (self == other)
12344 
 
690 chandransh 12345 
class resetCart_args:
559 chandransh 12346 
  """
12347 
  Attributes:
690 chandransh 12348 
   - cartId
12349 
   - items
559 chandransh 12350 
  """
12351 
 
12352 
  thrift_spec = (
12353 
    None, # 0
690 chandransh 12354 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12355 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12356 
  )
12357 
 
690 chandransh 12358 
  def __init__(self, cartId=None, items=None,):
12359 
    self.cartId = cartId
12360 
    self.items = items
559 chandransh 12361 
 
12362 
  def read(self, iprot):
12363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12365 
      return
12366 
    iprot.readStructBegin()
12367 
    while True:
12368 
      (fname, ftype, fid) = iprot.readFieldBegin()
12369 
      if ftype == TType.STOP:
12370 
        break
12371 
      if fid == 1:
12372 
        if ftype == TType.I64:
690 chandransh 12373 
          self.cartId = iprot.readI64();
559 chandransh 12374 
        else:
12375 
          iprot.skip(ftype)
12376 
      elif fid == 2:
690 chandransh 12377 
        if ftype == TType.MAP:
12378 
          self.items = {}
11980 amit.gupta 12379 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12380 
          for _i185 in xrange(_size181):
12381 
            _key186 = iprot.readI64();
12382 
            _val187 = iprot.readDouble();
12383 
            self.items[_key186] = _val187
690 chandransh 12384 
          iprot.readMapEnd()
559 chandransh 12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      else:
12388 
        iprot.skip(ftype)
12389 
      iprot.readFieldEnd()
12390 
    iprot.readStructEnd()
12391 
 
12392 
  def write(self, oprot):
12393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12395 
      return
690 chandransh 12396 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12397 
    if self.cartId is not None:
690 chandransh 12398 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12399 
      oprot.writeI64(self.cartId)
94 ashish 12400 
      oprot.writeFieldEnd()
3431 rajveer 12401 
    if self.items is not None:
690 chandransh 12402 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12403 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12404 
      for kiter188,viter189 in self.items.items():
12405 
        oprot.writeI64(kiter188)
12406 
        oprot.writeDouble(viter189)
690 chandransh 12407 
      oprot.writeMapEnd()
559 chandransh 12408 
      oprot.writeFieldEnd()
94 ashish 12409 
    oprot.writeFieldStop()
12410 
    oprot.writeStructEnd()
12411 
 
3431 rajveer 12412 
  def validate(self):
12413 
    return
12414 
 
12415 
 
94 ashish 12416 
  def __repr__(self):
12417 
    L = ['%s=%r' % (key, value)
12418 
      for key, value in self.__dict__.iteritems()]
12419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12420 
 
12421 
  def __eq__(self, other):
12422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12423 
 
12424 
  def __ne__(self, other):
12425 
    return not (self == other)
12426 
 
690 chandransh 12427 
class resetCart_result:
12428 
  """
12429 
  Attributes:
12430 
   - success
12431 
   - scex
12432 
  """
559 chandransh 12433 
 
12434 
  thrift_spec = (
690 chandransh 12435 
    (0, TType.BOOL, 'success', None, None, ), # 0
12436 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12437 
  )
12438 
 
690 chandransh 12439 
  def __init__(self, success=None, scex=None,):
12440 
    self.success = success
12441 
    self.scex = scex
12442 
 
559 chandransh 12443 
  def read(self, iprot):
12444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12446 
      return
12447 
    iprot.readStructBegin()
12448 
    while True:
12449 
      (fname, ftype, fid) = iprot.readFieldBegin()
12450 
      if ftype == TType.STOP:
12451 
        break
690 chandransh 12452 
      if fid == 0:
12453 
        if ftype == TType.BOOL:
12454 
          self.success = iprot.readBool();
12455 
        else:
12456 
          iprot.skip(ftype)
12457 
      elif fid == 1:
12458 
        if ftype == TType.STRUCT:
12459 
          self.scex = ShoppingCartException()
12460 
          self.scex.read(iprot)
12461 
        else:
12462 
          iprot.skip(ftype)
559 chandransh 12463 
      else:
12464 
        iprot.skip(ftype)
12465 
      iprot.readFieldEnd()
12466 
    iprot.readStructEnd()
12467 
 
12468 
  def write(self, oprot):
12469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12471 
      return
690 chandransh 12472 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12473 
    if self.success is not None:
690 chandransh 12474 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12475 
      oprot.writeBool(self.success)
12476 
      oprot.writeFieldEnd()
3431 rajveer 12477 
    if self.scex is not None:
690 chandransh 12478 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12479 
      self.scex.write(oprot)
12480 
      oprot.writeFieldEnd()
559 chandransh 12481 
    oprot.writeFieldStop()
12482 
    oprot.writeStructEnd()
12483 
 
3431 rajveer 12484 
  def validate(self):
12485 
    return
12486 
 
12487 
 
559 chandransh 12488 
  def __repr__(self):
12489 
    L = ['%s=%r' % (key, value)
12490 
      for key, value in self.__dict__.iteritems()]
12491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12492 
 
12493 
  def __eq__(self, other):
12494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12495 
 
12496 
  def __ne__(self, other):
12497 
    return not (self == other)
12498 
 
2981 rajveer 12499 
class getUserCount_args:
94 ashish 12500 
  """
12501 
  Attributes:
2981 rajveer 12502 
   - userType
559 chandransh 12503 
  """
12504 
 
12505 
  thrift_spec = (
12506 
    None, # 0
2981 rajveer 12507 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12508 
  )
12509 
 
2981 rajveer 12510 
  def __init__(self, userType=None,):
12511 
    self.userType = userType
559 chandransh 12512 
 
12513 
  def read(self, iprot):
12514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12516 
      return
12517 
    iprot.readStructBegin()
12518 
    while True:
12519 
      (fname, ftype, fid) = iprot.readFieldBegin()
12520 
      if ftype == TType.STOP:
12521 
        break
12522 
      if fid == 1:
2981 rajveer 12523 
        if ftype == TType.I32:
12524 
          self.userType = iprot.readI32();
559 chandransh 12525 
        else:
12526 
          iprot.skip(ftype)
12527 
      else:
12528 
        iprot.skip(ftype)
12529 
      iprot.readFieldEnd()
12530 
    iprot.readStructEnd()
12531 
 
12532 
  def write(self, oprot):
12533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12535 
      return
2981 rajveer 12536 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12537 
    if self.userType is not None:
2981 rajveer 12538 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12539 
      oprot.writeI32(self.userType)
559 chandransh 12540 
      oprot.writeFieldEnd()
12541 
    oprot.writeFieldStop()
12542 
    oprot.writeStructEnd()
12543 
 
3431 rajveer 12544 
  def validate(self):
12545 
    return
12546 
 
12547 
 
559 chandransh 12548 
  def __repr__(self):
12549 
    L = ['%s=%r' % (key, value)
12550 
      for key, value in self.__dict__.iteritems()]
12551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12552 
 
12553 
  def __eq__(self, other):
12554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12555 
 
12556 
  def __ne__(self, other):
12557 
    return not (self == other)
12558 
 
2981 rajveer 12559 
class getUserCount_result:
94 ashish 12560 
  """
12561 
  Attributes:
12562 
   - success
12563 
  """
12564 
 
12565 
  thrift_spec = (
2981 rajveer 12566 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12567 
  )
12568 
 
2981 rajveer 12569 
  def __init__(self, success=None,):
94 ashish 12570 
    self.success = success
12571 
 
12572 
  def read(self, iprot):
12573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12575 
      return
12576 
    iprot.readStructBegin()
12577 
    while True:
12578 
      (fname, ftype, fid) = iprot.readFieldBegin()
12579 
      if ftype == TType.STOP:
12580 
        break
12581 
      if fid == 0:
2981 rajveer 12582 
        if ftype == TType.I64:
12583 
          self.success = iprot.readI64();
94 ashish 12584 
        else:
12585 
          iprot.skip(ftype)
12586 
      else:
12587 
        iprot.skip(ftype)
12588 
      iprot.readFieldEnd()
12589 
    iprot.readStructEnd()
12590 
 
12591 
  def write(self, oprot):
12592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12594 
      return
2981 rajveer 12595 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12596 
    if self.success is not None:
2981 rajveer 12597 
      oprot.writeFieldBegin('success', TType.I64, 0)
12598 
      oprot.writeI64(self.success)
94 ashish 12599 
      oprot.writeFieldEnd()
12600 
    oprot.writeFieldStop()
12601 
    oprot.writeStructEnd()
12602 
 
3431 rajveer 12603 
  def validate(self):
12604 
    return
12605 
 
12606 
 
94 ashish 12607 
  def __repr__(self):
12608 
    L = ['%s=%r' % (key, value)
12609 
      for key, value in self.__dict__.iteritems()]
12610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12611 
 
12612 
  def __eq__(self, other):
12613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12614 
 
12615 
  def __ne__(self, other):
12616 
    return not (self == other)
12617 
 
2981 rajveer 12618 
class getAllUsers_args:
94 ashish 12619 
  """
12620 
  Attributes:
2981 rajveer 12621 
   - userType
12622 
   - startDate
12623 
   - endDate
94 ashish 12624 
  """
12625 
 
12626 
  thrift_spec = (
12627 
    None, # 0
2981 rajveer 12628 
    (1, TType.I32, 'userType', None, None, ), # 1
12629 
    (2, TType.I64, 'startDate', None, None, ), # 2
12630 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12631 
  )
12632 
 
2981 rajveer 12633 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12634 
    self.userType = userType
12635 
    self.startDate = startDate
12636 
    self.endDate = endDate
94 ashish 12637 
 
12638 
  def read(self, iprot):
12639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12641 
      return
12642 
    iprot.readStructBegin()
12643 
    while True:
12644 
      (fname, ftype, fid) = iprot.readFieldBegin()
12645 
      if ftype == TType.STOP:
12646 
        break
12647 
      if fid == 1:
2981 rajveer 12648 
        if ftype == TType.I32:
12649 
          self.userType = iprot.readI32();
94 ashish 12650 
        else:
12651 
          iprot.skip(ftype)
12652 
      elif fid == 2:
559 chandransh 12653 
        if ftype == TType.I64:
2981 rajveer 12654 
          self.startDate = iprot.readI64();
94 ashish 12655 
        else:
12656 
          iprot.skip(ftype)
2981 rajveer 12657 
      elif fid == 3:
12658 
        if ftype == TType.I64:
12659 
          self.endDate = iprot.readI64();
12660 
        else:
12661 
          iprot.skip(ftype)
94 ashish 12662 
      else:
12663 
        iprot.skip(ftype)
12664 
      iprot.readFieldEnd()
12665 
    iprot.readStructEnd()
12666 
 
12667 
  def write(self, oprot):
12668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12670 
      return
2981 rajveer 12671 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12672 
    if self.userType is not None:
2981 rajveer 12673 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12674 
      oprot.writeI32(self.userType)
94 ashish 12675 
      oprot.writeFieldEnd()
3431 rajveer 12676 
    if self.startDate is not None:
2981 rajveer 12677 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12678 
      oprot.writeI64(self.startDate)
94 ashish 12679 
      oprot.writeFieldEnd()
3431 rajveer 12680 
    if self.endDate is not None:
2981 rajveer 12681 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12682 
      oprot.writeI64(self.endDate)
12683 
      oprot.writeFieldEnd()
94 ashish 12684 
    oprot.writeFieldStop()
12685 
    oprot.writeStructEnd()
12686 
 
3431 rajveer 12687 
  def validate(self):
12688 
    return
12689 
 
12690 
 
94 ashish 12691 
  def __repr__(self):
12692 
    L = ['%s=%r' % (key, value)
12693 
      for key, value in self.__dict__.iteritems()]
12694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12695 
 
12696 
  def __eq__(self, other):
12697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12698 
 
12699 
  def __ne__(self, other):
12700 
    return not (self == other)
12701 
 
2981 rajveer 12702 
class getAllUsers_result:
94 ashish 12703 
  """
12704 
  Attributes:
12705 
   - success
12706 
  """
12707 
 
12708 
  thrift_spec = (
2981 rajveer 12709 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12710 
  )
12711 
 
2981 rajveer 12712 
  def __init__(self, success=None,):
94 ashish 12713 
    self.success = success
12714 
 
12715 
  def read(self, iprot):
12716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12718 
      return
12719 
    iprot.readStructBegin()
12720 
    while True:
12721 
      (fname, ftype, fid) = iprot.readFieldBegin()
12722 
      if ftype == TType.STOP:
12723 
        break
12724 
      if fid == 0:
2981 rajveer 12725 
        if ftype == TType.LIST:
12726 
          self.success = []
11980 amit.gupta 12727 
          (_etype193, _size190) = iprot.readListBegin()
12728 
          for _i194 in xrange(_size190):
12729 
            _elem195 = User()
12730 
            _elem195.read(iprot)
12731 
            self.success.append(_elem195)
2981 rajveer 12732 
          iprot.readListEnd()
94 ashish 12733 
        else:
12734 
          iprot.skip(ftype)
12735 
      else:
12736 
        iprot.skip(ftype)
12737 
      iprot.readFieldEnd()
12738 
    iprot.readStructEnd()
12739 
 
12740 
  def write(self, oprot):
12741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12743 
      return
2981 rajveer 12744 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12745 
    if self.success is not None:
2981 rajveer 12746 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12747 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 12748 
      for iter196 in self.success:
12749 
        iter196.write(oprot)
2981 rajveer 12750 
      oprot.writeListEnd()
94 ashish 12751 
      oprot.writeFieldEnd()
12752 
    oprot.writeFieldStop()
12753 
    oprot.writeStructEnd()
12754 
 
3431 rajveer 12755 
  def validate(self):
12756 
    return
12757 
 
12758 
 
94 ashish 12759 
  def __repr__(self):
12760 
    L = ['%s=%r' % (key, value)
12761 
      for key, value in self.__dict__.iteritems()]
12762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12763 
 
12764 
  def __eq__(self, other):
12765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12766 
 
12767 
  def __ne__(self, other):
12768 
    return not (self == other)
12769 
 
2981 rajveer 12770 
class getMyResearchItems_args:
559 chandransh 12771 
  """
12772 
  Attributes:
772 rajveer 12773 
   - userId
559 chandransh 12774 
  """
12775 
 
12776 
  thrift_spec = (
12777 
    None, # 0
772 rajveer 12778 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12779 
  )
12780 
 
772 rajveer 12781 
  def __init__(self, userId=None,):
12782 
    self.userId = userId
559 chandransh 12783 
 
12784 
  def read(self, iprot):
12785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12787 
      return
12788 
    iprot.readStructBegin()
12789 
    while True:
12790 
      (fname, ftype, fid) = iprot.readFieldBegin()
12791 
      if ftype == TType.STOP:
12792 
        break
12793 
      if fid == 1:
12794 
        if ftype == TType.I64:
772 rajveer 12795 
          self.userId = iprot.readI64();
559 chandransh 12796 
        else:
12797 
          iprot.skip(ftype)
12798 
      else:
12799 
        iprot.skip(ftype)
12800 
      iprot.readFieldEnd()
12801 
    iprot.readStructEnd()
12802 
 
12803 
  def write(self, oprot):
12804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12806 
      return
2981 rajveer 12807 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 12808 
    if self.userId is not None:
772 rajveer 12809 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12810 
      oprot.writeI64(self.userId)
559 chandransh 12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
3431 rajveer 12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
559 chandransh 12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
12829 
 
2981 rajveer 12830 
class getMyResearchItems_result:
559 chandransh 12831 
  """
12832 
  Attributes:
130 ashish 12833 
   - success
559 chandransh 12834 
   - scx
130 ashish 12835 
  """
12836 
 
12837 
  thrift_spec = (
2981 rajveer 12838 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12839 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12840 
  )
12841 
 
559 chandransh 12842 
  def __init__(self, success=None, scx=None,):
130 ashish 12843 
    self.success = success
559 chandransh 12844 
    self.scx = scx
130 ashish 12845 
 
12846 
  def read(self, iprot):
12847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12849 
      return
12850 
    iprot.readStructBegin()
12851 
    while True:
12852 
      (fname, ftype, fid) = iprot.readFieldBegin()
12853 
      if ftype == TType.STOP:
12854 
        break
12855 
      if fid == 0:
2981 rajveer 12856 
        if ftype == TType.LIST:
12857 
          self.success = []
11980 amit.gupta 12858 
          (_etype200, _size197) = iprot.readListBegin()
12859 
          for _i201 in xrange(_size197):
12860 
            _elem202 = iprot.readI64();
12861 
            self.success.append(_elem202)
2981 rajveer 12862 
          iprot.readListEnd()
130 ashish 12863 
        else:
12864 
          iprot.skip(ftype)
12865 
      elif fid == 1:
12866 
        if ftype == TType.STRUCT:
559 chandransh 12867 
          self.scx = WidgetException()
12868 
          self.scx.read(iprot)
130 ashish 12869 
        else:
12870 
          iprot.skip(ftype)
12871 
      else:
12872 
        iprot.skip(ftype)
12873 
      iprot.readFieldEnd()
12874 
    iprot.readStructEnd()
12875 
 
12876 
  def write(self, oprot):
12877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12879 
      return
2981 rajveer 12880 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 12881 
    if self.success is not None:
2981 rajveer 12882 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12883 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 12884 
      for iter203 in self.success:
12885 
        oprot.writeI64(iter203)
2981 rajveer 12886 
      oprot.writeListEnd()
130 ashish 12887 
      oprot.writeFieldEnd()
3431 rajveer 12888 
    if self.scx is not None:
559 chandransh 12889 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12890 
      self.scx.write(oprot)
130 ashish 12891 
      oprot.writeFieldEnd()
12892 
    oprot.writeFieldStop()
12893 
    oprot.writeStructEnd()
12894 
 
3431 rajveer 12895 
  def validate(self):
12896 
    return
12897 
 
12898 
 
130 ashish 12899 
  def __repr__(self):
12900 
    L = ['%s=%r' % (key, value)
12901 
      for key, value in self.__dict__.iteritems()]
12902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12903 
 
12904 
  def __eq__(self, other):
12905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12906 
 
12907 
  def __ne__(self, other):
12908 
    return not (self == other)
12909 
 
2981 rajveer 12910 
class updateMyResearch_args:
130 ashish 12911 
  """
12912 
  Attributes:
2981 rajveer 12913 
   - userId
12914 
   - itemId
130 ashish 12915 
  """
12916 
 
12917 
  thrift_spec = (
12918 
    None, # 0
2981 rajveer 12919 
    (1, TType.I64, 'userId', None, None, ), # 1
12920 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12921 
  )
12922 
 
2981 rajveer 12923 
  def __init__(self, userId=None, itemId=None,):
12924 
    self.userId = userId
12925 
    self.itemId = itemId
130 ashish 12926 
 
12927 
  def read(self, iprot):
12928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12930 
      return
12931 
    iprot.readStructBegin()
12932 
    while True:
12933 
      (fname, ftype, fid) = iprot.readFieldBegin()
12934 
      if ftype == TType.STOP:
12935 
        break
12936 
      if fid == 1:
559 chandransh 12937 
        if ftype == TType.I64:
2981 rajveer 12938 
          self.userId = iprot.readI64();
130 ashish 12939 
        else:
12940 
          iprot.skip(ftype)
12941 
      elif fid == 2:
559 chandransh 12942 
        if ftype == TType.I64:
2981 rajveer 12943 
          self.itemId = iprot.readI64();
559 chandransh 12944 
        else:
12945 
          iprot.skip(ftype)
130 ashish 12946 
      else:
12947 
        iprot.skip(ftype)
12948 
      iprot.readFieldEnd()
12949 
    iprot.readStructEnd()
12950 
 
12951 
  def write(self, oprot):
12952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12954 
      return
2981 rajveer 12955 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 12956 
    if self.userId is not None:
2981 rajveer 12957 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12958 
      oprot.writeI64(self.userId)
130 ashish 12959 
      oprot.writeFieldEnd()
3431 rajveer 12960 
    if self.itemId is not None:
2981 rajveer 12961 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12962 
      oprot.writeI64(self.itemId)
130 ashish 12963 
      oprot.writeFieldEnd()
12964 
    oprot.writeFieldStop()
12965 
    oprot.writeStructEnd()
12966 
 
3431 rajveer 12967 
  def validate(self):
12968 
    return
12969 
 
12970 
 
130 ashish 12971 
  def __repr__(self):
12972 
    L = ['%s=%r' % (key, value)
12973 
      for key, value in self.__dict__.iteritems()]
12974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12975 
 
12976 
  def __eq__(self, other):
12977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12978 
 
12979 
  def __ne__(self, other):
12980 
    return not (self == other)
12981 
 
2981 rajveer 12982 
class updateMyResearch_result:
12983 
  """
12984 
  Attributes:
12985 
   - success
12986 
   - scx
12987 
  """
559 chandransh 12988 
 
12989 
  thrift_spec = (
2981 rajveer 12990 
    (0, TType.BOOL, 'success', None, None, ), # 0
12991 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12992 
  )
12993 
 
2981 rajveer 12994 
  def __init__(self, success=None, scx=None,):
12995 
    self.success = success
12996 
    self.scx = scx
12997 
 
559 chandransh 12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
2981 rajveer 13007 
      if fid == 0:
13008 
        if ftype == TType.BOOL:
13009 
          self.success = iprot.readBool();
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      elif fid == 1:
13013 
        if ftype == TType.STRUCT:
13014 
          self.scx = WidgetException()
13015 
          self.scx.read(iprot)
13016 
        else:
13017 
          iprot.skip(ftype)
559 chandransh 13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
2981 rajveer 13027 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13028 
    if self.success is not None:
2981 rajveer 13029 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13030 
      oprot.writeBool(self.success)
13031 
      oprot.writeFieldEnd()
3431 rajveer 13032 
    if self.scx is not None:
2981 rajveer 13033 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13034 
      self.scx.write(oprot)
13035 
      oprot.writeFieldEnd()
559 chandransh 13036 
    oprot.writeFieldStop()
13037 
    oprot.writeStructEnd()
13038 
 
3431 rajveer 13039 
  def validate(self):
13040 
    return
13041 
 
13042 
 
559 chandransh 13043 
  def __repr__(self):
13044 
    L = ['%s=%r' % (key, value)
13045 
      for key, value in self.__dict__.iteritems()]
13046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13047 
 
13048 
  def __eq__(self, other):
13049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13050 
 
13051 
  def __ne__(self, other):
13052 
    return not (self == other)
13053 
 
2981 rajveer 13054 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13055 
  """
13056 
  Attributes:
2981 rajveer 13057 
   - userId
13058 
   - itemId
1596 ankur.sing 13059 
  """
559 chandransh 13060 
 
1596 ankur.sing 13061 
  thrift_spec = (
13062 
    None, # 0
2981 rajveer 13063 
    (1, TType.I64, 'userId', None, None, ), # 1
13064 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13065 
  )
13066 
 
2981 rajveer 13067 
  def __init__(self, userId=None, itemId=None,):
13068 
    self.userId = userId
13069 
    self.itemId = itemId
1596 ankur.sing 13070 
 
13071 
  def read(self, iprot):
13072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13074 
      return
13075 
    iprot.readStructBegin()
13076 
    while True:
13077 
      (fname, ftype, fid) = iprot.readFieldBegin()
13078 
      if ftype == TType.STOP:
13079 
        break
13080 
      if fid == 1:
2981 rajveer 13081 
        if ftype == TType.I64:
13082 
          self.userId = iprot.readI64();
1596 ankur.sing 13083 
        else:
13084 
          iprot.skip(ftype)
2981 rajveer 13085 
      elif fid == 2:
13086 
        if ftype == TType.I64:
13087 
          self.itemId = iprot.readI64();
13088 
        else:
13089 
          iprot.skip(ftype)
1596 ankur.sing 13090 
      else:
13091 
        iprot.skip(ftype)
13092 
      iprot.readFieldEnd()
13093 
    iprot.readStructEnd()
13094 
 
13095 
  def write(self, oprot):
13096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13098 
      return
2981 rajveer 13099 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13100 
    if self.userId is not None:
2981 rajveer 13101 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13102 
      oprot.writeI64(self.userId)
1596 ankur.sing 13103 
      oprot.writeFieldEnd()
3431 rajveer 13104 
    if self.itemId is not None:
2981 rajveer 13105 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13106 
      oprot.writeI64(self.itemId)
13107 
      oprot.writeFieldEnd()
1596 ankur.sing 13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
3431 rajveer 13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
1596 ankur.sing 13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
2981 rajveer 13126 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13127 
  """
13128 
  Attributes:
2981 rajveer 13129 
   - scx
1596 ankur.sing 13130 
  """
13131 
 
13132 
  thrift_spec = (
2981 rajveer 13133 
    None, # 0
13134 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13135 
  )
13136 
 
2981 rajveer 13137 
  def __init__(self, scx=None,):
13138 
    self.scx = scx
1596 ankur.sing 13139 
 
13140 
  def read(self, iprot):
13141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13143 
      return
13144 
    iprot.readStructBegin()
13145 
    while True:
13146 
      (fname, ftype, fid) = iprot.readFieldBegin()
13147 
      if ftype == TType.STOP:
13148 
        break
2981 rajveer 13149 
      if fid == 1:
13150 
        if ftype == TType.STRUCT:
13151 
          self.scx = WidgetException()
13152 
          self.scx.read(iprot)
1596 ankur.sing 13153 
        else:
13154 
          iprot.skip(ftype)
13155 
      else:
13156 
        iprot.skip(ftype)
13157 
      iprot.readFieldEnd()
13158 
    iprot.readStructEnd()
13159 
 
13160 
  def write(self, oprot):
13161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13163 
      return
2981 rajveer 13164 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13165 
    if self.scx is not None:
2981 rajveer 13166 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13167 
      self.scx.write(oprot)
1596 ankur.sing 13168 
      oprot.writeFieldEnd()
13169 
    oprot.writeFieldStop()
13170 
    oprot.writeStructEnd()
13171 
 
3431 rajveer 13172 
  def validate(self):
13173 
    return
13174 
 
13175 
 
1596 ankur.sing 13176 
  def __repr__(self):
13177 
    L = ['%s=%r' % (key, value)
13178 
      for key, value in self.__dict__.iteritems()]
13179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13180 
 
13181 
  def __eq__(self, other):
13182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13183 
 
13184 
  def __ne__(self, other):
13185 
    return not (self == other)
13186 
 
2981 rajveer 13187 
class getBrowseHistoryItems_args:
1673 ankur.sing 13188 
  """
13189 
  Attributes:
2981 rajveer 13190 
   - userId
1673 ankur.sing 13191 
  """
1596 ankur.sing 13192 
 
1673 ankur.sing 13193 
  thrift_spec = (
13194 
    None, # 0
2981 rajveer 13195 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13196 
  )
13197 
 
2981 rajveer 13198 
  def __init__(self, userId=None,):
13199 
    self.userId = userId
1673 ankur.sing 13200 
 
13201 
  def read(self, iprot):
13202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13204 
      return
13205 
    iprot.readStructBegin()
13206 
    while True:
13207 
      (fname, ftype, fid) = iprot.readFieldBegin()
13208 
      if ftype == TType.STOP:
13209 
        break
13210 
      if fid == 1:
1891 ankur.sing 13211 
        if ftype == TType.I64:
2981 rajveer 13212 
          self.userId = iprot.readI64();
1891 ankur.sing 13213 
        else:
13214 
          iprot.skip(ftype)
1673 ankur.sing 13215 
      else:
13216 
        iprot.skip(ftype)
13217 
      iprot.readFieldEnd()
13218 
    iprot.readStructEnd()
13219 
 
13220 
  def write(self, oprot):
13221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13223 
      return
2981 rajveer 13224 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13225 
    if self.userId is not None:
2981 rajveer 13226 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13227 
      oprot.writeI64(self.userId)
1673 ankur.sing 13228 
      oprot.writeFieldEnd()
13229 
    oprot.writeFieldStop()
13230 
    oprot.writeStructEnd()
13231 
 
3431 rajveer 13232 
  def validate(self):
13233 
    return
13234 
 
13235 
 
1673 ankur.sing 13236 
  def __repr__(self):
13237 
    L = ['%s=%r' % (key, value)
13238 
      for key, value in self.__dict__.iteritems()]
13239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13240 
 
13241 
  def __eq__(self, other):
13242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13243 
 
13244 
  def __ne__(self, other):
13245 
    return not (self == other)
13246 
 
2981 rajveer 13247 
class getBrowseHistoryItems_result:
1673 ankur.sing 13248 
  """
13249 
  Attributes:
13250 
   - success
2981 rajveer 13251 
   - scx
1673 ankur.sing 13252 
  """
13253 
 
13254 
  thrift_spec = (
2981 rajveer 13255 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13256 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13257 
  )
13258 
 
2981 rajveer 13259 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13260 
    self.success = success
2981 rajveer 13261 
    self.scx = scx
1673 ankur.sing 13262 
 
13263 
  def read(self, iprot):
13264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13266 
      return
13267 
    iprot.readStructBegin()
13268 
    while True:
13269 
      (fname, ftype, fid) = iprot.readFieldBegin()
13270 
      if ftype == TType.STOP:
13271 
        break
13272 
      if fid == 0:
13273 
        if ftype == TType.LIST:
13274 
          self.success = []
11980 amit.gupta 13275 
          (_etype207, _size204) = iprot.readListBegin()
13276 
          for _i208 in xrange(_size204):
13277 
            _elem209 = iprot.readI64();
13278 
            self.success.append(_elem209)
1673 ankur.sing 13279 
          iprot.readListEnd()
13280 
        else:
13281 
          iprot.skip(ftype)
2981 rajveer 13282 
      elif fid == 1:
13283 
        if ftype == TType.STRUCT:
13284 
          self.scx = WidgetException()
13285 
          self.scx.read(iprot)
13286 
        else:
13287 
          iprot.skip(ftype)
1673 ankur.sing 13288 
      else:
13289 
        iprot.skip(ftype)
13290 
      iprot.readFieldEnd()
13291 
    iprot.readStructEnd()
13292 
 
13293 
  def write(self, oprot):
13294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13296 
      return
2981 rajveer 13297 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13298 
    if self.success is not None:
1673 ankur.sing 13299 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13300 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13301 
      for iter210 in self.success:
13302 
        oprot.writeI64(iter210)
1673 ankur.sing 13303 
      oprot.writeListEnd()
13304 
      oprot.writeFieldEnd()
3431 rajveer 13305 
    if self.scx is not None:
2981 rajveer 13306 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13307 
      self.scx.write(oprot)
2642 varun.gupt 13308 
      oprot.writeFieldEnd()
13309 
    oprot.writeFieldStop()
13310 
    oprot.writeStructEnd()
13311 
 
3431 rajveer 13312 
  def validate(self):
13313 
    return
13314 
 
13315 
 
2642 varun.gupt 13316 
  def __repr__(self):
13317 
    L = ['%s=%r' % (key, value)
13318 
      for key, value in self.__dict__.iteritems()]
13319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13320 
 
13321 
  def __eq__(self, other):
13322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13323 
 
13324 
  def __ne__(self, other):
13325 
    return not (self == other)
13326 
 
2981 rajveer 13327 
class updateBrowseHistory_args:
2642 varun.gupt 13328 
  """
13329 
  Attributes:
2981 rajveer 13330 
   - userId
13331 
   - itemId
2642 varun.gupt 13332 
  """
13333 
 
13334 
  thrift_spec = (
13335 
    None, # 0
2981 rajveer 13336 
    (1, TType.I64, 'userId', None, None, ), # 1
13337 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13338 
  )
13339 
 
2981 rajveer 13340 
  def __init__(self, userId=None, itemId=None,):
13341 
    self.userId = userId
13342 
    self.itemId = itemId
2642 varun.gupt 13343 
 
13344 
  def read(self, iprot):
13345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13347 
      return
13348 
    iprot.readStructBegin()
13349 
    while True:
13350 
      (fname, ftype, fid) = iprot.readFieldBegin()
13351 
      if ftype == TType.STOP:
13352 
        break
13353 
      if fid == 1:
13354 
        if ftype == TType.I64:
2981 rajveer 13355 
          self.userId = iprot.readI64();
2642 varun.gupt 13356 
        else:
13357 
          iprot.skip(ftype)
13358 
      elif fid == 2:
13359 
        if ftype == TType.I64:
2981 rajveer 13360 
          self.itemId = iprot.readI64();
2642 varun.gupt 13361 
        else:
13362 
          iprot.skip(ftype)
13363 
      else:
13364 
        iprot.skip(ftype)
13365 
      iprot.readFieldEnd()
13366 
    iprot.readStructEnd()
13367 
 
13368 
  def write(self, oprot):
13369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13371 
      return
2981 rajveer 13372 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13373 
    if self.userId is not None:
2981 rajveer 13374 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13375 
      oprot.writeI64(self.userId)
2642 varun.gupt 13376 
      oprot.writeFieldEnd()
3431 rajveer 13377 
    if self.itemId is not None:
2981 rajveer 13378 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13379 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13380 
      oprot.writeFieldEnd()
13381 
    oprot.writeFieldStop()
13382 
    oprot.writeStructEnd()
13383 
 
3431 rajveer 13384 
  def validate(self):
13385 
    return
13386 
 
13387 
 
2642 varun.gupt 13388 
  def __repr__(self):
13389 
    L = ['%s=%r' % (key, value)
13390 
      for key, value in self.__dict__.iteritems()]
13391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13392 
 
13393 
  def __eq__(self, other):
13394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13395 
 
13396 
  def __ne__(self, other):
13397 
    return not (self == other)
13398 
 
2981 rajveer 13399 
class updateBrowseHistory_result:
2642 varun.gupt 13400 
 
13401 
  thrift_spec = (
13402 
  )
13403 
 
13404 
  def read(self, iprot):
13405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13407 
      return
13408 
    iprot.readStructBegin()
13409 
    while True:
13410 
      (fname, ftype, fid) = iprot.readFieldBegin()
13411 
      if ftype == TType.STOP:
13412 
        break
13413 
      else:
13414 
        iprot.skip(ftype)
13415 
      iprot.readFieldEnd()
13416 
    iprot.readStructEnd()
13417 
 
13418 
  def write(self, oprot):
13419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13421 
      return
2981 rajveer 13422 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13423 
    oprot.writeFieldStop()
13424 
    oprot.writeStructEnd()
13425 
 
3431 rajveer 13426 
  def validate(self):
13427 
    return
13428 
 
13429 
 
2642 varun.gupt 13430 
  def __repr__(self):
13431 
    L = ['%s=%r' % (key, value)
13432 
      for key, value in self.__dict__.iteritems()]
13433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13434 
 
13435 
  def __eq__(self, other):
13436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13437 
 
13438 
  def __ne__(self, other):
13439 
    return not (self == other)
13440 
 
3385 varun.gupt 13441 
class getCartsWithCouponCount_args:
13442 
  """
13443 
  Attributes:
13444 
   - couponCode
13445 
  """
2642 varun.gupt 13446 
 
3385 varun.gupt 13447 
  thrift_spec = (
13448 
    None, # 0
13449 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13450 
  )
13451 
 
13452 
  def __init__(self, couponCode=None,):
13453 
    self.couponCode = couponCode
13454 
 
13455 
  def read(self, iprot):
13456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13458 
      return
13459 
    iprot.readStructBegin()
13460 
    while True:
13461 
      (fname, ftype, fid) = iprot.readFieldBegin()
13462 
      if ftype == TType.STOP:
13463 
        break
13464 
      if fid == 1:
13465 
        if ftype == TType.STRING:
13466 
          self.couponCode = iprot.readString();
13467 
        else:
13468 
          iprot.skip(ftype)
13469 
      else:
13470 
        iprot.skip(ftype)
13471 
      iprot.readFieldEnd()
13472 
    iprot.readStructEnd()
13473 
 
13474 
  def write(self, oprot):
13475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13477 
      return
13478 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13479 
    if self.couponCode is not None:
3385 varun.gupt 13480 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13481 
      oprot.writeString(self.couponCode)
13482 
      oprot.writeFieldEnd()
13483 
    oprot.writeFieldStop()
13484 
    oprot.writeStructEnd()
13485 
 
3431 rajveer 13486 
  def validate(self):
13487 
    return
13488 
 
13489 
 
3385 varun.gupt 13490 
  def __repr__(self):
13491 
    L = ['%s=%r' % (key, value)
13492 
      for key, value in self.__dict__.iteritems()]
13493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13494 
 
13495 
  def __eq__(self, other):
13496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13497 
 
13498 
  def __ne__(self, other):
13499 
    return not (self == other)
13500 
 
13501 
class getCartsWithCouponCount_result:
13502 
  """
13503 
  Attributes:
13504 
   - success
13505 
  """
13506 
 
13507 
  thrift_spec = (
13508 
    (0, TType.I64, 'success', None, None, ), # 0
13509 
  )
13510 
 
13511 
  def __init__(self, success=None,):
13512 
    self.success = success
13513 
 
13514 
  def read(self, iprot):
13515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13517 
      return
13518 
    iprot.readStructBegin()
13519 
    while True:
13520 
      (fname, ftype, fid) = iprot.readFieldBegin()
13521 
      if ftype == TType.STOP:
13522 
        break
13523 
      if fid == 0:
13524 
        if ftype == TType.I64:
13525 
          self.success = iprot.readI64();
13526 
        else:
13527 
          iprot.skip(ftype)
13528 
      else:
13529 
        iprot.skip(ftype)
13530 
      iprot.readFieldEnd()
13531 
    iprot.readStructEnd()
13532 
 
13533 
  def write(self, oprot):
13534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13536 
      return
13537 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13538 
    if self.success is not None:
3385 varun.gupt 13539 
      oprot.writeFieldBegin('success', TType.I64, 0)
13540 
      oprot.writeI64(self.success)
13541 
      oprot.writeFieldEnd()
13542 
    oprot.writeFieldStop()
13543 
    oprot.writeStructEnd()
13544 
 
3431 rajveer 13545 
  def validate(self):
13546 
    return
13547 
 
13548 
 
3385 varun.gupt 13549 
  def __repr__(self):
13550 
    L = ['%s=%r' % (key, value)
13551 
      for key, value in self.__dict__.iteritems()]
13552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13553 
 
13554 
  def __eq__(self, other):
13555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13556 
 
13557 
  def __ne__(self, other):
13558 
    return not (self == other)
3499 mandeep.dh 13559 
 
13560 
class increaseTrustLevel_args:
13561 
  """
13562 
  Attributes:
13563 
   - userId
13564 
   - trustLevelDelta
13565 
  """
13566 
 
13567 
  thrift_spec = (
13568 
    None, # 0
13569 
    (1, TType.I64, 'userId', None, None, ), # 1
13570 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13571 
  )
13572 
 
13573 
  def __init__(self, userId=None, trustLevelDelta=None,):
13574 
    self.userId = userId
13575 
    self.trustLevelDelta = trustLevelDelta
13576 
 
13577 
  def read(self, iprot):
13578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13580 
      return
13581 
    iprot.readStructBegin()
13582 
    while True:
13583 
      (fname, ftype, fid) = iprot.readFieldBegin()
13584 
      if ftype == TType.STOP:
13585 
        break
13586 
      if fid == 1:
13587 
        if ftype == TType.I64:
13588 
          self.userId = iprot.readI64();
13589 
        else:
13590 
          iprot.skip(ftype)
13591 
      elif fid == 2:
13592 
        if ftype == TType.DOUBLE:
13593 
          self.trustLevelDelta = iprot.readDouble();
13594 
        else:
13595 
          iprot.skip(ftype)
13596 
      else:
13597 
        iprot.skip(ftype)
13598 
      iprot.readFieldEnd()
13599 
    iprot.readStructEnd()
13600 
 
13601 
  def write(self, oprot):
13602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13604 
      return
13605 
    oprot.writeStructBegin('increaseTrustLevel_args')
13606 
    if self.userId is not None:
13607 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13608 
      oprot.writeI64(self.userId)
13609 
      oprot.writeFieldEnd()
13610 
    if self.trustLevelDelta is not None:
13611 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13612 
      oprot.writeDouble(self.trustLevelDelta)
13613 
      oprot.writeFieldEnd()
13614 
    oprot.writeFieldStop()
13615 
    oprot.writeStructEnd()
13616 
 
13617 
  def validate(self):
13618 
    return
13619 
 
13620 
 
13621 
  def __repr__(self):
13622 
    L = ['%s=%r' % (key, value)
13623 
      for key, value in self.__dict__.iteritems()]
13624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13625 
 
13626 
  def __eq__(self, other):
13627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13628 
 
13629 
  def __ne__(self, other):
13630 
    return not (self == other)
4668 varun.gupt 13631 
 
5407 amar.kumar 13632 
class getTrustLevel_args:
13633 
  """
13634 
  Attributes:
13635 
   - userId
13636 
  """
13637 
 
13638 
  thrift_spec = (
13639 
    None, # 0
13640 
    (1, TType.I64, 'userId', None, None, ), # 1
13641 
  )
13642 
 
13643 
  def __init__(self, userId=None,):
13644 
    self.userId = userId
13645 
 
13646 
  def read(self, iprot):
13647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13649 
      return
13650 
    iprot.readStructBegin()
13651 
    while True:
13652 
      (fname, ftype, fid) = iprot.readFieldBegin()
13653 
      if ftype == TType.STOP:
13654 
        break
13655 
      if fid == 1:
13656 
        if ftype == TType.I64:
13657 
          self.userId = iprot.readI64();
13658 
        else:
13659 
          iprot.skip(ftype)
13660 
      else:
13661 
        iprot.skip(ftype)
13662 
      iprot.readFieldEnd()
13663 
    iprot.readStructEnd()
13664 
 
13665 
  def write(self, oprot):
13666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13668 
      return
13669 
    oprot.writeStructBegin('getTrustLevel_args')
13670 
    if self.userId is not None:
13671 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13672 
      oprot.writeI64(self.userId)
13673 
      oprot.writeFieldEnd()
13674 
    oprot.writeFieldStop()
13675 
    oprot.writeStructEnd()
13676 
 
13677 
  def validate(self):
13678 
    return
13679 
 
13680 
 
13681 
  def __repr__(self):
13682 
    L = ['%s=%r' % (key, value)
13683 
      for key, value in self.__dict__.iteritems()]
13684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13685 
 
13686 
  def __eq__(self, other):
13687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13688 
 
13689 
  def __ne__(self, other):
13690 
    return not (self == other)
13691 
 
13692 
class getTrustLevel_result:
13693 
  """
13694 
  Attributes:
13695 
   - success
13696 
  """
13697 
 
13698 
  thrift_spec = (
13699 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13700 
  )
13701 
 
13702 
  def __init__(self, success=None,):
13703 
    self.success = success
13704 
 
13705 
  def read(self, iprot):
13706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13708 
      return
13709 
    iprot.readStructBegin()
13710 
    while True:
13711 
      (fname, ftype, fid) = iprot.readFieldBegin()
13712 
      if ftype == TType.STOP:
13713 
        break
13714 
      if fid == 0:
13715 
        if ftype == TType.DOUBLE:
13716 
          self.success = iprot.readDouble();
13717 
        else:
13718 
          iprot.skip(ftype)
13719 
      else:
13720 
        iprot.skip(ftype)
13721 
      iprot.readFieldEnd()
13722 
    iprot.readStructEnd()
13723 
 
13724 
  def write(self, oprot):
13725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13727 
      return
13728 
    oprot.writeStructBegin('getTrustLevel_result')
13729 
    if self.success is not None:
13730 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13731 
      oprot.writeDouble(self.success)
13732 
      oprot.writeFieldEnd()
13733 
    oprot.writeFieldStop()
13734 
    oprot.writeStructEnd()
13735 
 
13736 
  def validate(self):
13737 
    return
13738 
 
13739 
 
13740 
  def __repr__(self):
13741 
    L = ['%s=%r' % (key, value)
13742 
      for key, value in self.__dict__.iteritems()]
13743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13744 
 
13745 
  def __eq__(self, other):
13746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13747 
 
13748 
  def __ne__(self, other):
13749 
    return not (self == other)
13750 
 
4668 varun.gupt 13751 
class showCODOption_args:
13752 
  """
13753 
  Attributes:
13754 
   - cartId
13755 
   - sourceId
13756 
   - pincode
13757 
  """
13758 
 
13759 
  thrift_spec = (
13760 
    None, # 0
13761 
    (1, TType.I64, 'cartId', None, None, ), # 1
13762 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13763 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13764 
  )
13765 
 
13766 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13767 
    self.cartId = cartId
13768 
    self.sourceId = sourceId
13769 
    self.pincode = pincode
13770 
 
13771 
  def read(self, iprot):
13772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13774 
      return
13775 
    iprot.readStructBegin()
13776 
    while True:
13777 
      (fname, ftype, fid) = iprot.readFieldBegin()
13778 
      if ftype == TType.STOP:
13779 
        break
13780 
      if fid == 1:
13781 
        if ftype == TType.I64:
13782 
          self.cartId = iprot.readI64();
13783 
        else:
13784 
          iprot.skip(ftype)
13785 
      elif fid == 2:
13786 
        if ftype == TType.I64:
13787 
          self.sourceId = iprot.readI64();
13788 
        else:
13789 
          iprot.skip(ftype)
13790 
      elif fid == 3:
13791 
        if ftype == TType.STRING:
13792 
          self.pincode = iprot.readString();
13793 
        else:
13794 
          iprot.skip(ftype)
13795 
      else:
13796 
        iprot.skip(ftype)
13797 
      iprot.readFieldEnd()
13798 
    iprot.readStructEnd()
13799 
 
13800 
  def write(self, oprot):
13801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13803 
      return
13804 
    oprot.writeStructBegin('showCODOption_args')
13805 
    if self.cartId is not None:
13806 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13807 
      oprot.writeI64(self.cartId)
13808 
      oprot.writeFieldEnd()
13809 
    if self.sourceId is not None:
13810 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13811 
      oprot.writeI64(self.sourceId)
13812 
      oprot.writeFieldEnd()
13813 
    if self.pincode is not None:
13814 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
13815 
      oprot.writeString(self.pincode)
13816 
      oprot.writeFieldEnd()
13817 
    oprot.writeFieldStop()
13818 
    oprot.writeStructEnd()
13819 
 
13820 
  def validate(self):
13821 
    return
13822 
 
13823 
 
13824 
  def __repr__(self):
13825 
    L = ['%s=%r' % (key, value)
13826 
      for key, value in self.__dict__.iteritems()]
13827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13828 
 
13829 
  def __eq__(self, other):
13830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13831 
 
13832 
  def __ne__(self, other):
13833 
    return not (self == other)
13834 
 
13835 
class showCODOption_result:
13836 
  """
13837 
  Attributes:
13838 
   - success
13839 
  """
13840 
 
13841 
  thrift_spec = (
13842 
    (0, TType.BOOL, 'success', None, None, ), # 0
13843 
  )
13844 
 
13845 
  def __init__(self, success=None,):
13846 
    self.success = success
13847 
 
13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
13857 
      if fid == 0:
13858 
        if ftype == TType.BOOL:
13859 
          self.success = iprot.readBool();
13860 
        else:
13861 
          iprot.skip(ftype)
13862 
      else:
13863 
        iprot.skip(ftype)
13864 
      iprot.readFieldEnd()
13865 
    iprot.readStructEnd()
13866 
 
13867 
  def write(self, oprot):
13868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13870 
      return
13871 
    oprot.writeStructBegin('showCODOption_result')
13872 
    if self.success is not None:
13873 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13874 
      oprot.writeBool(self.success)
13875 
      oprot.writeFieldEnd()
13876 
    oprot.writeFieldStop()
13877 
    oprot.writeStructEnd()
13878 
 
13879 
  def validate(self):
13880 
    return
13881 
 
13882 
 
13883 
  def __repr__(self):
13884 
    L = ['%s=%r' % (key, value)
13885 
      for key, value in self.__dict__.iteritems()]
13886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13887 
 
13888 
  def __eq__(self, other):
13889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13890 
 
13891 
  def __ne__(self, other):
13892 
    return not (self == other)
5623 anupam.sin 13893 
 
13894 
class getUserEmails_args:
13895 
  """
13896 
  Attributes:
13897 
   - startDate
13898 
   - endDate
13899 
  """
13900 
 
13901 
  thrift_spec = (
13902 
    None, # 0
13903 
    (1, TType.I64, 'startDate', None, None, ), # 1
13904 
    (2, TType.I64, 'endDate', None, None, ), # 2
13905 
  )
13906 
 
13907 
  def __init__(self, startDate=None, endDate=None,):
13908 
    self.startDate = startDate
13909 
    self.endDate = endDate
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.startDate = iprot.readI64();
13923 
        else:
13924 
          iprot.skip(ftype)
13925 
      elif fid == 2:
13926 
        if ftype == TType.I64:
13927 
          self.endDate = iprot.readI64();
13928 
        else:
13929 
          iprot.skip(ftype)
13930 
      else:
13931 
        iprot.skip(ftype)
13932 
      iprot.readFieldEnd()
13933 
    iprot.readStructEnd()
13934 
 
13935 
  def write(self, oprot):
13936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13938 
      return
13939 
    oprot.writeStructBegin('getUserEmails_args')
13940 
    if self.startDate is not None:
13941 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
13942 
      oprot.writeI64(self.startDate)
13943 
      oprot.writeFieldEnd()
13944 
    if self.endDate is not None:
13945 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
13946 
      oprot.writeI64(self.endDate)
13947 
      oprot.writeFieldEnd()
13948 
    oprot.writeFieldStop()
13949 
    oprot.writeStructEnd()
13950 
 
13951 
  def validate(self):
13952 
    return
13953 
 
13954 
 
13955 
  def __repr__(self):
13956 
    L = ['%s=%r' % (key, value)
13957 
      for key, value in self.__dict__.iteritems()]
13958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13959 
 
13960 
  def __eq__(self, other):
13961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13962 
 
13963 
  def __ne__(self, other):
13964 
    return not (self == other)
13965 
 
13966 
class getUserEmails_result:
13967 
  """
13968 
  Attributes:
13969 
   - success
13970 
  """
13971 
 
13972 
  thrift_spec = (
13973 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13974 
  )
13975 
 
13976 
  def __init__(self, success=None,):
13977 
    self.success = success
13978 
 
13979 
  def read(self, iprot):
13980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13982 
      return
13983 
    iprot.readStructBegin()
13984 
    while True:
13985 
      (fname, ftype, fid) = iprot.readFieldBegin()
13986 
      if ftype == TType.STOP:
13987 
        break
13988 
      if fid == 0:
13989 
        if ftype == TType.LIST:
13990 
          self.success = []
11980 amit.gupta 13991 
          (_etype214, _size211) = iprot.readListBegin()
13992 
          for _i215 in xrange(_size211):
13993 
            _elem216 = iprot.readString();
13994 
            self.success.append(_elem216)
5623 anupam.sin 13995 
          iprot.readListEnd()
13996 
        else:
13997 
          iprot.skip(ftype)
13998 
      else:
13999 
        iprot.skip(ftype)
14000 
      iprot.readFieldEnd()
14001 
    iprot.readStructEnd()
14002 
 
14003 
  def write(self, oprot):
14004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14006 
      return
14007 
    oprot.writeStructBegin('getUserEmails_result')
14008 
    if self.success is not None:
14009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14010 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14011 
      for iter217 in self.success:
14012 
        oprot.writeString(iter217)
5623 anupam.sin 14013 
      oprot.writeListEnd()
14014 
      oprot.writeFieldEnd()
14015 
    oprot.writeFieldStop()
14016 
    oprot.writeStructEnd()
14017 
 
14018 
  def validate(self):
14019 
    return
14020 
 
14021 
 
14022 
  def __repr__(self):
14023 
    L = ['%s=%r' % (key, value)
14024 
      for key, value in self.__dict__.iteritems()]
14025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14026 
 
14027 
  def __eq__(self, other):
14028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14029 
 
14030 
  def __ne__(self, other):
14031 
    return not (self == other)
6821 amar.kumar 14032 
 
6903 anupam.sin 14033 
class insureItem_args:
14034 
  """
14035 
  Attributes:
14036 
   - itemId
14037 
   - cartId
14038 
   - toInsure
9299 kshitij.so 14039 
   - insurerType
6903 anupam.sin 14040 
  """
14041 
 
14042 
  thrift_spec = (
14043 
    None, # 0
14044 
    (1, TType.I64, 'itemId', None, None, ), # 1
14045 
    (2, TType.I64, 'cartId', None, None, ), # 2
14046 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14047 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14048 
  )
14049 
 
9299 kshitij.so 14050 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14051 
    self.itemId = itemId
14052 
    self.cartId = cartId
14053 
    self.toInsure = toInsure
9299 kshitij.so 14054 
    self.insurerType = insurerType
6903 anupam.sin 14055 
 
14056 
  def read(self, iprot):
14057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14059 
      return
14060 
    iprot.readStructBegin()
14061 
    while True:
14062 
      (fname, ftype, fid) = iprot.readFieldBegin()
14063 
      if ftype == TType.STOP:
14064 
        break
14065 
      if fid == 1:
14066 
        if ftype == TType.I64:
14067 
          self.itemId = iprot.readI64();
14068 
        else:
14069 
          iprot.skip(ftype)
14070 
      elif fid == 2:
14071 
        if ftype == TType.I64:
14072 
          self.cartId = iprot.readI64();
14073 
        else:
14074 
          iprot.skip(ftype)
14075 
      elif fid == 3:
14076 
        if ftype == TType.BOOL:
14077 
          self.toInsure = iprot.readBool();
14078 
        else:
14079 
          iprot.skip(ftype)
9299 kshitij.so 14080 
      elif fid == 4:
14081 
        if ftype == TType.I32:
14082 
          self.insurerType = iprot.readI32();
14083 
        else:
14084 
          iprot.skip(ftype)
6903 anupam.sin 14085 
      else:
14086 
        iprot.skip(ftype)
14087 
      iprot.readFieldEnd()
14088 
    iprot.readStructEnd()
14089 
 
14090 
  def write(self, oprot):
14091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14093 
      return
14094 
    oprot.writeStructBegin('insureItem_args')
14095 
    if self.itemId is not None:
14096 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14097 
      oprot.writeI64(self.itemId)
14098 
      oprot.writeFieldEnd()
14099 
    if self.cartId is not None:
14100 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14101 
      oprot.writeI64(self.cartId)
14102 
      oprot.writeFieldEnd()
14103 
    if self.toInsure is not None:
14104 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14105 
      oprot.writeBool(self.toInsure)
14106 
      oprot.writeFieldEnd()
9299 kshitij.so 14107 
    if self.insurerType is not None:
14108 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14109 
      oprot.writeI32(self.insurerType)
14110 
      oprot.writeFieldEnd()
6903 anupam.sin 14111 
    oprot.writeFieldStop()
14112 
    oprot.writeStructEnd()
14113 
 
14114 
  def validate(self):
14115 
    return
14116 
 
14117 
 
14118 
  def __repr__(self):
14119 
    L = ['%s=%r' % (key, value)
14120 
      for key, value in self.__dict__.iteritems()]
14121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14122 
 
14123 
  def __eq__(self, other):
14124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14125 
 
14126 
  def __ne__(self, other):
14127 
    return not (self == other)
14128 
 
14129 
class insureItem_result:
14130 
  """
14131 
  Attributes:
14132 
   - success
14133 
  """
14134 
 
14135 
  thrift_spec = (
14136 
    (0, TType.BOOL, 'success', None, None, ), # 0
14137 
  )
14138 
 
14139 
  def __init__(self, success=None,):
14140 
    self.success = success
14141 
 
14142 
  def read(self, iprot):
14143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14145 
      return
14146 
    iprot.readStructBegin()
14147 
    while True:
14148 
      (fname, ftype, fid) = iprot.readFieldBegin()
14149 
      if ftype == TType.STOP:
14150 
        break
14151 
      if fid == 0:
14152 
        if ftype == TType.BOOL:
14153 
          self.success = iprot.readBool();
14154 
        else:
14155 
          iprot.skip(ftype)
14156 
      else:
14157 
        iprot.skip(ftype)
14158 
      iprot.readFieldEnd()
14159 
    iprot.readStructEnd()
14160 
 
14161 
  def write(self, oprot):
14162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14164 
      return
14165 
    oprot.writeStructBegin('insureItem_result')
14166 
    if self.success is not None:
14167 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14168 
      oprot.writeBool(self.success)
14169 
      oprot.writeFieldEnd()
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
14188 
class cancelInsurance_args:
14189 
  """
14190 
  Attributes:
14191 
   - cartId
14192 
  """
14193 
 
14194 
  thrift_spec = (
14195 
    None, # 0
14196 
    (1, TType.I64, 'cartId', None, None, ), # 1
14197 
  )
14198 
 
14199 
  def __init__(self, cartId=None,):
14200 
    self.cartId = cartId
14201 
 
14202 
  def read(self, iprot):
14203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14205 
      return
14206 
    iprot.readStructBegin()
14207 
    while True:
14208 
      (fname, ftype, fid) = iprot.readFieldBegin()
14209 
      if ftype == TType.STOP:
14210 
        break
14211 
      if fid == 1:
14212 
        if ftype == TType.I64:
14213 
          self.cartId = iprot.readI64();
14214 
        else:
14215 
          iprot.skip(ftype)
14216 
      else:
14217 
        iprot.skip(ftype)
14218 
      iprot.readFieldEnd()
14219 
    iprot.readStructEnd()
14220 
 
14221 
  def write(self, oprot):
14222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14224 
      return
14225 
    oprot.writeStructBegin('cancelInsurance_args')
14226 
    if self.cartId is not None:
14227 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14228 
      oprot.writeI64(self.cartId)
14229 
      oprot.writeFieldEnd()
14230 
    oprot.writeFieldStop()
14231 
    oprot.writeStructEnd()
14232 
 
14233 
  def validate(self):
14234 
    return
14235 
 
14236 
 
14237 
  def __repr__(self):
14238 
    L = ['%s=%r' % (key, value)
14239 
      for key, value in self.__dict__.iteritems()]
14240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14241 
 
14242 
  def __eq__(self, other):
14243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14244 
 
14245 
  def __ne__(self, other):
14246 
    return not (self == other)
14247 
 
14248 
class cancelInsurance_result:
14249 
  """
14250 
  Attributes:
14251 
   - success
14252 
  """
14253 
 
14254 
  thrift_spec = (
14255 
    (0, TType.BOOL, 'success', None, None, ), # 0
14256 
  )
14257 
 
14258 
  def __init__(self, success=None,):
14259 
    self.success = success
14260 
 
14261 
  def read(self, iprot):
14262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14264 
      return
14265 
    iprot.readStructBegin()
14266 
    while True:
14267 
      (fname, ftype, fid) = iprot.readFieldBegin()
14268 
      if ftype == TType.STOP:
14269 
        break
14270 
      if fid == 0:
14271 
        if ftype == TType.BOOL:
14272 
          self.success = iprot.readBool();
14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      else:
14276 
        iprot.skip(ftype)
14277 
      iprot.readFieldEnd()
14278 
    iprot.readStructEnd()
14279 
 
14280 
  def write(self, oprot):
14281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14283 
      return
14284 
    oprot.writeStructBegin('cancelInsurance_result')
14285 
    if self.success is not None:
14286 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14287 
      oprot.writeBool(self.success)
14288 
      oprot.writeFieldEnd()
14289 
    oprot.writeFieldStop()
14290 
    oprot.writeStructEnd()
14291 
 
14292 
  def validate(self):
14293 
    return
14294 
 
14295 
 
14296 
  def __repr__(self):
14297 
    L = ['%s=%r' % (key, value)
14298 
      for key, value in self.__dict__.iteritems()]
14299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14300 
 
14301 
  def __eq__(self, other):
14302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14303 
 
14304 
  def __ne__(self, other):
14305 
    return not (self == other)
14306 
 
14307 
class storeInsuranceSpecificDetails_args:
14308 
  """
14309 
  Attributes:
14310 
   - addressId
14311 
   - dob
14312 
   - guardianName
14313 
  """
14314 
 
14315 
  thrift_spec = (
14316 
    None, # 0
14317 
    (1, TType.I64, 'addressId', None, None, ), # 1
14318 
    (2, TType.STRING, 'dob', None, None, ), # 2
14319 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14320 
  )
14321 
 
14322 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14323 
    self.addressId = addressId
14324 
    self.dob = dob
14325 
    self.guardianName = guardianName
14326 
 
14327 
  def read(self, iprot):
14328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14330 
      return
14331 
    iprot.readStructBegin()
14332 
    while True:
14333 
      (fname, ftype, fid) = iprot.readFieldBegin()
14334 
      if ftype == TType.STOP:
14335 
        break
14336 
      if fid == 1:
14337 
        if ftype == TType.I64:
14338 
          self.addressId = iprot.readI64();
14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      elif fid == 2:
14342 
        if ftype == TType.STRING:
14343 
          self.dob = iprot.readString();
14344 
        else:
14345 
          iprot.skip(ftype)
14346 
      elif fid == 3:
14347 
        if ftype == TType.STRING:
14348 
          self.guardianName = iprot.readString();
14349 
        else:
14350 
          iprot.skip(ftype)
14351 
      else:
14352 
        iprot.skip(ftype)
14353 
      iprot.readFieldEnd()
14354 
    iprot.readStructEnd()
14355 
 
14356 
  def write(self, oprot):
14357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14359 
      return
14360 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14361 
    if self.addressId is not None:
14362 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14363 
      oprot.writeI64(self.addressId)
14364 
      oprot.writeFieldEnd()
14365 
    if self.dob is not None:
14366 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14367 
      oprot.writeString(self.dob)
14368 
      oprot.writeFieldEnd()
14369 
    if self.guardianName is not None:
14370 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14371 
      oprot.writeString(self.guardianName)
14372 
      oprot.writeFieldEnd()
14373 
    oprot.writeFieldStop()
14374 
    oprot.writeStructEnd()
14375 
 
14376 
  def validate(self):
14377 
    return
14378 
 
14379 
 
14380 
  def __repr__(self):
14381 
    L = ['%s=%r' % (key, value)
14382 
      for key, value in self.__dict__.iteritems()]
14383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14384 
 
14385 
  def __eq__(self, other):
14386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14387 
 
14388 
  def __ne__(self, other):
14389 
    return not (self == other)
14390 
 
14391 
class storeInsuranceSpecificDetails_result:
14392 
  """
14393 
  Attributes:
14394 
   - success
14395 
  """
14396 
 
14397 
  thrift_spec = (
14398 
    (0, TType.BOOL, 'success', None, None, ), # 0
14399 
  )
14400 
 
14401 
  def __init__(self, success=None,):
14402 
    self.success = success
14403 
 
14404 
  def read(self, iprot):
14405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14407 
      return
14408 
    iprot.readStructBegin()
14409 
    while True:
14410 
      (fname, ftype, fid) = iprot.readFieldBegin()
14411 
      if ftype == TType.STOP:
14412 
        break
14413 
      if fid == 0:
14414 
        if ftype == TType.BOOL:
14415 
          self.success = iprot.readBool();
14416 
        else:
14417 
          iprot.skip(ftype)
14418 
      else:
14419 
        iprot.skip(ftype)
14420 
      iprot.readFieldEnd()
14421 
    iprot.readStructEnd()
14422 
 
14423 
  def write(self, oprot):
14424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14426 
      return
14427 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14428 
    if self.success is not None:
14429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14430 
      oprot.writeBool(self.success)
14431 
      oprot.writeFieldEnd()
14432 
    oprot.writeFieldStop()
14433 
    oprot.writeStructEnd()
14434 
 
14435 
  def validate(self):
14436 
    return
14437 
 
14438 
 
14439 
  def __repr__(self):
14440 
    L = ['%s=%r' % (key, value)
14441 
      for key, value in self.__dict__.iteritems()]
14442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14443 
 
14444 
  def __eq__(self, other):
14445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14446 
 
14447 
  def __ne__(self, other):
14448 
    return not (self == other)
14449 
 
14450 
class isInsuranceDetailPresent_args:
14451 
  """
14452 
  Attributes:
14453 
   - addressId
14454 
  """
14455 
 
14456 
  thrift_spec = (
14457 
    None, # 0
14458 
    (1, TType.I64, 'addressId', None, None, ), # 1
14459 
  )
14460 
 
14461 
  def __init__(self, addressId=None,):
14462 
    self.addressId = addressId
14463 
 
14464 
  def read(self, iprot):
14465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14467 
      return
14468 
    iprot.readStructBegin()
14469 
    while True:
14470 
      (fname, ftype, fid) = iprot.readFieldBegin()
14471 
      if ftype == TType.STOP:
14472 
        break
14473 
      if fid == 1:
14474 
        if ftype == TType.I64:
14475 
          self.addressId = iprot.readI64();
14476 
        else:
14477 
          iprot.skip(ftype)
14478 
      else:
14479 
        iprot.skip(ftype)
14480 
      iprot.readFieldEnd()
14481 
    iprot.readStructEnd()
14482 
 
14483 
  def write(self, oprot):
14484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14486 
      return
14487 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14488 
    if self.addressId is not None:
14489 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14490 
      oprot.writeI64(self.addressId)
14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
14510 
class isInsuranceDetailPresent_result:
14511 
  """
14512 
  Attributes:
14513 
   - success
14514 
  """
14515 
 
14516 
  thrift_spec = (
14517 
    (0, TType.BOOL, 'success', None, None, ), # 0
14518 
  )
14519 
 
14520 
  def __init__(self, success=None,):
14521 
    self.success = success
14522 
 
14523 
  def read(self, iprot):
14524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14526 
      return
14527 
    iprot.readStructBegin()
14528 
    while True:
14529 
      (fname, ftype, fid) = iprot.readFieldBegin()
14530 
      if ftype == TType.STOP:
14531 
        break
14532 
      if fid == 0:
14533 
        if ftype == TType.BOOL:
14534 
          self.success = iprot.readBool();
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14547 
    if self.success is not None:
14548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14549 
      oprot.writeBool(self.success)
14550 
      oprot.writeFieldEnd()
14551 
    oprot.writeFieldStop()
14552 
    oprot.writeStructEnd()
14553 
 
14554 
  def validate(self):
14555 
    return
14556 
 
14557 
 
14558 
  def __repr__(self):
14559 
    L = ['%s=%r' % (key, value)
14560 
      for key, value in self.__dict__.iteritems()]
14561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14562 
 
14563 
  def __eq__(self, other):
14564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14565 
 
14566 
  def __ne__(self, other):
14567 
    return not (self == other)
14568 
 
9791 rajveer 14569 
class getProductsAddedToCart_args:
6821 amar.kumar 14570 
  """
14571 
  Attributes:
14572 
   - startDate
14573 
   - endDate
14574 
  """
14575 
 
14576 
  thrift_spec = (
14577 
    None, # 0
9791 rajveer 14578 
    (1, TType.I64, 'startDate', None, None, ), # 1
14579 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14580 
  )
14581 
 
9791 rajveer 14582 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14583 
    self.startDate = startDate
14584 
    self.endDate = endDate
14585 
 
14586 
  def read(self, iprot):
14587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14589 
      return
14590 
    iprot.readStructBegin()
14591 
    while True:
14592 
      (fname, ftype, fid) = iprot.readFieldBegin()
14593 
      if ftype == TType.STOP:
14594 
        break
14595 
      if fid == 1:
14596 
        if ftype == TType.I64:
9791 rajveer 14597 
          self.startDate = iprot.readI64();
6821 amar.kumar 14598 
        else:
14599 
          iprot.skip(ftype)
14600 
      elif fid == 2:
14601 
        if ftype == TType.I64:
14602 
          self.endDate = iprot.readI64();
14603 
        else:
14604 
          iprot.skip(ftype)
14605 
      else:
14606 
        iprot.skip(ftype)
14607 
      iprot.readFieldEnd()
14608 
    iprot.readStructEnd()
14609 
 
14610 
  def write(self, oprot):
14611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14613 
      return
9791 rajveer 14614 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14615 
    if self.startDate is not None:
9791 rajveer 14616 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14617 
      oprot.writeI64(self.startDate)
14618 
      oprot.writeFieldEnd()
14619 
    if self.endDate is not None:
9791 rajveer 14620 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14621 
      oprot.writeI64(self.endDate)
14622 
      oprot.writeFieldEnd()
14623 
    oprot.writeFieldStop()
14624 
    oprot.writeStructEnd()
14625 
 
14626 
  def validate(self):
14627 
    return
14628 
 
14629 
 
14630 
  def __repr__(self):
14631 
    L = ['%s=%r' % (key, value)
14632 
      for key, value in self.__dict__.iteritems()]
14633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14634 
 
14635 
  def __eq__(self, other):
14636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14637 
 
14638 
  def __ne__(self, other):
14639 
    return not (self == other)
14640 
 
9791 rajveer 14641 
class getProductsAddedToCart_result:
6821 amar.kumar 14642 
  """
14643 
  Attributes:
14644 
   - success
14645 
  """
14646 
 
14647 
  thrift_spec = (
9791 rajveer 14648 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14649 
  )
14650 
 
14651 
  def __init__(self, success=None,):
14652 
    self.success = success
14653 
 
14654 
  def read(self, iprot):
14655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14657 
      return
14658 
    iprot.readStructBegin()
14659 
    while True:
14660 
      (fname, ftype, fid) = iprot.readFieldBegin()
14661 
      if ftype == TType.STOP:
14662 
        break
14663 
      if fid == 0:
9791 rajveer 14664 
        if ftype == TType.LIST:
14665 
          self.success = []
11980 amit.gupta 14666 
          (_etype221, _size218) = iprot.readListBegin()
14667 
          for _i222 in xrange(_size218):
14668 
            _elem223 = iprot.readI64();
14669 
            self.success.append(_elem223)
9791 rajveer 14670 
          iprot.readListEnd()
6821 amar.kumar 14671 
        else:
14672 
          iprot.skip(ftype)
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
9791 rajveer 14682 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14683 
    if self.success is not None:
9791 rajveer 14684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14685 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14686 
      for iter224 in self.success:
14687 
        oprot.writeI64(iter224)
9791 rajveer 14688 
      oprot.writeListEnd()
6821 amar.kumar 14689 
      oprot.writeFieldEnd()
14690 
    oprot.writeFieldStop()
14691 
    oprot.writeStructEnd()
14692 
 
14693 
  def validate(self):
14694 
    return
14695 
 
14696 
 
14697 
  def __repr__(self):
14698 
    L = ['%s=%r' % (key, value)
14699 
      for key, value in self.__dict__.iteritems()]
14700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14701 
 
14702 
  def __eq__(self, other):
14703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14704 
 
14705 
  def __ne__(self, other):
14706 
    return not (self == other)
11592 amit.gupta 14707 
 
14708 
class validateCartPlus_args:
14709 
  """
14710 
  Attributes:
14711 
   - cartId
14712 
   - sourceId
11980 amit.gupta 14713 
   - dealerCoupon
11592 amit.gupta 14714 
  """
14715 
 
14716 
  thrift_spec = (
14717 
    None, # 0
14718 
    (1, TType.I64, 'cartId', None, None, ), # 1
14719 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 14720 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 14721 
  )
14722 
 
11980 amit.gupta 14723 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 14724 
    self.cartId = cartId
14725 
    self.sourceId = sourceId
11980 amit.gupta 14726 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 14727 
 
14728 
  def read(self, iprot):
14729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14731 
      return
14732 
    iprot.readStructBegin()
14733 
    while True:
14734 
      (fname, ftype, fid) = iprot.readFieldBegin()
14735 
      if ftype == TType.STOP:
14736 
        break
14737 
      if fid == 1:
14738 
        if ftype == TType.I64:
14739 
          self.cartId = iprot.readI64();
14740 
        else:
14741 
          iprot.skip(ftype)
14742 
      elif fid == 2:
14743 
        if ftype == TType.I64:
14744 
          self.sourceId = iprot.readI64();
14745 
        else:
14746 
          iprot.skip(ftype)
11980 amit.gupta 14747 
      elif fid == 3:
14748 
        if ftype == TType.STRING:
14749 
          self.dealerCoupon = iprot.readString();
14750 
        else:
14751 
          iprot.skip(ftype)
11592 amit.gupta 14752 
      else:
14753 
        iprot.skip(ftype)
14754 
      iprot.readFieldEnd()
14755 
    iprot.readStructEnd()
14756 
 
14757 
  def write(self, oprot):
14758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14760 
      return
14761 
    oprot.writeStructBegin('validateCartPlus_args')
14762 
    if self.cartId is not None:
14763 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14764 
      oprot.writeI64(self.cartId)
14765 
      oprot.writeFieldEnd()
14766 
    if self.sourceId is not None:
14767 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14768 
      oprot.writeI64(self.sourceId)
14769 
      oprot.writeFieldEnd()
11980 amit.gupta 14770 
    if self.dealerCoupon is not None:
14771 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
14772 
      oprot.writeString(self.dealerCoupon)
14773 
      oprot.writeFieldEnd()
11592 amit.gupta 14774 
    oprot.writeFieldStop()
14775 
    oprot.writeStructEnd()
14776 
 
14777 
  def validate(self):
14778 
    return
14779 
 
14780 
 
14781 
  def __repr__(self):
14782 
    L = ['%s=%r' % (key, value)
14783 
      for key, value in self.__dict__.iteritems()]
14784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14785 
 
14786 
  def __eq__(self, other):
14787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14788 
 
14789 
  def __ne__(self, other):
14790 
    return not (self == other)
14791 
 
14792 
class validateCartPlus_result:
14793 
  """
14794 
  Attributes:
14795 
   - success
14796 
   - scex
14797 
  """
14798 
 
14799 
  thrift_spec = (
14800 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
14801 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
14802 
  )
14803 
 
14804 
  def __init__(self, success=None, scex=None,):
14805 
    self.success = success
14806 
    self.scex = scex
14807 
 
14808 
  def read(self, iprot):
14809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14811 
      return
14812 
    iprot.readStructBegin()
14813 
    while True:
14814 
      (fname, ftype, fid) = iprot.readFieldBegin()
14815 
      if ftype == TType.STOP:
14816 
        break
14817 
      if fid == 0:
14818 
        if ftype == TType.STRUCT:
14819 
          self.success = CartPlus()
14820 
          self.success.read(iprot)
14821 
        else:
14822 
          iprot.skip(ftype)
14823 
      elif fid == 1:
14824 
        if ftype == TType.STRUCT:
14825 
          self.scex = ShoppingCartException()
14826 
          self.scex.read(iprot)
14827 
        else:
14828 
          iprot.skip(ftype)
14829 
      else:
14830 
        iprot.skip(ftype)
14831 
      iprot.readFieldEnd()
14832 
    iprot.readStructEnd()
14833 
 
14834 
  def write(self, oprot):
14835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14837 
      return
14838 
    oprot.writeStructBegin('validateCartPlus_result')
14839 
    if self.success is not None:
14840 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14841 
      self.success.write(oprot)
14842 
      oprot.writeFieldEnd()
14843 
    if self.scex is not None:
14844 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
14845 
      self.scex.write(oprot)
14846 
      oprot.writeFieldEnd()
14847 
    oprot.writeFieldStop()
14848 
    oprot.writeStructEnd()
14849 
 
14850 
  def validate(self):
14851 
    return
14852 
 
14853 
 
14854 
  def __repr__(self):
14855 
    L = ['%s=%r' % (key, value)
14856 
      for key, value in self.__dict__.iteritems()]
14857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14858 
 
14859 
  def __eq__(self, other):
14860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14861 
 
14862 
  def __ne__(self, other):
14863 
    return not (self == other)
11679 vikram.rag 14864 
 
14865 
class isPrivateDealUser_args:
14866 
  """
14867 
  Attributes:
14868 
   - userId
14869 
  """
14870 
 
14871 
  thrift_spec = (
14872 
    None, # 0
14873 
    (1, TType.I64, 'userId', None, None, ), # 1
14874 
  )
14875 
 
14876 
  def __init__(self, userId=None,):
14877 
    self.userId = userId
14878 
 
14879 
  def read(self, iprot):
14880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14882 
      return
14883 
    iprot.readStructBegin()
14884 
    while True:
14885 
      (fname, ftype, fid) = iprot.readFieldBegin()
14886 
      if ftype == TType.STOP:
14887 
        break
14888 
      if fid == 1:
14889 
        if ftype == TType.I64:
14890 
          self.userId = iprot.readI64();
14891 
        else:
14892 
          iprot.skip(ftype)
14893 
      else:
14894 
        iprot.skip(ftype)
14895 
      iprot.readFieldEnd()
14896 
    iprot.readStructEnd()
14897 
 
14898 
  def write(self, oprot):
14899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14901 
      return
14902 
    oprot.writeStructBegin('isPrivateDealUser_args')
14903 
    if self.userId is not None:
14904 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14905 
      oprot.writeI64(self.userId)
14906 
      oprot.writeFieldEnd()
14907 
    oprot.writeFieldStop()
14908 
    oprot.writeStructEnd()
14909 
 
14910 
  def validate(self):
14911 
    return
14912 
 
14913 
 
14914 
  def __repr__(self):
14915 
    L = ['%s=%r' % (key, value)
14916 
      for key, value in self.__dict__.iteritems()]
14917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14918 
 
14919 
  def __eq__(self, other):
14920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14921 
 
14922 
  def __ne__(self, other):
14923 
    return not (self == other)
14924 
 
14925 
class isPrivateDealUser_result:
14926 
  """
14927 
  Attributes:
14928 
   - success
14929 
  """
14930 
 
14931 
  thrift_spec = (
14932 
    (0, TType.BOOL, 'success', None, None, ), # 0
14933 
  )
14934 
 
14935 
  def __init__(self, success=None,):
14936 
    self.success = success
14937 
 
14938 
  def read(self, iprot):
14939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14941 
      return
14942 
    iprot.readStructBegin()
14943 
    while True:
14944 
      (fname, ftype, fid) = iprot.readFieldBegin()
14945 
      if ftype == TType.STOP:
14946 
        break
14947 
      if fid == 0:
14948 
        if ftype == TType.BOOL:
14949 
          self.success = iprot.readBool();
14950 
        else:
14951 
          iprot.skip(ftype)
14952 
      else:
14953 
        iprot.skip(ftype)
14954 
      iprot.readFieldEnd()
14955 
    iprot.readStructEnd()
14956 
 
14957 
  def write(self, oprot):
14958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14960 
      return
14961 
    oprot.writeStructBegin('isPrivateDealUser_result')
14962 
    if self.success is not None:
14963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14964 
      oprot.writeBool(self.success)
14965 
      oprot.writeFieldEnd()
14966 
    oprot.writeFieldStop()
14967 
    oprot.writeStructEnd()
14968 
 
14969 
  def validate(self):
14970 
    return
14971 
 
14972 
 
14973 
  def __repr__(self):
14974 
    L = ['%s=%r' % (key, value)
14975 
      for key, value in self.__dict__.iteritems()]
14976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14977 
 
14978 
  def __eq__(self, other):
14979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14980 
 
14981 
  def __ne__(self, other):
14982 
    return not (self == other)
11890 kshitij.so 14983 
 
14984 
class addPrivateDealUser_args:
14985 
  """
14986 
  Attributes:
14987 
   - userId
14988 
  """
14989 
 
14990 
  thrift_spec = (
14991 
    None, # 0
14992 
    (1, TType.I64, 'userId', None, None, ), # 1
14993 
  )
14994 
 
14995 
  def __init__(self, userId=None,):
14996 
    self.userId = userId
14997 
 
14998 
  def read(self, iprot):
14999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15001 
      return
15002 
    iprot.readStructBegin()
15003 
    while True:
15004 
      (fname, ftype, fid) = iprot.readFieldBegin()
15005 
      if ftype == TType.STOP:
15006 
        break
15007 
      if fid == 1:
15008 
        if ftype == TType.I64:
15009 
          self.userId = iprot.readI64();
15010 
        else:
15011 
          iprot.skip(ftype)
15012 
      else:
15013 
        iprot.skip(ftype)
15014 
      iprot.readFieldEnd()
15015 
    iprot.readStructEnd()
15016 
 
15017 
  def write(self, oprot):
15018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15020 
      return
15021 
    oprot.writeStructBegin('addPrivateDealUser_args')
15022 
    if self.userId is not None:
15023 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15024 
      oprot.writeI64(self.userId)
15025 
      oprot.writeFieldEnd()
15026 
    oprot.writeFieldStop()
15027 
    oprot.writeStructEnd()
15028 
 
15029 
  def validate(self):
15030 
    return
15031 
 
15032 
 
15033 
  def __repr__(self):
15034 
    L = ['%s=%r' % (key, value)
15035 
      for key, value in self.__dict__.iteritems()]
15036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15037 
 
15038 
  def __eq__(self, other):
15039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15040 
 
15041 
  def __ne__(self, other):
15042 
    return not (self == other)
15043 
 
15044 
class addPrivateDealUser_result:
15045 
  """
15046 
  Attributes:
15047 
   - success
15048 
  """
15049 
 
15050 
  thrift_spec = (
15051 
    (0, TType.BOOL, 'success', None, None, ), # 0
15052 
  )
15053 
 
15054 
  def __init__(self, success=None,):
15055 
    self.success = success
15056 
 
15057 
  def read(self, iprot):
15058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15060 
      return
15061 
    iprot.readStructBegin()
15062 
    while True:
15063 
      (fname, ftype, fid) = iprot.readFieldBegin()
15064 
      if ftype == TType.STOP:
15065 
        break
15066 
      if fid == 0:
15067 
        if ftype == TType.BOOL:
15068 
          self.success = iprot.readBool();
15069 
        else:
15070 
          iprot.skip(ftype)
15071 
      else:
15072 
        iprot.skip(ftype)
15073 
      iprot.readFieldEnd()
15074 
    iprot.readStructEnd()
15075 
 
15076 
  def write(self, oprot):
15077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15079 
      return
15080 
    oprot.writeStructBegin('addPrivateDealUser_result')
15081 
    if self.success is not None:
15082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15083 
      oprot.writeBool(self.success)
15084 
      oprot.writeFieldEnd()
15085 
    oprot.writeFieldStop()
15086 
    oprot.writeStructEnd()
15087 
 
15088 
  def validate(self):
15089 
    return
15090 
 
15091 
 
15092 
  def __repr__(self):
15093 
    L = ['%s=%r' % (key, value)
15094 
      for key, value in self.__dict__.iteritems()]
15095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15096 
 
15097 
  def __eq__(self, other):
15098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15099 
 
15100 
  def __ne__(self, other):
15101 
    return not (self == other)
15102 
 
15103 
class changePrivateDealUserStatus_args:
15104 
  """
15105 
  Attributes:
15106 
   - userId
15107 
   - isActive
15108 
  """
15109 
 
15110 
  thrift_spec = (
15111 
    None, # 0
15112 
    (1, TType.I64, 'userId', None, None, ), # 1
15113 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15114 
  )
15115 
 
15116 
  def __init__(self, userId=None, isActive=None,):
15117 
    self.userId = userId
15118 
    self.isActive = isActive
15119 
 
15120 
  def read(self, iprot):
15121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15123 
      return
15124 
    iprot.readStructBegin()
15125 
    while True:
15126 
      (fname, ftype, fid) = iprot.readFieldBegin()
15127 
      if ftype == TType.STOP:
15128 
        break
15129 
      if fid == 1:
15130 
        if ftype == TType.I64:
15131 
          self.userId = iprot.readI64();
15132 
        else:
15133 
          iprot.skip(ftype)
15134 
      elif fid == 2:
15135 
        if ftype == TType.BOOL:
15136 
          self.isActive = iprot.readBool();
15137 
        else:
15138 
          iprot.skip(ftype)
15139 
      else:
15140 
        iprot.skip(ftype)
15141 
      iprot.readFieldEnd()
15142 
    iprot.readStructEnd()
15143 
 
15144 
  def write(self, oprot):
15145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15147 
      return
15148 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15149 
    if self.userId is not None:
15150 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15151 
      oprot.writeI64(self.userId)
15152 
      oprot.writeFieldEnd()
15153 
    if self.isActive is not None:
15154 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15155 
      oprot.writeBool(self.isActive)
15156 
      oprot.writeFieldEnd()
15157 
    oprot.writeFieldStop()
15158 
    oprot.writeStructEnd()
15159 
 
15160 
  def validate(self):
15161 
    return
15162 
 
15163 
 
15164 
  def __repr__(self):
15165 
    L = ['%s=%r' % (key, value)
15166 
      for key, value in self.__dict__.iteritems()]
15167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15168 
 
15169 
  def __eq__(self, other):
15170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15171 
 
15172 
  def __ne__(self, other):
15173 
    return not (self == other)
15174 
 
15175 
class changePrivateDealUserStatus_result:
15176 
  """
15177 
  Attributes:
15178 
   - success
15179 
  """
15180 
 
15181 
  thrift_spec = (
15182 
    (0, TType.BOOL, 'success', None, None, ), # 0
15183 
  )
15184 
 
15185 
  def __init__(self, success=None,):
15186 
    self.success = success
15187 
 
15188 
  def read(self, iprot):
15189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15191 
      return
15192 
    iprot.readStructBegin()
15193 
    while True:
15194 
      (fname, ftype, fid) = iprot.readFieldBegin()
15195 
      if ftype == TType.STOP:
15196 
        break
15197 
      if fid == 0:
15198 
        if ftype == TType.BOOL:
15199 
          self.success = iprot.readBool();
15200 
        else:
15201 
          iprot.skip(ftype)
15202 
      else:
15203 
        iprot.skip(ftype)
15204 
      iprot.readFieldEnd()
15205 
    iprot.readStructEnd()
15206 
 
15207 
  def write(self, oprot):
15208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15210 
      return
15211 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15212 
    if self.success is not None:
15213 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15214 
      oprot.writeBool(self.success)
15215 
      oprot.writeFieldEnd()
15216 
    oprot.writeFieldStop()
15217 
    oprot.writeStructEnd()
15218 
 
15219 
  def validate(self):
15220 
    return
15221 
 
15222 
 
15223 
  def __repr__(self):
15224 
    L = ['%s=%r' % (key, value)
15225 
      for key, value in self.__dict__.iteritems()]
15226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15227 
 
15228 
  def __eq__(self, other):
15229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15230 
 
15231 
  def __ne__(self, other):
15232 
    return not (self == other)
15233 
 
15234 
class getPrivateDealUser_args:
15235 
  """
15236 
  Attributes:
15237 
   - userId
15238 
  """
15239 
 
15240 
  thrift_spec = (
15241 
    None, # 0
15242 
    (1, TType.I64, 'userId', None, None, ), # 1
15243 
  )
15244 
 
15245 
  def __init__(self, userId=None,):
15246 
    self.userId = userId
15247 
 
15248 
  def read(self, iprot):
15249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15251 
      return
15252 
    iprot.readStructBegin()
15253 
    while True:
15254 
      (fname, ftype, fid) = iprot.readFieldBegin()
15255 
      if ftype == TType.STOP:
15256 
        break
15257 
      if fid == 1:
15258 
        if ftype == TType.I64:
15259 
          self.userId = iprot.readI64();
15260 
        else:
15261 
          iprot.skip(ftype)
15262 
      else:
15263 
        iprot.skip(ftype)
15264 
      iprot.readFieldEnd()
15265 
    iprot.readStructEnd()
15266 
 
15267 
  def write(self, oprot):
15268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15270 
      return
15271 
    oprot.writeStructBegin('getPrivateDealUser_args')
15272 
    if self.userId is not None:
15273 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15274 
      oprot.writeI64(self.userId)
15275 
      oprot.writeFieldEnd()
15276 
    oprot.writeFieldStop()
15277 
    oprot.writeStructEnd()
15278 
 
15279 
  def validate(self):
15280 
    return
15281 
 
15282 
 
15283 
  def __repr__(self):
15284 
    L = ['%s=%r' % (key, value)
15285 
      for key, value in self.__dict__.iteritems()]
15286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15287 
 
15288 
  def __eq__(self, other):
15289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15290 
 
15291 
  def __ne__(self, other):
15292 
    return not (self == other)
15293 
 
15294 
class getPrivateDealUser_result:
15295 
  """
15296 
  Attributes:
15297 
   - success
15298 
  """
15299 
 
15300 
  thrift_spec = (
15301 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15302 
  )
15303 
 
15304 
  def __init__(self, success=None,):
15305 
    self.success = success
15306 
 
15307 
  def read(self, iprot):
15308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15310 
      return
15311 
    iprot.readStructBegin()
15312 
    while True:
15313 
      (fname, ftype, fid) = iprot.readFieldBegin()
15314 
      if ftype == TType.STOP:
15315 
        break
15316 
      if fid == 0:
15317 
        if ftype == TType.STRUCT:
15318 
          self.success = PrivateDealUser()
15319 
          self.success.read(iprot)
15320 
        else:
15321 
          iprot.skip(ftype)
15322 
      else:
15323 
        iprot.skip(ftype)
15324 
      iprot.readFieldEnd()
15325 
    iprot.readStructEnd()
15326 
 
15327 
  def write(self, oprot):
15328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15330 
      return
15331 
    oprot.writeStructBegin('getPrivateDealUser_result')
15332 
    if self.success is not None:
15333 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15334 
      self.success.write(oprot)
15335 
      oprot.writeFieldEnd()
15336 
    oprot.writeFieldStop()
15337 
    oprot.writeStructEnd()
15338 
 
15339 
  def validate(self):
15340 
    return
15341 
 
15342 
 
15343 
  def __repr__(self):
15344 
    L = ['%s=%r' % (key, value)
15345 
      for key, value in self.__dict__.iteritems()]
15346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15347 
 
15348 
  def __eq__(self, other):
15349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15350 
 
15351 
  def __ne__(self, other):
15352 
    return not (self == other)
12696 amit.gupta 15353 
 
15354 
class registerCounter_args:
15355 
  """
15356 
  Attributes:
15357 
   - counter
15358 
   - userId
15359 
  """
15360 
 
15361 
  thrift_spec = (
15362 
    None, # 0
15363 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15364 
    (2, TType.I64, 'userId', None, None, ), # 2
15365 
  )
15366 
 
15367 
  def __init__(self, counter=None, userId=None,):
15368 
    self.counter = counter
15369 
    self.userId = userId
15370 
 
15371 
  def read(self, iprot):
15372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15374 
      return
15375 
    iprot.readStructBegin()
15376 
    while True:
15377 
      (fname, ftype, fid) = iprot.readFieldBegin()
15378 
      if ftype == TType.STOP:
15379 
        break
15380 
      if fid == 1:
15381 
        if ftype == TType.STRUCT:
15382 
          self.counter = Counter()
15383 
          self.counter.read(iprot)
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      elif fid == 2:
15387 
        if ftype == TType.I64:
15388 
          self.userId = iprot.readI64();
15389 
        else:
15390 
          iprot.skip(ftype)
15391 
      else:
15392 
        iprot.skip(ftype)
15393 
      iprot.readFieldEnd()
15394 
    iprot.readStructEnd()
15395 
 
15396 
  def write(self, oprot):
15397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15399 
      return
15400 
    oprot.writeStructBegin('registerCounter_args')
15401 
    if self.counter is not None:
15402 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15403 
      self.counter.write(oprot)
15404 
      oprot.writeFieldEnd()
15405 
    if self.userId is not None:
15406 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15407 
      oprot.writeI64(self.userId)
15408 
      oprot.writeFieldEnd()
15409 
    oprot.writeFieldStop()
15410 
    oprot.writeStructEnd()
15411 
 
15412 
  def validate(self):
15413 
    return
15414 
 
15415 
 
15416 
  def __repr__(self):
15417 
    L = ['%s=%r' % (key, value)
15418 
      for key, value in self.__dict__.iteritems()]
15419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15420 
 
15421 
  def __eq__(self, other):
15422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15423 
 
15424 
  def __ne__(self, other):
15425 
    return not (self == other)
15426 
 
15427 
class registerCounter_result:
15428 
  """
15429 
  Attributes:
15430 
   - success
15431 
  """
15432 
 
15433 
  thrift_spec = (
15434 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15435 
  )
15436 
 
15437 
  def __init__(self, success=None,):
15438 
    self.success = success
15439 
 
15440 
  def read(self, iprot):
15441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15443 
      return
15444 
    iprot.readStructBegin()
15445 
    while True:
15446 
      (fname, ftype, fid) = iprot.readFieldBegin()
15447 
      if ftype == TType.STOP:
15448 
        break
15449 
      if fid == 0:
15450 
        if ftype == TType.MAP:
15451 
          self.success = {}
15452 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15453 
          for _i229 in xrange(_size225):
15454 
            _key230 = iprot.readString();
15455 
            _val231 = iprot.readString();
15456 
            self.success[_key230] = _val231
15457 
          iprot.readMapEnd()
15458 
        else:
15459 
          iprot.skip(ftype)
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('registerCounter_result')
15470 
    if self.success is not None:
15471 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15472 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15473 
      for kiter232,viter233 in self.success.items():
15474 
        oprot.writeString(kiter232)
15475 
        oprot.writeString(viter233)
15476 
      oprot.writeMapEnd()
15477 
      oprot.writeFieldEnd()
15478 
    oprot.writeFieldStop()
15479 
    oprot.writeStructEnd()
15480 
 
15481 
  def validate(self):
15482 
    return
15483 
 
15484 
 
15485 
  def __repr__(self):
15486 
    L = ['%s=%r' % (key, value)
15487 
      for key, value in self.__dict__.iteritems()]
15488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15489 
 
15490 
  def __eq__(self, other):
15491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15492 
 
15493 
  def __ne__(self, other):
15494 
    return not (self == other)