Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
559 chandransh 22 
  def createAnonymousUser(self, jsessionId):
94 ashish 23 
    """
24 
    Parameters:
559 chandransh 25 
     - jsessionId
94 ashish 26 
    """
27 
    pass
28 
 
559 chandransh 29 
  def getUserById(self, userId):
94 ashish 30 
    """
31 
    Parameters:
32 
     - userId
33 
    """
34 
    pass
35 
 
559 chandransh 36 
  def createUser(self, user):
94 ashish 37 
    """
38 
    Parameters:
559 chandransh 39 
     - user
94 ashish 40 
    """
41 
    pass
42 
 
559 chandransh 43 
  def updateUser(self, user):
94 ashish 44 
    """
45 
    Parameters:
559 chandransh 46 
     - user
94 ashish 47 
    """
48 
    pass
49 
 
559 chandransh 50 
  def deleteUser(self, userId):
94 ashish 51 
    """
52 
    Parameters:
53 
     - userId
54 
    """
55 
    pass
56 
 
559 chandransh 57 
  def getUserState(self, userId):
94 ashish 58 
    """
59 
    Parameters:
60 
     - userId
61 
    """
62 
    pass
63 
 
559 chandransh 64 
  def authenticateUser(self, email, password):
94 ashish 65 
    """
66 
    Parameters:
67 
     - email
68 
     - password
69 
    """
70 
    pass
71 
 
72 
  def userExists(self, email):
73 
    """
74 
    Parameters:
75 
     - email
76 
    """
77 
    pass
78 
 
567 rajveer 79 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 80 
    """
81 
    Parameters:
82 
     - userId
83 
     - address
513 rajveer 84 
     - setDefault
94 ashish 85 
    """
86 
    pass
87 
 
88 
  def removeAddressForUser(self, userid, addressId):
89 
    """
90 
    Parameters:
91 
     - userid
92 
     - addressId
93 
    """
94 
    pass
95 
 
96 
  def setUserAsLoggedIn(self, userId, timestamp):
97 
    """
98 
    Parameters:
99 
     - userId
100 
     - timestamp
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedOut(self, userid, timestamp):
105 
    """
106 
    Parameters:
107 
     - userid
108 
     - timestamp
109 
    """
110 
    pass
111 
 
504 rajveer 112 
  def setDefaultAddress(self, userid, addressId):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - addressId
117 
    """
118 
    pass
119 
 
594 rajveer 120 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 121 
    """
122 
    Parameters:
123 
     - userid
594 rajveer 124 
     - oldPassword
125 
     - newPassword
94 ashish 126 
    """
127 
    pass
128 
 
581 rajveer 129 
  def forgotPassword(self, email):
130 
    """
131 
    Parameters:
132 
     - email
133 
    """
134 
    pass
135 
 
594 rajveer 136 
  def getAllAddressesForUser(self, userId):
137 
    """
138 
    Parameters:
139 
     - userId
140 
    """
141 
    pass
142 
 
143 
  def getDefaultAddressId(self, userId):
144 
    """
145 
    Parameters:
146 
     - userId
147 
    """
148 
    pass
149 
 
559 chandransh 150 
  def createCart(self, userId):
94 ashish 151 
    """
152 
    Parameters:
559 chandransh 153 
     - userId
94 ashish 154 
    """
155 
    pass
156 
 
559 chandransh 157 
  def getCurrentCart(self, userId):
94 ashish 158 
    """
159 
    Parameters:
559 chandransh 160 
     - userId
94 ashish 161 
    """
162 
    pass
163 
 
559 chandransh 164 
  def getCart(self, cartId):
94 ashish 165 
    """
166 
    Parameters:
559 chandransh 167 
     - cartId
94 ashish 168 
    """
169 
    pass
170 
 
559 chandransh 171 
  def getCartsForUser(self, userId, status):
94 ashish 172 
    """
173 
    Parameters:
559 chandransh 174 
     - userId
175 
     - status
94 ashish 176 
    """
177 
    pass
178 
 
559 chandransh 179 
  def getCartsByStatus(self, status):
94 ashish 180 
    """
181 
    Parameters:
559 chandransh 182 
     - status
94 ashish 183 
    """
184 
    pass
185 
 
559 chandransh 186 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 187 
    """
188 
    Parameters:
559 chandransh 189 
     - from_time
190 
     - to_time
191 
     - status
94 ashish 192 
    """
193 
    pass
194 
 
559 chandransh 195 
  def changeCartStatus(self, cartId, status):
130 ashish 196 
    """
197 
    Parameters:
559 chandransh 198 
     - cartId
199 
     - status
130 ashish 200 
    """
201 
    pass
94 ashish 202 
 
559 chandransh 203 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 204 
    """
205 
    Parameters:
559 chandransh 206 
     - cartId
207 
     - itemId
208 
     - quantity
130 ashish 209 
    """
210 
    pass
211 
 
559 chandransh 212 
  def deleteItemFromCart(self, cartId, itemId):
213 
    """
214 
    Parameters:
215 
     - cartId
216 
     - itemId
217 
    """
218 
    pass
130 ashish 219 
 
559 chandransh 220 
  def changeQuantity(self, cartId, itemId, quantity):
221 
    """
222 
    Parameters:
223 
     - cartId
224 
     - itemId
225 
     - quantity
226 
    """
227 
    pass
228 
 
229 
  def changeItemStatus(self, cartId, itemId, status):
230 
    """
231 
    Parameters:
232 
     - cartId
233 
     - itemId
234 
     - status
235 
    """
236 
    pass
237 
 
238 
  def addAddressToCart(self, cartId, addressId):
239 
    """
240 
    Parameters:
241 
     - cartId
242 
     - addressId
243 
    """
244 
    pass
245 
 
690 chandransh 246 
  def createOrders(self, cartId):
559 chandransh 247 
    """
690 chandransh 248 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
249 
 
559 chandransh 250 
    Parameters:
251 
     - cartId
252 
    """
253 
    pass
254 
 
255 
  def validateCart(self, cartId):
256 
    """
690 chandransh 257 
    Validates that:
258 
    1. The checkout timestamp is greater than the updatedOn timestamp.
259 
    2. None of the lines in the cart for an inactive item.
260 
    3. The estimate for any of the lines in cart doesn't change.
261 
    Returns true only if all three hold.
262 
 
559 chandransh 263 
    Parameters:
264 
     - cartId
265 
    """
266 
    pass
267 
 
690 chandransh 268 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 269 
    """
690 chandransh 270 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
271 
 
575 chandransh 272 
    Parameters:
690 chandransh 273 
     - fromCartId
274 
     - toCartId
275 
    """
276 
    pass
277 
 
278 
  def checkOut(self, cartId):
279 
    """
280 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
281 
 
282 
    Parameters:
575 chandransh 283 
     - cartId
284 
    """
285 
    pass
286 
 
690 chandransh 287 
  def resetCart(self, cartId, items):
559 chandransh 288 
    """
690 chandransh 289 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
290 
    This methods removes the specified quantiry of the specified item from the cart.
291 
 
559 chandransh 292 
    Parameters:
690 chandransh 293 
     - cartId
294 
     - items
559 chandransh 295 
    """
296 
    pass
297 
 
298 
  def addWidget(self, widget):
299 
    """
300 
    Parameters:
301 
     - widget
302 
    """
303 
    pass
304 
 
305 
  def addItemToWidget(self, widget_id, items):
306 
    """
307 
    Parameters:
308 
     - widget_id
309 
     - items
310 
    """
311 
    pass
312 
 
313 
  def deleteItemFromWidget(self, widget_id, item_id):
314 
    """
315 
    Parameters:
316 
     - widget_id
317 
     - item_id
318 
    """
319 
    pass
320 
 
321 
  def updateWidget(self, widgetId, enable):
322 
    """
323 
    Parameters:
324 
     - widgetId
325 
     - enable
326 
    """
327 
    pass
328 
 
329 
  def updateWidgetItem(self, widgetId, enable):
330 
    """
331 
    Parameters:
332 
     - widgetId
333 
     - enable
334 
    """
335 
    pass
336 
 
337 
  def getWidget(self, type, userId, onlyEnabled):
338 
    """
339 
    Parameters:
340 
     - type
341 
     - userId
342 
     - onlyEnabled
343 
    """
344 
    pass
345 
 
346 
  def getMyResearch(self, user_id):
347 
    """
348 
    Parameters:
349 
     - user_id
350 
    """
351 
    pass
352 
 
353 
  def updateMyResearch(self, user_id, item_id):
354 
    """
355 
    Parameters:
356 
     - user_id
357 
     - item_id
358 
    """
359 
    pass
360 
 
361 
  def deleteItemFromMyResearch(self, user_id, item_id):
362 
    """
363 
    Parameters:
364 
     - user_id
365 
     - item_id
366 
    """
367 
    pass
368 
 
369 
  def updateRatings(self, item_id, type, rating, user_id):
370 
    """
371 
    Parameters:
372 
     - item_id
373 
     - type
374 
     - rating
375 
     - user_id
376 
    """
377 
    pass
378 
 
379 
  def getRatings(self, item_id, user_id):
380 
    """
381 
    Parameters:
382 
     - item_id
383 
     - user_id
384 
    """
385 
    pass
386 
 
387 
  def updateBrowseHistory(self, user_id, item_id, isSessionId):
388 
    """
389 
    Parameters:
390 
     - user_id
391 
     - item_id
392 
     - isSessionId
393 
    """
394 
    pass
395 
 
396 
  def getBrowseHistory(self, userId, isSessionId):
397 
    """
398 
    Parameters:
399 
     - userId
400 
     - isSessionId
401 
    """
402 
    pass
403 
 
404 
 
94 ashish 405 
class Client(Iface):
406 
  """
407 
  service
408 
  """
409 
  def __init__(self, iprot, oprot=None):
410 
    self._iprot = self._oprot = iprot
411 
    if oprot != None:
412 
      self._oprot = oprot
413 
    self._seqid = 0
414 
 
559 chandransh 415 
  def createAnonymousUser(self, jsessionId):
94 ashish 416 
    """
417 
    Parameters:
559 chandransh 418 
     - jsessionId
94 ashish 419 
    """
559 chandransh 420 
    self.send_createAnonymousUser(jsessionId)
421 
    return self.recv_createAnonymousUser()
94 ashish 422 
 
559 chandransh 423 
  def send_createAnonymousUser(self, jsessionId):
424 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
425 
    args = createAnonymousUser_args()
426 
    args.jsessionId = jsessionId
94 ashish 427 
    args.write(self._oprot)
428 
    self._oprot.writeMessageEnd()
429 
    self._oprot.trans.flush()
430 
 
559 chandransh 431 
  def recv_createAnonymousUser(self, ):
94 ashish 432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
433 
    if mtype == TMessageType.EXCEPTION:
434 
      x = TApplicationException()
435 
      x.read(self._iprot)
436 
      self._iprot.readMessageEnd()
437 
      raise x
559 chandransh 438 
    result = createAnonymousUser_result()
94 ashish 439 
    result.read(self._iprot)
440 
    self._iprot.readMessageEnd()
441 
    if result.success != None:
442 
      return result.success
559 chandransh 443 
    if result.ucex != None:
444 
      raise result.ucex
445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 446 
 
559 chandransh 447 
  def getUserById(self, userId):
94 ashish 448 
    """
449 
    Parameters:
450 
     - userId
451 
    """
559 chandransh 452 
    self.send_getUserById(userId)
453 
    return self.recv_getUserById()
94 ashish 454 
 
559 chandransh 455 
  def send_getUserById(self, userId):
456 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
457 
    args = getUserById_args()
94 ashish 458 
    args.userId = userId
459 
    args.write(self._oprot)
460 
    self._oprot.writeMessageEnd()
461 
    self._oprot.trans.flush()
462 
 
559 chandransh 463 
  def recv_getUserById(self, ):
94 ashish 464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
465 
    if mtype == TMessageType.EXCEPTION:
466 
      x = TApplicationException()
467 
      x.read(self._iprot)
468 
      self._iprot.readMessageEnd()
469 
      raise x
559 chandransh 470 
    result = getUserById_result()
94 ashish 471 
    result.read(self._iprot)
472 
    self._iprot.readMessageEnd()
473 
    if result.success != None:
474 
      return result.success
559 chandransh 475 
    if result.ucex != None:
476 
      raise result.ucex
477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 478 
 
559 chandransh 479 
  def createUser(self, user):
94 ashish 480 
    """
481 
    Parameters:
559 chandransh 482 
     - user
94 ashish 483 
    """
559 chandransh 484 
    self.send_createUser(user)
485 
    return self.recv_createUser()
94 ashish 486 
 
559 chandransh 487 
  def send_createUser(self, user):
488 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
489 
    args = createUser_args()
490 
    args.user = user
94 ashish 491 
    args.write(self._oprot)
492 
    self._oprot.writeMessageEnd()
493 
    self._oprot.trans.flush()
494 
 
559 chandransh 495 
  def recv_createUser(self, ):
94 ashish 496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
497 
    if mtype == TMessageType.EXCEPTION:
498 
      x = TApplicationException()
499 
      x.read(self._iprot)
500 
      self._iprot.readMessageEnd()
501 
      raise x
559 chandransh 502 
    result = createUser_result()
94 ashish 503 
    result.read(self._iprot)
504 
    self._iprot.readMessageEnd()
505 
    if result.success != None:
506 
      return result.success
559 chandransh 507 
    if result.ucex != None:
508 
      raise result.ucex
509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 510 
 
559 chandransh 511 
  def updateUser(self, user):
94 ashish 512 
    """
513 
    Parameters:
559 chandransh 514 
     - user
94 ashish 515 
    """
559 chandransh 516 
    self.send_updateUser(user)
517 
    return self.recv_updateUser()
94 ashish 518 
 
559 chandransh 519 
  def send_updateUser(self, user):
520 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
521 
    args = updateUser_args()
522 
    args.user = user
94 ashish 523 
    args.write(self._oprot)
524 
    self._oprot.writeMessageEnd()
525 
    self._oprot.trans.flush()
526 
 
559 chandransh 527 
  def recv_updateUser(self, ):
94 ashish 528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
529 
    if mtype == TMessageType.EXCEPTION:
530 
      x = TApplicationException()
531 
      x.read(self._iprot)
532 
      self._iprot.readMessageEnd()
533 
      raise x
559 chandransh 534 
    result = updateUser_result()
94 ashish 535 
    result.read(self._iprot)
536 
    self._iprot.readMessageEnd()
537 
    if result.success != None:
538 
      return result.success
559 chandransh 539 
    if result.ucex != None:
540 
      raise result.ucex
541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 542 
 
559 chandransh 543 
  def deleteUser(self, userId):
94 ashish 544 
    """
545 
    Parameters:
546 
     - userId
547 
    """
559 chandransh 548 
    self.send_deleteUser(userId)
549 
    return self.recv_deleteUser()
94 ashish 550 
 
559 chandransh 551 
  def send_deleteUser(self, userId):
552 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
553 
    args = deleteUser_args()
94 ashish 554 
    args.userId = userId
555 
    args.write(self._oprot)
556 
    self._oprot.writeMessageEnd()
557 
    self._oprot.trans.flush()
558 
 
559 chandransh 559 
  def recv_deleteUser(self, ):
94 ashish 560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
561 
    if mtype == TMessageType.EXCEPTION:
562 
      x = TApplicationException()
563 
      x.read(self._iprot)
564 
      self._iprot.readMessageEnd()
565 
      raise x
559 chandransh 566 
    result = deleteUser_result()
94 ashish 567 
    result.read(self._iprot)
568 
    self._iprot.readMessageEnd()
569 
    if result.success != None:
570 
      return result.success
559 chandransh 571 
    if result.ucex != None:
572 
      raise result.ucex
573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 574 
 
559 chandransh 575 
  def getUserState(self, userId):
94 ashish 576 
    """
577 
    Parameters:
578 
     - userId
579 
    """
559 chandransh 580 
    self.send_getUserState(userId)
581 
    return self.recv_getUserState()
94 ashish 582 
 
559 chandransh 583 
  def send_getUserState(self, userId):
584 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
585 
    args = getUserState_args()
94 ashish 586 
    args.userId = userId
587 
    args.write(self._oprot)
588 
    self._oprot.writeMessageEnd()
589 
    self._oprot.trans.flush()
590 
 
559 chandransh 591 
  def recv_getUserState(self, ):
94 ashish 592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
593 
    if mtype == TMessageType.EXCEPTION:
594 
      x = TApplicationException()
595 
      x.read(self._iprot)
596 
      self._iprot.readMessageEnd()
597 
      raise x
559 chandransh 598 
    result = getUserState_result()
94 ashish 599 
    result.read(self._iprot)
600 
    self._iprot.readMessageEnd()
601 
    if result.success != None:
602 
      return result.success
559 chandransh 603 
    if result.ucex != None:
604 
      raise result.ucex
605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 606 
 
559 chandransh 607 
  def authenticateUser(self, email, password):
94 ashish 608 
    """
609 
    Parameters:
610 
     - email
611 
     - password
612 
    """
559 chandransh 613 
    self.send_authenticateUser(email, password)
122 ashish 614 
    return self.recv_authenticateUser()
615 
 
559 chandransh 616 
  def send_authenticateUser(self, email, password):
122 ashish 617 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
618 
    args = authenticateUser_args()
559 chandransh 619 
    args.email = email
122 ashish 620 
    args.password = password
621 
    args.write(self._oprot)
622 
    self._oprot.writeMessageEnd()
623 
    self._oprot.trans.flush()
624 
 
625 
  def recv_authenticateUser(self, ):
626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
627 
    if mtype == TMessageType.EXCEPTION:
628 
      x = TApplicationException()
629 
      x.read(self._iprot)
630 
      self._iprot.readMessageEnd()
631 
      raise x
632 
    result = authenticateUser_result()
633 
    result.read(self._iprot)
634 
    self._iprot.readMessageEnd()
635 
    if result.success != None:
636 
      return result.success
559 chandransh 637 
    if result.auex != None:
638 
      raise result.auex
122 ashish 639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
640 
 
94 ashish 641 
  def userExists(self, email):
642 
    """
643 
    Parameters:
644 
     - email
645 
    """
646 
    self.send_userExists(email)
647 
    return self.recv_userExists()
648 
 
649 
  def send_userExists(self, email):
650 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
651 
    args = userExists_args()
652 
    args.email = email
653 
    args.write(self._oprot)
654 
    self._oprot.writeMessageEnd()
655 
    self._oprot.trans.flush()
656 
 
657 
  def recv_userExists(self, ):
658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
659 
    if mtype == TMessageType.EXCEPTION:
660 
      x = TApplicationException()
661 
      x.read(self._iprot)
662 
      self._iprot.readMessageEnd()
663 
      raise x
664 
    result = userExists_result()
665 
    result.read(self._iprot)
666 
    self._iprot.readMessageEnd()
667 
    if result.success != None:
668 
      return result.success
669 
    if result.ucx != None:
670 
      raise result.ucx
671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
672 
 
567 rajveer 673 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 674 
    """
675 
    Parameters:
676 
     - userId
677 
     - address
513 rajveer 678 
     - setDefault
94 ashish 679 
    """
567 rajveer 680 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 681 
    return self.recv_addAddressForUser()
682 
 
567 rajveer 683 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 684 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
685 
    args = addAddressForUser_args()
559 chandransh 686 
    args.userId = userId
94 ashish 687 
    args.address = address
513 rajveer 688 
    args.setDefault = setDefault
94 ashish 689 
    args.write(self._oprot)
690 
    self._oprot.writeMessageEnd()
691 
    self._oprot.trans.flush()
692 
 
693 
  def recv_addAddressForUser(self, ):
694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
695 
    if mtype == TMessageType.EXCEPTION:
696 
      x = TApplicationException()
697 
      x.read(self._iprot)
698 
      self._iprot.readMessageEnd()
699 
      raise x
700 
    result = addAddressForUser_result()
701 
    result.read(self._iprot)
702 
    self._iprot.readMessageEnd()
703 
    if result.success != None:
704 
      return result.success
705 
    if result.ucx != None:
706 
      raise result.ucx
707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
708 
 
709 
  def removeAddressForUser(self, userid, addressId):
710 
    """
711 
    Parameters:
712 
     - userid
713 
     - addressId
714 
    """
715 
    self.send_removeAddressForUser(userid, addressId)
716 
    return self.recv_removeAddressForUser()
717 
 
718 
  def send_removeAddressForUser(self, userid, addressId):
719 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
720 
    args = removeAddressForUser_args()
721 
    args.userid = userid
722 
    args.addressId = addressId
723 
    args.write(self._oprot)
724 
    self._oprot.writeMessageEnd()
725 
    self._oprot.trans.flush()
726 
 
727 
  def recv_removeAddressForUser(self, ):
728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
729 
    if mtype == TMessageType.EXCEPTION:
730 
      x = TApplicationException()
731 
      x.read(self._iprot)
732 
      self._iprot.readMessageEnd()
733 
      raise x
734 
    result = removeAddressForUser_result()
735 
    result.read(self._iprot)
736 
    self._iprot.readMessageEnd()
737 
    if result.success != None:
738 
      return result.success
739 
    if result.ucx != None:
740 
      raise result.ucx
741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
742 
 
743 
  def setUserAsLoggedIn(self, userId, timestamp):
744 
    """
745 
    Parameters:
746 
     - userId
747 
     - timestamp
748 
    """
749 
    self.send_setUserAsLoggedIn(userId, timestamp)
750 
    return self.recv_setUserAsLoggedIn()
751 
 
752 
  def send_setUserAsLoggedIn(self, userId, timestamp):
753 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
754 
    args = setUserAsLoggedIn_args()
755 
    args.userId = userId
756 
    args.timestamp = timestamp
757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
761 
  def recv_setUserAsLoggedIn(self, ):
762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
768 
    result = setUserAsLoggedIn_result()
769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
771 
    if result.success != None:
772 
      return result.success
773 
    if result.ucx != None:
774 
      raise result.ucx
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
776 
 
777 
  def setUserAsLoggedOut(self, userid, timestamp):
778 
    """
779 
    Parameters:
780 
     - userid
781 
     - timestamp
782 
    """
783 
    self.send_setUserAsLoggedOut(userid, timestamp)
784 
    return self.recv_setUserAsLoggedOut()
785 
 
786 
  def send_setUserAsLoggedOut(self, userid, timestamp):
787 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
788 
    args = setUserAsLoggedOut_args()
789 
    args.userid = userid
790 
    args.timestamp = timestamp
791 
    args.write(self._oprot)
792 
    self._oprot.writeMessageEnd()
793 
    self._oprot.trans.flush()
794 
 
795 
  def recv_setUserAsLoggedOut(self, ):
796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
797 
    if mtype == TMessageType.EXCEPTION:
798 
      x = TApplicationException()
799 
      x.read(self._iprot)
800 
      self._iprot.readMessageEnd()
801 
      raise x
802 
    result = setUserAsLoggedOut_result()
803 
    result.read(self._iprot)
804 
    self._iprot.readMessageEnd()
805 
    if result.success != None:
806 
      return result.success
807 
    if result.ucx != None:
808 
      raise result.ucx
809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
810 
 
504 rajveer 811 
  def setDefaultAddress(self, userid, addressId):
812 
    """
813 
    Parameters:
814 
     - userid
815 
     - addressId
816 
    """
817 
    self.send_setDefaultAddress(userid, addressId)
818 
    return self.recv_setDefaultAddress()
819 
 
820 
  def send_setDefaultAddress(self, userid, addressId):
821 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
822 
    args = setDefaultAddress_args()
823 
    args.userid = userid
824 
    args.addressId = addressId
825 
    args.write(self._oprot)
826 
    self._oprot.writeMessageEnd()
827 
    self._oprot.trans.flush()
828 
 
829 
  def recv_setDefaultAddress(self, ):
830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
831 
    if mtype == TMessageType.EXCEPTION:
832 
      x = TApplicationException()
833 
      x.read(self._iprot)
834 
      self._iprot.readMessageEnd()
835 
      raise x
836 
    result = setDefaultAddress_result()
837 
    result.read(self._iprot)
838 
    self._iprot.readMessageEnd()
839 
    if result.success != None:
840 
      return result.success
841 
    if result.ucx != None:
842 
      raise result.ucx
843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
844 
 
594 rajveer 845 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 846 
    """
847 
    Parameters:
848 
     - userid
594 rajveer 849 
     - oldPassword
850 
     - newPassword
94 ashish 851 
    """
594 rajveer 852 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 853 
    return self.recv_updatePassword()
854 
 
594 rajveer 855 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 856 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
857 
    args = updatePassword_args()
858 
    args.userid = userid
594 rajveer 859 
    args.oldPassword = oldPassword
860 
    args.newPassword = newPassword
94 ashish 861 
    args.write(self._oprot)
862 
    self._oprot.writeMessageEnd()
863 
    self._oprot.trans.flush()
864 
 
865 
  def recv_updatePassword(self, ):
866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
867 
    if mtype == TMessageType.EXCEPTION:
868 
      x = TApplicationException()
869 
      x.read(self._iprot)
870 
      self._iprot.readMessageEnd()
871 
      raise x
872 
    result = updatePassword_result()
873 
    result.read(self._iprot)
874 
    self._iprot.readMessageEnd()
875 
    if result.success != None:
876 
      return result.success
877 
    if result.ucx != None:
878 
      raise result.ucx
879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
880 
 
581 rajveer 881 
  def forgotPassword(self, email):
882 
    """
883 
    Parameters:
884 
     - email
885 
    """
886 
    self.send_forgotPassword(email)
887 
    return self.recv_forgotPassword()
888 
 
889 
  def send_forgotPassword(self, email):
890 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
891 
    args = forgotPassword_args()
892 
    args.email = email
893 
    args.write(self._oprot)
894 
    self._oprot.writeMessageEnd()
895 
    self._oprot.trans.flush()
896 
 
897 
  def recv_forgotPassword(self, ):
898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
899 
    if mtype == TMessageType.EXCEPTION:
900 
      x = TApplicationException()
901 
      x.read(self._iprot)
902 
      self._iprot.readMessageEnd()
903 
      raise x
904 
    result = forgotPassword_result()
905 
    result.read(self._iprot)
906 
    self._iprot.readMessageEnd()
907 
    if result.success != None:
908 
      return result.success
909 
    if result.ucx != None:
910 
      raise result.ucx
911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
912 
 
594 rajveer 913 
  def getAllAddressesForUser(self, userId):
914 
    """
915 
    Parameters:
916 
     - userId
917 
    """
918 
    self.send_getAllAddressesForUser(userId)
919 
    return self.recv_getAllAddressesForUser()
920 
 
921 
  def send_getAllAddressesForUser(self, userId):
922 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
923 
    args = getAllAddressesForUser_args()
924 
    args.userId = userId
925 
    args.write(self._oprot)
926 
    self._oprot.writeMessageEnd()
927 
    self._oprot.trans.flush()
928 
 
929 
  def recv_getAllAddressesForUser(self, ):
930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
931 
    if mtype == TMessageType.EXCEPTION:
932 
      x = TApplicationException()
933 
      x.read(self._iprot)
934 
      self._iprot.readMessageEnd()
935 
      raise x
936 
    result = getAllAddressesForUser_result()
937 
    result.read(self._iprot)
938 
    self._iprot.readMessageEnd()
939 
    if result.success != None:
940 
      return result.success
941 
    if result.ucx != None:
942 
      raise result.ucx
943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
944 
 
945 
  def getDefaultAddressId(self, userId):
946 
    """
947 
    Parameters:
948 
     - userId
949 
    """
950 
    self.send_getDefaultAddressId(userId)
951 
    return self.recv_getDefaultAddressId()
952 
 
953 
  def send_getDefaultAddressId(self, userId):
954 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
955 
    args = getDefaultAddressId_args()
956 
    args.userId = userId
957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_getDefaultAddressId(self, ):
962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
963 
    if mtype == TMessageType.EXCEPTION:
964 
      x = TApplicationException()
965 
      x.read(self._iprot)
966 
      self._iprot.readMessageEnd()
967 
      raise x
968 
    result = getDefaultAddressId_result()
969 
    result.read(self._iprot)
970 
    self._iprot.readMessageEnd()
971 
    if result.success != None:
972 
      return result.success
973 
    if result.ucx != None:
974 
      raise result.ucx
975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
976 
 
559 chandransh 977 
  def createCart(self, userId):
94 ashish 978 
    """
979 
    Parameters:
559 chandransh 980 
     - userId
94 ashish 981 
    """
559 chandransh 982 
    self.send_createCart(userId)
983 
    return self.recv_createCart()
94 ashish 984 
 
559 chandransh 985 
  def send_createCart(self, userId):
986 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
987 
    args = createCart_args()
988 
    args.userId = userId
94 ashish 989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
559 chandransh 993 
  def recv_createCart(self, ):
94 ashish 994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
559 chandransh 1000 
    result = createCart_result()
94 ashish 1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
1003 
    if result.success != None:
1004 
      return result.success
559 chandransh 1005 
    if result.scx != None:
1006 
      raise result.scx
1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1008 
 
559 chandransh 1009 
  def getCurrentCart(self, userId):
94 ashish 1010 
    """
1011 
    Parameters:
559 chandransh 1012 
     - userId
94 ashish 1013 
    """
559 chandransh 1014 
    self.send_getCurrentCart(userId)
1015 
    return self.recv_getCurrentCart()
94 ashish 1016 
 
559 chandransh 1017 
  def send_getCurrentCart(self, userId):
1018 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1019 
    args = getCurrentCart_args()
1020 
    args.userId = userId
94 ashish 1021 
    args.write(self._oprot)
1022 
    self._oprot.writeMessageEnd()
1023 
    self._oprot.trans.flush()
1024 
 
559 chandransh 1025 
  def recv_getCurrentCart(self, ):
94 ashish 1026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1027 
    if mtype == TMessageType.EXCEPTION:
1028 
      x = TApplicationException()
1029 
      x.read(self._iprot)
1030 
      self._iprot.readMessageEnd()
1031 
      raise x
559 chandransh 1032 
    result = getCurrentCart_result()
94 ashish 1033 
    result.read(self._iprot)
1034 
    self._iprot.readMessageEnd()
1035 
    if result.success != None:
1036 
      return result.success
559 chandransh 1037 
    if result.scx != None:
1038 
      raise result.scx
1039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1040 
 
559 chandransh 1041 
  def getCart(self, cartId):
94 ashish 1042 
    """
1043 
    Parameters:
559 chandransh 1044 
     - cartId
94 ashish 1045 
    """
559 chandransh 1046 
    self.send_getCart(cartId)
1047 
    return self.recv_getCart()
94 ashish 1048 
 
559 chandransh 1049 
  def send_getCart(self, cartId):
1050 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1051 
    args = getCart_args()
1052 
    args.cartId = cartId
94 ashish 1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
559 chandransh 1057 
  def recv_getCart(self, ):
94 ashish 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
559 chandransh 1064 
    result = getCart_result()
94 ashish 1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
1067 
    if result.success != None:
1068 
      return result.success
559 chandransh 1069 
    if result.scx != None:
1070 
      raise result.scx
1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1072 
 
559 chandransh 1073 
  def getCartsForUser(self, userId, status):
94 ashish 1074 
    """
1075 
    Parameters:
559 chandransh 1076 
     - userId
1077 
     - status
94 ashish 1078 
    """
559 chandransh 1079 
    self.send_getCartsForUser(userId, status)
1080 
    return self.recv_getCartsForUser()
94 ashish 1081 
 
559 chandransh 1082 
  def send_getCartsForUser(self, userId, status):
1083 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1084 
    args = getCartsForUser_args()
1085 
    args.userId = userId
1086 
    args.status = status
94 ashish 1087 
    args.write(self._oprot)
1088 
    self._oprot.writeMessageEnd()
1089 
    self._oprot.trans.flush()
1090 
 
559 chandransh 1091 
  def recv_getCartsForUser(self, ):
94 ashish 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
559 chandransh 1098 
    result = getCartsForUser_result()
94 ashish 1099 
    result.read(self._iprot)
1100 
    self._iprot.readMessageEnd()
1101 
    if result.success != None:
1102 
      return result.success
559 chandransh 1103 
    if result.scx != None:
1104 
      raise result.scx
1105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 1106 
 
559 chandransh 1107 
  def getCartsByStatus(self, status):
94 ashish 1108 
    """
1109 
    Parameters:
559 chandransh 1110 
     - status
94 ashish 1111 
    """
559 chandransh 1112 
    self.send_getCartsByStatus(status)
1113 
    return self.recv_getCartsByStatus()
94 ashish 1114 
 
559 chandransh 1115 
  def send_getCartsByStatus(self, status):
1116 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
1117 
    args = getCartsByStatus_args()
1118 
    args.status = status
94 ashish 1119 
    args.write(self._oprot)
1120 
    self._oprot.writeMessageEnd()
1121 
    self._oprot.trans.flush()
1122 
 
559 chandransh 1123 
  def recv_getCartsByStatus(self, ):
94 ashish 1124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1125 
    if mtype == TMessageType.EXCEPTION:
1126 
      x = TApplicationException()
1127 
      x.read(self._iprot)
1128 
      self._iprot.readMessageEnd()
1129 
      raise x
559 chandransh 1130 
    result = getCartsByStatus_result()
94 ashish 1131 
    result.read(self._iprot)
1132 
    self._iprot.readMessageEnd()
1133 
    if result.success != None:
1134 
      return result.success
559 chandransh 1135 
    if result.scx != None:
1136 
      raise result.scx
1137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 1138 
 
559 chandransh 1139 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 1140 
    """
1141 
    Parameters:
559 chandransh 1142 
     - from_time
1143 
     - to_time
1144 
     - status
94 ashish 1145 
    """
559 chandransh 1146 
    self.send_getCartsByTime(from_time, to_time, status)
1147 
    return self.recv_getCartsByTime()
94 ashish 1148 
 
559 chandransh 1149 
  def send_getCartsByTime(self, from_time, to_time, status):
1150 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
1151 
    args = getCartsByTime_args()
1152 
    args.from_time = from_time
1153 
    args.to_time = to_time
1154 
    args.status = status
94 ashish 1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
559 chandransh 1159 
  def recv_getCartsByTime(self, ):
94 ashish 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
559 chandransh 1166 
    result = getCartsByTime_result()
94 ashish 1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.success != None:
1170 
      return result.success
559 chandransh 1171 
    if result.scx != None:
1172 
      raise result.scx
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 1174 
 
559 chandransh 1175 
  def changeCartStatus(self, cartId, status):
130 ashish 1176 
    """
1177 
    Parameters:
559 chandransh 1178 
     - cartId
1179 
     - status
130 ashish 1180 
    """
559 chandransh 1181 
    self.send_changeCartStatus(cartId, status)
1182 
    self.recv_changeCartStatus()
94 ashish 1183 
 
559 chandransh 1184 
  def send_changeCartStatus(self, cartId, status):
1185 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
1186 
    args = changeCartStatus_args()
1187 
    args.cartId = cartId
1188 
    args.status = status
130 ashish 1189 
    args.write(self._oprot)
1190 
    self._oprot.writeMessageEnd()
1191 
    self._oprot.trans.flush()
1192 
 
559 chandransh 1193 
  def recv_changeCartStatus(self, ):
130 ashish 1194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1195 
    if mtype == TMessageType.EXCEPTION:
1196 
      x = TApplicationException()
1197 
      x.read(self._iprot)
1198 
      self._iprot.readMessageEnd()
1199 
      raise x
559 chandransh 1200 
    result = changeCartStatus_result()
130 ashish 1201 
    result.read(self._iprot)
1202 
    self._iprot.readMessageEnd()
559 chandransh 1203 
    if result.scx != None:
1204 
      raise result.scx
1205 
    return
1206 
 
1207 
  def addItemToCart(self, cartId, itemId, quantity):
1208 
    """
1209 
    Parameters:
1210 
     - cartId
1211 
     - itemId
1212 
     - quantity
1213 
    """
1214 
    self.send_addItemToCart(cartId, itemId, quantity)
1215 
    self.recv_addItemToCart()
1216 
 
1217 
  def send_addItemToCart(self, cartId, itemId, quantity):
1218 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
1219 
    args = addItemToCart_args()
1220 
    args.cartId = cartId
1221 
    args.itemId = itemId
1222 
    args.quantity = quantity
1223 
    args.write(self._oprot)
1224 
    self._oprot.writeMessageEnd()
1225 
    self._oprot.trans.flush()
1226 
 
1227 
  def recv_addItemToCart(self, ):
1228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1229 
    if mtype == TMessageType.EXCEPTION:
1230 
      x = TApplicationException()
1231 
      x.read(self._iprot)
1232 
      self._iprot.readMessageEnd()
1233 
      raise x
1234 
    result = addItemToCart_result()
1235 
    result.read(self._iprot)
1236 
    self._iprot.readMessageEnd()
1237 
    if result.scx != None:
1238 
      raise result.scx
1239 
    return
1240 
 
1241 
  def deleteItemFromCart(self, cartId, itemId):
1242 
    """
1243 
    Parameters:
1244 
     - cartId
1245 
     - itemId
1246 
    """
1247 
    self.send_deleteItemFromCart(cartId, itemId)
1248 
    self.recv_deleteItemFromCart()
1249 
 
1250 
  def send_deleteItemFromCart(self, cartId, itemId):
1251 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
1252 
    args = deleteItemFromCart_args()
1253 
    args.cartId = cartId
1254 
    args.itemId = itemId
1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_deleteItemFromCart(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = deleteItemFromCart_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
1269 
    if result.scx != None:
1270 
      raise result.scx
1271 
    return
1272 
 
1273 
  def changeQuantity(self, cartId, itemId, quantity):
1274 
    """
1275 
    Parameters:
1276 
     - cartId
1277 
     - itemId
1278 
     - quantity
1279 
    """
1280 
    self.send_changeQuantity(cartId, itemId, quantity)
1281 
    self.recv_changeQuantity()
1282 
 
1283 
  def send_changeQuantity(self, cartId, itemId, quantity):
1284 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
1285 
    args = changeQuantity_args()
1286 
    args.cartId = cartId
1287 
    args.itemId = itemId
1288 
    args.quantity = quantity
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_changeQuantity(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 = changeQuantity_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.scx != None:
1304 
      raise result.scx
1305 
    return
1306 
 
1307 
  def changeItemStatus(self, cartId, itemId, status):
1308 
    """
1309 
    Parameters:
1310 
     - cartId
1311 
     - itemId
1312 
     - status
1313 
    """
1314 
    self.send_changeItemStatus(cartId, itemId, status)
1315 
    self.recv_changeItemStatus()
1316 
 
1317 
  def send_changeItemStatus(self, cartId, itemId, status):
1318 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1319 
    args = changeItemStatus_args()
1320 
    args.cartId = cartId
1321 
    args.itemId = itemId
1322 
    args.status = status
1323 
    args.write(self._oprot)
1324 
    self._oprot.writeMessageEnd()
1325 
    self._oprot.trans.flush()
1326 
 
1327 
  def recv_changeItemStatus(self, ):
1328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1329 
    if mtype == TMessageType.EXCEPTION:
1330 
      x = TApplicationException()
1331 
      x.read(self._iprot)
1332 
      self._iprot.readMessageEnd()
1333 
      raise x
1334 
    result = changeItemStatus_result()
1335 
    result.read(self._iprot)
1336 
    self._iprot.readMessageEnd()
1337 
    if result.scx != None:
1338 
      raise result.scx
1339 
    return
1340 
 
1341 
  def addAddressToCart(self, cartId, addressId):
1342 
    """
1343 
    Parameters:
1344 
     - cartId
1345 
     - addressId
1346 
    """
1347 
    self.send_addAddressToCart(cartId, addressId)
1348 
    self.recv_addAddressToCart()
1349 
 
1350 
  def send_addAddressToCart(self, cartId, addressId):
1351 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
1352 
    args = addAddressToCart_args()
1353 
    args.cartId = cartId
1354 
    args.addressId = addressId
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_addAddressToCart(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = addAddressToCart_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
575 chandransh 1369 
    if result.scx != None:
1370 
      raise result.scx
559 chandransh 1371 
    return
1372 
 
690 chandransh 1373 
  def createOrders(self, cartId):
559 chandransh 1374 
    """
690 chandransh 1375 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
1376 
 
559 chandransh 1377 
    Parameters:
1378 
     - cartId
1379 
    """
690 chandransh 1380 
    self.send_createOrders(cartId)
1381 
    return self.recv_createOrders()
559 chandransh 1382 
 
690 chandransh 1383 
  def send_createOrders(self, cartId):
1384 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
1385 
    args = createOrders_args()
559 chandransh 1386 
    args.cartId = cartId
1387 
    args.write(self._oprot)
1388 
    self._oprot.writeMessageEnd()
1389 
    self._oprot.trans.flush()
1390 
 
690 chandransh 1391 
  def recv_createOrders(self, ):
559 chandransh 1392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1393 
    if mtype == TMessageType.EXCEPTION:
1394 
      x = TApplicationException()
1395 
      x.read(self._iprot)
1396 
      self._iprot.readMessageEnd()
1397 
      raise x
690 chandransh 1398 
    result = createOrders_result()
559 chandransh 1399 
    result.read(self._iprot)
1400 
    self._iprot.readMessageEnd()
130 ashish 1401 
    if result.success != None:
1402 
      return result.success
559 chandransh 1403 
    if result.scx != None:
1404 
      raise result.scx
690 chandransh 1405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 1406 
 
559 chandransh 1407 
  def validateCart(self, cartId):
130 ashish 1408 
    """
690 chandransh 1409 
    Validates that:
1410 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1411 
    2. None of the lines in the cart for an inactive item.
1412 
    3. The estimate for any of the lines in cart doesn't change.
1413 
    Returns true only if all three hold.
1414 
 
130 ashish 1415 
    Parameters:
559 chandransh 1416 
     - cartId
130 ashish 1417 
    """
559 chandransh 1418 
    self.send_validateCart(cartId)
1419 
    return self.recv_validateCart()
130 ashish 1420 
 
559 chandransh 1421 
  def send_validateCart(self, cartId):
1422 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
1423 
    args = validateCart_args()
1424 
    args.cartId = cartId
130 ashish 1425 
    args.write(self._oprot)
1426 
    self._oprot.writeMessageEnd()
1427 
    self._oprot.trans.flush()
1428 
 
559 chandransh 1429 
  def recv_validateCart(self, ):
130 ashish 1430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1431 
    if mtype == TMessageType.EXCEPTION:
1432 
      x = TApplicationException()
1433 
      x.read(self._iprot)
1434 
      self._iprot.readMessageEnd()
1435 
      raise x
559 chandransh 1436 
    result = validateCart_result()
130 ashish 1437 
    result.read(self._iprot)
1438 
    self._iprot.readMessageEnd()
1439 
    if result.success != None:
1440 
      return result.success
575 chandransh 1441 
    if result.scex != None:
1442 
      raise result.scex
559 chandransh 1443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 1444 
 
690 chandransh 1445 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 1446 
    """
690 chandransh 1447 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
1448 
 
575 chandransh 1449 
    Parameters:
690 chandransh 1450 
     - fromCartId
1451 
     - toCartId
1452 
    """
1453 
    self.send_mergeCart(fromCartId, toCartId)
1454 
    self.recv_mergeCart()
1455 
 
1456 
  def send_mergeCart(self, fromCartId, toCartId):
1457 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
1458 
    args = mergeCart_args()
1459 
    args.fromCartId = fromCartId
1460 
    args.toCartId = toCartId
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_mergeCart(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = mergeCart_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
1475 
    return
1476 
 
1477 
  def checkOut(self, cartId):
1478 
    """
1479 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
1480 
 
1481 
    Parameters:
575 chandransh 1482 
     - cartId
1483 
    """
690 chandransh 1484 
    self.send_checkOut(cartId)
1485 
    return self.recv_checkOut()
575 chandransh 1486 
 
690 chandransh 1487 
  def send_checkOut(self, cartId):
1488 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
1489 
    args = checkOut_args()
575 chandransh 1490 
    args.cartId = cartId
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
690 chandransh 1495 
  def recv_checkOut(self, ):
575 chandransh 1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
690 chandransh 1502 
    result = checkOut_result()
575 chandransh 1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
1505 
    if result.success != None:
1506 
      return result.success
1507 
    if result.scex != None:
1508 
      raise result.scex
690 chandransh 1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 1510 
 
690 chandransh 1511 
  def resetCart(self, cartId, items):
559 chandransh 1512 
    """
690 chandransh 1513 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
1514 
    This methods removes the specified quantiry of the specified item from the cart.
1515 
 
559 chandransh 1516 
    Parameters:
690 chandransh 1517 
     - cartId
1518 
     - items
559 chandransh 1519 
    """
690 chandransh 1520 
    self.send_resetCart(cartId, items)
1521 
    return self.recv_resetCart()
130 ashish 1522 
 
690 chandransh 1523 
  def send_resetCart(self, cartId, items):
1524 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
1525 
    args = resetCart_args()
1526 
    args.cartId = cartId
1527 
    args.items = items
559 chandransh 1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
690 chandransh 1532 
  def recv_resetCart(self, ):
559 chandransh 1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
690 chandransh 1539 
    result = resetCart_result()
559 chandransh 1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
690 chandransh 1542 
    if result.success != None:
1543 
      return result.success
1544 
    if result.scex != None:
1545 
      raise result.scex
1546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 1547 
 
1548 
  def addWidget(self, widget):
1549 
    """
1550 
    Parameters:
1551 
     - widget
1552 
    """
1553 
    self.send_addWidget(widget)
1554 
    self.recv_addWidget()
1555 
 
1556 
  def send_addWidget(self, widget):
1557 
    self._oprot.writeMessageBegin('addWidget', TMessageType.CALL, self._seqid)
1558 
    args = addWidget_args()
1559 
    args.widget = widget
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_addWidget(self, ):
1565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1566 
    if mtype == TMessageType.EXCEPTION:
1567 
      x = TApplicationException()
1568 
      x.read(self._iprot)
1569 
      self._iprot.readMessageEnd()
1570 
      raise x
1571 
    result = addWidget_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
1574 
    if result.scx != None:
1575 
      raise result.scx
1576 
    return
1577 
 
1578 
  def addItemToWidget(self, widget_id, items):
1579 
    """
1580 
    Parameters:
1581 
     - widget_id
1582 
     - items
1583 
    """
1584 
    self.send_addItemToWidget(widget_id, items)
1585 
    self.recv_addItemToWidget()
1586 
 
1587 
  def send_addItemToWidget(self, widget_id, items):
1588 
    self._oprot.writeMessageBegin('addItemToWidget', TMessageType.CALL, self._seqid)
1589 
    args = addItemToWidget_args()
1590 
    args.widget_id = widget_id
1591 
    args.items = items
1592 
    args.write(self._oprot)
1593 
    self._oprot.writeMessageEnd()
1594 
    self._oprot.trans.flush()
1595 
 
1596 
  def recv_addItemToWidget(self, ):
1597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1598 
    if mtype == TMessageType.EXCEPTION:
1599 
      x = TApplicationException()
1600 
      x.read(self._iprot)
1601 
      self._iprot.readMessageEnd()
1602 
      raise x
1603 
    result = addItemToWidget_result()
1604 
    result.read(self._iprot)
1605 
    self._iprot.readMessageEnd()
1606 
    if result.scx != None:
1607 
      raise result.scx
1608 
    return
1609 
 
1610 
  def deleteItemFromWidget(self, widget_id, item_id):
1611 
    """
1612 
    Parameters:
1613 
     - widget_id
1614 
     - item_id
1615 
    """
1616 
    self.send_deleteItemFromWidget(widget_id, item_id)
1617 
    self.recv_deleteItemFromWidget()
1618 
 
1619 
  def send_deleteItemFromWidget(self, widget_id, item_id):
1620 
    self._oprot.writeMessageBegin('deleteItemFromWidget', TMessageType.CALL, self._seqid)
1621 
    args = deleteItemFromWidget_args()
1622 
    args.widget_id = widget_id
1623 
    args.item_id = item_id
1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
1628 
  def recv_deleteItemFromWidget(self, ):
1629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1630 
    if mtype == TMessageType.EXCEPTION:
1631 
      x = TApplicationException()
1632 
      x.read(self._iprot)
1633 
      self._iprot.readMessageEnd()
1634 
      raise x
1635 
    result = deleteItemFromWidget_result()
1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
1638 
    if result.scx != None:
1639 
      raise result.scx
1640 
    return
1641 
 
1642 
  def updateWidget(self, widgetId, enable):
1643 
    """
1644 
    Parameters:
1645 
     - widgetId
1646 
     - enable
1647 
    """
1648 
    self.send_updateWidget(widgetId, enable)
1649 
    self.recv_updateWidget()
1650 
 
1651 
  def send_updateWidget(self, widgetId, enable):
1652 
    self._oprot.writeMessageBegin('updateWidget', TMessageType.CALL, self._seqid)
1653 
    args = updateWidget_args()
1654 
    args.widgetId = widgetId
1655 
    args.enable = enable
1656 
    args.write(self._oprot)
1657 
    self._oprot.writeMessageEnd()
1658 
    self._oprot.trans.flush()
1659 
 
1660 
  def recv_updateWidget(self, ):
1661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1662 
    if mtype == TMessageType.EXCEPTION:
1663 
      x = TApplicationException()
1664 
      x.read(self._iprot)
1665 
      self._iprot.readMessageEnd()
1666 
      raise x
1667 
    result = updateWidget_result()
1668 
    result.read(self._iprot)
1669 
    self._iprot.readMessageEnd()
1670 
    if result.scx != None:
1671 
      raise result.scx
1672 
    return
1673 
 
1674 
  def updateWidgetItem(self, widgetId, enable):
1675 
    """
1676 
    Parameters:
1677 
     - widgetId
1678 
     - enable
1679 
    """
1680 
    self.send_updateWidgetItem(widgetId, enable)
1681 
    self.recv_updateWidgetItem()
1682 
 
1683 
  def send_updateWidgetItem(self, widgetId, enable):
1684 
    self._oprot.writeMessageBegin('updateWidgetItem', TMessageType.CALL, self._seqid)
1685 
    args = updateWidgetItem_args()
1686 
    args.widgetId = widgetId
1687 
    args.enable = enable
1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
1692 
  def recv_updateWidgetItem(self, ):
1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
1699 
    result = updateWidgetItem_result()
1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
1702 
    if result.scx != None:
1703 
      raise result.scx
1704 
    return
1705 
 
1706 
  def getWidget(self, type, userId, onlyEnabled):
1707 
    """
1708 
    Parameters:
1709 
     - type
1710 
     - userId
1711 
     - onlyEnabled
1712 
    """
1713 
    self.send_getWidget(type, userId, onlyEnabled)
1714 
    return self.recv_getWidget()
1715 
 
1716 
  def send_getWidget(self, type, userId, onlyEnabled):
1717 
    self._oprot.writeMessageBegin('getWidget', TMessageType.CALL, self._seqid)
1718 
    args = getWidget_args()
1719 
    args.type = type
1720 
    args.userId = userId
1721 
    args.onlyEnabled = onlyEnabled
1722 
    args.write(self._oprot)
1723 
    self._oprot.writeMessageEnd()
1724 
    self._oprot.trans.flush()
1725 
 
1726 
  def recv_getWidget(self, ):
1727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1728 
    if mtype == TMessageType.EXCEPTION:
1729 
      x = TApplicationException()
1730 
      x.read(self._iprot)
1731 
      self._iprot.readMessageEnd()
1732 
      raise x
1733 
    result = getWidget_result()
1734 
    result.read(self._iprot)
1735 
    self._iprot.readMessageEnd()
1736 
    if result.success != None:
1737 
      return result.success
1738 
    if result.scx != None:
1739 
      raise result.scx
1740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWidget failed: unknown result");
1741 
 
1742 
  def getMyResearch(self, user_id):
1743 
    """
1744 
    Parameters:
1745 
     - user_id
1746 
    """
1747 
    self.send_getMyResearch(user_id)
1748 
    return self.recv_getMyResearch()
1749 
 
1750 
  def send_getMyResearch(self, user_id):
1751 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
1752 
    args = getMyResearch_args()
1753 
    args.user_id = user_id
1754 
    args.write(self._oprot)
1755 
    self._oprot.writeMessageEnd()
1756 
    self._oprot.trans.flush()
1757 
 
1758 
  def recv_getMyResearch(self, ):
1759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1760 
    if mtype == TMessageType.EXCEPTION:
1761 
      x = TApplicationException()
1762 
      x.read(self._iprot)
1763 
      self._iprot.readMessageEnd()
1764 
      raise x
1765 
    result = getMyResearch_result()
1766 
    result.read(self._iprot)
1767 
    self._iprot.readMessageEnd()
1768 
    if result.success != None:
1769 
      return result.success
1770 
    if result.scx != None:
1771 
      raise result.scx
1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
1773 
 
1774 
  def updateMyResearch(self, user_id, item_id):
1775 
    """
1776 
    Parameters:
1777 
     - user_id
1778 
     - item_id
1779 
    """
1780 
    self.send_updateMyResearch(user_id, item_id)
1781 
    return self.recv_updateMyResearch()
1782 
 
1783 
  def send_updateMyResearch(self, user_id, item_id):
1784 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
1785 
    args = updateMyResearch_args()
1786 
    args.user_id = user_id
1787 
    args.item_id = item_id
1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
1792 
  def recv_updateMyResearch(self, ):
1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
1799 
    result = updateMyResearch_result()
1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
1802 
    if result.success != None:
1803 
      return result.success
1804 
    if result.scx != None:
1805 
      raise result.scx
1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
1807 
 
1808 
  def deleteItemFromMyResearch(self, user_id, item_id):
1809 
    """
1810 
    Parameters:
1811 
     - user_id
1812 
     - item_id
1813 
    """
1814 
    self.send_deleteItemFromMyResearch(user_id, item_id)
1815 
    self.recv_deleteItemFromMyResearch()
1816 
 
1817 
  def send_deleteItemFromMyResearch(self, user_id, item_id):
1818 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
1819 
    args = deleteItemFromMyResearch_args()
1820 
    args.user_id = user_id
1821 
    args.item_id = item_id
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_deleteItemFromMyResearch(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = deleteItemFromMyResearch_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.scx != None:
1837 
      raise result.scx
1838 
    return
1839 
 
1840 
  def updateRatings(self, item_id, type, rating, user_id):
1841 
    """
1842 
    Parameters:
1843 
     - item_id
1844 
     - type
1845 
     - rating
1846 
     - user_id
1847 
    """
1848 
    self.send_updateRatings(item_id, type, rating, user_id)
1849 
    self.recv_updateRatings()
1850 
 
1851 
  def send_updateRatings(self, item_id, type, rating, user_id):
1852 
    self._oprot.writeMessageBegin('updateRatings', TMessageType.CALL, self._seqid)
1853 
    args = updateRatings_args()
1854 
    args.item_id = item_id
1855 
    args.type = type
1856 
    args.rating = rating
1857 
    args.user_id = user_id
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_updateRatings(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = updateRatings_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    return
1873 
 
1874 
  def getRatings(self, item_id, user_id):
1875 
    """
1876 
    Parameters:
1877 
     - item_id
1878 
     - user_id
1879 
    """
1880 
    self.send_getRatings(item_id, user_id)
1881 
    return self.recv_getRatings()
1882 
 
1883 
  def send_getRatings(self, item_id, user_id):
1884 
    self._oprot.writeMessageBegin('getRatings', TMessageType.CALL, self._seqid)
1885 
    args = getRatings_args()
1886 
    args.item_id = item_id
1887 
    args.user_id = user_id
1888 
    args.write(self._oprot)
1889 
    self._oprot.writeMessageEnd()
1890 
    self._oprot.trans.flush()
1891 
 
1892 
  def recv_getRatings(self, ):
1893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1894 
    if mtype == TMessageType.EXCEPTION:
1895 
      x = TApplicationException()
1896 
      x.read(self._iprot)
1897 
      self._iprot.readMessageEnd()
1898 
      raise x
1899 
    result = getRatings_result()
1900 
    result.read(self._iprot)
1901 
    self._iprot.readMessageEnd()
1902 
    if result.success != None:
1903 
      return result.success
1904 
    if result.scx != None:
1905 
      raise result.scx
1906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRatings failed: unknown result");
1907 
 
1908 
  def updateBrowseHistory(self, user_id, item_id, isSessionId):
1909 
    """
1910 
    Parameters:
1911 
     - user_id
1912 
     - item_id
1913 
     - isSessionId
1914 
    """
1915 
    self.send_updateBrowseHistory(user_id, item_id, isSessionId)
1916 
    self.recv_updateBrowseHistory()
1917 
 
1918 
  def send_updateBrowseHistory(self, user_id, item_id, isSessionId):
1919 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
1920 
    args = updateBrowseHistory_args()
1921 
    args.user_id = user_id
1922 
    args.item_id = item_id
1923 
    args.isSessionId = isSessionId
1924 
    args.write(self._oprot)
1925 
    self._oprot.writeMessageEnd()
1926 
    self._oprot.trans.flush()
1927 
 
1928 
  def recv_updateBrowseHistory(self, ):
1929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1930 
    if mtype == TMessageType.EXCEPTION:
1931 
      x = TApplicationException()
1932 
      x.read(self._iprot)
1933 
      self._iprot.readMessageEnd()
1934 
      raise x
1935 
    result = updateBrowseHistory_result()
1936 
    result.read(self._iprot)
1937 
    self._iprot.readMessageEnd()
1938 
    return
1939 
 
1940 
  def getBrowseHistory(self, userId, isSessionId):
1941 
    """
1942 
    Parameters:
1943 
     - userId
1944 
     - isSessionId
1945 
    """
1946 
    self.send_getBrowseHistory(userId, isSessionId)
1947 
    return self.recv_getBrowseHistory()
1948 
 
1949 
  def send_getBrowseHistory(self, userId, isSessionId):
1950 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
1951 
    args = getBrowseHistory_args()
1952 
    args.userId = userId
1953 
    args.isSessionId = isSessionId
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_getBrowseHistory(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = getBrowseHistory_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
1968 
    if result.success != None:
1969 
      return result.success
1970 
    if result.scx != None:
1971 
      raise result.scx
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
1973 
 
1974 
 
94 ashish 1975 
class Processor(Iface, TProcessor):
1976 
  def __init__(self, handler):
1977 
    self._handler = handler
1978 
    self._processMap = {}
559 chandransh 1979 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
1980 
    self._processMap["getUserById"] = Processor.process_getUserById
1981 
    self._processMap["createUser"] = Processor.process_createUser
1982 
    self._processMap["updateUser"] = Processor.process_updateUser
1983 
    self._processMap["deleteUser"] = Processor.process_deleteUser
1984 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 1985 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 1986 
    self._processMap["userExists"] = Processor.process_userExists
1987 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
1988 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
1989 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
1990 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 1991 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 1992 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 1993 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 1994 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1995 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
559 chandransh 1996 
    self._processMap["createCart"] = Processor.process_createCart
1997 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
1998 
    self._processMap["getCart"] = Processor.process_getCart
1999 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2000 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2001 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2002 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2003 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2004 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2005 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2006 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2007 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
690 chandransh 2008 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2009 
    self._processMap["validateCart"] = Processor.process_validateCart
2010 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2011 
    self._processMap["checkOut"] = Processor.process_checkOut
2012 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2013 
    self._processMap["addWidget"] = Processor.process_addWidget
2014 
    self._processMap["addItemToWidget"] = Processor.process_addItemToWidget
2015 
    self._processMap["deleteItemFromWidget"] = Processor.process_deleteItemFromWidget
2016 
    self._processMap["updateWidget"] = Processor.process_updateWidget
2017 
    self._processMap["updateWidgetItem"] = Processor.process_updateWidgetItem
2018 
    self._processMap["getWidget"] = Processor.process_getWidget
2019 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2020 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2021 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2022 
    self._processMap["updateRatings"] = Processor.process_updateRatings
2023 
    self._processMap["getRatings"] = Processor.process_getRatings
2024 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2025 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
94 ashish 2026 
 
2027 
  def process(self, iprot, oprot):
2028 
    (name, type, seqid) = iprot.readMessageBegin()
2029 
    if name not in self._processMap:
2030 
      iprot.skip(TType.STRUCT)
2031 
      iprot.readMessageEnd()
2032 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2033 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2034 
      x.write(oprot)
2035 
      oprot.writeMessageEnd()
2036 
      oprot.trans.flush()
2037 
      return
2038 
    else:
2039 
      self._processMap[name](self, seqid, iprot, oprot)
2040 
    return True
2041 
 
559 chandransh 2042 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2043 
    args = createAnonymousUser_args()
94 ashish 2044 
    args.read(iprot)
2045 
    iprot.readMessageEnd()
559 chandransh 2046 
    result = createAnonymousUser_result()
94 ashish 2047 
    try:
559 chandransh 2048 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2049 
    except UserContextException, ucex:
2050 
      result.ucex = ucex
2051 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2052 
    result.write(oprot)
2053 
    oprot.writeMessageEnd()
2054 
    oprot.trans.flush()
2055 
 
559 chandransh 2056 
  def process_getUserById(self, seqid, iprot, oprot):
2057 
    args = getUserById_args()
94 ashish 2058 
    args.read(iprot)
2059 
    iprot.readMessageEnd()
559 chandransh 2060 
    result = getUserById_result()
94 ashish 2061 
    try:
559 chandransh 2062 
      result.success = self._handler.getUserById(args.userId)
2063 
    except UserContextException, ucex:
2064 
      result.ucex = ucex
2065 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2066 
    result.write(oprot)
2067 
    oprot.writeMessageEnd()
2068 
    oprot.trans.flush()
2069 
 
559 chandransh 2070 
  def process_createUser(self, seqid, iprot, oprot):
2071 
    args = createUser_args()
94 ashish 2072 
    args.read(iprot)
2073 
    iprot.readMessageEnd()
559 chandransh 2074 
    result = createUser_result()
94 ashish 2075 
    try:
559 chandransh 2076 
      result.success = self._handler.createUser(args.user)
2077 
    except UserContextException, ucex:
2078 
      result.ucex = ucex
2079 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2080 
    result.write(oprot)
2081 
    oprot.writeMessageEnd()
2082 
    oprot.trans.flush()
2083 
 
559 chandransh 2084 
  def process_updateUser(self, seqid, iprot, oprot):
2085 
    args = updateUser_args()
94 ashish 2086 
    args.read(iprot)
2087 
    iprot.readMessageEnd()
559 chandransh 2088 
    result = updateUser_result()
94 ashish 2089 
    try:
559 chandransh 2090 
      result.success = self._handler.updateUser(args.user)
2091 
    except UserContextException, ucex:
2092 
      result.ucex = ucex
2093 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2094 
    result.write(oprot)
2095 
    oprot.writeMessageEnd()
2096 
    oprot.trans.flush()
2097 
 
559 chandransh 2098 
  def process_deleteUser(self, seqid, iprot, oprot):
2099 
    args = deleteUser_args()
94 ashish 2100 
    args.read(iprot)
2101 
    iprot.readMessageEnd()
559 chandransh 2102 
    result = deleteUser_result()
94 ashish 2103 
    try:
559 chandransh 2104 
      result.success = self._handler.deleteUser(args.userId)
2105 
    except UserContextException, ucex:
2106 
      result.ucex = ucex
2107 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2108 
    result.write(oprot)
2109 
    oprot.writeMessageEnd()
2110 
    oprot.trans.flush()
2111 
 
559 chandransh 2112 
  def process_getUserState(self, seqid, iprot, oprot):
2113 
    args = getUserState_args()
94 ashish 2114 
    args.read(iprot)
2115 
    iprot.readMessageEnd()
559 chandransh 2116 
    result = getUserState_result()
94 ashish 2117 
    try:
559 chandransh 2118 
      result.success = self._handler.getUserState(args.userId)
2119 
    except UserContextException, ucex:
2120 
      result.ucex = ucex
2121 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2122 
    result.write(oprot)
2123 
    oprot.writeMessageEnd()
2124 
    oprot.trans.flush()
2125 
 
122 ashish 2126 
  def process_authenticateUser(self, seqid, iprot, oprot):
2127 
    args = authenticateUser_args()
2128 
    args.read(iprot)
2129 
    iprot.readMessageEnd()
2130 
    result = authenticateUser_result()
2131 
    try:
559 chandransh 2132 
      result.success = self._handler.authenticateUser(args.email, args.password)
2133 
    except AuthenticationException, auex:
2134 
      result.auex = auex
122 ashish 2135 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2136 
    result.write(oprot)
2137 
    oprot.writeMessageEnd()
2138 
    oprot.trans.flush()
2139 
 
94 ashish 2140 
  def process_userExists(self, seqid, iprot, oprot):
2141 
    args = userExists_args()
2142 
    args.read(iprot)
2143 
    iprot.readMessageEnd()
2144 
    result = userExists_result()
2145 
    try:
2146 
      result.success = self._handler.userExists(args.email)
2147 
    except UserContextException, ucx:
2148 
      result.ucx = ucx
2149 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2150 
    result.write(oprot)
2151 
    oprot.writeMessageEnd()
2152 
    oprot.trans.flush()
2153 
 
2154 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2155 
    args = addAddressForUser_args()
2156 
    args.read(iprot)
2157 
    iprot.readMessageEnd()
2158 
    result = addAddressForUser_result()
2159 
    try:
567 rajveer 2160 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2161 
    except UserContextException, ucx:
2162 
      result.ucx = ucx
2163 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2164 
    result.write(oprot)
2165 
    oprot.writeMessageEnd()
2166 
    oprot.trans.flush()
2167 
 
2168 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2169 
    args = removeAddressForUser_args()
2170 
    args.read(iprot)
2171 
    iprot.readMessageEnd()
2172 
    result = removeAddressForUser_result()
2173 
    try:
2174 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
2175 
    except UserContextException, ucx:
2176 
      result.ucx = ucx
2177 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
2178 
    result.write(oprot)
2179 
    oprot.writeMessageEnd()
2180 
    oprot.trans.flush()
2181 
 
2182 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
2183 
    args = setUserAsLoggedIn_args()
2184 
    args.read(iprot)
2185 
    iprot.readMessageEnd()
2186 
    result = setUserAsLoggedIn_result()
2187 
    try:
2188 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
2189 
    except UserContextException, ucx:
2190 
      result.ucx = ucx
2191 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
2192 
    result.write(oprot)
2193 
    oprot.writeMessageEnd()
2194 
    oprot.trans.flush()
2195 
 
2196 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
2197 
    args = setUserAsLoggedOut_args()
2198 
    args.read(iprot)
2199 
    iprot.readMessageEnd()
2200 
    result = setUserAsLoggedOut_result()
2201 
    try:
2202 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
2203 
    except UserContextException, ucx:
2204 
      result.ucx = ucx
2205 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
2206 
    result.write(oprot)
2207 
    oprot.writeMessageEnd()
2208 
    oprot.trans.flush()
2209 
 
504 rajveer 2210 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
2211 
    args = setDefaultAddress_args()
2212 
    args.read(iprot)
2213 
    iprot.readMessageEnd()
2214 
    result = setDefaultAddress_result()
2215 
    try:
2216 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
2217 
    except UserContextException, ucx:
2218 
      result.ucx = ucx
2219 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
2220 
    result.write(oprot)
2221 
    oprot.writeMessageEnd()
2222 
    oprot.trans.flush()
2223 
 
94 ashish 2224 
  def process_updatePassword(self, seqid, iprot, oprot):
2225 
    args = updatePassword_args()
2226 
    args.read(iprot)
2227 
    iprot.readMessageEnd()
2228 
    result = updatePassword_result()
2229 
    try:
594 rajveer 2230 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 2231 
    except UserContextException, ucx:
2232 
      result.ucx = ucx
2233 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
2234 
    result.write(oprot)
2235 
    oprot.writeMessageEnd()
2236 
    oprot.trans.flush()
2237 
 
581 rajveer 2238 
  def process_forgotPassword(self, seqid, iprot, oprot):
2239 
    args = forgotPassword_args()
2240 
    args.read(iprot)
2241 
    iprot.readMessageEnd()
2242 
    result = forgotPassword_result()
2243 
    try:
2244 
      result.success = self._handler.forgotPassword(args.email)
2245 
    except UserContextException, ucx:
2246 
      result.ucx = ucx
2247 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
2248 
    result.write(oprot)
2249 
    oprot.writeMessageEnd()
2250 
    oprot.trans.flush()
2251 
 
594 rajveer 2252 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
2253 
    args = getAllAddressesForUser_args()
2254 
    args.read(iprot)
2255 
    iprot.readMessageEnd()
2256 
    result = getAllAddressesForUser_result()
2257 
    try:
2258 
      result.success = self._handler.getAllAddressesForUser(args.userId)
2259 
    except UserContextException, ucx:
2260 
      result.ucx = ucx
2261 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
2262 
    result.write(oprot)
2263 
    oprot.writeMessageEnd()
2264 
    oprot.trans.flush()
2265 
 
2266 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
2267 
    args = getDefaultAddressId_args()
2268 
    args.read(iprot)
2269 
    iprot.readMessageEnd()
2270 
    result = getDefaultAddressId_result()
2271 
    try:
2272 
      result.success = self._handler.getDefaultAddressId(args.userId)
2273 
    except UserContextException, ucx:
2274 
      result.ucx = ucx
2275 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
2276 
    result.write(oprot)
2277 
    oprot.writeMessageEnd()
2278 
    oprot.trans.flush()
2279 
 
559 chandransh 2280 
  def process_createCart(self, seqid, iprot, oprot):
2281 
    args = createCart_args()
94 ashish 2282 
    args.read(iprot)
2283 
    iprot.readMessageEnd()
559 chandransh 2284 
    result = createCart_result()
94 ashish 2285 
    try:
559 chandransh 2286 
      result.success = self._handler.createCart(args.userId)
2287 
    except ShoppingCartException, scx:
2288 
      result.scx = scx
2289 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 2290 
    result.write(oprot)
2291 
    oprot.writeMessageEnd()
2292 
    oprot.trans.flush()
2293 
 
559 chandransh 2294 
  def process_getCurrentCart(self, seqid, iprot, oprot):
2295 
    args = getCurrentCart_args()
94 ashish 2296 
    args.read(iprot)
2297 
    iprot.readMessageEnd()
559 chandransh 2298 
    result = getCurrentCart_result()
94 ashish 2299 
    try:
559 chandransh 2300 
      result.success = self._handler.getCurrentCart(args.userId)
2301 
    except ShoppingCartException, scx:
2302 
      result.scx = scx
2303 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 2304 
    result.write(oprot)
2305 
    oprot.writeMessageEnd()
2306 
    oprot.trans.flush()
2307 
 
559 chandransh 2308 
  def process_getCart(self, seqid, iprot, oprot):
2309 
    args = getCart_args()
94 ashish 2310 
    args.read(iprot)
2311 
    iprot.readMessageEnd()
559 chandransh 2312 
    result = getCart_result()
94 ashish 2313 
    try:
559 chandransh 2314 
      result.success = self._handler.getCart(args.cartId)
2315 
    except ShoppingCartException, scx:
2316 
      result.scx = scx
2317 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 2318 
    result.write(oprot)
2319 
    oprot.writeMessageEnd()
2320 
    oprot.trans.flush()
2321 
 
559 chandransh 2322 
  def process_getCartsForUser(self, seqid, iprot, oprot):
2323 
    args = getCartsForUser_args()
94 ashish 2324 
    args.read(iprot)
2325 
    iprot.readMessageEnd()
559 chandransh 2326 
    result = getCartsForUser_result()
94 ashish 2327 
    try:
559 chandransh 2328 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
2329 
    except ShoppingCartException, scx:
2330 
      result.scx = scx
2331 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 2332 
    result.write(oprot)
2333 
    oprot.writeMessageEnd()
2334 
    oprot.trans.flush()
2335 
 
559 chandransh 2336 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
2337 
    args = getCartsByStatus_args()
94 ashish 2338 
    args.read(iprot)
2339 
    iprot.readMessageEnd()
559 chandransh 2340 
    result = getCartsByStatus_result()
94 ashish 2341 
    try:
559 chandransh 2342 
      result.success = self._handler.getCartsByStatus(args.status)
2343 
    except ShoppingCartException, scx:
2344 
      result.scx = scx
2345 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 2346 
    result.write(oprot)
2347 
    oprot.writeMessageEnd()
2348 
    oprot.trans.flush()
2349 
 
559 chandransh 2350 
  def process_getCartsByTime(self, seqid, iprot, oprot):
2351 
    args = getCartsByTime_args()
94 ashish 2352 
    args.read(iprot)
2353 
    iprot.readMessageEnd()
559 chandransh 2354 
    result = getCartsByTime_result()
94 ashish 2355 
    try:
559 chandransh 2356 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
2357 
    except ShoppingCartException, scx:
2358 
      result.scx = scx
2359 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 2360 
    result.write(oprot)
2361 
    oprot.writeMessageEnd()
2362 
    oprot.trans.flush()
2363 
 
559 chandransh 2364 
  def process_changeCartStatus(self, seqid, iprot, oprot):
2365 
    args = changeCartStatus_args()
130 ashish 2366 
    args.read(iprot)
2367 
    iprot.readMessageEnd()
559 chandransh 2368 
    result = changeCartStatus_result()
130 ashish 2369 
    try:
559 chandransh 2370 
      self._handler.changeCartStatus(args.cartId, args.status)
2371 
    except ShoppingCartException, scx:
2372 
      result.scx = scx
2373 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 2374 
    result.write(oprot)
2375 
    oprot.writeMessageEnd()
2376 
    oprot.trans.flush()
94 ashish 2377 
 
559 chandransh 2378 
  def process_addItemToCart(self, seqid, iprot, oprot):
2379 
    args = addItemToCart_args()
130 ashish 2380 
    args.read(iprot)
2381 
    iprot.readMessageEnd()
559 chandransh 2382 
    result = addItemToCart_result()
130 ashish 2383 
    try:
559 chandransh 2384 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
2385 
    except ShoppingCartException, scx:
2386 
      result.scx = scx
2387 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 2388 
    result.write(oprot)
2389 
    oprot.writeMessageEnd()
2390 
    oprot.trans.flush()
2391 
 
559 chandransh 2392 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
2393 
    args = deleteItemFromCart_args()
2394 
    args.read(iprot)
2395 
    iprot.readMessageEnd()
2396 
    result = deleteItemFromCart_result()
2397 
    try:
2398 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
2399 
    except ShoppingCartException, scx:
2400 
      result.scx = scx
2401 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
2402 
    result.write(oprot)
2403 
    oprot.writeMessageEnd()
2404 
    oprot.trans.flush()
130 ashish 2405 
 
559 chandransh 2406 
  def process_changeQuantity(self, seqid, iprot, oprot):
2407 
    args = changeQuantity_args()
2408 
    args.read(iprot)
2409 
    iprot.readMessageEnd()
2410 
    result = changeQuantity_result()
2411 
    try:
2412 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
2413 
    except ShoppingCartException, scx:
2414 
      result.scx = scx
2415 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
2416 
    result.write(oprot)
2417 
    oprot.writeMessageEnd()
2418 
    oprot.trans.flush()
2419 
 
2420 
  def process_changeItemStatus(self, seqid, iprot, oprot):
2421 
    args = changeItemStatus_args()
2422 
    args.read(iprot)
2423 
    iprot.readMessageEnd()
2424 
    result = changeItemStatus_result()
2425 
    try:
2426 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
2427 
    except ShoppingCartException, scx:
2428 
      result.scx = scx
2429 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
2430 
    result.write(oprot)
2431 
    oprot.writeMessageEnd()
2432 
    oprot.trans.flush()
2433 
 
2434 
  def process_addAddressToCart(self, seqid, iprot, oprot):
2435 
    args = addAddressToCart_args()
2436 
    args.read(iprot)
2437 
    iprot.readMessageEnd()
2438 
    result = addAddressToCart_result()
575 chandransh 2439 
    try:
2440 
      self._handler.addAddressToCart(args.cartId, args.addressId)
2441 
    except ShoppingCartException, scx:
2442 
      result.scx = scx
559 chandransh 2443 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
2444 
    result.write(oprot)
2445 
    oprot.writeMessageEnd()
2446 
    oprot.trans.flush()
2447 
 
690 chandransh 2448 
  def process_createOrders(self, seqid, iprot, oprot):
2449 
    args = createOrders_args()
559 chandransh 2450 
    args.read(iprot)
2451 
    iprot.readMessageEnd()
690 chandransh 2452 
    result = createOrders_result()
559 chandransh 2453 
    try:
690 chandransh 2454 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 2455 
    except ShoppingCartException, scx:
2456 
      result.scx = scx
690 chandransh 2457 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 2458 
    result.write(oprot)
2459 
    oprot.writeMessageEnd()
2460 
    oprot.trans.flush()
2461 
 
2462 
  def process_validateCart(self, seqid, iprot, oprot):
2463 
    args = validateCart_args()
2464 
    args.read(iprot)
2465 
    iprot.readMessageEnd()
2466 
    result = validateCart_result()
575 chandransh 2467 
    try:
2468 
      result.success = self._handler.validateCart(args.cartId)
2469 
    except ShoppingCartException, scex:
2470 
      result.scex = scex
559 chandransh 2471 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
2472 
    result.write(oprot)
2473 
    oprot.writeMessageEnd()
2474 
    oprot.trans.flush()
2475 
 
690 chandransh 2476 
  def process_mergeCart(self, seqid, iprot, oprot):
2477 
    args = mergeCart_args()
575 chandransh 2478 
    args.read(iprot)
2479 
    iprot.readMessageEnd()
690 chandransh 2480 
    result = mergeCart_result()
2481 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
2482 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
2483 
    result.write(oprot)
2484 
    oprot.writeMessageEnd()
2485 
    oprot.trans.flush()
2486 
 
2487 
  def process_checkOut(self, seqid, iprot, oprot):
2488 
    args = checkOut_args()
2489 
    args.read(iprot)
2490 
    iprot.readMessageEnd()
2491 
    result = checkOut_result()
575 chandransh 2492 
    try:
690 chandransh 2493 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 2494 
    except ShoppingCartException, scex:
2495 
      result.scex = scex
690 chandransh 2496 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 2497 
    result.write(oprot)
2498 
    oprot.writeMessageEnd()
2499 
    oprot.trans.flush()
2500 
 
690 chandransh 2501 
  def process_resetCart(self, seqid, iprot, oprot):
2502 
    args = resetCart_args()
559 chandransh 2503 
    args.read(iprot)
2504 
    iprot.readMessageEnd()
690 chandransh 2505 
    result = resetCart_result()
2506 
    try:
2507 
      result.success = self._handler.resetCart(args.cartId, args.items)
2508 
    except ShoppingCartException, scex:
2509 
      result.scex = scex
2510 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 2511 
    result.write(oprot)
2512 
    oprot.writeMessageEnd()
2513 
    oprot.trans.flush()
2514 
 
2515 
  def process_addWidget(self, seqid, iprot, oprot):
2516 
    args = addWidget_args()
2517 
    args.read(iprot)
2518 
    iprot.readMessageEnd()
2519 
    result = addWidget_result()
2520 
    try:
2521 
      self._handler.addWidget(args.widget)
2522 
    except WidgetException, scx:
2523 
      result.scx = scx
2524 
    oprot.writeMessageBegin("addWidget", TMessageType.REPLY, seqid)
2525 
    result.write(oprot)
2526 
    oprot.writeMessageEnd()
2527 
    oprot.trans.flush()
2528 
 
2529 
  def process_addItemToWidget(self, seqid, iprot, oprot):
2530 
    args = addItemToWidget_args()
2531 
    args.read(iprot)
2532 
    iprot.readMessageEnd()
2533 
    result = addItemToWidget_result()
2534 
    try:
2535 
      self._handler.addItemToWidget(args.widget_id, args.items)
2536 
    except WidgetException, scx:
2537 
      result.scx = scx
2538 
    oprot.writeMessageBegin("addItemToWidget", TMessageType.REPLY, seqid)
2539 
    result.write(oprot)
2540 
    oprot.writeMessageEnd()
2541 
    oprot.trans.flush()
2542 
 
2543 
  def process_deleteItemFromWidget(self, seqid, iprot, oprot):
2544 
    args = deleteItemFromWidget_args()
2545 
    args.read(iprot)
2546 
    iprot.readMessageEnd()
2547 
    result = deleteItemFromWidget_result()
2548 
    try:
2549 
      self._handler.deleteItemFromWidget(args.widget_id, args.item_id)
2550 
    except WidgetException, scx:
2551 
      result.scx = scx
2552 
    oprot.writeMessageBegin("deleteItemFromWidget", TMessageType.REPLY, seqid)
2553 
    result.write(oprot)
2554 
    oprot.writeMessageEnd()
2555 
    oprot.trans.flush()
2556 
 
2557 
  def process_updateWidget(self, seqid, iprot, oprot):
2558 
    args = updateWidget_args()
2559 
    args.read(iprot)
2560 
    iprot.readMessageEnd()
2561 
    result = updateWidget_result()
2562 
    try:
2563 
      self._handler.updateWidget(args.widgetId, args.enable)
2564 
    except WidgetException, scx:
2565 
      result.scx = scx
2566 
    oprot.writeMessageBegin("updateWidget", TMessageType.REPLY, seqid)
2567 
    result.write(oprot)
2568 
    oprot.writeMessageEnd()
2569 
    oprot.trans.flush()
2570 
 
2571 
  def process_updateWidgetItem(self, seqid, iprot, oprot):
2572 
    args = updateWidgetItem_args()
2573 
    args.read(iprot)
2574 
    iprot.readMessageEnd()
2575 
    result = updateWidgetItem_result()
2576 
    try:
2577 
      self._handler.updateWidgetItem(args.widgetId, args.enable)
2578 
    except WidgetException, scx:
2579 
      result.scx = scx
2580 
    oprot.writeMessageBegin("updateWidgetItem", TMessageType.REPLY, seqid)
2581 
    result.write(oprot)
2582 
    oprot.writeMessageEnd()
2583 
    oprot.trans.flush()
2584 
 
2585 
  def process_getWidget(self, seqid, iprot, oprot):
2586 
    args = getWidget_args()
2587 
    args.read(iprot)
2588 
    iprot.readMessageEnd()
2589 
    result = getWidget_result()
2590 
    try:
2591 
      result.success = self._handler.getWidget(args.type, args.userId, args.onlyEnabled)
2592 
    except WidgetException, scx:
2593 
      result.scx = scx
2594 
    oprot.writeMessageBegin("getWidget", TMessageType.REPLY, seqid)
2595 
    result.write(oprot)
2596 
    oprot.writeMessageEnd()
2597 
    oprot.trans.flush()
2598 
 
2599 
  def process_getMyResearch(self, seqid, iprot, oprot):
2600 
    args = getMyResearch_args()
2601 
    args.read(iprot)
2602 
    iprot.readMessageEnd()
2603 
    result = getMyResearch_result()
2604 
    try:
2605 
      result.success = self._handler.getMyResearch(args.user_id)
2606 
    except WidgetException, scx:
2607 
      result.scx = scx
2608 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
2609 
    result.write(oprot)
2610 
    oprot.writeMessageEnd()
2611 
    oprot.trans.flush()
2612 
 
2613 
  def process_updateMyResearch(self, seqid, iprot, oprot):
2614 
    args = updateMyResearch_args()
2615 
    args.read(iprot)
2616 
    iprot.readMessageEnd()
2617 
    result = updateMyResearch_result()
2618 
    try:
2619 
      result.success = self._handler.updateMyResearch(args.user_id, args.item_id)
2620 
    except WidgetException, scx:
2621 
      result.scx = scx
2622 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
2623 
    result.write(oprot)
2624 
    oprot.writeMessageEnd()
2625 
    oprot.trans.flush()
2626 
 
2627 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
2628 
    args = deleteItemFromMyResearch_args()
2629 
    args.read(iprot)
2630 
    iprot.readMessageEnd()
2631 
    result = deleteItemFromMyResearch_result()
2632 
    try:
2633 
      self._handler.deleteItemFromMyResearch(args.user_id, args.item_id)
2634 
    except WidgetException, scx:
2635 
      result.scx = scx
2636 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
2637 
    result.write(oprot)
2638 
    oprot.writeMessageEnd()
2639 
    oprot.trans.flush()
2640 
 
2641 
  def process_updateRatings(self, seqid, iprot, oprot):
2642 
    args = updateRatings_args()
2643 
    args.read(iprot)
2644 
    iprot.readMessageEnd()
2645 
    result = updateRatings_result()
2646 
    self._handler.updateRatings(args.item_id, args.type, args.rating, args.user_id)
2647 
    oprot.writeMessageBegin("updateRatings", TMessageType.REPLY, seqid)
2648 
    result.write(oprot)
2649 
    oprot.writeMessageEnd()
2650 
    oprot.trans.flush()
2651 
 
2652 
  def process_getRatings(self, seqid, iprot, oprot):
2653 
    args = getRatings_args()
2654 
    args.read(iprot)
2655 
    iprot.readMessageEnd()
2656 
    result = getRatings_result()
2657 
    try:
2658 
      result.success = self._handler.getRatings(args.item_id, args.user_id)
2659 
    except WidgetException, scx:
2660 
      result.scx = scx
2661 
    oprot.writeMessageBegin("getRatings", TMessageType.REPLY, seqid)
2662 
    result.write(oprot)
2663 
    oprot.writeMessageEnd()
2664 
    oprot.trans.flush()
2665 
 
2666 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
2667 
    args = updateBrowseHistory_args()
2668 
    args.read(iprot)
2669 
    iprot.readMessageEnd()
2670 
    result = updateBrowseHistory_result()
2671 
    self._handler.updateBrowseHistory(args.user_id, args.item_id, args.isSessionId)
2672 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2673 
    result.write(oprot)
2674 
    oprot.writeMessageEnd()
2675 
    oprot.trans.flush()
2676 
 
2677 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
2678 
    args = getBrowseHistory_args()
2679 
    args.read(iprot)
2680 
    iprot.readMessageEnd()
2681 
    result = getBrowseHistory_result()
2682 
    try:
2683 
      result.success = self._handler.getBrowseHistory(args.userId, args.isSessionId)
2684 
    except WidgetException, scx:
2685 
      result.scx = scx
2686 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
2687 
    result.write(oprot)
2688 
    oprot.writeMessageEnd()
2689 
    oprot.trans.flush()
2690 
 
2691 
 
94 ashish 2692 
# HELPER FUNCTIONS AND STRUCTURES
2693 
 
559 chandransh 2694 
class createAnonymousUser_args:
94 ashish 2695 
  """
2696 
  Attributes:
559 chandransh 2697 
   - jsessionId
94 ashish 2698 
  """
2699 
 
2700 
  thrift_spec = (
2701 
    None, # 0
559 chandransh 2702 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 2703 
  )
2704 
 
559 chandransh 2705 
  def __init__(self, jsessionId=None,):
2706 
    self.jsessionId = jsessionId
94 ashish 2707 
 
2708 
  def read(self, iprot):
2709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2711 
      return
2712 
    iprot.readStructBegin()
2713 
    while True:
2714 
      (fname, ftype, fid) = iprot.readFieldBegin()
2715 
      if ftype == TType.STOP:
2716 
        break
2717 
      if fid == 1:
559 chandransh 2718 
        if ftype == TType.STRING:
2719 
          self.jsessionId = iprot.readString();
94 ashish 2720 
        else:
2721 
          iprot.skip(ftype)
2722 
      else:
2723 
        iprot.skip(ftype)
2724 
      iprot.readFieldEnd()
2725 
    iprot.readStructEnd()
2726 
 
2727 
  def write(self, oprot):
2728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2730 
      return
559 chandransh 2731 
    oprot.writeStructBegin('createAnonymousUser_args')
2732 
    if self.jsessionId != None:
2733 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
2734 
      oprot.writeString(self.jsessionId)
94 ashish 2735 
      oprot.writeFieldEnd()
2736 
    oprot.writeFieldStop()
2737 
    oprot.writeStructEnd()
2738 
 
2739 
  def __repr__(self):
2740 
    L = ['%s=%r' % (key, value)
2741 
      for key, value in self.__dict__.iteritems()]
2742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2743 
 
2744 
  def __eq__(self, other):
2745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2746 
 
2747 
  def __ne__(self, other):
2748 
    return not (self == other)
2749 
 
559 chandransh 2750 
class createAnonymousUser_result:
94 ashish 2751 
  """
2752 
  Attributes:
2753 
   - success
559 chandransh 2754 
   - ucex
94 ashish 2755 
  """
2756 
 
2757 
  thrift_spec = (
559 chandransh 2758 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2759 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2760 
  )
2761 
 
559 chandransh 2762 
  def __init__(self, success=None, ucex=None,):
94 ashish 2763 
    self.success = success
559 chandransh 2764 
    self.ucex = ucex
94 ashish 2765 
 
2766 
  def read(self, iprot):
2767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2769 
      return
2770 
    iprot.readStructBegin()
2771 
    while True:
2772 
      (fname, ftype, fid) = iprot.readFieldBegin()
2773 
      if ftype == TType.STOP:
2774 
        break
2775 
      if fid == 0:
2776 
        if ftype == TType.STRUCT:
559 chandransh 2777 
          self.success = User()
94 ashish 2778 
          self.success.read(iprot)
2779 
        else:
2780 
          iprot.skip(ftype)
2781 
      elif fid == 1:
2782 
        if ftype == TType.STRUCT:
559 chandransh 2783 
          self.ucex = UserContextException()
2784 
          self.ucex.read(iprot)
94 ashish 2785 
        else:
2786 
          iprot.skip(ftype)
2787 
      else:
2788 
        iprot.skip(ftype)
2789 
      iprot.readFieldEnd()
2790 
    iprot.readStructEnd()
2791 
 
2792 
  def write(self, oprot):
2793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2795 
      return
559 chandransh 2796 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 2797 
    if self.success != None:
2798 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2799 
      self.success.write(oprot)
2800 
      oprot.writeFieldEnd()
559 chandransh 2801 
    if self.ucex != None:
2802 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2803 
      self.ucex.write(oprot)
94 ashish 2804 
      oprot.writeFieldEnd()
2805 
    oprot.writeFieldStop()
2806 
    oprot.writeStructEnd()
2807 
 
2808 
  def __repr__(self):
2809 
    L = ['%s=%r' % (key, value)
2810 
      for key, value in self.__dict__.iteritems()]
2811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2812 
 
2813 
  def __eq__(self, other):
2814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2815 
 
2816 
  def __ne__(self, other):
2817 
    return not (self == other)
2818 
 
559 chandransh 2819 
class getUserById_args:
94 ashish 2820 
  """
2821 
  Attributes:
2822 
   - userId
2823 
  """
2824 
 
2825 
  thrift_spec = (
2826 
    None, # 0
2827 
    (1, TType.I64, 'userId', None, None, ), # 1
2828 
  )
2829 
 
559 chandransh 2830 
  def __init__(self, userId=None,):
94 ashish 2831 
    self.userId = userId
2832 
 
2833 
  def read(self, iprot):
2834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2836 
      return
2837 
    iprot.readStructBegin()
2838 
    while True:
2839 
      (fname, ftype, fid) = iprot.readFieldBegin()
2840 
      if ftype == TType.STOP:
2841 
        break
2842 
      if fid == 1:
2843 
        if ftype == TType.I64:
2844 
          self.userId = iprot.readI64();
2845 
        else:
2846 
          iprot.skip(ftype)
2847 
      else:
2848 
        iprot.skip(ftype)
2849 
      iprot.readFieldEnd()
2850 
    iprot.readStructEnd()
2851 
 
2852 
  def write(self, oprot):
2853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2855 
      return
559 chandransh 2856 
    oprot.writeStructBegin('getUserById_args')
94 ashish 2857 
    if self.userId != None:
2858 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2859 
      oprot.writeI64(self.userId)
2860 
      oprot.writeFieldEnd()
2861 
    oprot.writeFieldStop()
2862 
    oprot.writeStructEnd()
2863 
 
2864 
  def __repr__(self):
2865 
    L = ['%s=%r' % (key, value)
2866 
      for key, value in self.__dict__.iteritems()]
2867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2868 
 
2869 
  def __eq__(self, other):
2870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2871 
 
2872 
  def __ne__(self, other):
2873 
    return not (self == other)
2874 
 
559 chandransh 2875 
class getUserById_result:
94 ashish 2876 
  """
2877 
  Attributes:
2878 
   - success
559 chandransh 2879 
   - ucex
94 ashish 2880 
  """
2881 
 
2882 
  thrift_spec = (
559 chandransh 2883 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2884 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2885 
  )
2886 
 
559 chandransh 2887 
  def __init__(self, success=None, ucex=None,):
94 ashish 2888 
    self.success = success
559 chandransh 2889 
    self.ucex = ucex
94 ashish 2890 
 
2891 
  def read(self, iprot):
2892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2894 
      return
2895 
    iprot.readStructBegin()
2896 
    while True:
2897 
      (fname, ftype, fid) = iprot.readFieldBegin()
2898 
      if ftype == TType.STOP:
2899 
        break
2900 
      if fid == 0:
2901 
        if ftype == TType.STRUCT:
559 chandransh 2902 
          self.success = User()
94 ashish 2903 
          self.success.read(iprot)
2904 
        else:
2905 
          iprot.skip(ftype)
2906 
      elif fid == 1:
2907 
        if ftype == TType.STRUCT:
559 chandransh 2908 
          self.ucex = UserContextException()
2909 
          self.ucex.read(iprot)
94 ashish 2910 
        else:
2911 
          iprot.skip(ftype)
2912 
      else:
2913 
        iprot.skip(ftype)
2914 
      iprot.readFieldEnd()
2915 
    iprot.readStructEnd()
2916 
 
2917 
  def write(self, oprot):
2918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2920 
      return
559 chandransh 2921 
    oprot.writeStructBegin('getUserById_result')
94 ashish 2922 
    if self.success != None:
2923 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2924 
      self.success.write(oprot)
2925 
      oprot.writeFieldEnd()
559 chandransh 2926 
    if self.ucex != None:
2927 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2928 
      self.ucex.write(oprot)
94 ashish 2929 
      oprot.writeFieldEnd()
2930 
    oprot.writeFieldStop()
2931 
    oprot.writeStructEnd()
2932 
 
2933 
  def __repr__(self):
2934 
    L = ['%s=%r' % (key, value)
2935 
      for key, value in self.__dict__.iteritems()]
2936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2937 
 
2938 
  def __eq__(self, other):
2939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2940 
 
2941 
  def __ne__(self, other):
2942 
    return not (self == other)
2943 
 
559 chandransh 2944 
class createUser_args:
94 ashish 2945 
  """
2946 
  Attributes:
559 chandransh 2947 
   - user
94 ashish 2948 
  """
2949 
 
2950 
  thrift_spec = (
2951 
    None, # 0
559 chandransh 2952 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 2953 
  )
2954 
 
559 chandransh 2955 
  def __init__(self, user=None,):
2956 
    self.user = user
94 ashish 2957 
 
2958 
  def read(self, iprot):
2959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2961 
      return
2962 
    iprot.readStructBegin()
2963 
    while True:
2964 
      (fname, ftype, fid) = iprot.readFieldBegin()
2965 
      if ftype == TType.STOP:
2966 
        break
2967 
      if fid == 1:
559 chandransh 2968 
        if ftype == TType.STRUCT:
2969 
          self.user = User()
2970 
          self.user.read(iprot)
94 ashish 2971 
        else:
2972 
          iprot.skip(ftype)
2973 
      else:
2974 
        iprot.skip(ftype)
2975 
      iprot.readFieldEnd()
2976 
    iprot.readStructEnd()
2977 
 
2978 
  def write(self, oprot):
2979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2981 
      return
559 chandransh 2982 
    oprot.writeStructBegin('createUser_args')
2983 
    if self.user != None:
2984 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
2985 
      self.user.write(oprot)
94 ashish 2986 
      oprot.writeFieldEnd()
2987 
    oprot.writeFieldStop()
2988 
    oprot.writeStructEnd()
2989 
 
2990 
  def __repr__(self):
2991 
    L = ['%s=%r' % (key, value)
2992 
      for key, value in self.__dict__.iteritems()]
2993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2994 
 
2995 
  def __eq__(self, other):
2996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2997 
 
2998 
  def __ne__(self, other):
2999 
    return not (self == other)
3000 
 
559 chandransh 3001 
class createUser_result:
94 ashish 3002 
  """
3003 
  Attributes:
3004 
   - success
559 chandransh 3005 
   - ucex
94 ashish 3006 
  """
3007 
 
3008 
  thrift_spec = (
559 chandransh 3009 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3010 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3011 
  )
3012 
 
559 chandransh 3013 
  def __init__(self, success=None, ucex=None,):
94 ashish 3014 
    self.success = success
559 chandransh 3015 
    self.ucex = ucex
94 ashish 3016 
 
3017 
  def read(self, iprot):
3018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3020 
      return
3021 
    iprot.readStructBegin()
3022 
    while True:
3023 
      (fname, ftype, fid) = iprot.readFieldBegin()
3024 
      if ftype == TType.STOP:
3025 
        break
3026 
      if fid == 0:
3027 
        if ftype == TType.STRUCT:
559 chandransh 3028 
          self.success = User()
94 ashish 3029 
          self.success.read(iprot)
3030 
        else:
3031 
          iprot.skip(ftype)
3032 
      elif fid == 1:
3033 
        if ftype == TType.STRUCT:
559 chandransh 3034 
          self.ucex = UserContextException()
3035 
          self.ucex.read(iprot)
94 ashish 3036 
        else:
3037 
          iprot.skip(ftype)
3038 
      else:
3039 
        iprot.skip(ftype)
3040 
      iprot.readFieldEnd()
3041 
    iprot.readStructEnd()
3042 
 
3043 
  def write(self, oprot):
3044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3046 
      return
559 chandransh 3047 
    oprot.writeStructBegin('createUser_result')
94 ashish 3048 
    if self.success != None:
3049 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3050 
      self.success.write(oprot)
3051 
      oprot.writeFieldEnd()
559 chandransh 3052 
    if self.ucex != None:
3053 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3054 
      self.ucex.write(oprot)
94 ashish 3055 
      oprot.writeFieldEnd()
3056 
    oprot.writeFieldStop()
3057 
    oprot.writeStructEnd()
3058 
 
3059 
  def __repr__(self):
3060 
    L = ['%s=%r' % (key, value)
3061 
      for key, value in self.__dict__.iteritems()]
3062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3063 
 
3064 
  def __eq__(self, other):
3065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3066 
 
3067 
  def __ne__(self, other):
3068 
    return not (self == other)
3069 
 
559 chandransh 3070 
class updateUser_args:
94 ashish 3071 
  """
3072 
  Attributes:
559 chandransh 3073 
   - user
94 ashish 3074 
  """
3075 
 
3076 
  thrift_spec = (
3077 
    None, # 0
559 chandransh 3078 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 3079 
  )
3080 
 
559 chandransh 3081 
  def __init__(self, user=None,):
3082 
    self.user = user
94 ashish 3083 
 
3084 
  def read(self, iprot):
3085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3087 
      return
3088 
    iprot.readStructBegin()
3089 
    while True:
3090 
      (fname, ftype, fid) = iprot.readFieldBegin()
3091 
      if ftype == TType.STOP:
3092 
        break
3093 
      if fid == 1:
559 chandransh 3094 
        if ftype == TType.STRUCT:
3095 
          self.user = User()
3096 
          self.user.read(iprot)
94 ashish 3097 
        else:
3098 
          iprot.skip(ftype)
3099 
      else:
3100 
        iprot.skip(ftype)
3101 
      iprot.readFieldEnd()
3102 
    iprot.readStructEnd()
3103 
 
3104 
  def write(self, oprot):
3105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3107 
      return
559 chandransh 3108 
    oprot.writeStructBegin('updateUser_args')
3109 
    if self.user != None:
3110 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
3111 
      self.user.write(oprot)
94 ashish 3112 
      oprot.writeFieldEnd()
3113 
    oprot.writeFieldStop()
3114 
    oprot.writeStructEnd()
3115 
 
3116 
  def __repr__(self):
3117 
    L = ['%s=%r' % (key, value)
3118 
      for key, value in self.__dict__.iteritems()]
3119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3120 
 
3121 
  def __eq__(self, other):
3122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3123 
 
3124 
  def __ne__(self, other):
3125 
    return not (self == other)
3126 
 
559 chandransh 3127 
class updateUser_result:
94 ashish 3128 
  """
3129 
  Attributes:
3130 
   - success
559 chandransh 3131 
   - ucex
94 ashish 3132 
  """
3133 
 
3134 
  thrift_spec = (
559 chandransh 3135 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3136 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3137 
  )
3138 
 
559 chandransh 3139 
  def __init__(self, success=None, ucex=None,):
94 ashish 3140 
    self.success = success
559 chandransh 3141 
    self.ucex = ucex
94 ashish 3142 
 
3143 
  def read(self, iprot):
3144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3146 
      return
3147 
    iprot.readStructBegin()
3148 
    while True:
3149 
      (fname, ftype, fid) = iprot.readFieldBegin()
3150 
      if ftype == TType.STOP:
3151 
        break
3152 
      if fid == 0:
3153 
        if ftype == TType.STRUCT:
559 chandransh 3154 
          self.success = User()
94 ashish 3155 
          self.success.read(iprot)
3156 
        else:
3157 
          iprot.skip(ftype)
3158 
      elif fid == 1:
3159 
        if ftype == TType.STRUCT:
559 chandransh 3160 
          self.ucex = UserContextException()
3161 
          self.ucex.read(iprot)
94 ashish 3162 
        else:
3163 
          iprot.skip(ftype)
3164 
      else:
3165 
        iprot.skip(ftype)
3166 
      iprot.readFieldEnd()
3167 
    iprot.readStructEnd()
3168 
 
3169 
  def write(self, oprot):
3170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3172 
      return
559 chandransh 3173 
    oprot.writeStructBegin('updateUser_result')
94 ashish 3174 
    if self.success != None:
3175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3176 
      self.success.write(oprot)
3177 
      oprot.writeFieldEnd()
559 chandransh 3178 
    if self.ucex != None:
3179 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3180 
      self.ucex.write(oprot)
94 ashish 3181 
      oprot.writeFieldEnd()
3182 
    oprot.writeFieldStop()
3183 
    oprot.writeStructEnd()
3184 
 
3185 
  def __repr__(self):
3186 
    L = ['%s=%r' % (key, value)
3187 
      for key, value in self.__dict__.iteritems()]
3188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3189 
 
3190 
  def __eq__(self, other):
3191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3192 
 
3193 
  def __ne__(self, other):
3194 
    return not (self == other)
3195 
 
559 chandransh 3196 
class deleteUser_args:
94 ashish 3197 
  """
3198 
  Attributes:
3199 
   - userId
3200 
  """
3201 
 
3202 
  thrift_spec = (
3203 
    None, # 0
3204 
    (1, TType.I64, 'userId', None, None, ), # 1
3205 
  )
3206 
 
559 chandransh 3207 
  def __init__(self, userId=None,):
94 ashish 3208 
    self.userId = userId
3209 
 
3210 
  def read(self, iprot):
3211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3213 
      return
3214 
    iprot.readStructBegin()
3215 
    while True:
3216 
      (fname, ftype, fid) = iprot.readFieldBegin()
3217 
      if ftype == TType.STOP:
3218 
        break
3219 
      if fid == 1:
3220 
        if ftype == TType.I64:
3221 
          self.userId = iprot.readI64();
3222 
        else:
3223 
          iprot.skip(ftype)
3224 
      else:
3225 
        iprot.skip(ftype)
3226 
      iprot.readFieldEnd()
3227 
    iprot.readStructEnd()
3228 
 
3229 
  def write(self, oprot):
3230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3232 
      return
559 chandransh 3233 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 3234 
    if self.userId != None:
3235 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3236 
      oprot.writeI64(self.userId)
3237 
      oprot.writeFieldEnd()
3238 
    oprot.writeFieldStop()
3239 
    oprot.writeStructEnd()
3240 
 
3241 
  def __repr__(self):
3242 
    L = ['%s=%r' % (key, value)
3243 
      for key, value in self.__dict__.iteritems()]
3244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3245 
 
3246 
  def __eq__(self, other):
3247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3248 
 
3249 
  def __ne__(self, other):
3250 
    return not (self == other)
3251 
 
559 chandransh 3252 
class deleteUser_result:
94 ashish 3253 
  """
3254 
  Attributes:
3255 
   - success
559 chandransh 3256 
   - ucex
94 ashish 3257 
  """
3258 
 
3259 
  thrift_spec = (
559 chandransh 3260 
    (0, TType.BOOL, 'success', None, None, ), # 0
3261 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3262 
  )
3263 
 
559 chandransh 3264 
  def __init__(self, success=None, ucex=None,):
94 ashish 3265 
    self.success = success
559 chandransh 3266 
    self.ucex = ucex
94 ashish 3267 
 
3268 
  def read(self, iprot):
3269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3271 
      return
3272 
    iprot.readStructBegin()
3273 
    while True:
3274 
      (fname, ftype, fid) = iprot.readFieldBegin()
3275 
      if ftype == TType.STOP:
3276 
        break
3277 
      if fid == 0:
559 chandransh 3278 
        if ftype == TType.BOOL:
3279 
          self.success = iprot.readBool();
94 ashish 3280 
        else:
3281 
          iprot.skip(ftype)
3282 
      elif fid == 1:
3283 
        if ftype == TType.STRUCT:
559 chandransh 3284 
          self.ucex = UserContextException()
3285 
          self.ucex.read(iprot)
94 ashish 3286 
        else:
3287 
          iprot.skip(ftype)
3288 
      else:
3289 
        iprot.skip(ftype)
3290 
      iprot.readFieldEnd()
3291 
    iprot.readStructEnd()
3292 
 
3293 
  def write(self, oprot):
3294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3296 
      return
559 chandransh 3297 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 3298 
    if self.success != None:
559 chandransh 3299 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3300 
      oprot.writeBool(self.success)
94 ashish 3301 
      oprot.writeFieldEnd()
559 chandransh 3302 
    if self.ucex != None:
3303 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3304 
      self.ucex.write(oprot)
94 ashish 3305 
      oprot.writeFieldEnd()
3306 
    oprot.writeFieldStop()
3307 
    oprot.writeStructEnd()
3308 
 
3309 
  def __repr__(self):
3310 
    L = ['%s=%r' % (key, value)
3311 
      for key, value in self.__dict__.iteritems()]
3312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3313 
 
3314 
  def __eq__(self, other):
3315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3316 
 
3317 
  def __ne__(self, other):
3318 
    return not (self == other)
3319 
 
559 chandransh 3320 
class getUserState_args:
94 ashish 3321 
  """
3322 
  Attributes:
3323 
   - userId
3324 
  """
3325 
 
3326 
  thrift_spec = (
3327 
    None, # 0
3328 
    (1, TType.I64, 'userId', None, None, ), # 1
3329 
  )
3330 
 
559 chandransh 3331 
  def __init__(self, userId=None,):
94 ashish 3332 
    self.userId = userId
3333 
 
3334 
  def read(self, iprot):
3335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3337 
      return
3338 
    iprot.readStructBegin()
3339 
    while True:
3340 
      (fname, ftype, fid) = iprot.readFieldBegin()
3341 
      if ftype == TType.STOP:
3342 
        break
3343 
      if fid == 1:
3344 
        if ftype == TType.I64:
3345 
          self.userId = iprot.readI64();
3346 
        else:
3347 
          iprot.skip(ftype)
3348 
      else:
3349 
        iprot.skip(ftype)
3350 
      iprot.readFieldEnd()
3351 
    iprot.readStructEnd()
3352 
 
3353 
  def write(self, oprot):
3354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3356 
      return
559 chandransh 3357 
    oprot.writeStructBegin('getUserState_args')
94 ashish 3358 
    if self.userId != None:
3359 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3360 
      oprot.writeI64(self.userId)
3361 
      oprot.writeFieldEnd()
3362 
    oprot.writeFieldStop()
3363 
    oprot.writeStructEnd()
3364 
 
3365 
  def __repr__(self):
3366 
    L = ['%s=%r' % (key, value)
3367 
      for key, value in self.__dict__.iteritems()]
3368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3369 
 
3370 
  def __eq__(self, other):
3371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3372 
 
3373 
  def __ne__(self, other):
3374 
    return not (self == other)
3375 
 
559 chandransh 3376 
class getUserState_result:
94 ashish 3377 
  """
3378 
  Attributes:
3379 
   - success
559 chandransh 3380 
   - ucex
94 ashish 3381 
  """
3382 
 
3383 
  thrift_spec = (
559 chandransh 3384 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
3385 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3386 
  )
3387 
 
559 chandransh 3388 
  def __init__(self, success=None, ucex=None,):
94 ashish 3389 
    self.success = success
559 chandransh 3390 
    self.ucex = ucex
94 ashish 3391 
 
3392 
  def read(self, iprot):
3393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3395 
      return
3396 
    iprot.readStructBegin()
3397 
    while True:
3398 
      (fname, ftype, fid) = iprot.readFieldBegin()
3399 
      if ftype == TType.STOP:
3400 
        break
3401 
      if fid == 0:
3402 
        if ftype == TType.STRUCT:
559 chandransh 3403 
          self.success = UserState()
94 ashish 3404 
          self.success.read(iprot)
3405 
        else:
3406 
          iprot.skip(ftype)
3407 
      elif fid == 1:
3408 
        if ftype == TType.STRUCT:
559 chandransh 3409 
          self.ucex = UserContextException()
3410 
          self.ucex.read(iprot)
94 ashish 3411 
        else:
3412 
          iprot.skip(ftype)
3413 
      else:
3414 
        iprot.skip(ftype)
3415 
      iprot.readFieldEnd()
3416 
    iprot.readStructEnd()
3417 
 
3418 
  def write(self, oprot):
3419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3421 
      return
559 chandransh 3422 
    oprot.writeStructBegin('getUserState_result')
94 ashish 3423 
    if self.success != None:
3424 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3425 
      self.success.write(oprot)
3426 
      oprot.writeFieldEnd()
559 chandransh 3427 
    if self.ucex != None:
3428 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3429 
      self.ucex.write(oprot)
94 ashish 3430 
      oprot.writeFieldEnd()
3431 
    oprot.writeFieldStop()
3432 
    oprot.writeStructEnd()
3433 
 
3434 
  def __repr__(self):
3435 
    L = ['%s=%r' % (key, value)
3436 
      for key, value in self.__dict__.iteritems()]
3437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3438 
 
3439 
  def __eq__(self, other):
3440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3441 
 
3442 
  def __ne__(self, other):
3443 
    return not (self == other)
3444 
 
559 chandransh 3445 
class authenticateUser_args:
94 ashish 3446 
  """
3447 
  Attributes:
3448 
   - email
3449 
   - password
3450 
  """
3451 
 
3452 
  thrift_spec = (
3453 
    None, # 0
3454 
    (1, TType.STRING, 'email', None, None, ), # 1
3455 
    (2, TType.STRING, 'password', None, None, ), # 2
3456 
  )
3457 
 
3458 
  def __init__(self, email=None, password=None,):
3459 
    self.email = email
3460 
    self.password = password
3461 
 
3462 
  def read(self, iprot):
3463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3465 
      return
3466 
    iprot.readStructBegin()
3467 
    while True:
3468 
      (fname, ftype, fid) = iprot.readFieldBegin()
3469 
      if ftype == TType.STOP:
3470 
        break
3471 
      if fid == 1:
3472 
        if ftype == TType.STRING:
3473 
          self.email = iprot.readString();
3474 
        else:
3475 
          iprot.skip(ftype)
3476 
      elif fid == 2:
3477 
        if ftype == TType.STRING:
3478 
          self.password = iprot.readString();
3479 
        else:
3480 
          iprot.skip(ftype)
3481 
      else:
3482 
        iprot.skip(ftype)
3483 
      iprot.readFieldEnd()
3484 
    iprot.readStructEnd()
3485 
 
3486 
  def write(self, oprot):
3487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3489 
      return
559 chandransh 3490 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 3491 
    if self.email != None:
3492 
      oprot.writeFieldBegin('email', TType.STRING, 1)
3493 
      oprot.writeString(self.email)
3494 
      oprot.writeFieldEnd()
3495 
    if self.password != None:
3496 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3497 
      oprot.writeString(self.password)
3498 
      oprot.writeFieldEnd()
3499 
    oprot.writeFieldStop()
3500 
    oprot.writeStructEnd()
3501 
 
3502 
  def __repr__(self):
3503 
    L = ['%s=%r' % (key, value)
3504 
      for key, value in self.__dict__.iteritems()]
3505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3506 
 
3507 
  def __eq__(self, other):
3508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3509 
 
3510 
  def __ne__(self, other):
3511 
    return not (self == other)
3512 
 
559 chandransh 3513 
class authenticateUser_result:
94 ashish 3514 
  """
3515 
  Attributes:
3516 
   - success
559 chandransh 3517 
   - auex
94 ashish 3518 
  """
3519 
 
3520 
  thrift_spec = (
559 chandransh 3521 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3522 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 3523 
  )
3524 
 
559 chandransh 3525 
  def __init__(self, success=None, auex=None,):
94 ashish 3526 
    self.success = success
559 chandransh 3527 
    self.auex = auex
94 ashish 3528 
 
3529 
  def read(self, iprot):
3530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3532 
      return
3533 
    iprot.readStructBegin()
3534 
    while True:
3535 
      (fname, ftype, fid) = iprot.readFieldBegin()
3536 
      if ftype == TType.STOP:
3537 
        break
3538 
      if fid == 0:
3539 
        if ftype == TType.STRUCT:
559 chandransh 3540 
          self.success = User()
94 ashish 3541 
          self.success.read(iprot)
3542 
        else:
3543 
          iprot.skip(ftype)
3544 
      elif fid == 1:
3545 
        if ftype == TType.STRUCT:
559 chandransh 3546 
          self.auex = AuthenticationException()
3547 
          self.auex.read(iprot)
94 ashish 3548 
        else:
3549 
          iprot.skip(ftype)
3550 
      else:
3551 
        iprot.skip(ftype)
3552 
      iprot.readFieldEnd()
3553 
    iprot.readStructEnd()
3554 
 
3555 
  def write(self, oprot):
3556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3558 
      return
559 chandransh 3559 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 3560 
    if self.success != None:
3561 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3562 
      self.success.write(oprot)
3563 
      oprot.writeFieldEnd()
559 chandransh 3564 
    if self.auex != None:
3565 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
3566 
      self.auex.write(oprot)
94 ashish 3567 
      oprot.writeFieldEnd()
3568 
    oprot.writeFieldStop()
3569 
    oprot.writeStructEnd()
3570 
 
3571 
  def __repr__(self):
3572 
    L = ['%s=%r' % (key, value)
3573 
      for key, value in self.__dict__.iteritems()]
3574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3575 
 
3576 
  def __eq__(self, other):
3577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3578 
 
3579 
  def __ne__(self, other):
3580 
    return not (self == other)
3581 
 
559 chandransh 3582 
class userExists_args:
122 ashish 3583 
  """
3584 
  Attributes:
559 chandransh 3585 
   - email
122 ashish 3586 
  """
3587 
 
3588 
  thrift_spec = (
3589 
    None, # 0
559 chandransh 3590 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 3591 
  )
3592 
 
559 chandransh 3593 
  def __init__(self, email=None,):
3594 
    self.email = email
122 ashish 3595 
 
3596 
  def read(self, iprot):
3597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3599 
      return
3600 
    iprot.readStructBegin()
3601 
    while True:
3602 
      (fname, ftype, fid) = iprot.readFieldBegin()
3603 
      if ftype == TType.STOP:
3604 
        break
3605 
      if fid == 1:
3606 
        if ftype == TType.STRING:
559 chandransh 3607 
          self.email = iprot.readString();
122 ashish 3608 
        else:
3609 
          iprot.skip(ftype)
559 chandransh 3610 
      else:
3611 
        iprot.skip(ftype)
3612 
      iprot.readFieldEnd()
3613 
    iprot.readStructEnd()
3614 
 
3615 
  def write(self, oprot):
3616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3618 
      return
3619 
    oprot.writeStructBegin('userExists_args')
3620 
    if self.email != None:
3621 
      oprot.writeFieldBegin('email', TType.STRING, 1)
3622 
      oprot.writeString(self.email)
3623 
      oprot.writeFieldEnd()
3624 
    oprot.writeFieldStop()
3625 
    oprot.writeStructEnd()
3626 
 
3627 
  def __repr__(self):
3628 
    L = ['%s=%r' % (key, value)
3629 
      for key, value in self.__dict__.iteritems()]
3630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3631 
 
3632 
  def __eq__(self, other):
3633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3634 
 
3635 
  def __ne__(self, other):
3636 
    return not (self == other)
3637 
 
3638 
class userExists_result:
3639 
  """
3640 
  Attributes:
3641 
   - success
3642 
   - ucx
3643 
  """
3644 
 
3645 
  thrift_spec = (
3646 
    (0, TType.BOOL, 'success', None, None, ), # 0
3647 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3648 
  )
3649 
 
3650 
  def __init__(self, success=None, ucx=None,):
3651 
    self.success = success
3652 
    self.ucx = ucx
3653 
 
3654 
  def read(self, iprot):
3655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3657 
      return
3658 
    iprot.readStructBegin()
3659 
    while True:
3660 
      (fname, ftype, fid) = iprot.readFieldBegin()
3661 
      if ftype == TType.STOP:
3662 
        break
3663 
      if fid == 0:
3664 
        if ftype == TType.BOOL:
3665 
          self.success = iprot.readBool();
3666 
        else:
3667 
          iprot.skip(ftype)
3668 
      elif fid == 1:
3669 
        if ftype == TType.STRUCT:
3670 
          self.ucx = UserContextException()
3671 
          self.ucx.read(iprot)
3672 
        else:
3673 
          iprot.skip(ftype)
3674 
      else:
3675 
        iprot.skip(ftype)
3676 
      iprot.readFieldEnd()
3677 
    iprot.readStructEnd()
3678 
 
3679 
  def write(self, oprot):
3680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3682 
      return
3683 
    oprot.writeStructBegin('userExists_result')
3684 
    if self.success != None:
3685 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3686 
      oprot.writeBool(self.success)
3687 
      oprot.writeFieldEnd()
3688 
    if self.ucx != None:
3689 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3690 
      self.ucx.write(oprot)
3691 
      oprot.writeFieldEnd()
3692 
    oprot.writeFieldStop()
3693 
    oprot.writeStructEnd()
3694 
 
3695 
  def __repr__(self):
3696 
    L = ['%s=%r' % (key, value)
3697 
      for key, value in self.__dict__.iteritems()]
3698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3699 
 
3700 
  def __eq__(self, other):
3701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3702 
 
3703 
  def __ne__(self, other):
3704 
    return not (self == other)
3705 
 
3706 
class addAddressForUser_args:
3707 
  """
3708 
  Attributes:
3709 
   - userId
3710 
   - address
3711 
   - setDefault
3712 
  """
3713 
 
3714 
  thrift_spec = (
3715 
    None, # 0
3716 
    (1, TType.I64, 'userId', None, None, ), # 1
3717 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 3718 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 3719 
  )
3720 
 
567 rajveer 3721 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 3722 
    self.userId = userId
3723 
    self.address = address
3724 
    self.setDefault = setDefault
3725 
 
3726 
  def read(self, iprot):
3727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3729 
      return
3730 
    iprot.readStructBegin()
3731 
    while True:
3732 
      (fname, ftype, fid) = iprot.readFieldBegin()
3733 
      if ftype == TType.STOP:
3734 
        break
3735 
      if fid == 1:
3736 
        if ftype == TType.I64:
3737 
          self.userId = iprot.readI64();
3738 
        else:
3739 
          iprot.skip(ftype)
122 ashish 3740 
      elif fid == 2:
559 chandransh 3741 
        if ftype == TType.STRUCT:
3742 
          self.address = Address()
3743 
          self.address.read(iprot)
122 ashish 3744 
        else:
3745 
          iprot.skip(ftype)
3746 
      elif fid == 3:
3747 
        if ftype == TType.BOOL:
559 chandransh 3748 
          self.setDefault = iprot.readBool();
122 ashish 3749 
        else:
3750 
          iprot.skip(ftype)
3751 
      else:
3752 
        iprot.skip(ftype)
3753 
      iprot.readFieldEnd()
3754 
    iprot.readStructEnd()
3755 
 
3756 
  def write(self, oprot):
3757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3759 
      return
559 chandransh 3760 
    oprot.writeStructBegin('addAddressForUser_args')
3761 
    if self.userId != None:
3762 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3763 
      oprot.writeI64(self.userId)
122 ashish 3764 
      oprot.writeFieldEnd()
559 chandransh 3765 
    if self.address != None:
3766 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
3767 
      self.address.write(oprot)
122 ashish 3768 
      oprot.writeFieldEnd()
559 chandransh 3769 
    if self.setDefault != None:
567 rajveer 3770 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 3771 
      oprot.writeBool(self.setDefault)
3772 
      oprot.writeFieldEnd()
122 ashish 3773 
    oprot.writeFieldStop()
3774 
    oprot.writeStructEnd()
3775 
 
3776 
  def __repr__(self):
3777 
    L = ['%s=%r' % (key, value)
3778 
      for key, value in self.__dict__.iteritems()]
3779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3780 
 
3781 
  def __eq__(self, other):
3782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3783 
 
3784 
  def __ne__(self, other):
3785 
    return not (self == other)
3786 
 
559 chandransh 3787 
class addAddressForUser_result:
122 ashish 3788 
  """
3789 
  Attributes:
3790 
   - success
559 chandransh 3791 
   - ucx
122 ashish 3792 
  """
3793 
 
3794 
  thrift_spec = (
567 rajveer 3795 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 3796 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 3797 
  )
3798 
 
559 chandransh 3799 
  def __init__(self, success=None, ucx=None,):
122 ashish 3800 
    self.success = success
559 chandransh 3801 
    self.ucx = ucx
122 ashish 3802 
 
3803 
  def read(self, iprot):
3804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3806 
      return
3807 
    iprot.readStructBegin()
3808 
    while True:
3809 
      (fname, ftype, fid) = iprot.readFieldBegin()
3810 
      if ftype == TType.STOP:
3811 
        break
3812 
      if fid == 0:
567 rajveer 3813 
        if ftype == TType.I64:
3814 
          self.success = iprot.readI64();
122 ashish 3815 
        else:
3816 
          iprot.skip(ftype)
3817 
      elif fid == 1:
3818 
        if ftype == TType.STRUCT:
559 chandransh 3819 
          self.ucx = UserContextException()
3820 
          self.ucx.read(iprot)
122 ashish 3821 
        else:
3822 
          iprot.skip(ftype)
3823 
      else:
3824 
        iprot.skip(ftype)
3825 
      iprot.readFieldEnd()
3826 
    iprot.readStructEnd()
3827 
 
3828 
  def write(self, oprot):
3829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3831 
      return
559 chandransh 3832 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 3833 
    if self.success != None:
567 rajveer 3834 
      oprot.writeFieldBegin('success', TType.I64, 0)
3835 
      oprot.writeI64(self.success)
122 ashish 3836 
      oprot.writeFieldEnd()
559 chandransh 3837 
    if self.ucx != None:
3838 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3839 
      self.ucx.write(oprot)
122 ashish 3840 
      oprot.writeFieldEnd()
3841 
    oprot.writeFieldStop()
3842 
    oprot.writeStructEnd()
3843 
 
3844 
  def __repr__(self):
3845 
    L = ['%s=%r' % (key, value)
3846 
      for key, value in self.__dict__.iteritems()]
3847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3848 
 
3849 
  def __eq__(self, other):
3850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3851 
 
3852 
  def __ne__(self, other):
3853 
    return not (self == other)
3854 
 
559 chandransh 3855 
class removeAddressForUser_args:
94 ashish 3856 
  """
3857 
  Attributes:
559 chandransh 3858 
   - userid
3859 
   - addressId
94 ashish 3860 
  """
3861 
 
3862 
  thrift_spec = (
3863 
    None, # 0
559 chandransh 3864 
    (1, TType.I64, 'userid', None, None, ), # 1
3865 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 3866 
  )
3867 
 
559 chandransh 3868 
  def __init__(self, userid=None, addressId=None,):
3869 
    self.userid = userid
3870 
    self.addressId = addressId
94 ashish 3871 
 
3872 
  def read(self, iprot):
3873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3875 
      return
3876 
    iprot.readStructBegin()
3877 
    while True:
3878 
      (fname, ftype, fid) = iprot.readFieldBegin()
3879 
      if ftype == TType.STOP:
3880 
        break
3881 
      if fid == 1:
559 chandransh 3882 
        if ftype == TType.I64:
3883 
          self.userid = iprot.readI64();
94 ashish 3884 
        else:
3885 
          iprot.skip(ftype)
559 chandransh 3886 
      elif fid == 2:
3887 
        if ftype == TType.I64:
3888 
          self.addressId = iprot.readI64();
3889 
        else:
3890 
          iprot.skip(ftype)
94 ashish 3891 
      else:
3892 
        iprot.skip(ftype)
3893 
      iprot.readFieldEnd()
3894 
    iprot.readStructEnd()
3895 
 
3896 
  def write(self, oprot):
3897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3899 
      return
559 chandransh 3900 
    oprot.writeStructBegin('removeAddressForUser_args')
3901 
    if self.userid != None:
3902 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3903 
      oprot.writeI64(self.userid)
94 ashish 3904 
      oprot.writeFieldEnd()
559 chandransh 3905 
    if self.addressId != None:
3906 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3907 
      oprot.writeI64(self.addressId)
3908 
      oprot.writeFieldEnd()
94 ashish 3909 
    oprot.writeFieldStop()
3910 
    oprot.writeStructEnd()
3911 
 
3912 
  def __repr__(self):
3913 
    L = ['%s=%r' % (key, value)
3914 
      for key, value in self.__dict__.iteritems()]
3915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3916 
 
3917 
  def __eq__(self, other):
3918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3919 
 
3920 
  def __ne__(self, other):
3921 
    return not (self == other)
3922 
 
559 chandransh 3923 
class removeAddressForUser_result:
94 ashish 3924 
  """
3925 
  Attributes:
3926 
   - success
3927 
   - ucx
3928 
  """
3929 
 
3930 
  thrift_spec = (
3931 
    (0, TType.BOOL, 'success', None, None, ), # 0
3932 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3933 
  )
3934 
 
3935 
  def __init__(self, success=None, ucx=None,):
3936 
    self.success = success
3937 
    self.ucx = ucx
3938 
 
3939 
  def read(self, iprot):
3940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3942 
      return
3943 
    iprot.readStructBegin()
3944 
    while True:
3945 
      (fname, ftype, fid) = iprot.readFieldBegin()
3946 
      if ftype == TType.STOP:
3947 
        break
3948 
      if fid == 0:
3949 
        if ftype == TType.BOOL:
3950 
          self.success = iprot.readBool();
3951 
        else:
3952 
          iprot.skip(ftype)
3953 
      elif fid == 1:
3954 
        if ftype == TType.STRUCT:
3955 
          self.ucx = UserContextException()
3956 
          self.ucx.read(iprot)
3957 
        else:
3958 
          iprot.skip(ftype)
3959 
      else:
3960 
        iprot.skip(ftype)
3961 
      iprot.readFieldEnd()
3962 
    iprot.readStructEnd()
3963 
 
3964 
  def write(self, oprot):
3965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3967 
      return
559 chandransh 3968 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 3969 
    if self.success != None:
3970 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3971 
      oprot.writeBool(self.success)
3972 
      oprot.writeFieldEnd()
3973 
    if self.ucx != None:
3974 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3975 
      self.ucx.write(oprot)
3976 
      oprot.writeFieldEnd()
3977 
    oprot.writeFieldStop()
3978 
    oprot.writeStructEnd()
3979 
 
3980 
  def __repr__(self):
3981 
    L = ['%s=%r' % (key, value)
3982 
      for key, value in self.__dict__.iteritems()]
3983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3984 
 
3985 
  def __eq__(self, other):
3986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3987 
 
3988 
  def __ne__(self, other):
3989 
    return not (self == other)
3990 
 
559 chandransh 3991 
class setUserAsLoggedIn_args:
94 ashish 3992 
  """
3993 
  Attributes:
559 chandransh 3994 
   - userId
94 ashish 3995 
   - timestamp
3996 
  """
3997 
 
3998 
  thrift_spec = (
3999 
    None, # 0
559 chandransh 4000 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 4001 
    (2, TType.I64, 'timestamp', None, None, ), # 2
4002 
  )
4003 
 
559 chandransh 4004 
  def __init__(self, userId=None, timestamp=None,):
4005 
    self.userId = userId
94 ashish 4006 
    self.timestamp = timestamp
4007 
 
4008 
  def read(self, iprot):
4009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4011 
      return
4012 
    iprot.readStructBegin()
4013 
    while True:
4014 
      (fname, ftype, fid) = iprot.readFieldBegin()
4015 
      if ftype == TType.STOP:
4016 
        break
4017 
      if fid == 1:
559 chandransh 4018 
        if ftype == TType.I64:
4019 
          self.userId = iprot.readI64();
94 ashish 4020 
        else:
4021 
          iprot.skip(ftype)
4022 
      elif fid == 2:
4023 
        if ftype == TType.I64:
4024 
          self.timestamp = iprot.readI64();
4025 
        else:
4026 
          iprot.skip(ftype)
4027 
      else:
4028 
        iprot.skip(ftype)
4029 
      iprot.readFieldEnd()
4030 
    iprot.readStructEnd()
4031 
 
4032 
  def write(self, oprot):
4033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4035 
      return
559 chandransh 4036 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
4037 
    if self.userId != None:
4038 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4039 
      oprot.writeI64(self.userId)
94 ashish 4040 
      oprot.writeFieldEnd()
4041 
    if self.timestamp != None:
4042 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
4043 
      oprot.writeI64(self.timestamp)
4044 
      oprot.writeFieldEnd()
4045 
    oprot.writeFieldStop()
4046 
    oprot.writeStructEnd()
4047 
 
4048 
  def __repr__(self):
4049 
    L = ['%s=%r' % (key, value)
4050 
      for key, value in self.__dict__.iteritems()]
4051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4052 
 
4053 
  def __eq__(self, other):
4054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4055 
 
4056 
  def __ne__(self, other):
4057 
    return not (self == other)
4058 
 
559 chandransh 4059 
class setUserAsLoggedIn_result:
94 ashish 4060 
  """
4061 
  Attributes:
4062 
   - success
4063 
   - ucx
4064 
  """
4065 
 
4066 
  thrift_spec = (
4067 
    (0, TType.BOOL, 'success', None, None, ), # 0
4068 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4069 
  )
4070 
 
4071 
  def __init__(self, success=None, ucx=None,):
4072 
    self.success = success
4073 
    self.ucx = ucx
4074 
 
4075 
  def read(self, iprot):
4076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4078 
      return
4079 
    iprot.readStructBegin()
4080 
    while True:
4081 
      (fname, ftype, fid) = iprot.readFieldBegin()
4082 
      if ftype == TType.STOP:
4083 
        break
4084 
      if fid == 0:
4085 
        if ftype == TType.BOOL:
4086 
          self.success = iprot.readBool();
4087 
        else:
4088 
          iprot.skip(ftype)
4089 
      elif fid == 1:
4090 
        if ftype == TType.STRUCT:
4091 
          self.ucx = UserContextException()
4092 
          self.ucx.read(iprot)
4093 
        else:
4094 
          iprot.skip(ftype)
4095 
      else:
4096 
        iprot.skip(ftype)
4097 
      iprot.readFieldEnd()
4098 
    iprot.readStructEnd()
4099 
 
4100 
  def write(self, oprot):
4101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4103 
      return
559 chandransh 4104 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 4105 
    if self.success != None:
4106 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4107 
      oprot.writeBool(self.success)
4108 
      oprot.writeFieldEnd()
4109 
    if self.ucx != None:
4110 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4111 
      self.ucx.write(oprot)
4112 
      oprot.writeFieldEnd()
4113 
    oprot.writeFieldStop()
4114 
    oprot.writeStructEnd()
4115 
 
4116 
  def __repr__(self):
4117 
    L = ['%s=%r' % (key, value)
4118 
      for key, value in self.__dict__.iteritems()]
4119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4120 
 
4121 
  def __eq__(self, other):
4122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4123 
 
4124 
  def __ne__(self, other):
4125 
    return not (self == other)
4126 
 
559 chandransh 4127 
class setUserAsLoggedOut_args:
94 ashish 4128 
  """
4129 
  Attributes:
4130 
   - userid
4131 
   - timestamp
4132 
  """
4133 
 
4134 
  thrift_spec = (
4135 
    None, # 0
559 chandransh 4136 
    (1, TType.I64, 'userid', None, None, ), # 1
4137 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 4138 
  )
4139 
 
559 chandransh 4140 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 4141 
    self.userid = userid
4142 
    self.timestamp = timestamp
4143 
 
4144 
  def read(self, iprot):
4145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4147 
      return
4148 
    iprot.readStructBegin()
4149 
    while True:
4150 
      (fname, ftype, fid) = iprot.readFieldBegin()
4151 
      if ftype == TType.STOP:
4152 
        break
4153 
      if fid == 1:
4154 
        if ftype == TType.I64:
4155 
          self.userid = iprot.readI64();
4156 
        else:
4157 
          iprot.skip(ftype)
559 chandransh 4158 
      elif fid == 2:
94 ashish 4159 
        if ftype == TType.I64:
4160 
          self.timestamp = iprot.readI64();
4161 
        else:
4162 
          iprot.skip(ftype)
4163 
      else:
4164 
        iprot.skip(ftype)
4165 
      iprot.readFieldEnd()
4166 
    iprot.readStructEnd()
4167 
 
4168 
  def write(self, oprot):
4169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4171 
      return
559 chandransh 4172 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 4173 
    if self.userid != None:
559 chandransh 4174 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 4175 
      oprot.writeI64(self.userid)
4176 
      oprot.writeFieldEnd()
4177 
    if self.timestamp != None:
559 chandransh 4178 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 4179 
      oprot.writeI64(self.timestamp)
4180 
      oprot.writeFieldEnd()
4181 
    oprot.writeFieldStop()
4182 
    oprot.writeStructEnd()
4183 
 
4184 
  def __repr__(self):
4185 
    L = ['%s=%r' % (key, value)
4186 
      for key, value in self.__dict__.iteritems()]
4187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4188 
 
4189 
  def __eq__(self, other):
4190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4191 
 
4192 
  def __ne__(self, other):
4193 
    return not (self == other)
4194 
 
559 chandransh 4195 
class setUserAsLoggedOut_result:
94 ashish 4196 
  """
4197 
  Attributes:
4198 
   - success
4199 
   - ucx
4200 
  """
4201 
 
4202 
  thrift_spec = (
4203 
    (0, TType.BOOL, 'success', None, None, ), # 0
4204 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4205 
  )
4206 
 
4207 
  def __init__(self, success=None, ucx=None,):
4208 
    self.success = success
4209 
    self.ucx = ucx
4210 
 
4211 
  def read(self, iprot):
4212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4214 
      return
4215 
    iprot.readStructBegin()
4216 
    while True:
4217 
      (fname, ftype, fid) = iprot.readFieldBegin()
4218 
      if ftype == TType.STOP:
4219 
        break
4220 
      if fid == 0:
4221 
        if ftype == TType.BOOL:
4222 
          self.success = iprot.readBool();
4223 
        else:
4224 
          iprot.skip(ftype)
4225 
      elif fid == 1:
4226 
        if ftype == TType.STRUCT:
4227 
          self.ucx = UserContextException()
4228 
          self.ucx.read(iprot)
4229 
        else:
4230 
          iprot.skip(ftype)
4231 
      else:
4232 
        iprot.skip(ftype)
4233 
      iprot.readFieldEnd()
4234 
    iprot.readStructEnd()
4235 
 
4236 
  def write(self, oprot):
4237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4239 
      return
559 chandransh 4240 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 4241 
    if self.success != None:
4242 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4243 
      oprot.writeBool(self.success)
4244 
      oprot.writeFieldEnd()
4245 
    if self.ucx != None:
4246 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4247 
      self.ucx.write(oprot)
4248 
      oprot.writeFieldEnd()
4249 
    oprot.writeFieldStop()
4250 
    oprot.writeStructEnd()
4251 
 
4252 
  def __repr__(self):
4253 
    L = ['%s=%r' % (key, value)
4254 
      for key, value in self.__dict__.iteritems()]
4255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4256 
 
4257 
  def __eq__(self, other):
4258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4259 
 
4260 
  def __ne__(self, other):
4261 
    return not (self == other)
4262 
 
559 chandransh 4263 
class setDefaultAddress_args:
94 ashish 4264 
  """
4265 
  Attributes:
4266 
   - userid
4267 
   - addressId
4268 
  """
4269 
 
4270 
  thrift_spec = (
4271 
    None, # 0
4272 
    (1, TType.I64, 'userid', None, None, ), # 1
4273 
    (2, TType.I64, 'addressId', None, None, ), # 2
4274 
  )
4275 
 
4276 
  def __init__(self, userid=None, addressId=None,):
4277 
    self.userid = userid
4278 
    self.addressId = addressId
4279 
 
4280 
  def read(self, iprot):
4281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4283 
      return
4284 
    iprot.readStructBegin()
4285 
    while True:
4286 
      (fname, ftype, fid) = iprot.readFieldBegin()
4287 
      if ftype == TType.STOP:
4288 
        break
4289 
      if fid == 1:
4290 
        if ftype == TType.I64:
4291 
          self.userid = iprot.readI64();
4292 
        else:
4293 
          iprot.skip(ftype)
4294 
      elif fid == 2:
4295 
        if ftype == TType.I64:
4296 
          self.addressId = iprot.readI64();
4297 
        else:
4298 
          iprot.skip(ftype)
4299 
      else:
4300 
        iprot.skip(ftype)
4301 
      iprot.readFieldEnd()
4302 
    iprot.readStructEnd()
4303 
 
4304 
  def write(self, oprot):
4305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4307 
      return
559 chandransh 4308 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 4309 
    if self.userid != None:
4310 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4311 
      oprot.writeI64(self.userid)
4312 
      oprot.writeFieldEnd()
4313 
    if self.addressId != None:
4314 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
4315 
      oprot.writeI64(self.addressId)
4316 
      oprot.writeFieldEnd()
4317 
    oprot.writeFieldStop()
4318 
    oprot.writeStructEnd()
4319 
 
4320 
  def __repr__(self):
4321 
    L = ['%s=%r' % (key, value)
4322 
      for key, value in self.__dict__.iteritems()]
4323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4324 
 
4325 
  def __eq__(self, other):
4326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4327 
 
4328 
  def __ne__(self, other):
4329 
    return not (self == other)
4330 
 
559 chandransh 4331 
class setDefaultAddress_result:
94 ashish 4332 
  """
4333 
  Attributes:
4334 
   - success
4335 
   - ucx
4336 
  """
4337 
 
4338 
  thrift_spec = (
4339 
    (0, TType.BOOL, 'success', None, None, ), # 0
4340 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4341 
  )
4342 
 
4343 
  def __init__(self, success=None, ucx=None,):
4344 
    self.success = success
4345 
    self.ucx = ucx
4346 
 
4347 
  def read(self, iprot):
4348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4350 
      return
4351 
    iprot.readStructBegin()
4352 
    while True:
4353 
      (fname, ftype, fid) = iprot.readFieldBegin()
4354 
      if ftype == TType.STOP:
4355 
        break
4356 
      if fid == 0:
4357 
        if ftype == TType.BOOL:
4358 
          self.success = iprot.readBool();
4359 
        else:
4360 
          iprot.skip(ftype)
4361 
      elif fid == 1:
4362 
        if ftype == TType.STRUCT:
4363 
          self.ucx = UserContextException()
4364 
          self.ucx.read(iprot)
4365 
        else:
4366 
          iprot.skip(ftype)
4367 
      else:
4368 
        iprot.skip(ftype)
4369 
      iprot.readFieldEnd()
4370 
    iprot.readStructEnd()
4371 
 
4372 
  def write(self, oprot):
4373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4375 
      return
559 chandransh 4376 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 4377 
    if self.success != None:
4378 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4379 
      oprot.writeBool(self.success)
4380 
      oprot.writeFieldEnd()
4381 
    if self.ucx != None:
4382 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4383 
      self.ucx.write(oprot)
4384 
      oprot.writeFieldEnd()
4385 
    oprot.writeFieldStop()
4386 
    oprot.writeStructEnd()
4387 
 
4388 
  def __repr__(self):
4389 
    L = ['%s=%r' % (key, value)
4390 
      for key, value in self.__dict__.iteritems()]
4391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4392 
 
4393 
  def __eq__(self, other):
4394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4395 
 
4396 
  def __ne__(self, other):
4397 
    return not (self == other)
4398 
 
559 chandransh 4399 
class updatePassword_args:
94 ashish 4400 
  """
4401 
  Attributes:
559 chandransh 4402 
   - userid
594 rajveer 4403 
   - oldPassword
4404 
   - newPassword
94 ashish 4405 
  """
4406 
 
4407 
  thrift_spec = (
4408 
    None, # 0
559 chandransh 4409 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 4410 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
4411 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 4412 
  )
4413 
 
594 rajveer 4414 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 4415 
    self.userid = userid
594 rajveer 4416 
    self.oldPassword = oldPassword
4417 
    self.newPassword = newPassword
94 ashish 4418 
 
4419 
  def read(self, iprot):
4420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4422 
      return
4423 
    iprot.readStructBegin()
4424 
    while True:
4425 
      (fname, ftype, fid) = iprot.readFieldBegin()
4426 
      if ftype == TType.STOP:
4427 
        break
4428 
      if fid == 1:
4429 
        if ftype == TType.I64:
559 chandransh 4430 
          self.userid = iprot.readI64();
94 ashish 4431 
        else:
4432 
          iprot.skip(ftype)
4433 
      elif fid == 2:
559 chandransh 4434 
        if ftype == TType.STRING:
594 rajveer 4435 
          self.oldPassword = iprot.readString();
94 ashish 4436 
        else:
4437 
          iprot.skip(ftype)
594 rajveer 4438 
      elif fid == 3:
4439 
        if ftype == TType.STRING:
4440 
          self.newPassword = iprot.readString();
4441 
        else:
4442 
          iprot.skip(ftype)
94 ashish 4443 
      else:
4444 
        iprot.skip(ftype)
4445 
      iprot.readFieldEnd()
4446 
    iprot.readStructEnd()
4447 
 
4448 
  def write(self, oprot):
4449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4451 
      return
559 chandransh 4452 
    oprot.writeStructBegin('updatePassword_args')
4453 
    if self.userid != None:
4454 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4455 
      oprot.writeI64(self.userid)
94 ashish 4456 
      oprot.writeFieldEnd()
594 rajveer 4457 
    if self.oldPassword != None:
4458 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
4459 
      oprot.writeString(self.oldPassword)
94 ashish 4460 
      oprot.writeFieldEnd()
594 rajveer 4461 
    if self.newPassword != None:
4462 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
4463 
      oprot.writeString(self.newPassword)
4464 
      oprot.writeFieldEnd()
94 ashish 4465 
    oprot.writeFieldStop()
4466 
    oprot.writeStructEnd()
4467 
 
4468 
  def __repr__(self):
4469 
    L = ['%s=%r' % (key, value)
4470 
      for key, value in self.__dict__.iteritems()]
4471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4472 
 
4473 
  def __eq__(self, other):
4474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4475 
 
4476 
  def __ne__(self, other):
4477 
    return not (self == other)
4478 
 
559 chandransh 4479 
class updatePassword_result:
94 ashish 4480 
  """
4481 
  Attributes:
4482 
   - success
4483 
   - ucx
4484 
  """
4485 
 
4486 
  thrift_spec = (
4487 
    (0, TType.BOOL, 'success', None, None, ), # 0
4488 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4489 
  )
4490 
 
4491 
  def __init__(self, success=None, ucx=None,):
4492 
    self.success = success
4493 
    self.ucx = ucx
4494 
 
4495 
  def read(self, iprot):
4496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4498 
      return
4499 
    iprot.readStructBegin()
4500 
    while True:
4501 
      (fname, ftype, fid) = iprot.readFieldBegin()
4502 
      if ftype == TType.STOP:
4503 
        break
4504 
      if fid == 0:
4505 
        if ftype == TType.BOOL:
4506 
          self.success = iprot.readBool();
4507 
        else:
4508 
          iprot.skip(ftype)
4509 
      elif fid == 1:
4510 
        if ftype == TType.STRUCT:
4511 
          self.ucx = UserContextException()
4512 
          self.ucx.read(iprot)
4513 
        else:
4514 
          iprot.skip(ftype)
4515 
      else:
4516 
        iprot.skip(ftype)
4517 
      iprot.readFieldEnd()
4518 
    iprot.readStructEnd()
4519 
 
4520 
  def write(self, oprot):
4521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4523 
      return
559 chandransh 4524 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 4525 
    if self.success != None:
4526 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4527 
      oprot.writeBool(self.success)
4528 
      oprot.writeFieldEnd()
4529 
    if self.ucx != None:
4530 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4531 
      self.ucx.write(oprot)
4532 
      oprot.writeFieldEnd()
4533 
    oprot.writeFieldStop()
4534 
    oprot.writeStructEnd()
4535 
 
4536 
  def __repr__(self):
4537 
    L = ['%s=%r' % (key, value)
4538 
      for key, value in self.__dict__.iteritems()]
4539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4540 
 
4541 
  def __eq__(self, other):
4542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4543 
 
4544 
  def __ne__(self, other):
4545 
    return not (self == other)
4546 
 
581 rajveer 4547 
class forgotPassword_args:
4548 
  """
4549 
  Attributes:
4550 
   - email
4551 
  """
4552 
 
4553 
  thrift_spec = (
4554 
    None, # 0
4555 
    (1, TType.STRING, 'email', None, None, ), # 1
4556 
  )
4557 
 
4558 
  def __init__(self, email=None,):
4559 
    self.email = email
4560 
 
4561 
  def read(self, iprot):
4562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4564 
      return
4565 
    iprot.readStructBegin()
4566 
    while True:
4567 
      (fname, ftype, fid) = iprot.readFieldBegin()
4568 
      if ftype == TType.STOP:
4569 
        break
4570 
      if fid == 1:
4571 
        if ftype == TType.STRING:
4572 
          self.email = iprot.readString();
4573 
        else:
4574 
          iprot.skip(ftype)
4575 
      else:
4576 
        iprot.skip(ftype)
4577 
      iprot.readFieldEnd()
4578 
    iprot.readStructEnd()
4579 
 
4580 
  def write(self, oprot):
4581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4583 
      return
4584 
    oprot.writeStructBegin('forgotPassword_args')
4585 
    if self.email != None:
4586 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4587 
      oprot.writeString(self.email)
4588 
      oprot.writeFieldEnd()
4589 
    oprot.writeFieldStop()
4590 
    oprot.writeStructEnd()
4591 
 
4592 
  def __repr__(self):
4593 
    L = ['%s=%r' % (key, value)
4594 
      for key, value in self.__dict__.iteritems()]
4595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4596 
 
4597 
  def __eq__(self, other):
4598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4599 
 
4600 
  def __ne__(self, other):
4601 
    return not (self == other)
4602 
 
4603 
class forgotPassword_result:
4604 
  """
4605 
  Attributes:
4606 
   - success
4607 
   - ucx
4608 
  """
4609 
 
4610 
  thrift_spec = (
4611 
    (0, TType.BOOL, 'success', None, None, ), # 0
4612 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4613 
  )
4614 
 
4615 
  def __init__(self, success=None, ucx=None,):
4616 
    self.success = success
4617 
    self.ucx = ucx
4618 
 
4619 
  def read(self, iprot):
4620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4622 
      return
4623 
    iprot.readStructBegin()
4624 
    while True:
4625 
      (fname, ftype, fid) = iprot.readFieldBegin()
4626 
      if ftype == TType.STOP:
4627 
        break
4628 
      if fid == 0:
4629 
        if ftype == TType.BOOL:
4630 
          self.success = iprot.readBool();
4631 
        else:
4632 
          iprot.skip(ftype)
4633 
      elif fid == 1:
4634 
        if ftype == TType.STRUCT:
4635 
          self.ucx = UserContextException()
4636 
          self.ucx.read(iprot)
4637 
        else:
4638 
          iprot.skip(ftype)
4639 
      else:
4640 
        iprot.skip(ftype)
4641 
      iprot.readFieldEnd()
4642 
    iprot.readStructEnd()
4643 
 
4644 
  def write(self, oprot):
4645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4647 
      return
4648 
    oprot.writeStructBegin('forgotPassword_result')
4649 
    if self.success != None:
4650 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4651 
      oprot.writeBool(self.success)
4652 
      oprot.writeFieldEnd()
4653 
    if self.ucx != None:
4654 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4655 
      self.ucx.write(oprot)
4656 
      oprot.writeFieldEnd()
4657 
    oprot.writeFieldStop()
4658 
    oprot.writeStructEnd()
4659 
 
4660 
  def __repr__(self):
4661 
    L = ['%s=%r' % (key, value)
4662 
      for key, value in self.__dict__.iteritems()]
4663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4664 
 
4665 
  def __eq__(self, other):
4666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4667 
 
4668 
  def __ne__(self, other):
4669 
    return not (self == other)
4670 
 
594 rajveer 4671 
class getAllAddressesForUser_args:
4672 
  """
4673 
  Attributes:
4674 
   - userId
4675 
  """
4676 
 
4677 
  thrift_spec = (
4678 
    None, # 0
4679 
    (1, TType.I64, 'userId', None, None, ), # 1
4680 
  )
4681 
 
4682 
  def __init__(self, userId=None,):
4683 
    self.userId = userId
4684 
 
4685 
  def read(self, iprot):
4686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4688 
      return
4689 
    iprot.readStructBegin()
4690 
    while True:
4691 
      (fname, ftype, fid) = iprot.readFieldBegin()
4692 
      if ftype == TType.STOP:
4693 
        break
4694 
      if fid == 1:
4695 
        if ftype == TType.I64:
4696 
          self.userId = iprot.readI64();
4697 
        else:
4698 
          iprot.skip(ftype)
4699 
      else:
4700 
        iprot.skip(ftype)
4701 
      iprot.readFieldEnd()
4702 
    iprot.readStructEnd()
4703 
 
4704 
  def write(self, oprot):
4705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4707 
      return
4708 
    oprot.writeStructBegin('getAllAddressesForUser_args')
4709 
    if self.userId != None:
4710 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4711 
      oprot.writeI64(self.userId)
4712 
      oprot.writeFieldEnd()
4713 
    oprot.writeFieldStop()
4714 
    oprot.writeStructEnd()
4715 
 
4716 
  def __repr__(self):
4717 
    L = ['%s=%r' % (key, value)
4718 
      for key, value in self.__dict__.iteritems()]
4719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4720 
 
4721 
  def __eq__(self, other):
4722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4723 
 
4724 
  def __ne__(self, other):
4725 
    return not (self == other)
4726 
 
4727 
class getAllAddressesForUser_result:
4728 
  """
4729 
  Attributes:
4730 
   - success
4731 
   - ucx
4732 
  """
4733 
 
4734 
  thrift_spec = (
4735 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
4736 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4737 
  )
4738 
 
4739 
  def __init__(self, success=None, ucx=None,):
4740 
    self.success = success
4741 
    self.ucx = ucx
4742 
 
4743 
  def read(self, iprot):
4744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4746 
      return
4747 
    iprot.readStructBegin()
4748 
    while True:
4749 
      (fname, ftype, fid) = iprot.readFieldBegin()
4750 
      if ftype == TType.STOP:
4751 
        break
4752 
      if fid == 0:
4753 
        if ftype == TType.LIST:
4754 
          self.success = []
4755 
          (_etype40, _size37) = iprot.readListBegin()
4756 
          for _i41 in xrange(_size37):
4757 
            _elem42 = Address()
4758 
            _elem42.read(iprot)
4759 
            self.success.append(_elem42)
4760 
          iprot.readListEnd()
4761 
        else:
4762 
          iprot.skip(ftype)
4763 
      elif fid == 1:
4764 
        if ftype == TType.STRUCT:
4765 
          self.ucx = UserContextException()
4766 
          self.ucx.read(iprot)
4767 
        else:
4768 
          iprot.skip(ftype)
4769 
      else:
4770 
        iprot.skip(ftype)
4771 
      iprot.readFieldEnd()
4772 
    iprot.readStructEnd()
4773 
 
4774 
  def write(self, oprot):
4775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4777 
      return
4778 
    oprot.writeStructBegin('getAllAddressesForUser_result')
4779 
    if self.success != None:
4780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4781 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4782 
      for iter43 in self.success:
4783 
        iter43.write(oprot)
4784 
      oprot.writeListEnd()
4785 
      oprot.writeFieldEnd()
4786 
    if self.ucx != None:
4787 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4788 
      self.ucx.write(oprot)
4789 
      oprot.writeFieldEnd()
4790 
    oprot.writeFieldStop()
4791 
    oprot.writeStructEnd()
4792 
 
4793 
  def __repr__(self):
4794 
    L = ['%s=%r' % (key, value)
4795 
      for key, value in self.__dict__.iteritems()]
4796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4797 
 
4798 
  def __eq__(self, other):
4799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4800 
 
4801 
  def __ne__(self, other):
4802 
    return not (self == other)
4803 
 
4804 
class getDefaultAddressId_args:
4805 
  """
4806 
  Attributes:
4807 
   - userId
4808 
  """
4809 
 
4810 
  thrift_spec = (
4811 
    None, # 0
4812 
    (1, TType.I64, 'userId', None, None, ), # 1
4813 
  )
4814 
 
4815 
  def __init__(self, userId=None,):
4816 
    self.userId = userId
4817 
 
4818 
  def read(self, iprot):
4819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4821 
      return
4822 
    iprot.readStructBegin()
4823 
    while True:
4824 
      (fname, ftype, fid) = iprot.readFieldBegin()
4825 
      if ftype == TType.STOP:
4826 
        break
4827 
      if fid == 1:
4828 
        if ftype == TType.I64:
4829 
          self.userId = iprot.readI64();
4830 
        else:
4831 
          iprot.skip(ftype)
4832 
      else:
4833 
        iprot.skip(ftype)
4834 
      iprot.readFieldEnd()
4835 
    iprot.readStructEnd()
4836 
 
4837 
  def write(self, oprot):
4838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4840 
      return
4841 
    oprot.writeStructBegin('getDefaultAddressId_args')
4842 
    if self.userId != None:
4843 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4844 
      oprot.writeI64(self.userId)
4845 
      oprot.writeFieldEnd()
4846 
    oprot.writeFieldStop()
4847 
    oprot.writeStructEnd()
4848 
 
4849 
  def __repr__(self):
4850 
    L = ['%s=%r' % (key, value)
4851 
      for key, value in self.__dict__.iteritems()]
4852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4853 
 
4854 
  def __eq__(self, other):
4855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4856 
 
4857 
  def __ne__(self, other):
4858 
    return not (self == other)
4859 
 
4860 
class getDefaultAddressId_result:
4861 
  """
4862 
  Attributes:
4863 
   - success
4864 
   - ucx
4865 
  """
4866 
 
4867 
  thrift_spec = (
4868 
    (0, TType.I64, 'success', None, None, ), # 0
4869 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4870 
  )
4871 
 
4872 
  def __init__(self, success=None, ucx=None,):
4873 
    self.success = success
4874 
    self.ucx = ucx
4875 
 
4876 
  def read(self, iprot):
4877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4879 
      return
4880 
    iprot.readStructBegin()
4881 
    while True:
4882 
      (fname, ftype, fid) = iprot.readFieldBegin()
4883 
      if ftype == TType.STOP:
4884 
        break
4885 
      if fid == 0:
4886 
        if ftype == TType.I64:
4887 
          self.success = iprot.readI64();
4888 
        else:
4889 
          iprot.skip(ftype)
4890 
      elif fid == 1:
4891 
        if ftype == TType.STRUCT:
4892 
          self.ucx = UserContextException()
4893 
          self.ucx.read(iprot)
4894 
        else:
4895 
          iprot.skip(ftype)
4896 
      else:
4897 
        iprot.skip(ftype)
4898 
      iprot.readFieldEnd()
4899 
    iprot.readStructEnd()
4900 
 
4901 
  def write(self, oprot):
4902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4904 
      return
4905 
    oprot.writeStructBegin('getDefaultAddressId_result')
4906 
    if self.success != None:
4907 
      oprot.writeFieldBegin('success', TType.I64, 0)
4908 
      oprot.writeI64(self.success)
4909 
      oprot.writeFieldEnd()
4910 
    if self.ucx != None:
4911 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4912 
      self.ucx.write(oprot)
4913 
      oprot.writeFieldEnd()
4914 
    oprot.writeFieldStop()
4915 
    oprot.writeStructEnd()
4916 
 
4917 
  def __repr__(self):
4918 
    L = ['%s=%r' % (key, value)
4919 
      for key, value in self.__dict__.iteritems()]
4920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4921 
 
4922 
  def __eq__(self, other):
4923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4924 
 
4925 
  def __ne__(self, other):
4926 
    return not (self == other)
4927 
 
559 chandransh 4928 
class createCart_args:
94 ashish 4929 
  """
4930 
  Attributes:
559 chandransh 4931 
   - userId
94 ashish 4932 
  """
4933 
 
4934 
  thrift_spec = (
4935 
    None, # 0
559 chandransh 4936 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 4937 
  )
4938 
 
559 chandransh 4939 
  def __init__(self, userId=None,):
4940 
    self.userId = userId
94 ashish 4941 
 
4942 
  def read(self, iprot):
4943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4945 
      return
4946 
    iprot.readStructBegin()
4947 
    while True:
4948 
      (fname, ftype, fid) = iprot.readFieldBegin()
4949 
      if ftype == TType.STOP:
4950 
        break
4951 
      if fid == 1:
4952 
        if ftype == TType.I64:
559 chandransh 4953 
          self.userId = iprot.readI64();
94 ashish 4954 
        else:
4955 
          iprot.skip(ftype)
559 chandransh 4956 
      else:
4957 
        iprot.skip(ftype)
4958 
      iprot.readFieldEnd()
4959 
    iprot.readStructEnd()
4960 
 
4961 
  def write(self, oprot):
4962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4964 
      return
4965 
    oprot.writeStructBegin('createCart_args')
4966 
    if self.userId != None:
4967 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4968 
      oprot.writeI64(self.userId)
4969 
      oprot.writeFieldEnd()
4970 
    oprot.writeFieldStop()
4971 
    oprot.writeStructEnd()
4972 
 
4973 
  def __repr__(self):
4974 
    L = ['%s=%r' % (key, value)
4975 
      for key, value in self.__dict__.iteritems()]
4976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4977 
 
4978 
  def __eq__(self, other):
4979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4980 
 
4981 
  def __ne__(self, other):
4982 
    return not (self == other)
4983 
 
4984 
class createCart_result:
4985 
  """
4986 
  Attributes:
4987 
   - success
4988 
   - scx
4989 
  """
4990 
 
4991 
  thrift_spec = (
4992 
    (0, TType.I64, 'success', None, None, ), # 0
4993 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
4994 
  )
4995 
 
4996 
  def __init__(self, success=None, scx=None,):
4997 
    self.success = success
4998 
    self.scx = scx
4999 
 
5000 
  def read(self, iprot):
5001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5003 
      return
5004 
    iprot.readStructBegin()
5005 
    while True:
5006 
      (fname, ftype, fid) = iprot.readFieldBegin()
5007 
      if ftype == TType.STOP:
5008 
        break
5009 
      if fid == 0:
94 ashish 5010 
        if ftype == TType.I64:
559 chandransh 5011 
          self.success = iprot.readI64();
94 ashish 5012 
        else:
5013 
          iprot.skip(ftype)
559 chandransh 5014 
      elif fid == 1:
5015 
        if ftype == TType.STRUCT:
5016 
          self.scx = ShoppingCartException()
5017 
          self.scx.read(iprot)
5018 
        else:
5019 
          iprot.skip(ftype)
94 ashish 5020 
      else:
5021 
        iprot.skip(ftype)
5022 
      iprot.readFieldEnd()
5023 
    iprot.readStructEnd()
5024 
 
5025 
  def write(self, oprot):
5026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5028 
      return
559 chandransh 5029 
    oprot.writeStructBegin('createCart_result')
5030 
    if self.success != None:
5031 
      oprot.writeFieldBegin('success', TType.I64, 0)
5032 
      oprot.writeI64(self.success)
94 ashish 5033 
      oprot.writeFieldEnd()
559 chandransh 5034 
    if self.scx != None:
5035 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5036 
      self.scx.write(oprot)
94 ashish 5037 
      oprot.writeFieldEnd()
5038 
    oprot.writeFieldStop()
5039 
    oprot.writeStructEnd()
5040 
 
5041 
  def __repr__(self):
5042 
    L = ['%s=%r' % (key, value)
5043 
      for key, value in self.__dict__.iteritems()]
5044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5045 
 
5046 
  def __eq__(self, other):
5047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5048 
 
5049 
  def __ne__(self, other):
5050 
    return not (self == other)
5051 
 
559 chandransh 5052 
class getCurrentCart_args:
94 ashish 5053 
  """
5054 
  Attributes:
559 chandransh 5055 
   - userId
5056 
  """
5057 
 
5058 
  thrift_spec = (
5059 
    None, # 0
5060 
    (1, TType.I64, 'userId', None, None, ), # 1
5061 
  )
5062 
 
5063 
  def __init__(self, userId=None,):
5064 
    self.userId = userId
5065 
 
5066 
  def read(self, iprot):
5067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5069 
      return
5070 
    iprot.readStructBegin()
5071 
    while True:
5072 
      (fname, ftype, fid) = iprot.readFieldBegin()
5073 
      if ftype == TType.STOP:
5074 
        break
5075 
      if fid == 1:
5076 
        if ftype == TType.I64:
5077 
          self.userId = iprot.readI64();
5078 
        else:
5079 
          iprot.skip(ftype)
5080 
      else:
5081 
        iprot.skip(ftype)
5082 
      iprot.readFieldEnd()
5083 
    iprot.readStructEnd()
5084 
 
5085 
  def write(self, oprot):
5086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5088 
      return
5089 
    oprot.writeStructBegin('getCurrentCart_args')
5090 
    if self.userId != None:
5091 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5092 
      oprot.writeI64(self.userId)
5093 
      oprot.writeFieldEnd()
5094 
    oprot.writeFieldStop()
5095 
    oprot.writeStructEnd()
5096 
 
5097 
  def __repr__(self):
5098 
    L = ['%s=%r' % (key, value)
5099 
      for key, value in self.__dict__.iteritems()]
5100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5101 
 
5102 
  def __eq__(self, other):
5103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5104 
 
5105 
  def __ne__(self, other):
5106 
    return not (self == other)
5107 
 
5108 
class getCurrentCart_result:
5109 
  """
5110 
  Attributes:
94 ashish 5111 
   - success
559 chandransh 5112 
   - scx
94 ashish 5113 
  """
5114 
 
5115 
  thrift_spec = (
559 chandransh 5116 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
5117 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 5118 
  )
5119 
 
559 chandransh 5120 
  def __init__(self, success=None, scx=None,):
94 ashish 5121 
    self.success = success
559 chandransh 5122 
    self.scx = scx
94 ashish 5123 
 
5124 
  def read(self, iprot):
5125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5127 
      return
5128 
    iprot.readStructBegin()
5129 
    while True:
5130 
      (fname, ftype, fid) = iprot.readFieldBegin()
5131 
      if ftype == TType.STOP:
5132 
        break
5133 
      if fid == 0:
559 chandransh 5134 
        if ftype == TType.STRUCT:
5135 
          self.success = Cart()
5136 
          self.success.read(iprot)
94 ashish 5137 
        else:
5138 
          iprot.skip(ftype)
5139 
      elif fid == 1:
5140 
        if ftype == TType.STRUCT:
559 chandransh 5141 
          self.scx = ShoppingCartException()
5142 
          self.scx.read(iprot)
94 ashish 5143 
        else:
5144 
          iprot.skip(ftype)
5145 
      else:
5146 
        iprot.skip(ftype)
5147 
      iprot.readFieldEnd()
5148 
    iprot.readStructEnd()
5149 
 
5150 
  def write(self, oprot):
5151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5153 
      return
559 chandransh 5154 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 5155 
    if self.success != None:
559 chandransh 5156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5157 
      self.success.write(oprot)
94 ashish 5158 
      oprot.writeFieldEnd()
559 chandransh 5159 
    if self.scx != None:
5160 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5161 
      self.scx.write(oprot)
94 ashish 5162 
      oprot.writeFieldEnd()
5163 
    oprot.writeFieldStop()
5164 
    oprot.writeStructEnd()
5165 
 
5166 
  def __repr__(self):
5167 
    L = ['%s=%r' % (key, value)
5168 
      for key, value in self.__dict__.iteritems()]
5169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5170 
 
5171 
  def __eq__(self, other):
5172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5173 
 
5174 
  def __ne__(self, other):
5175 
    return not (self == other)
5176 
 
559 chandransh 5177 
class getCart_args:
504 rajveer 5178 
  """
5179 
  Attributes:
559 chandransh 5180 
   - cartId
504 rajveer 5181 
  """
5182 
 
5183 
  thrift_spec = (
5184 
    None, # 0
559 chandransh 5185 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 5186 
  )
5187 
 
559 chandransh 5188 
  def __init__(self, cartId=None,):
5189 
    self.cartId = cartId
504 rajveer 5190 
 
5191 
  def read(self, iprot):
5192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5194 
      return
5195 
    iprot.readStructBegin()
5196 
    while True:
5197 
      (fname, ftype, fid) = iprot.readFieldBegin()
5198 
      if ftype == TType.STOP:
5199 
        break
5200 
      if fid == 1:
5201 
        if ftype == TType.I64:
559 chandransh 5202 
          self.cartId = iprot.readI64();
504 rajveer 5203 
        else:
5204 
          iprot.skip(ftype)
5205 
      else:
5206 
        iprot.skip(ftype)
5207 
      iprot.readFieldEnd()
5208 
    iprot.readStructEnd()
5209 
 
5210 
  def write(self, oprot):
5211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5213 
      return
559 chandransh 5214 
    oprot.writeStructBegin('getCart_args')
5215 
    if self.cartId != None:
5216 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5217 
      oprot.writeI64(self.cartId)
504 rajveer 5218 
      oprot.writeFieldEnd()
5219 
    oprot.writeFieldStop()
5220 
    oprot.writeStructEnd()
5221 
 
5222 
  def __repr__(self):
5223 
    L = ['%s=%r' % (key, value)
5224 
      for key, value in self.__dict__.iteritems()]
5225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5226 
 
5227 
  def __eq__(self, other):
5228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5229 
 
5230 
  def __ne__(self, other):
5231 
    return not (self == other)
5232 
 
559 chandransh 5233 
class getCart_result:
504 rajveer 5234 
  """
5235 
  Attributes:
5236 
   - success
559 chandransh 5237 
   - scx
504 rajveer 5238 
  """
5239 
 
5240 
  thrift_spec = (
559 chandransh 5241 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
5242 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 5243 
  )
5244 
 
559 chandransh 5245 
  def __init__(self, success=None, scx=None,):
504 rajveer 5246 
    self.success = success
559 chandransh 5247 
    self.scx = scx
504 rajveer 5248 
 
5249 
  def read(self, iprot):
5250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5252 
      return
5253 
    iprot.readStructBegin()
5254 
    while True:
5255 
      (fname, ftype, fid) = iprot.readFieldBegin()
5256 
      if ftype == TType.STOP:
5257 
        break
5258 
      if fid == 0:
559 chandransh 5259 
        if ftype == TType.STRUCT:
5260 
          self.success = Cart()
5261 
          self.success.read(iprot)
504 rajveer 5262 
        else:
5263 
          iprot.skip(ftype)
5264 
      elif fid == 1:
5265 
        if ftype == TType.STRUCT:
559 chandransh 5266 
          self.scx = ShoppingCartException()
5267 
          self.scx.read(iprot)
504 rajveer 5268 
        else:
5269 
          iprot.skip(ftype)
5270 
      else:
5271 
        iprot.skip(ftype)
5272 
      iprot.readFieldEnd()
5273 
    iprot.readStructEnd()
5274 
 
5275 
  def write(self, oprot):
5276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5278 
      return
559 chandransh 5279 
    oprot.writeStructBegin('getCart_result')
504 rajveer 5280 
    if self.success != None:
559 chandransh 5281 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5282 
      self.success.write(oprot)
504 rajveer 5283 
      oprot.writeFieldEnd()
559 chandransh 5284 
    if self.scx != None:
5285 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5286 
      self.scx.write(oprot)
504 rajveer 5287 
      oprot.writeFieldEnd()
5288 
    oprot.writeFieldStop()
5289 
    oprot.writeStructEnd()
5290 
 
5291 
  def __repr__(self):
5292 
    L = ['%s=%r' % (key, value)
5293 
      for key, value in self.__dict__.iteritems()]
5294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5295 
 
5296 
  def __eq__(self, other):
5297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5298 
 
5299 
  def __ne__(self, other):
5300 
    return not (self == other)
5301 
 
559 chandransh 5302 
class getCartsForUser_args:
94 ashish 5303 
  """
5304 
  Attributes:
559 chandransh 5305 
   - userId
5306 
   - status
94 ashish 5307 
  """
5308 
 
5309 
  thrift_spec = (
5310 
    None, # 0
559 chandransh 5311 
    (1, TType.I64, 'userId', None, None, ), # 1
5312 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 5313 
  )
5314 
 
559 chandransh 5315 
  def __init__(self, userId=None, status=None,):
5316 
    self.userId = userId
5317 
    self.status = status
94 ashish 5318 
 
5319 
  def read(self, iprot):
5320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5322 
      return
5323 
    iprot.readStructBegin()
5324 
    while True:
5325 
      (fname, ftype, fid) = iprot.readFieldBegin()
5326 
      if ftype == TType.STOP:
5327 
        break
5328 
      if fid == 1:
5329 
        if ftype == TType.I64:
559 chandransh 5330 
          self.userId = iprot.readI64();
94 ashish 5331 
        else:
5332 
          iprot.skip(ftype)
5333 
      elif fid == 2:
559 chandransh 5334 
        if ftype == TType.I32:
5335 
          self.status = iprot.readI32();
94 ashish 5336 
        else:
5337 
          iprot.skip(ftype)
5338 
      else:
5339 
        iprot.skip(ftype)
5340 
      iprot.readFieldEnd()
5341 
    iprot.readStructEnd()
5342 
 
5343 
  def write(self, oprot):
5344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5346 
      return
559 chandransh 5347 
    oprot.writeStructBegin('getCartsForUser_args')
5348 
    if self.userId != None:
5349 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5350 
      oprot.writeI64(self.userId)
94 ashish 5351 
      oprot.writeFieldEnd()
559 chandransh 5352 
    if self.status != None:
5353 
      oprot.writeFieldBegin('status', TType.I32, 2)
5354 
      oprot.writeI32(self.status)
94 ashish 5355 
      oprot.writeFieldEnd()
5356 
    oprot.writeFieldStop()
5357 
    oprot.writeStructEnd()
5358 
 
5359 
  def __repr__(self):
5360 
    L = ['%s=%r' % (key, value)
5361 
      for key, value in self.__dict__.iteritems()]
5362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5363 
 
5364 
  def __eq__(self, other):
5365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5366 
 
5367 
  def __ne__(self, other):
5368 
    return not (self == other)
5369 
 
559 chandransh 5370 
class getCartsForUser_result:
94 ashish 5371 
  """
5372 
  Attributes:
5373 
   - success
559 chandransh 5374 
   - scx
94 ashish 5375 
  """
5376 
 
5377 
  thrift_spec = (
559 chandransh 5378 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
5379 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 5380 
  )
5381 
 
559 chandransh 5382 
  def __init__(self, success=None, scx=None,):
94 ashish 5383 
    self.success = success
559 chandransh 5384 
    self.scx = scx
94 ashish 5385 
 
5386 
  def read(self, iprot):
5387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5389 
      return
5390 
    iprot.readStructBegin()
5391 
    while True:
5392 
      (fname, ftype, fid) = iprot.readFieldBegin()
5393 
      if ftype == TType.STOP:
5394 
        break
5395 
      if fid == 0:
559 chandransh 5396 
        if ftype == TType.LIST:
5397 
          self.success = []
594 rajveer 5398 
          (_etype47, _size44) = iprot.readListBegin()
5399 
          for _i48 in xrange(_size44):
5400 
            _elem49 = Cart()
5401 
            _elem49.read(iprot)
5402 
            self.success.append(_elem49)
559 chandransh 5403 
          iprot.readListEnd()
94 ashish 5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      elif fid == 1:
5407 
        if ftype == TType.STRUCT:
559 chandransh 5408 
          self.scx = ShoppingCartException()
5409 
          self.scx.read(iprot)
94 ashish 5410 
        else:
5411 
          iprot.skip(ftype)
5412 
      else:
5413 
        iprot.skip(ftype)
5414 
      iprot.readFieldEnd()
5415 
    iprot.readStructEnd()
5416 
 
5417 
  def write(self, oprot):
5418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5420 
      return
559 chandransh 5421 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 5422 
    if self.success != None:
559 chandransh 5423 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5424 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
594 rajveer 5425 
      for iter50 in self.success:
5426 
        iter50.write(oprot)
559 chandransh 5427 
      oprot.writeListEnd()
94 ashish 5428 
      oprot.writeFieldEnd()
559 chandransh 5429 
    if self.scx != None:
5430 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5431 
      self.scx.write(oprot)
94 ashish 5432 
      oprot.writeFieldEnd()
5433 
    oprot.writeFieldStop()
5434 
    oprot.writeStructEnd()
5435 
 
5436 
  def __repr__(self):
5437 
    L = ['%s=%r' % (key, value)
5438 
      for key, value in self.__dict__.iteritems()]
5439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5440 
 
5441 
  def __eq__(self, other):
5442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5443 
 
5444 
  def __ne__(self, other):
5445 
    return not (self == other)
5446 
 
559 chandransh 5447 
class getCartsByStatus_args:
94 ashish 5448 
  """
5449 
  Attributes:
559 chandransh 5450 
   - status
94 ashish 5451 
  """
5452 
 
5453 
  thrift_spec = (
5454 
    None, # 0
559 chandransh 5455 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 5456 
  )
5457 
 
559 chandransh 5458 
  def __init__(self, status=None,):
5459 
    self.status = status
94 ashish 5460 
 
5461 
  def read(self, iprot):
5462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5464 
      return
5465 
    iprot.readStructBegin()
5466 
    while True:
5467 
      (fname, ftype, fid) = iprot.readFieldBegin()
5468 
      if ftype == TType.STOP:
5469 
        break
5470 
      if fid == 1:
559 chandransh 5471 
        if ftype == TType.I32:
5472 
          self.status = iprot.readI32();
5473 
        else:
5474 
          iprot.skip(ftype)
5475 
      else:
5476 
        iprot.skip(ftype)
5477 
      iprot.readFieldEnd()
5478 
    iprot.readStructEnd()
5479 
 
5480 
  def write(self, oprot):
5481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5483 
      return
5484 
    oprot.writeStructBegin('getCartsByStatus_args')
5485 
    if self.status != None:
5486 
      oprot.writeFieldBegin('status', TType.I32, 1)
5487 
      oprot.writeI32(self.status)
5488 
      oprot.writeFieldEnd()
5489 
    oprot.writeFieldStop()
5490 
    oprot.writeStructEnd()
5491 
 
5492 
  def __repr__(self):
5493 
    L = ['%s=%r' % (key, value)
5494 
      for key, value in self.__dict__.iteritems()]
5495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5496 
 
5497 
  def __eq__(self, other):
5498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5499 
 
5500 
  def __ne__(self, other):
5501 
    return not (self == other)
5502 
 
5503 
class getCartsByStatus_result:
5504 
  """
5505 
  Attributes:
5506 
   - success
5507 
   - scx
5508 
  """
5509 
 
5510 
  thrift_spec = (
5511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
5512 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5513 
  )
5514 
 
5515 
  def __init__(self, success=None, scx=None,):
5516 
    self.success = success
5517 
    self.scx = scx
5518 
 
5519 
  def read(self, iprot):
5520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5522 
      return
5523 
    iprot.readStructBegin()
5524 
    while True:
5525 
      (fname, ftype, fid) = iprot.readFieldBegin()
5526 
      if ftype == TType.STOP:
5527 
        break
5528 
      if fid == 0:
5529 
        if ftype == TType.LIST:
5530 
          self.success = []
594 rajveer 5531 
          (_etype54, _size51) = iprot.readListBegin()
5532 
          for _i55 in xrange(_size51):
5533 
            _elem56 = Cart()
5534 
            _elem56.read(iprot)
5535 
            self.success.append(_elem56)
559 chandransh 5536 
          iprot.readListEnd()
5537 
        else:
5538 
          iprot.skip(ftype)
5539 
      elif fid == 1:
5540 
        if ftype == TType.STRUCT:
5541 
          self.scx = ShoppingCartException()
5542 
          self.scx.read(iprot)
5543 
        else:
5544 
          iprot.skip(ftype)
5545 
      else:
5546 
        iprot.skip(ftype)
5547 
      iprot.readFieldEnd()
5548 
    iprot.readStructEnd()
5549 
 
5550 
  def write(self, oprot):
5551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5553 
      return
5554 
    oprot.writeStructBegin('getCartsByStatus_result')
5555 
    if self.success != None:
5556 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5557 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
594 rajveer 5558 
      for iter57 in self.success:
5559 
        iter57.write(oprot)
559 chandransh 5560 
      oprot.writeListEnd()
5561 
      oprot.writeFieldEnd()
5562 
    if self.scx != None:
5563 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5564 
      self.scx.write(oprot)
5565 
      oprot.writeFieldEnd()
5566 
    oprot.writeFieldStop()
5567 
    oprot.writeStructEnd()
5568 
 
5569 
  def __repr__(self):
5570 
    L = ['%s=%r' % (key, value)
5571 
      for key, value in self.__dict__.iteritems()]
5572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5573 
 
5574 
  def __eq__(self, other):
5575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5576 
 
5577 
  def __ne__(self, other):
5578 
    return not (self == other)
5579 
 
5580 
class getCartsByTime_args:
5581 
  """
5582 
  Attributes:
5583 
   - from_time
5584 
   - to_time
5585 
   - status
5586 
  """
5587 
 
5588 
  thrift_spec = (
5589 
    None, # 0
5590 
    (1, TType.I64, 'from_time', None, None, ), # 1
5591 
    (2, TType.I64, 'to_time', None, None, ), # 2
5592 
    (3, TType.I32, 'status', None, None, ), # 3
5593 
  )
5594 
 
5595 
  def __init__(self, from_time=None, to_time=None, status=None,):
5596 
    self.from_time = from_time
5597 
    self.to_time = to_time
5598 
    self.status = status
5599 
 
5600 
  def read(self, iprot):
5601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5603 
      return
5604 
    iprot.readStructBegin()
5605 
    while True:
5606 
      (fname, ftype, fid) = iprot.readFieldBegin()
5607 
      if ftype == TType.STOP:
5608 
        break
5609 
      if fid == 1:
94 ashish 5610 
        if ftype == TType.I64:
559 chandransh 5611 
          self.from_time = iprot.readI64();
94 ashish 5612 
        else:
5613 
          iprot.skip(ftype)
122 ashish 5614 
      elif fid == 2:
559 chandransh 5615 
        if ftype == TType.I64:
5616 
          self.to_time = iprot.readI64();
122 ashish 5617 
        else:
5618 
          iprot.skip(ftype)
559 chandransh 5619 
      elif fid == 3:
5620 
        if ftype == TType.I32:
5621 
          self.status = iprot.readI32();
5622 
        else:
5623 
          iprot.skip(ftype)
94 ashish 5624 
      else:
5625 
        iprot.skip(ftype)
5626 
      iprot.readFieldEnd()
5627 
    iprot.readStructEnd()
5628 
 
5629 
  def write(self, oprot):
5630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5632 
      return
559 chandransh 5633 
    oprot.writeStructBegin('getCartsByTime_args')
5634 
    if self.from_time != None:
5635 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
5636 
      oprot.writeI64(self.from_time)
94 ashish 5637 
      oprot.writeFieldEnd()
559 chandransh 5638 
    if self.to_time != None:
5639 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
5640 
      oprot.writeI64(self.to_time)
122 ashish 5641 
      oprot.writeFieldEnd()
559 chandransh 5642 
    if self.status != None:
5643 
      oprot.writeFieldBegin('status', TType.I32, 3)
5644 
      oprot.writeI32(self.status)
5645 
      oprot.writeFieldEnd()
94 ashish 5646 
    oprot.writeFieldStop()
5647 
    oprot.writeStructEnd()
5648 
 
5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
559 chandransh 5660 
class getCartsByTime_result:
94 ashish 5661 
  """
5662 
  Attributes:
5663 
   - success
559 chandransh 5664 
   - scx
94 ashish 5665 
  """
5666 
 
5667 
  thrift_spec = (
559 chandransh 5668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
5669 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 5670 
  )
5671 
 
559 chandransh 5672 
  def __init__(self, success=None, scx=None,):
94 ashish 5673 
    self.success = success
559 chandransh 5674 
    self.scx = scx
94 ashish 5675 
 
5676 
  def read(self, iprot):
5677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5679 
      return
5680 
    iprot.readStructBegin()
5681 
    while True:
5682 
      (fname, ftype, fid) = iprot.readFieldBegin()
5683 
      if ftype == TType.STOP:
5684 
        break
5685 
      if fid == 0:
559 chandransh 5686 
        if ftype == TType.LIST:
5687 
          self.success = []
594 rajveer 5688 
          (_etype61, _size58) = iprot.readListBegin()
5689 
          for _i62 in xrange(_size58):
5690 
            _elem63 = Cart()
5691 
            _elem63.read(iprot)
5692 
            self.success.append(_elem63)
559 chandransh 5693 
          iprot.readListEnd()
94 ashish 5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      elif fid == 1:
5697 
        if ftype == TType.STRUCT:
559 chandransh 5698 
          self.scx = ShoppingCartException()
5699 
          self.scx.read(iprot)
94 ashish 5700 
        else:
5701 
          iprot.skip(ftype)
5702 
      else:
5703 
        iprot.skip(ftype)
5704 
      iprot.readFieldEnd()
5705 
    iprot.readStructEnd()
5706 
 
5707 
  def write(self, oprot):
5708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5710 
      return
559 chandransh 5711 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 5712 
    if self.success != None:
559 chandransh 5713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
594 rajveer 5715 
      for iter64 in self.success:
5716 
        iter64.write(oprot)
559 chandransh 5717 
      oprot.writeListEnd()
94 ashish 5718 
      oprot.writeFieldEnd()
559 chandransh 5719 
    if self.scx != None:
5720 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5721 
      self.scx.write(oprot)
94 ashish 5722 
      oprot.writeFieldEnd()
5723 
    oprot.writeFieldStop()
5724 
    oprot.writeStructEnd()
5725 
 
5726 
  def __repr__(self):
5727 
    L = ['%s=%r' % (key, value)
5728 
      for key, value in self.__dict__.iteritems()]
5729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5730 
 
5731 
  def __eq__(self, other):
5732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5733 
 
5734 
  def __ne__(self, other):
5735 
    return not (self == other)
5736 
 
559 chandransh 5737 
class changeCartStatus_args:
94 ashish 5738 
  """
5739 
  Attributes:
559 chandransh 5740 
   - cartId
5741 
   - status
94 ashish 5742 
  """
5743 
 
5744 
  thrift_spec = (
5745 
    None, # 0
559 chandransh 5746 
    (1, TType.I64, 'cartId', None, None, ), # 1
5747 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 5748 
  )
5749 
 
559 chandransh 5750 
  def __init__(self, cartId=None, status=None,):
5751 
    self.cartId = cartId
5752 
    self.status = status
94 ashish 5753 
 
5754 
  def read(self, iprot):
5755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5757 
      return
5758 
    iprot.readStructBegin()
5759 
    while True:
5760 
      (fname, ftype, fid) = iprot.readFieldBegin()
5761 
      if ftype == TType.STOP:
5762 
        break
5763 
      if fid == 1:
5764 
        if ftype == TType.I64:
559 chandransh 5765 
          self.cartId = iprot.readI64();
94 ashish 5766 
        else:
5767 
          iprot.skip(ftype)
559 chandransh 5768 
      elif fid == 2:
5769 
        if ftype == TType.I32:
5770 
          self.status = iprot.readI32();
5771 
        else:
5772 
          iprot.skip(ftype)
94 ashish 5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
559 chandransh 5782 
    oprot.writeStructBegin('changeCartStatus_args')
5783 
    if self.cartId != None:
5784 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5785 
      oprot.writeI64(self.cartId)
94 ashish 5786 
      oprot.writeFieldEnd()
559 chandransh 5787 
    if self.status != None:
5788 
      oprot.writeFieldBegin('status', TType.I32, 2)
5789 
      oprot.writeI32(self.status)
5790 
      oprot.writeFieldEnd()
94 ashish 5791 
    oprot.writeFieldStop()
5792 
    oprot.writeStructEnd()
5793 
 
5794 
  def __repr__(self):
5795 
    L = ['%s=%r' % (key, value)
5796 
      for key, value in self.__dict__.iteritems()]
5797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5798 
 
5799 
  def __eq__(self, other):
5800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5801 
 
5802 
  def __ne__(self, other):
5803 
    return not (self == other)
5804 
 
559 chandransh 5805 
class changeCartStatus_result:
94 ashish 5806 
  """
5807 
  Attributes:
559 chandransh 5808 
   - scx
5809 
  """
5810 
 
5811 
  thrift_spec = (
5812 
    None, # 0
5813 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5814 
  )
5815 
 
5816 
  def __init__(self, scx=None,):
5817 
    self.scx = scx
5818 
 
5819 
  def read(self, iprot):
5820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5822 
      return
5823 
    iprot.readStructBegin()
5824 
    while True:
5825 
      (fname, ftype, fid) = iprot.readFieldBegin()
5826 
      if ftype == TType.STOP:
5827 
        break
5828 
      if fid == 1:
5829 
        if ftype == TType.STRUCT:
5830 
          self.scx = ShoppingCartException()
5831 
          self.scx.read(iprot)
5832 
        else:
5833 
          iprot.skip(ftype)
5834 
      else:
5835 
        iprot.skip(ftype)
5836 
      iprot.readFieldEnd()
5837 
    iprot.readStructEnd()
5838 
 
5839 
  def write(self, oprot):
5840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5842 
      return
5843 
    oprot.writeStructBegin('changeCartStatus_result')
5844 
    if self.scx != None:
5845 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5846 
      self.scx.write(oprot)
5847 
      oprot.writeFieldEnd()
5848 
    oprot.writeFieldStop()
5849 
    oprot.writeStructEnd()
5850 
 
5851 
  def __repr__(self):
5852 
    L = ['%s=%r' % (key, value)
5853 
      for key, value in self.__dict__.iteritems()]
5854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5855 
 
5856 
  def __eq__(self, other):
5857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5858 
 
5859 
  def __ne__(self, other):
5860 
    return not (self == other)
5861 
 
5862 
class addItemToCart_args:
5863 
  """
5864 
  Attributes:
5865 
   - cartId
5866 
   - itemId
5867 
   - quantity
5868 
  """
5869 
 
5870 
  thrift_spec = (
5871 
    None, # 0
5872 
    (1, TType.I64, 'cartId', None, None, ), # 1
5873 
    (2, TType.I64, 'itemId', None, None, ), # 2
5874 
    (3, TType.I64, 'quantity', None, None, ), # 3
5875 
  )
5876 
 
5877 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
5878 
    self.cartId = cartId
5879 
    self.itemId = itemId
5880 
    self.quantity = quantity
5881 
 
5882 
  def read(self, iprot):
5883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5885 
      return
5886 
    iprot.readStructBegin()
5887 
    while True:
5888 
      (fname, ftype, fid) = iprot.readFieldBegin()
5889 
      if ftype == TType.STOP:
5890 
        break
5891 
      if fid == 1:
5892 
        if ftype == TType.I64:
5893 
          self.cartId = iprot.readI64();
5894 
        else:
5895 
          iprot.skip(ftype)
5896 
      elif fid == 2:
5897 
        if ftype == TType.I64:
5898 
          self.itemId = iprot.readI64();
5899 
        else:
5900 
          iprot.skip(ftype)
5901 
      elif fid == 3:
5902 
        if ftype == TType.I64:
5903 
          self.quantity = iprot.readI64();
5904 
        else:
5905 
          iprot.skip(ftype)
5906 
      else:
5907 
        iprot.skip(ftype)
5908 
      iprot.readFieldEnd()
5909 
    iprot.readStructEnd()
5910 
 
5911 
  def write(self, oprot):
5912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5914 
      return
5915 
    oprot.writeStructBegin('addItemToCart_args')
5916 
    if self.cartId != None:
5917 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5918 
      oprot.writeI64(self.cartId)
5919 
      oprot.writeFieldEnd()
5920 
    if self.itemId != None:
5921 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
5922 
      oprot.writeI64(self.itemId)
5923 
      oprot.writeFieldEnd()
5924 
    if self.quantity != None:
5925 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5926 
      oprot.writeI64(self.quantity)
5927 
      oprot.writeFieldEnd()
5928 
    oprot.writeFieldStop()
5929 
    oprot.writeStructEnd()
5930 
 
5931 
  def __repr__(self):
5932 
    L = ['%s=%r' % (key, value)
5933 
      for key, value in self.__dict__.iteritems()]
5934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5935 
 
5936 
  def __eq__(self, other):
5937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5938 
 
5939 
  def __ne__(self, other):
5940 
    return not (self == other)
5941 
 
5942 
class addItemToCart_result:
5943 
  """
5944 
  Attributes:
5945 
   - scx
5946 
  """
5947 
 
5948 
  thrift_spec = (
5949 
    None, # 0
5950 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5951 
  )
5952 
 
5953 
  def __init__(self, scx=None,):
5954 
    self.scx = scx
5955 
 
5956 
  def read(self, iprot):
5957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5959 
      return
5960 
    iprot.readStructBegin()
5961 
    while True:
5962 
      (fname, ftype, fid) = iprot.readFieldBegin()
5963 
      if ftype == TType.STOP:
5964 
        break
5965 
      if fid == 1:
5966 
        if ftype == TType.STRUCT:
5967 
          self.scx = ShoppingCartException()
5968 
          self.scx.read(iprot)
5969 
        else:
5970 
          iprot.skip(ftype)
5971 
      else:
5972 
        iprot.skip(ftype)
5973 
      iprot.readFieldEnd()
5974 
    iprot.readStructEnd()
5975 
 
5976 
  def write(self, oprot):
5977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5979 
      return
5980 
    oprot.writeStructBegin('addItemToCart_result')
5981 
    if self.scx != None:
5982 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5983 
      self.scx.write(oprot)
5984 
      oprot.writeFieldEnd()
5985 
    oprot.writeFieldStop()
5986 
    oprot.writeStructEnd()
5987 
 
5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
5999 
class deleteItemFromCart_args:
6000 
  """
6001 
  Attributes:
6002 
   - cartId
6003 
   - itemId
6004 
  """
6005 
 
6006 
  thrift_spec = (
6007 
    None, # 0
6008 
    (1, TType.I64, 'cartId', None, None, ), # 1
6009 
    (2, TType.I64, 'itemId', None, None, ), # 2
6010 
  )
6011 
 
6012 
  def __init__(self, cartId=None, itemId=None,):
6013 
    self.cartId = cartId
6014 
    self.itemId = itemId
6015 
 
6016 
  def read(self, iprot):
6017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6019 
      return
6020 
    iprot.readStructBegin()
6021 
    while True:
6022 
      (fname, ftype, fid) = iprot.readFieldBegin()
6023 
      if ftype == TType.STOP:
6024 
        break
6025 
      if fid == 1:
6026 
        if ftype == TType.I64:
6027 
          self.cartId = iprot.readI64();
6028 
        else:
6029 
          iprot.skip(ftype)
6030 
      elif fid == 2:
6031 
        if ftype == TType.I64:
6032 
          self.itemId = iprot.readI64();
6033 
        else:
6034 
          iprot.skip(ftype)
6035 
      else:
6036 
        iprot.skip(ftype)
6037 
      iprot.readFieldEnd()
6038 
    iprot.readStructEnd()
6039 
 
6040 
  def write(self, oprot):
6041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6043 
      return
6044 
    oprot.writeStructBegin('deleteItemFromCart_args')
6045 
    if self.cartId != None:
6046 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6047 
      oprot.writeI64(self.cartId)
6048 
      oprot.writeFieldEnd()
6049 
    if self.itemId != None:
6050 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
6051 
      oprot.writeI64(self.itemId)
6052 
      oprot.writeFieldEnd()
6053 
    oprot.writeFieldStop()
6054 
    oprot.writeStructEnd()
6055 
 
6056 
  def __repr__(self):
6057 
    L = ['%s=%r' % (key, value)
6058 
      for key, value in self.__dict__.iteritems()]
6059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6060 
 
6061 
  def __eq__(self, other):
6062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6063 
 
6064 
  def __ne__(self, other):
6065 
    return not (self == other)
6066 
 
6067 
class deleteItemFromCart_result:
6068 
  """
6069 
  Attributes:
6070 
   - scx
6071 
  """
6072 
 
6073 
  thrift_spec = (
6074 
    None, # 0
6075 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
6076 
  )
6077 
 
6078 
  def __init__(self, scx=None,):
6079 
    self.scx = scx
6080 
 
6081 
  def read(self, iprot):
6082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6084 
      return
6085 
    iprot.readStructBegin()
6086 
    while True:
6087 
      (fname, ftype, fid) = iprot.readFieldBegin()
6088 
      if ftype == TType.STOP:
6089 
        break
6090 
      if fid == 1:
6091 
        if ftype == TType.STRUCT:
6092 
          self.scx = ShoppingCartException()
6093 
          self.scx.read(iprot)
6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      else:
6097 
        iprot.skip(ftype)
6098 
      iprot.readFieldEnd()
6099 
    iprot.readStructEnd()
6100 
 
6101 
  def write(self, oprot):
6102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6104 
      return
6105 
    oprot.writeStructBegin('deleteItemFromCart_result')
6106 
    if self.scx != None:
6107 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6108 
      self.scx.write(oprot)
6109 
      oprot.writeFieldEnd()
6110 
    oprot.writeFieldStop()
6111 
    oprot.writeStructEnd()
6112 
 
6113 
  def __repr__(self):
6114 
    L = ['%s=%r' % (key, value)
6115 
      for key, value in self.__dict__.iteritems()]
6116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6117 
 
6118 
  def __eq__(self, other):
6119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6120 
 
6121 
  def __ne__(self, other):
6122 
    return not (self == other)
6123 
 
6124 
class changeQuantity_args:
6125 
  """
6126 
  Attributes:
6127 
   - cartId
6128 
   - itemId
6129 
   - quantity
6130 
  """
6131 
 
6132 
  thrift_spec = (
6133 
    None, # 0
6134 
    (1, TType.I64, 'cartId', None, None, ), # 1
6135 
    (2, TType.I64, 'itemId', None, None, ), # 2
6136 
    (3, TType.I64, 'quantity', None, None, ), # 3
6137 
  )
6138 
 
6139 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
6140 
    self.cartId = cartId
6141 
    self.itemId = itemId
6142 
    self.quantity = quantity
6143 
 
6144 
  def read(self, iprot):
6145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6147 
      return
6148 
    iprot.readStructBegin()
6149 
    while True:
6150 
      (fname, ftype, fid) = iprot.readFieldBegin()
6151 
      if ftype == TType.STOP:
6152 
        break
6153 
      if fid == 1:
6154 
        if ftype == TType.I64:
6155 
          self.cartId = iprot.readI64();
6156 
        else:
6157 
          iprot.skip(ftype)
6158 
      elif fid == 2:
6159 
        if ftype == TType.I64:
6160 
          self.itemId = iprot.readI64();
6161 
        else:
6162 
          iprot.skip(ftype)
6163 
      elif fid == 3:
6164 
        if ftype == TType.I64:
6165 
          self.quantity = iprot.readI64();
6166 
        else:
6167 
          iprot.skip(ftype)
6168 
      else:
6169 
        iprot.skip(ftype)
6170 
      iprot.readFieldEnd()
6171 
    iprot.readStructEnd()
6172 
 
6173 
  def write(self, oprot):
6174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6176 
      return
6177 
    oprot.writeStructBegin('changeQuantity_args')
6178 
    if self.cartId != None:
6179 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6180 
      oprot.writeI64(self.cartId)
6181 
      oprot.writeFieldEnd()
6182 
    if self.itemId != None:
6183 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
6184 
      oprot.writeI64(self.itemId)
6185 
      oprot.writeFieldEnd()
6186 
    if self.quantity != None:
6187 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
6188 
      oprot.writeI64(self.quantity)
6189 
      oprot.writeFieldEnd()
6190 
    oprot.writeFieldStop()
6191 
    oprot.writeStructEnd()
6192 
 
6193 
  def __repr__(self):
6194 
    L = ['%s=%r' % (key, value)
6195 
      for key, value in self.__dict__.iteritems()]
6196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6197 
 
6198 
  def __eq__(self, other):
6199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6200 
 
6201 
  def __ne__(self, other):
6202 
    return not (self == other)
6203 
 
6204 
class changeQuantity_result:
6205 
  """
6206 
  Attributes:
6207 
   - scx
6208 
  """
6209 
 
6210 
  thrift_spec = (
6211 
    None, # 0
6212 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
6213 
  )
6214 
 
6215 
  def __init__(self, scx=None,):
6216 
    self.scx = scx
6217 
 
6218 
  def read(self, iprot):
6219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6221 
      return
6222 
    iprot.readStructBegin()
6223 
    while True:
6224 
      (fname, ftype, fid) = iprot.readFieldBegin()
6225 
      if ftype == TType.STOP:
6226 
        break
6227 
      if fid == 1:
6228 
        if ftype == TType.STRUCT:
6229 
          self.scx = ShoppingCartException()
6230 
          self.scx.read(iprot)
6231 
        else:
6232 
          iprot.skip(ftype)
6233 
      else:
6234 
        iprot.skip(ftype)
6235 
      iprot.readFieldEnd()
6236 
    iprot.readStructEnd()
6237 
 
6238 
  def write(self, oprot):
6239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6241 
      return
6242 
    oprot.writeStructBegin('changeQuantity_result')
6243 
    if self.scx != None:
6244 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6245 
      self.scx.write(oprot)
6246 
      oprot.writeFieldEnd()
6247 
    oprot.writeFieldStop()
6248 
    oprot.writeStructEnd()
6249 
 
6250 
  def __repr__(self):
6251 
    L = ['%s=%r' % (key, value)
6252 
      for key, value in self.__dict__.iteritems()]
6253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6254 
 
6255 
  def __eq__(self, other):
6256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6257 
 
6258 
  def __ne__(self, other):
6259 
    return not (self == other)
6260 
 
6261 
class changeItemStatus_args:
6262 
  """
6263 
  Attributes:
6264 
   - cartId
6265 
   - itemId
6266 
   - status
6267 
  """
6268 
 
6269 
  thrift_spec = (
6270 
    None, # 0
6271 
    (1, TType.I64, 'cartId', None, None, ), # 1
6272 
    (2, TType.I64, 'itemId', None, None, ), # 2
6273 
    (3, TType.I32, 'status', None, None, ), # 3
6274 
  )
6275 
 
6276 
  def __init__(self, cartId=None, itemId=None, status=None,):
6277 
    self.cartId = cartId
6278 
    self.itemId = itemId
6279 
    self.status = status
6280 
 
6281 
  def read(self, iprot):
6282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6284 
      return
6285 
    iprot.readStructBegin()
6286 
    while True:
6287 
      (fname, ftype, fid) = iprot.readFieldBegin()
6288 
      if ftype == TType.STOP:
6289 
        break
6290 
      if fid == 1:
6291 
        if ftype == TType.I64:
6292 
          self.cartId = iprot.readI64();
6293 
        else:
6294 
          iprot.skip(ftype)
6295 
      elif fid == 2:
6296 
        if ftype == TType.I64:
6297 
          self.itemId = iprot.readI64();
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      elif fid == 3:
6301 
        if ftype == TType.I32:
6302 
          self.status = iprot.readI32();
6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      else:
6306 
        iprot.skip(ftype)
6307 
      iprot.readFieldEnd()
6308 
    iprot.readStructEnd()
6309 
 
6310 
  def write(self, oprot):
6311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6313 
      return
6314 
    oprot.writeStructBegin('changeItemStatus_args')
6315 
    if self.cartId != None:
6316 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6317 
      oprot.writeI64(self.cartId)
6318 
      oprot.writeFieldEnd()
6319 
    if self.itemId != None:
6320 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
6321 
      oprot.writeI64(self.itemId)
6322 
      oprot.writeFieldEnd()
6323 
    if self.status != None:
6324 
      oprot.writeFieldBegin('status', TType.I32, 3)
6325 
      oprot.writeI32(self.status)
6326 
      oprot.writeFieldEnd()
6327 
    oprot.writeFieldStop()
6328 
    oprot.writeStructEnd()
6329 
 
6330 
  def __repr__(self):
6331 
    L = ['%s=%r' % (key, value)
6332 
      for key, value in self.__dict__.iteritems()]
6333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6334 
 
6335 
  def __eq__(self, other):
6336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6337 
 
6338 
  def __ne__(self, other):
6339 
    return not (self == other)
6340 
 
6341 
class changeItemStatus_result:
6342 
  """
6343 
  Attributes:
6344 
   - scx
6345 
  """
6346 
 
6347 
  thrift_spec = (
6348 
    None, # 0
6349 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
6350 
  )
6351 
 
6352 
  def __init__(self, scx=None,):
6353 
    self.scx = scx
6354 
 
6355 
  def read(self, iprot):
6356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6358 
      return
6359 
    iprot.readStructBegin()
6360 
    while True:
6361 
      (fname, ftype, fid) = iprot.readFieldBegin()
6362 
      if ftype == TType.STOP:
6363 
        break
6364 
      if fid == 1:
6365 
        if ftype == TType.STRUCT:
6366 
          self.scx = ShoppingCartException()
6367 
          self.scx.read(iprot)
6368 
        else:
6369 
          iprot.skip(ftype)
6370 
      else:
6371 
        iprot.skip(ftype)
6372 
      iprot.readFieldEnd()
6373 
    iprot.readStructEnd()
6374 
 
6375 
  def write(self, oprot):
6376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6378 
      return
6379 
    oprot.writeStructBegin('changeItemStatus_result')
6380 
    if self.scx != None:
6381 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6382 
      self.scx.write(oprot)
6383 
      oprot.writeFieldEnd()
6384 
    oprot.writeFieldStop()
6385 
    oprot.writeStructEnd()
6386 
 
6387 
  def __repr__(self):
6388 
    L = ['%s=%r' % (key, value)
6389 
      for key, value in self.__dict__.iteritems()]
6390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6391 
 
6392 
  def __eq__(self, other):
6393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6394 
 
6395 
  def __ne__(self, other):
6396 
    return not (self == other)
6397 
 
6398 
class addAddressToCart_args:
6399 
  """
6400 
  Attributes:
6401 
   - cartId
6402 
   - addressId
6403 
  """
6404 
 
6405 
  thrift_spec = (
6406 
    None, # 0
6407 
    (1, TType.I64, 'cartId', None, None, ), # 1
6408 
    (2, TType.I64, 'addressId', None, None, ), # 2
6409 
  )
6410 
 
6411 
  def __init__(self, cartId=None, addressId=None,):
6412 
    self.cartId = cartId
6413 
    self.addressId = addressId
6414 
 
6415 
  def read(self, iprot):
6416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6418 
      return
6419 
    iprot.readStructBegin()
6420 
    while True:
6421 
      (fname, ftype, fid) = iprot.readFieldBegin()
6422 
      if ftype == TType.STOP:
6423 
        break
6424 
      if fid == 1:
6425 
        if ftype == TType.I64:
6426 
          self.cartId = iprot.readI64();
6427 
        else:
6428 
          iprot.skip(ftype)
6429 
      elif fid == 2:
6430 
        if ftype == TType.I64:
6431 
          self.addressId = iprot.readI64();
6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      else:
6435 
        iprot.skip(ftype)
6436 
      iprot.readFieldEnd()
6437 
    iprot.readStructEnd()
6438 
 
6439 
  def write(self, oprot):
6440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6442 
      return
6443 
    oprot.writeStructBegin('addAddressToCart_args')
6444 
    if self.cartId != None:
6445 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6446 
      oprot.writeI64(self.cartId)
6447 
      oprot.writeFieldEnd()
6448 
    if self.addressId != None:
6449 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6450 
      oprot.writeI64(self.addressId)
6451 
      oprot.writeFieldEnd()
6452 
    oprot.writeFieldStop()
6453 
    oprot.writeStructEnd()
6454 
 
6455 
  def __repr__(self):
6456 
    L = ['%s=%r' % (key, value)
6457 
      for key, value in self.__dict__.iteritems()]
6458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6459 
 
6460 
  def __eq__(self, other):
6461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6462 
 
6463 
  def __ne__(self, other):
6464 
    return not (self == other)
6465 
 
6466 
class addAddressToCart_result:
575 chandransh 6467 
  """
6468 
  Attributes:
6469 
   - scx
6470 
  """
559 chandransh 6471 
 
6472 
  thrift_spec = (
575 chandransh 6473 
    None, # 0
6474 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 6475 
  )
6476 
 
575 chandransh 6477 
  def __init__(self, scx=None,):
6478 
    self.scx = scx
6479 
 
559 chandransh 6480 
  def read(self, iprot):
6481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6483 
      return
6484 
    iprot.readStructBegin()
6485 
    while True:
6486 
      (fname, ftype, fid) = iprot.readFieldBegin()
6487 
      if ftype == TType.STOP:
6488 
        break
575 chandransh 6489 
      if fid == 1:
6490 
        if ftype == TType.STRUCT:
6491 
          self.scx = ShoppingCartException()
6492 
          self.scx.read(iprot)
6493 
        else:
6494 
          iprot.skip(ftype)
559 chandransh 6495 
      else:
6496 
        iprot.skip(ftype)
6497 
      iprot.readFieldEnd()
6498 
    iprot.readStructEnd()
6499 
 
6500 
  def write(self, oprot):
6501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6503 
      return
6504 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 6505 
    if self.scx != None:
6506 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6507 
      self.scx.write(oprot)
6508 
      oprot.writeFieldEnd()
559 chandransh 6509 
    oprot.writeFieldStop()
6510 
    oprot.writeStructEnd()
6511 
 
6512 
  def __repr__(self):
6513 
    L = ['%s=%r' % (key, value)
6514 
      for key, value in self.__dict__.iteritems()]
6515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6516 
 
6517 
  def __eq__(self, other):
6518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6519 
 
6520 
  def __ne__(self, other):
6521 
    return not (self == other)
6522 
 
690 chandransh 6523 
class createOrders_args:
559 chandransh 6524 
  """
6525 
  Attributes:
6526 
   - cartId
6527 
  """
6528 
 
6529 
  thrift_spec = (
6530 
    None, # 0
6531 
    (1, TType.I64, 'cartId', None, None, ), # 1
6532 
  )
6533 
 
6534 
  def __init__(self, cartId=None,):
6535 
    self.cartId = cartId
6536 
 
6537 
  def read(self, iprot):
6538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6540 
      return
6541 
    iprot.readStructBegin()
6542 
    while True:
6543 
      (fname, ftype, fid) = iprot.readFieldBegin()
6544 
      if ftype == TType.STOP:
6545 
        break
6546 
      if fid == 1:
6547 
        if ftype == TType.I64:
6548 
          self.cartId = iprot.readI64();
6549 
        else:
6550 
          iprot.skip(ftype)
6551 
      else:
6552 
        iprot.skip(ftype)
6553 
      iprot.readFieldEnd()
6554 
    iprot.readStructEnd()
6555 
 
6556 
  def write(self, oprot):
6557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6559 
      return
690 chandransh 6560 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 6561 
    if self.cartId != None:
6562 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6563 
      oprot.writeI64(self.cartId)
6564 
      oprot.writeFieldEnd()
6565 
    oprot.writeFieldStop()
6566 
    oprot.writeStructEnd()
6567 
 
6568 
  def __repr__(self):
6569 
    L = ['%s=%r' % (key, value)
6570 
      for key, value in self.__dict__.iteritems()]
6571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6572 
 
6573 
  def __eq__(self, other):
6574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6575 
 
6576 
  def __ne__(self, other):
6577 
    return not (self == other)
6578 
 
690 chandransh 6579 
class createOrders_result:
559 chandransh 6580 
  """
6581 
  Attributes:
94 ashish 6582 
   - success
559 chandransh 6583 
   - scx
94 ashish 6584 
  """
6585 
 
6586 
  thrift_spec = (
575 chandransh 6587 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6588 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 6589 
  )
6590 
 
559 chandransh 6591 
  def __init__(self, success=None, scx=None,):
94 ashish 6592 
    self.success = success
559 chandransh 6593 
    self.scx = scx
94 ashish 6594 
 
6595 
  def read(self, iprot):
6596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6598 
      return
6599 
    iprot.readStructBegin()
6600 
    while True:
6601 
      (fname, ftype, fid) = iprot.readFieldBegin()
6602 
      if ftype == TType.STOP:
6603 
        break
6604 
      if fid == 0:
575 chandransh 6605 
        if ftype == TType.I64:
6606 
          self.success = iprot.readI64();
94 ashish 6607 
        else:
6608 
          iprot.skip(ftype)
6609 
      elif fid == 1:
6610 
        if ftype == TType.STRUCT:
559 chandransh 6611 
          self.scx = ShoppingCartException()
6612 
          self.scx.read(iprot)
94 ashish 6613 
        else:
6614 
          iprot.skip(ftype)
6615 
      else:
6616 
        iprot.skip(ftype)
6617 
      iprot.readFieldEnd()
6618 
    iprot.readStructEnd()
6619 
 
6620 
  def write(self, oprot):
6621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6623 
      return
690 chandransh 6624 
    oprot.writeStructBegin('createOrders_result')
94 ashish 6625 
    if self.success != None:
575 chandransh 6626 
      oprot.writeFieldBegin('success', TType.I64, 0)
6627 
      oprot.writeI64(self.success)
94 ashish 6628 
      oprot.writeFieldEnd()
559 chandransh 6629 
    if self.scx != None:
6630 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6631 
      self.scx.write(oprot)
94 ashish 6632 
      oprot.writeFieldEnd()
6633 
    oprot.writeFieldStop()
6634 
    oprot.writeStructEnd()
6635 
 
6636 
  def __repr__(self):
6637 
    L = ['%s=%r' % (key, value)
6638 
      for key, value in self.__dict__.iteritems()]
6639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6640 
 
6641 
  def __eq__(self, other):
6642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6643 
 
6644 
  def __ne__(self, other):
6645 
    return not (self == other)
6646 
 
559 chandransh 6647 
class validateCart_args:
94 ashish 6648 
  """
6649 
  Attributes:
559 chandransh 6650 
   - cartId
94 ashish 6651 
  """
6652 
 
6653 
  thrift_spec = (
6654 
    None, # 0
559 chandransh 6655 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 6656 
  )
6657 
 
559 chandransh 6658 
  def __init__(self, cartId=None,):
6659 
    self.cartId = cartId
94 ashish 6660 
 
6661 
  def read(self, iprot):
6662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6664 
      return
6665 
    iprot.readStructBegin()
6666 
    while True:
6667 
      (fname, ftype, fid) = iprot.readFieldBegin()
6668 
      if ftype == TType.STOP:
6669 
        break
6670 
      if fid == 1:
6671 
        if ftype == TType.I64:
559 chandransh 6672 
          self.cartId = iprot.readI64();
94 ashish 6673 
        else:
6674 
          iprot.skip(ftype)
6675 
      else:
6676 
        iprot.skip(ftype)
6677 
      iprot.readFieldEnd()
6678 
    iprot.readStructEnd()
6679 
 
6680 
  def write(self, oprot):
6681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6683 
      return
559 chandransh 6684 
    oprot.writeStructBegin('validateCart_args')
6685 
    if self.cartId != None:
6686 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6687 
      oprot.writeI64(self.cartId)
94 ashish 6688 
      oprot.writeFieldEnd()
6689 
    oprot.writeFieldStop()
6690 
    oprot.writeStructEnd()
6691 
 
6692 
  def __repr__(self):
6693 
    L = ['%s=%r' % (key, value)
6694 
      for key, value in self.__dict__.iteritems()]
6695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6696 
 
6697 
  def __eq__(self, other):
6698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6699 
 
6700 
  def __ne__(self, other):
6701 
    return not (self == other)
6702 
 
559 chandransh 6703 
class validateCart_result:
94 ashish 6704 
  """
6705 
  Attributes:
6706 
   - success
575 chandransh 6707 
   - scex
94 ashish 6708 
  """
6709 
 
6710 
  thrift_spec = (
6711 
    (0, TType.BOOL, 'success', None, None, ), # 0
575 chandransh 6712 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 6713 
  )
6714 
 
575 chandransh 6715 
  def __init__(self, success=None, scex=None,):
94 ashish 6716 
    self.success = success
575 chandransh 6717 
    self.scex = scex
94 ashish 6718 
 
6719 
  def read(self, iprot):
6720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6722 
      return
6723 
    iprot.readStructBegin()
6724 
    while True:
6725 
      (fname, ftype, fid) = iprot.readFieldBegin()
6726 
      if ftype == TType.STOP:
6727 
        break
6728 
      if fid == 0:
6729 
        if ftype == TType.BOOL:
6730 
          self.success = iprot.readBool();
6731 
        else:
6732 
          iprot.skip(ftype)
575 chandransh 6733 
      elif fid == 1:
6734 
        if ftype == TType.STRUCT:
6735 
          self.scex = ShoppingCartException()
6736 
          self.scex.read(iprot)
6737 
        else:
6738 
          iprot.skip(ftype)
94 ashish 6739 
      else:
6740 
        iprot.skip(ftype)
6741 
      iprot.readFieldEnd()
6742 
    iprot.readStructEnd()
6743 
 
6744 
  def write(self, oprot):
6745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6747 
      return
559 chandransh 6748 
    oprot.writeStructBegin('validateCart_result')
94 ashish 6749 
    if self.success != None:
6750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6751 
      oprot.writeBool(self.success)
6752 
      oprot.writeFieldEnd()
575 chandransh 6753 
    if self.scex != None:
6754 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
6755 
      self.scex.write(oprot)
6756 
      oprot.writeFieldEnd()
559 chandransh 6757 
    oprot.writeFieldStop()
6758 
    oprot.writeStructEnd()
6759 
 
6760 
  def __repr__(self):
6761 
    L = ['%s=%r' % (key, value)
6762 
      for key, value in self.__dict__.iteritems()]
6763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6764 
 
6765 
  def __eq__(self, other):
6766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6767 
 
6768 
  def __ne__(self, other):
6769 
    return not (self == other)
6770 
 
690 chandransh 6771 
class mergeCart_args:
575 chandransh 6772 
  """
6773 
  Attributes:
690 chandransh 6774 
   - fromCartId
6775 
   - toCartId
6776 
  """
6777 
 
6778 
  thrift_spec = (
6779 
    None, # 0
6780 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
6781 
    (2, TType.I64, 'toCartId', None, None, ), # 2
6782 
  )
6783 
 
6784 
  def __init__(self, fromCartId=None, toCartId=None,):
6785 
    self.fromCartId = fromCartId
6786 
    self.toCartId = toCartId
6787 
 
6788 
  def read(self, iprot):
6789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6791 
      return
6792 
    iprot.readStructBegin()
6793 
    while True:
6794 
      (fname, ftype, fid) = iprot.readFieldBegin()
6795 
      if ftype == TType.STOP:
6796 
        break
6797 
      if fid == 1:
6798 
        if ftype == TType.I64:
6799 
          self.fromCartId = iprot.readI64();
6800 
        else:
6801 
          iprot.skip(ftype)
6802 
      elif fid == 2:
6803 
        if ftype == TType.I64:
6804 
          self.toCartId = iprot.readI64();
6805 
        else:
6806 
          iprot.skip(ftype)
6807 
      else:
6808 
        iprot.skip(ftype)
6809 
      iprot.readFieldEnd()
6810 
    iprot.readStructEnd()
6811 
 
6812 
  def write(self, oprot):
6813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6815 
      return
6816 
    oprot.writeStructBegin('mergeCart_args')
6817 
    if self.fromCartId != None:
6818 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
6819 
      oprot.writeI64(self.fromCartId)
6820 
      oprot.writeFieldEnd()
6821 
    if self.toCartId != None:
6822 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
6823 
      oprot.writeI64(self.toCartId)
6824 
      oprot.writeFieldEnd()
6825 
    oprot.writeFieldStop()
6826 
    oprot.writeStructEnd()
6827 
 
6828 
  def __repr__(self):
6829 
    L = ['%s=%r' % (key, value)
6830 
      for key, value in self.__dict__.iteritems()]
6831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6832 
 
6833 
  def __eq__(self, other):
6834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6835 
 
6836 
  def __ne__(self, other):
6837 
    return not (self == other)
6838 
 
6839 
class mergeCart_result:
6840 
 
6841 
  thrift_spec = (
6842 
  )
6843 
 
6844 
  def read(self, iprot):
6845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6847 
      return
6848 
    iprot.readStructBegin()
6849 
    while True:
6850 
      (fname, ftype, fid) = iprot.readFieldBegin()
6851 
      if ftype == TType.STOP:
6852 
        break
6853 
      else:
6854 
        iprot.skip(ftype)
6855 
      iprot.readFieldEnd()
6856 
    iprot.readStructEnd()
6857 
 
6858 
  def write(self, oprot):
6859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6861 
      return
6862 
    oprot.writeStructBegin('mergeCart_result')
6863 
    oprot.writeFieldStop()
6864 
    oprot.writeStructEnd()
6865 
 
6866 
  def __repr__(self):
6867 
    L = ['%s=%r' % (key, value)
6868 
      for key, value in self.__dict__.iteritems()]
6869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6870 
 
6871 
  def __eq__(self, other):
6872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6873 
 
6874 
  def __ne__(self, other):
6875 
    return not (self == other)
6876 
 
6877 
class checkOut_args:
6878 
  """
6879 
  Attributes:
575 chandransh 6880 
   - cartId
6881 
  """
6882 
 
6883 
  thrift_spec = (
6884 
    None, # 0
6885 
    (1, TType.I64, 'cartId', None, None, ), # 1
6886 
  )
6887 
 
6888 
  def __init__(self, cartId=None,):
6889 
    self.cartId = cartId
6890 
 
6891 
  def read(self, iprot):
6892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6894 
      return
6895 
    iprot.readStructBegin()
6896 
    while True:
6897 
      (fname, ftype, fid) = iprot.readFieldBegin()
6898 
      if ftype == TType.STOP:
6899 
        break
6900 
      if fid == 1:
6901 
        if ftype == TType.I64:
6902 
          self.cartId = iprot.readI64();
6903 
        else:
6904 
          iprot.skip(ftype)
6905 
      else:
6906 
        iprot.skip(ftype)
6907 
      iprot.readFieldEnd()
6908 
    iprot.readStructEnd()
6909 
 
6910 
  def write(self, oprot):
6911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6913 
      return
690 chandransh 6914 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 6915 
    if self.cartId != None:
6916 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6917 
      oprot.writeI64(self.cartId)
6918 
      oprot.writeFieldEnd()
6919 
    oprot.writeFieldStop()
6920 
    oprot.writeStructEnd()
6921 
 
6922 
  def __repr__(self):
6923 
    L = ['%s=%r' % (key, value)
6924 
      for key, value in self.__dict__.iteritems()]
6925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6926 
 
6927 
  def __eq__(self, other):
6928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6929 
 
6930 
  def __ne__(self, other):
6931 
    return not (self == other)
6932 
 
690 chandransh 6933 
class checkOut_result:
575 chandransh 6934 
  """
6935 
  Attributes:
6936 
   - success
6937 
   - scex
6938 
  """
6939 
 
6940 
  thrift_spec = (
6941 
    (0, TType.BOOL, 'success', None, None, ), # 0
6942 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
6943 
  )
6944 
 
6945 
  def __init__(self, success=None, scex=None,):
6946 
    self.success = success
6947 
    self.scex = scex
6948 
 
6949 
  def read(self, iprot):
6950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6952 
      return
6953 
    iprot.readStructBegin()
6954 
    while True:
6955 
      (fname, ftype, fid) = iprot.readFieldBegin()
6956 
      if ftype == TType.STOP:
6957 
        break
6958 
      if fid == 0:
6959 
        if ftype == TType.BOOL:
6960 
          self.success = iprot.readBool();
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      elif fid == 1:
6964 
        if ftype == TType.STRUCT:
6965 
          self.scex = ShoppingCartException()
6966 
          self.scex.read(iprot)
6967 
        else:
6968 
          iprot.skip(ftype)
6969 
      else:
6970 
        iprot.skip(ftype)
6971 
      iprot.readFieldEnd()
6972 
    iprot.readStructEnd()
6973 
 
6974 
  def write(self, oprot):
6975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6977 
      return
690 chandransh 6978 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 6979 
    if self.success != None:
6980 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6981 
      oprot.writeBool(self.success)
6982 
      oprot.writeFieldEnd()
6983 
    if self.scex != None:
6984 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
6985 
      self.scex.write(oprot)
6986 
      oprot.writeFieldEnd()
6987 
    oprot.writeFieldStop()
6988 
    oprot.writeStructEnd()
6989 
 
6990 
  def __repr__(self):
6991 
    L = ['%s=%r' % (key, value)
6992 
      for key, value in self.__dict__.iteritems()]
6993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6994 
 
6995 
  def __eq__(self, other):
6996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6997 
 
6998 
  def __ne__(self, other):
6999 
    return not (self == other)
7000 
 
690 chandransh 7001 
class resetCart_args:
559 chandransh 7002 
  """
7003 
  Attributes:
690 chandransh 7004 
   - cartId
7005 
   - items
559 chandransh 7006 
  """
7007 
 
7008 
  thrift_spec = (
7009 
    None, # 0
690 chandransh 7010 
    (1, TType.I64, 'cartId', None, None, ), # 1
7011 
    (2, TType.MAP, 'items', (TType.I64,None,TType.I64,None), None, ), # 2
559 chandransh 7012 
  )
7013 
 
690 chandransh 7014 
  def __init__(self, cartId=None, items=None,):
7015 
    self.cartId = cartId
7016 
    self.items = items
559 chandransh 7017 
 
7018 
  def read(self, iprot):
7019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7021 
      return
7022 
    iprot.readStructBegin()
7023 
    while True:
7024 
      (fname, ftype, fid) = iprot.readFieldBegin()
7025 
      if ftype == TType.STOP:
7026 
        break
7027 
      if fid == 1:
7028 
        if ftype == TType.I64:
690 chandransh 7029 
          self.cartId = iprot.readI64();
559 chandransh 7030 
        else:
7031 
          iprot.skip(ftype)
7032 
      elif fid == 2:
690 chandransh 7033 
        if ftype == TType.MAP:
7034 
          self.items = {}
7035 
          (_ktype66, _vtype67, _size65 ) = iprot.readMapBegin()
7036 
          for _i69 in xrange(_size65):
7037 
            _key70 = iprot.readI64();
7038 
            _val71 = iprot.readI64();
7039 
            self.items[_key70] = _val71
7040 
          iprot.readMapEnd()
559 chandransh 7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      else:
7044 
        iprot.skip(ftype)
7045 
      iprot.readFieldEnd()
7046 
    iprot.readStructEnd()
7047 
 
7048 
  def write(self, oprot):
7049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7051 
      return
690 chandransh 7052 
    oprot.writeStructBegin('resetCart_args')
7053 
    if self.cartId != None:
7054 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
7055 
      oprot.writeI64(self.cartId)
94 ashish 7056 
      oprot.writeFieldEnd()
690 chandransh 7057 
    if self.items != None:
7058 
      oprot.writeFieldBegin('items', TType.MAP, 2)
7059 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.items))
7060 
      for kiter72,viter73 in self.items.items():
7061 
        oprot.writeI64(kiter72)
7062 
        oprot.writeI64(viter73)
7063 
      oprot.writeMapEnd()
559 chandransh 7064 
      oprot.writeFieldEnd()
94 ashish 7065 
    oprot.writeFieldStop()
7066 
    oprot.writeStructEnd()
7067 
 
7068 
  def __repr__(self):
7069 
    L = ['%s=%r' % (key, value)
7070 
      for key, value in self.__dict__.iteritems()]
7071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7072 
 
7073 
  def __eq__(self, other):
7074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7075 
 
7076 
  def __ne__(self, other):
7077 
    return not (self == other)
7078 
 
690 chandransh 7079 
class resetCart_result:
7080 
  """
7081 
  Attributes:
7082 
   - success
7083 
   - scex
7084 
  """
559 chandransh 7085 
 
7086 
  thrift_spec = (
690 chandransh 7087 
    (0, TType.BOOL, 'success', None, None, ), # 0
7088 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 7089 
  )
7090 
 
690 chandransh 7091 
  def __init__(self, success=None, scex=None,):
7092 
    self.success = success
7093 
    self.scex = scex
7094 
 
559 chandransh 7095 
  def read(self, iprot):
7096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7098 
      return
7099 
    iprot.readStructBegin()
7100 
    while True:
7101 
      (fname, ftype, fid) = iprot.readFieldBegin()
7102 
      if ftype == TType.STOP:
7103 
        break
690 chandransh 7104 
      if fid == 0:
7105 
        if ftype == TType.BOOL:
7106 
          self.success = iprot.readBool();
7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      elif fid == 1:
7110 
        if ftype == TType.STRUCT:
7111 
          self.scex = ShoppingCartException()
7112 
          self.scex.read(iprot)
7113 
        else:
7114 
          iprot.skip(ftype)
559 chandransh 7115 
      else:
7116 
        iprot.skip(ftype)
7117 
      iprot.readFieldEnd()
7118 
    iprot.readStructEnd()
7119 
 
7120 
  def write(self, oprot):
7121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7123 
      return
690 chandransh 7124 
    oprot.writeStructBegin('resetCart_result')
7125 
    if self.success != None:
7126 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7127 
      oprot.writeBool(self.success)
7128 
      oprot.writeFieldEnd()
7129 
    if self.scex != None:
7130 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
7131 
      self.scex.write(oprot)
7132 
      oprot.writeFieldEnd()
559 chandransh 7133 
    oprot.writeFieldStop()
7134 
    oprot.writeStructEnd()
7135 
 
7136 
  def __repr__(self):
7137 
    L = ['%s=%r' % (key, value)
7138 
      for key, value in self.__dict__.iteritems()]
7139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7140 
 
7141 
  def __eq__(self, other):
7142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7143 
 
7144 
  def __ne__(self, other):
7145 
    return not (self == other)
7146 
 
7147 
class addWidget_args:
94 ashish 7148 
  """
7149 
  Attributes:
559 chandransh 7150 
   - widget
94 ashish 7151 
  """
7152 
 
7153 
  thrift_spec = (
7154 
    None, # 0
559 chandransh 7155 
    (1, TType.STRUCT, 'widget', (Widget, Widget.thrift_spec), None, ), # 1
94 ashish 7156 
  )
7157 
 
559 chandransh 7158 
  def __init__(self, widget=None,):
7159 
    self.widget = widget
94 ashish 7160 
 
7161 
  def read(self, iprot):
7162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7164 
      return
7165 
    iprot.readStructBegin()
7166 
    while True:
7167 
      (fname, ftype, fid) = iprot.readFieldBegin()
7168 
      if ftype == TType.STOP:
7169 
        break
7170 
      if fid == 1:
559 chandransh 7171 
        if ftype == TType.STRUCT:
7172 
          self.widget = Widget()
7173 
          self.widget.read(iprot)
7174 
        else:
7175 
          iprot.skip(ftype)
7176 
      else:
7177 
        iprot.skip(ftype)
7178 
      iprot.readFieldEnd()
7179 
    iprot.readStructEnd()
7180 
 
7181 
  def write(self, oprot):
7182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7184 
      return
7185 
    oprot.writeStructBegin('addWidget_args')
7186 
    if self.widget != None:
7187 
      oprot.writeFieldBegin('widget', TType.STRUCT, 1)
7188 
      self.widget.write(oprot)
7189 
      oprot.writeFieldEnd()
7190 
    oprot.writeFieldStop()
7191 
    oprot.writeStructEnd()
7192 
 
7193 
  def __repr__(self):
7194 
    L = ['%s=%r' % (key, value)
7195 
      for key, value in self.__dict__.iteritems()]
7196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7197 
 
7198 
  def __eq__(self, other):
7199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7200 
 
7201 
  def __ne__(self, other):
7202 
    return not (self == other)
7203 
 
7204 
class addWidget_result:
7205 
  """
7206 
  Attributes:
7207 
   - scx
7208 
  """
7209 
 
7210 
  thrift_spec = (
7211 
    None, # 0
7212 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7213 
  )
7214 
 
7215 
  def __init__(self, scx=None,):
7216 
    self.scx = scx
7217 
 
7218 
  def read(self, iprot):
7219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7221 
      return
7222 
    iprot.readStructBegin()
7223 
    while True:
7224 
      (fname, ftype, fid) = iprot.readFieldBegin()
7225 
      if ftype == TType.STOP:
7226 
        break
7227 
      if fid == 1:
7228 
        if ftype == TType.STRUCT:
7229 
          self.scx = WidgetException()
7230 
          self.scx.read(iprot)
7231 
        else:
7232 
          iprot.skip(ftype)
7233 
      else:
7234 
        iprot.skip(ftype)
7235 
      iprot.readFieldEnd()
7236 
    iprot.readStructEnd()
7237 
 
7238 
  def write(self, oprot):
7239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7241 
      return
7242 
    oprot.writeStructBegin('addWidget_result')
7243 
    if self.scx != None:
7244 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7245 
      self.scx.write(oprot)
7246 
      oprot.writeFieldEnd()
7247 
    oprot.writeFieldStop()
7248 
    oprot.writeStructEnd()
7249 
 
7250 
  def __repr__(self):
7251 
    L = ['%s=%r' % (key, value)
7252 
      for key, value in self.__dict__.iteritems()]
7253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7254 
 
7255 
  def __eq__(self, other):
7256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7257 
 
7258 
  def __ne__(self, other):
7259 
    return not (self == other)
7260 
 
7261 
class addItemToWidget_args:
7262 
  """
7263 
  Attributes:
7264 
   - widget_id
7265 
   - items
7266 
  """
7267 
 
7268 
  thrift_spec = (
7269 
    None, # 0
7270 
    (1, TType.I64, 'widget_id', None, None, ), # 1
7271 
    (2, TType.LIST, 'items', (TType.I64,None), None, ), # 2
7272 
  )
7273 
 
7274 
  def __init__(self, widget_id=None, items=None,):
7275 
    self.widget_id = widget_id
7276 
    self.items = items
7277 
 
7278 
  def read(self, iprot):
7279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7281 
      return
7282 
    iprot.readStructBegin()
7283 
    while True:
7284 
      (fname, ftype, fid) = iprot.readFieldBegin()
7285 
      if ftype == TType.STOP:
7286 
        break
7287 
      if fid == 1:
94 ashish 7288 
        if ftype == TType.I64:
559 chandransh 7289 
          self.widget_id = iprot.readI64();
94 ashish 7290 
        else:
7291 
          iprot.skip(ftype)
559 chandransh 7292 
      elif fid == 2:
7293 
        if ftype == TType.LIST:
7294 
          self.items = []
690 chandransh 7295 
          (_etype77, _size74) = iprot.readListBegin()
7296 
          for _i78 in xrange(_size74):
7297 
            _elem79 = iprot.readI64();
7298 
            self.items.append(_elem79)
559 chandransh 7299 
          iprot.readListEnd()
7300 
        else:
7301 
          iprot.skip(ftype)
94 ashish 7302 
      else:
7303 
        iprot.skip(ftype)
7304 
      iprot.readFieldEnd()
7305 
    iprot.readStructEnd()
7306 
 
7307 
  def write(self, oprot):
7308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7310 
      return
559 chandransh 7311 
    oprot.writeStructBegin('addItemToWidget_args')
7312 
    if self.widget_id != None:
7313 
      oprot.writeFieldBegin('widget_id', TType.I64, 1)
7314 
      oprot.writeI64(self.widget_id)
94 ashish 7315 
      oprot.writeFieldEnd()
559 chandransh 7316 
    if self.items != None:
7317 
      oprot.writeFieldBegin('items', TType.LIST, 2)
7318 
      oprot.writeListBegin(TType.I64, len(self.items))
690 chandransh 7319 
      for iter80 in self.items:
7320 
        oprot.writeI64(iter80)
559 chandransh 7321 
      oprot.writeListEnd()
7322 
      oprot.writeFieldEnd()
94 ashish 7323 
    oprot.writeFieldStop()
7324 
    oprot.writeStructEnd()
7325 
 
7326 
  def __repr__(self):
7327 
    L = ['%s=%r' % (key, value)
7328 
      for key, value in self.__dict__.iteritems()]
7329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7330 
 
7331 
  def __eq__(self, other):
7332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7333 
 
7334 
  def __ne__(self, other):
7335 
    return not (self == other)
7336 
 
559 chandransh 7337 
class addItemToWidget_result:
94 ashish 7338 
  """
7339 
  Attributes:
559 chandransh 7340 
   - scx
7341 
  """
7342 
 
7343 
  thrift_spec = (
7344 
    None, # 0
7345 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7346 
  )
7347 
 
7348 
  def __init__(self, scx=None,):
7349 
    self.scx = scx
7350 
 
7351 
  def read(self, iprot):
7352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7354 
      return
7355 
    iprot.readStructBegin()
7356 
    while True:
7357 
      (fname, ftype, fid) = iprot.readFieldBegin()
7358 
      if ftype == TType.STOP:
7359 
        break
7360 
      if fid == 1:
7361 
        if ftype == TType.STRUCT:
7362 
          self.scx = WidgetException()
7363 
          self.scx.read(iprot)
7364 
        else:
7365 
          iprot.skip(ftype)
7366 
      else:
7367 
        iprot.skip(ftype)
7368 
      iprot.readFieldEnd()
7369 
    iprot.readStructEnd()
7370 
 
7371 
  def write(self, oprot):
7372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7374 
      return
7375 
    oprot.writeStructBegin('addItemToWidget_result')
7376 
    if self.scx != None:
7377 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7378 
      self.scx.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def __repr__(self):
7384 
    L = ['%s=%r' % (key, value)
7385 
      for key, value in self.__dict__.iteritems()]
7386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7387 
 
7388 
  def __eq__(self, other):
7389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7390 
 
7391 
  def __ne__(self, other):
7392 
    return not (self == other)
7393 
 
7394 
class deleteItemFromWidget_args:
7395 
  """
7396 
  Attributes:
7397 
   - widget_id
7398 
   - item_id
7399 
  """
7400 
 
7401 
  thrift_spec = (
7402 
    None, # 0
7403 
    (1, TType.I64, 'widget_id', None, None, ), # 1
7404 
    (2, TType.I64, 'item_id', None, None, ), # 2
7405 
  )
7406 
 
7407 
  def __init__(self, widget_id=None, item_id=None,):
7408 
    self.widget_id = widget_id
7409 
    self.item_id = item_id
7410 
 
7411 
  def read(self, iprot):
7412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7414 
      return
7415 
    iprot.readStructBegin()
7416 
    while True:
7417 
      (fname, ftype, fid) = iprot.readFieldBegin()
7418 
      if ftype == TType.STOP:
7419 
        break
7420 
      if fid == 1:
7421 
        if ftype == TType.I64:
7422 
          self.widget_id = iprot.readI64();
7423 
        else:
7424 
          iprot.skip(ftype)
7425 
      elif fid == 2:
7426 
        if ftype == TType.I64:
7427 
          self.item_id = iprot.readI64();
7428 
        else:
7429 
          iprot.skip(ftype)
7430 
      else:
7431 
        iprot.skip(ftype)
7432 
      iprot.readFieldEnd()
7433 
    iprot.readStructEnd()
7434 
 
7435 
  def write(self, oprot):
7436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7438 
      return
7439 
    oprot.writeStructBegin('deleteItemFromWidget_args')
7440 
    if self.widget_id != None:
7441 
      oprot.writeFieldBegin('widget_id', TType.I64, 1)
7442 
      oprot.writeI64(self.widget_id)
7443 
      oprot.writeFieldEnd()
7444 
    if self.item_id != None:
7445 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
7446 
      oprot.writeI64(self.item_id)
7447 
      oprot.writeFieldEnd()
7448 
    oprot.writeFieldStop()
7449 
    oprot.writeStructEnd()
7450 
 
7451 
  def __repr__(self):
7452 
    L = ['%s=%r' % (key, value)
7453 
      for key, value in self.__dict__.iteritems()]
7454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7455 
 
7456 
  def __eq__(self, other):
7457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7458 
 
7459 
  def __ne__(self, other):
7460 
    return not (self == other)
7461 
 
7462 
class deleteItemFromWidget_result:
7463 
  """
7464 
  Attributes:
7465 
   - scx
7466 
  """
7467 
 
7468 
  thrift_spec = (
7469 
    None, # 0
7470 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7471 
  )
7472 
 
7473 
  def __init__(self, scx=None,):
7474 
    self.scx = scx
7475 
 
7476 
  def read(self, iprot):
7477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7479 
      return
7480 
    iprot.readStructBegin()
7481 
    while True:
7482 
      (fname, ftype, fid) = iprot.readFieldBegin()
7483 
      if ftype == TType.STOP:
7484 
        break
7485 
      if fid == 1:
7486 
        if ftype == TType.STRUCT:
7487 
          self.scx = WidgetException()
7488 
          self.scx.read(iprot)
7489 
        else:
7490 
          iprot.skip(ftype)
7491 
      else:
7492 
        iprot.skip(ftype)
7493 
      iprot.readFieldEnd()
7494 
    iprot.readStructEnd()
7495 
 
7496 
  def write(self, oprot):
7497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7499 
      return
7500 
    oprot.writeStructBegin('deleteItemFromWidget_result')
7501 
    if self.scx != None:
7502 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7503 
      self.scx.write(oprot)
7504 
      oprot.writeFieldEnd()
7505 
    oprot.writeFieldStop()
7506 
    oprot.writeStructEnd()
7507 
 
7508 
  def __repr__(self):
7509 
    L = ['%s=%r' % (key, value)
7510 
      for key, value in self.__dict__.iteritems()]
7511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7512 
 
7513 
  def __eq__(self, other):
7514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7515 
 
7516 
  def __ne__(self, other):
7517 
    return not (self == other)
7518 
 
7519 
class updateWidget_args:
7520 
  """
7521 
  Attributes:
7522 
   - widgetId
7523 
   - enable
7524 
  """
7525 
 
7526 
  thrift_spec = (
7527 
    None, # 0
7528 
    (1, TType.I64, 'widgetId', None, None, ), # 1
7529 
    (2, TType.BOOL, 'enable', None, None, ), # 2
7530 
  )
7531 
 
7532 
  def __init__(self, widgetId=None, enable=None,):
7533 
    self.widgetId = widgetId
7534 
    self.enable = enable
7535 
 
7536 
  def read(self, iprot):
7537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7539 
      return
7540 
    iprot.readStructBegin()
7541 
    while True:
7542 
      (fname, ftype, fid) = iprot.readFieldBegin()
7543 
      if ftype == TType.STOP:
7544 
        break
7545 
      if fid == 1:
7546 
        if ftype == TType.I64:
7547 
          self.widgetId = iprot.readI64();
7548 
        else:
7549 
          iprot.skip(ftype)
7550 
      elif fid == 2:
7551 
        if ftype == TType.BOOL:
7552 
          self.enable = iprot.readBool();
7553 
        else:
7554 
          iprot.skip(ftype)
7555 
      else:
7556 
        iprot.skip(ftype)
7557 
      iprot.readFieldEnd()
7558 
    iprot.readStructEnd()
7559 
 
7560 
  def write(self, oprot):
7561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7563 
      return
7564 
    oprot.writeStructBegin('updateWidget_args')
7565 
    if self.widgetId != None:
7566 
      oprot.writeFieldBegin('widgetId', TType.I64, 1)
7567 
      oprot.writeI64(self.widgetId)
7568 
      oprot.writeFieldEnd()
7569 
    if self.enable != None:
7570 
      oprot.writeFieldBegin('enable', TType.BOOL, 2)
7571 
      oprot.writeBool(self.enable)
7572 
      oprot.writeFieldEnd()
7573 
    oprot.writeFieldStop()
7574 
    oprot.writeStructEnd()
7575 
 
7576 
  def __repr__(self):
7577 
    L = ['%s=%r' % (key, value)
7578 
      for key, value in self.__dict__.iteritems()]
7579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7580 
 
7581 
  def __eq__(self, other):
7582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7583 
 
7584 
  def __ne__(self, other):
7585 
    return not (self == other)
7586 
 
7587 
class updateWidget_result:
7588 
  """
7589 
  Attributes:
7590 
   - scx
7591 
  """
7592 
 
7593 
  thrift_spec = (
7594 
    None, # 0
7595 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7596 
  )
7597 
 
7598 
  def __init__(self, scx=None,):
7599 
    self.scx = scx
7600 
 
7601 
  def read(self, iprot):
7602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7604 
      return
7605 
    iprot.readStructBegin()
7606 
    while True:
7607 
      (fname, ftype, fid) = iprot.readFieldBegin()
7608 
      if ftype == TType.STOP:
7609 
        break
7610 
      if fid == 1:
7611 
        if ftype == TType.STRUCT:
7612 
          self.scx = WidgetException()
7613 
          self.scx.read(iprot)
7614 
        else:
7615 
          iprot.skip(ftype)
7616 
      else:
7617 
        iprot.skip(ftype)
7618 
      iprot.readFieldEnd()
7619 
    iprot.readStructEnd()
7620 
 
7621 
  def write(self, oprot):
7622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7624 
      return
7625 
    oprot.writeStructBegin('updateWidget_result')
7626 
    if self.scx != None:
7627 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7628 
      self.scx.write(oprot)
7629 
      oprot.writeFieldEnd()
7630 
    oprot.writeFieldStop()
7631 
    oprot.writeStructEnd()
7632 
 
7633 
  def __repr__(self):
7634 
    L = ['%s=%r' % (key, value)
7635 
      for key, value in self.__dict__.iteritems()]
7636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7637 
 
7638 
  def __eq__(self, other):
7639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7640 
 
7641 
  def __ne__(self, other):
7642 
    return not (self == other)
7643 
 
7644 
class updateWidgetItem_args:
7645 
  """
7646 
  Attributes:
7647 
   - widgetId
7648 
   - enable
7649 
  """
7650 
 
7651 
  thrift_spec = (
7652 
    None, # 0
7653 
    (1, TType.I64, 'widgetId', None, None, ), # 1
7654 
    (2, TType.BOOL, 'enable', None, None, ), # 2
7655 
  )
7656 
 
7657 
  def __init__(self, widgetId=None, enable=None,):
7658 
    self.widgetId = widgetId
7659 
    self.enable = enable
7660 
 
7661 
  def read(self, iprot):
7662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7664 
      return
7665 
    iprot.readStructBegin()
7666 
    while True:
7667 
      (fname, ftype, fid) = iprot.readFieldBegin()
7668 
      if ftype == TType.STOP:
7669 
        break
7670 
      if fid == 1:
7671 
        if ftype == TType.I64:
7672 
          self.widgetId = iprot.readI64();
7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      elif fid == 2:
7676 
        if ftype == TType.BOOL:
7677 
          self.enable = iprot.readBool();
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      else:
7681 
        iprot.skip(ftype)
7682 
      iprot.readFieldEnd()
7683 
    iprot.readStructEnd()
7684 
 
7685 
  def write(self, oprot):
7686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7688 
      return
7689 
    oprot.writeStructBegin('updateWidgetItem_args')
7690 
    if self.widgetId != None:
7691 
      oprot.writeFieldBegin('widgetId', TType.I64, 1)
7692 
      oprot.writeI64(self.widgetId)
7693 
      oprot.writeFieldEnd()
7694 
    if self.enable != None:
7695 
      oprot.writeFieldBegin('enable', TType.BOOL, 2)
7696 
      oprot.writeBool(self.enable)
7697 
      oprot.writeFieldEnd()
7698 
    oprot.writeFieldStop()
7699 
    oprot.writeStructEnd()
7700 
 
7701 
  def __repr__(self):
7702 
    L = ['%s=%r' % (key, value)
7703 
      for key, value in self.__dict__.iteritems()]
7704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7705 
 
7706 
  def __eq__(self, other):
7707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7708 
 
7709 
  def __ne__(self, other):
7710 
    return not (self == other)
7711 
 
7712 
class updateWidgetItem_result:
7713 
  """
7714 
  Attributes:
7715 
   - scx
7716 
  """
7717 
 
7718 
  thrift_spec = (
7719 
    None, # 0
7720 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7721 
  )
7722 
 
7723 
  def __init__(self, scx=None,):
7724 
    self.scx = scx
7725 
 
7726 
  def read(self, iprot):
7727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7729 
      return
7730 
    iprot.readStructBegin()
7731 
    while True:
7732 
      (fname, ftype, fid) = iprot.readFieldBegin()
7733 
      if ftype == TType.STOP:
7734 
        break
7735 
      if fid == 1:
7736 
        if ftype == TType.STRUCT:
7737 
          self.scx = WidgetException()
7738 
          self.scx.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('updateWidgetItem_result')
7751 
    if self.scx != None:
7752 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7753 
      self.scx.write(oprot)
7754 
      oprot.writeFieldEnd()
7755 
    oprot.writeFieldStop()
7756 
    oprot.writeStructEnd()
7757 
 
7758 
  def __repr__(self):
7759 
    L = ['%s=%r' % (key, value)
7760 
      for key, value in self.__dict__.iteritems()]
7761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7762 
 
7763 
  def __eq__(self, other):
7764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7765 
 
7766 
  def __ne__(self, other):
7767 
    return not (self == other)
7768 
 
7769 
class getWidget_args:
7770 
  """
7771 
  Attributes:
7772 
   - type
7773 
   - userId
7774 
   - onlyEnabled
7775 
  """
7776 
 
7777 
  thrift_spec = (
7778 
    None, # 0
7779 
    (1, TType.I32, 'type', None, None, ), # 1
7780 
    (2, TType.I64, 'userId', None, None, ), # 2
7781 
    (3, TType.BOOL, 'onlyEnabled', None, None, ), # 3
7782 
  )
7783 
 
7784 
  def __init__(self, type=None, userId=None, onlyEnabled=None,):
7785 
    self.type = type
7786 
    self.userId = userId
7787 
    self.onlyEnabled = onlyEnabled
7788 
 
7789 
  def read(self, iprot):
7790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7792 
      return
7793 
    iprot.readStructBegin()
7794 
    while True:
7795 
      (fname, ftype, fid) = iprot.readFieldBegin()
7796 
      if ftype == TType.STOP:
7797 
        break
7798 
      if fid == 1:
7799 
        if ftype == TType.I32:
7800 
          self.type = iprot.readI32();
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      elif fid == 2:
7804 
        if ftype == TType.I64:
7805 
          self.userId = iprot.readI64();
7806 
        else:
7807 
          iprot.skip(ftype)
7808 
      elif fid == 3:
7809 
        if ftype == TType.BOOL:
7810 
          self.onlyEnabled = iprot.readBool();
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      else:
7814 
        iprot.skip(ftype)
7815 
      iprot.readFieldEnd()
7816 
    iprot.readStructEnd()
7817 
 
7818 
  def write(self, oprot):
7819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7821 
      return
7822 
    oprot.writeStructBegin('getWidget_args')
7823 
    if self.type != None:
7824 
      oprot.writeFieldBegin('type', TType.I32, 1)
7825 
      oprot.writeI32(self.type)
7826 
      oprot.writeFieldEnd()
7827 
    if self.userId != None:
7828 
      oprot.writeFieldBegin('userId', TType.I64, 2)
7829 
      oprot.writeI64(self.userId)
7830 
      oprot.writeFieldEnd()
7831 
    if self.onlyEnabled != None:
7832 
      oprot.writeFieldBegin('onlyEnabled', TType.BOOL, 3)
7833 
      oprot.writeBool(self.onlyEnabled)
7834 
      oprot.writeFieldEnd()
7835 
    oprot.writeFieldStop()
7836 
    oprot.writeStructEnd()
7837 
 
7838 
  def __repr__(self):
7839 
    L = ['%s=%r' % (key, value)
7840 
      for key, value in self.__dict__.iteritems()]
7841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7842 
 
7843 
  def __eq__(self, other):
7844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7845 
 
7846 
  def __ne__(self, other):
7847 
    return not (self == other)
7848 
 
7849 
class getWidget_result:
7850 
  """
7851 
  Attributes:
94 ashish 7852 
   - success
559 chandransh 7853 
   - scx
94 ashish 7854 
  """
7855 
 
7856 
  thrift_spec = (
559 chandransh 7857 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
7858 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 7859 
  )
7860 
 
559 chandransh 7861 
  def __init__(self, success=None, scx=None,):
94 ashish 7862 
    self.success = success
559 chandransh 7863 
    self.scx = scx
94 ashish 7864 
 
7865 
  def read(self, iprot):
7866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7868 
      return
7869 
    iprot.readStructBegin()
7870 
    while True:
7871 
      (fname, ftype, fid) = iprot.readFieldBegin()
7872 
      if ftype == TType.STOP:
7873 
        break
7874 
      if fid == 0:
559 chandransh 7875 
        if ftype == TType.STRUCT:
7876 
          self.success = Widget()
7877 
          self.success.read(iprot)
94 ashish 7878 
        else:
7879 
          iprot.skip(ftype)
7880 
      elif fid == 1:
7881 
        if ftype == TType.STRUCT:
559 chandransh 7882 
          self.scx = WidgetException()
7883 
          self.scx.read(iprot)
94 ashish 7884 
        else:
7885 
          iprot.skip(ftype)
7886 
      else:
7887 
        iprot.skip(ftype)
7888 
      iprot.readFieldEnd()
7889 
    iprot.readStructEnd()
7890 
 
7891 
  def write(self, oprot):
7892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7894 
      return
559 chandransh 7895 
    oprot.writeStructBegin('getWidget_result')
94 ashish 7896 
    if self.success != None:
559 chandransh 7897 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7898 
      self.success.write(oprot)
94 ashish 7899 
      oprot.writeFieldEnd()
559 chandransh 7900 
    if self.scx != None:
7901 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7902 
      self.scx.write(oprot)
94 ashish 7903 
      oprot.writeFieldEnd()
7904 
    oprot.writeFieldStop()
7905 
    oprot.writeStructEnd()
7906 
 
7907 
  def __repr__(self):
7908 
    L = ['%s=%r' % (key, value)
7909 
      for key, value in self.__dict__.iteritems()]
7910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7911 
 
7912 
  def __eq__(self, other):
7913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7914 
 
7915 
  def __ne__(self, other):
7916 
    return not (self == other)
7917 
 
559 chandransh 7918 
class getMyResearch_args:
94 ashish 7919 
  """
7920 
  Attributes:
559 chandransh 7921 
   - user_id
94 ashish 7922 
  """
7923 
 
7924 
  thrift_spec = (
7925 
    None, # 0
559 chandransh 7926 
    (1, TType.I64, 'user_id', None, None, ), # 1
94 ashish 7927 
  )
7928 
 
559 chandransh 7929 
  def __init__(self, user_id=None,):
7930 
    self.user_id = user_id
94 ashish 7931 
 
7932 
  def read(self, iprot):
7933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7935 
      return
7936 
    iprot.readStructBegin()
7937 
    while True:
7938 
      (fname, ftype, fid) = iprot.readFieldBegin()
7939 
      if ftype == TType.STOP:
7940 
        break
7941 
      if fid == 1:
7942 
        if ftype == TType.I64:
559 chandransh 7943 
          self.user_id = iprot.readI64();
94 ashish 7944 
        else:
7945 
          iprot.skip(ftype)
7946 
      else:
7947 
        iprot.skip(ftype)
7948 
      iprot.readFieldEnd()
7949 
    iprot.readStructEnd()
7950 
 
7951 
  def write(self, oprot):
7952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7954 
      return
559 chandransh 7955 
    oprot.writeStructBegin('getMyResearch_args')
7956 
    if self.user_id != None:
7957 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
7958 
      oprot.writeI64(self.user_id)
94 ashish 7959 
      oprot.writeFieldEnd()
7960 
    oprot.writeFieldStop()
7961 
    oprot.writeStructEnd()
7962 
 
7963 
  def __repr__(self):
7964 
    L = ['%s=%r' % (key, value)
7965 
      for key, value in self.__dict__.iteritems()]
7966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7967 
 
7968 
  def __eq__(self, other):
7969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7970 
 
7971 
  def __ne__(self, other):
7972 
    return not (self == other)
7973 
 
559 chandransh 7974 
class getMyResearch_result:
94 ashish 7975 
  """
7976 
  Attributes:
7977 
   - success
559 chandransh 7978 
   - scx
94 ashish 7979 
  """
7980 
 
7981 
  thrift_spec = (
559 chandransh 7982 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
7983 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 7984 
  )
7985 
 
559 chandransh 7986 
  def __init__(self, success=None, scx=None,):
94 ashish 7987 
    self.success = success
559 chandransh 7988 
    self.scx = scx
94 ashish 7989 
 
7990 
  def read(self, iprot):
7991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7993 
      return
7994 
    iprot.readStructBegin()
7995 
    while True:
7996 
      (fname, ftype, fid) = iprot.readFieldBegin()
7997 
      if ftype == TType.STOP:
7998 
        break
7999 
      if fid == 0:
559 chandransh 8000 
        if ftype == TType.STRUCT:
8001 
          self.success = Widget()
8002 
          self.success.read(iprot)
94 ashish 8003 
        else:
8004 
          iprot.skip(ftype)
8005 
      elif fid == 1:
8006 
        if ftype == TType.STRUCT:
559 chandransh 8007 
          self.scx = WidgetException()
8008 
          self.scx.read(iprot)
94 ashish 8009 
        else:
8010 
          iprot.skip(ftype)
8011 
      else:
8012 
        iprot.skip(ftype)
8013 
      iprot.readFieldEnd()
8014 
    iprot.readStructEnd()
8015 
 
8016 
  def write(self, oprot):
8017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8019 
      return
559 chandransh 8020 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 8021 
    if self.success != None:
559 chandransh 8022 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8023 
      self.success.write(oprot)
94 ashish 8024 
      oprot.writeFieldEnd()
559 chandransh 8025 
    if self.scx != None:
8026 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8027 
      self.scx.write(oprot)
94 ashish 8028 
      oprot.writeFieldEnd()
8029 
    oprot.writeFieldStop()
8030 
    oprot.writeStructEnd()
8031 
 
8032 
  def __repr__(self):
8033 
    L = ['%s=%r' % (key, value)
8034 
      for key, value in self.__dict__.iteritems()]
8035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8036 
 
8037 
  def __eq__(self, other):
8038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8039 
 
8040 
  def __ne__(self, other):
8041 
    return not (self == other)
8042 
 
559 chandransh 8043 
class updateMyResearch_args:
94 ashish 8044 
  """
8045 
  Attributes:
559 chandransh 8046 
   - user_id
8047 
   - item_id
94 ashish 8048 
  """
8049 
 
8050 
  thrift_spec = (
8051 
    None, # 0
559 chandransh 8052 
    (1, TType.I64, 'user_id', None, None, ), # 1
8053 
    (2, TType.I64, 'item_id', None, None, ), # 2
94 ashish 8054 
  )
8055 
 
559 chandransh 8056 
  def __init__(self, user_id=None, item_id=None,):
8057 
    self.user_id = user_id
8058 
    self.item_id = item_id
94 ashish 8059 
 
8060 
  def read(self, iprot):
8061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8063 
      return
8064 
    iprot.readStructBegin()
8065 
    while True:
8066 
      (fname, ftype, fid) = iprot.readFieldBegin()
8067 
      if ftype == TType.STOP:
8068 
        break
8069 
      if fid == 1:
8070 
        if ftype == TType.I64:
559 chandransh 8071 
          self.user_id = iprot.readI64();
94 ashish 8072 
        else:
8073 
          iprot.skip(ftype)
8074 
      elif fid == 2:
559 chandransh 8075 
        if ftype == TType.I64:
8076 
          self.item_id = iprot.readI64();
94 ashish 8077 
        else:
8078 
          iprot.skip(ftype)
8079 
      else:
8080 
        iprot.skip(ftype)
8081 
      iprot.readFieldEnd()
8082 
    iprot.readStructEnd()
8083 
 
8084 
  def write(self, oprot):
8085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8087 
      return
559 chandransh 8088 
    oprot.writeStructBegin('updateMyResearch_args')
8089 
    if self.user_id != None:
8090 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
8091 
      oprot.writeI64(self.user_id)
94 ashish 8092 
      oprot.writeFieldEnd()
559 chandransh 8093 
    if self.item_id != None:
8094 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
8095 
      oprot.writeI64(self.item_id)
94 ashish 8096 
      oprot.writeFieldEnd()
8097 
    oprot.writeFieldStop()
8098 
    oprot.writeStructEnd()
8099 
 
8100 
  def __repr__(self):
8101 
    L = ['%s=%r' % (key, value)
8102 
      for key, value in self.__dict__.iteritems()]
8103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8104 
 
8105 
  def __eq__(self, other):
8106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8107 
 
8108 
  def __ne__(self, other):
8109 
    return not (self == other)
8110 
 
559 chandransh 8111 
class updateMyResearch_result:
94 ashish 8112 
  """
8113 
  Attributes:
8114 
   - success
559 chandransh 8115 
   - scx
94 ashish 8116 
  """
8117 
 
8118 
  thrift_spec = (
8119 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 8120 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 8121 
  )
8122 
 
559 chandransh 8123 
  def __init__(self, success=None, scx=None,):
94 ashish 8124 
    self.success = success
559 chandransh 8125 
    self.scx = scx
94 ashish 8126 
 
8127 
  def read(self, iprot):
8128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8130 
      return
8131 
    iprot.readStructBegin()
8132 
    while True:
8133 
      (fname, ftype, fid) = iprot.readFieldBegin()
8134 
      if ftype == TType.STOP:
8135 
        break
8136 
      if fid == 0:
8137 
        if ftype == TType.BOOL:
8138 
          self.success = iprot.readBool();
8139 
        else:
8140 
          iprot.skip(ftype)
8141 
      elif fid == 1:
8142 
        if ftype == TType.STRUCT:
559 chandransh 8143 
          self.scx = WidgetException()
8144 
          self.scx.read(iprot)
94 ashish 8145 
        else:
8146 
          iprot.skip(ftype)
8147 
      else:
8148 
        iprot.skip(ftype)
8149 
      iprot.readFieldEnd()
8150 
    iprot.readStructEnd()
8151 
 
8152 
  def write(self, oprot):
8153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8155 
      return
559 chandransh 8156 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 8157 
    if self.success != None:
8158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8159 
      oprot.writeBool(self.success)
8160 
      oprot.writeFieldEnd()
559 chandransh 8161 
    if self.scx != None:
8162 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8163 
      self.scx.write(oprot)
94 ashish 8164 
      oprot.writeFieldEnd()
8165 
    oprot.writeFieldStop()
8166 
    oprot.writeStructEnd()
8167 
 
8168 
  def __repr__(self):
8169 
    L = ['%s=%r' % (key, value)
8170 
      for key, value in self.__dict__.iteritems()]
8171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8172 
 
8173 
  def __eq__(self, other):
8174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8175 
 
8176 
  def __ne__(self, other):
8177 
    return not (self == other)
8178 
 
559 chandransh 8179 
class deleteItemFromMyResearch_args:
130 ashish 8180 
  """
8181 
  Attributes:
559 chandransh 8182 
   - user_id
8183 
   - item_id
130 ashish 8184 
  """
94 ashish 8185 
 
130 ashish 8186 
  thrift_spec = (
8187 
    None, # 0
559 chandransh 8188 
    (1, TType.I64, 'user_id', None, None, ), # 1
8189 
    (2, TType.I64, 'item_id', None, None, ), # 2
130 ashish 8190 
  )
8191 
 
559 chandransh 8192 
  def __init__(self, user_id=None, item_id=None,):
8193 
    self.user_id = user_id
8194 
    self.item_id = item_id
130 ashish 8195 
 
8196 
  def read(self, iprot):
8197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8199 
      return
8200 
    iprot.readStructBegin()
8201 
    while True:
8202 
      (fname, ftype, fid) = iprot.readFieldBegin()
8203 
      if ftype == TType.STOP:
8204 
        break
8205 
      if fid == 1:
8206 
        if ftype == TType.I64:
559 chandransh 8207 
          self.user_id = iprot.readI64();
130 ashish 8208 
        else:
8209 
          iprot.skip(ftype)
559 chandransh 8210 
      elif fid == 2:
8211 
        if ftype == TType.I64:
8212 
          self.item_id = iprot.readI64();
8213 
        else:
8214 
          iprot.skip(ftype)
130 ashish 8215 
      else:
8216 
        iprot.skip(ftype)
8217 
      iprot.readFieldEnd()
8218 
    iprot.readStructEnd()
8219 
 
8220 
  def write(self, oprot):
8221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8223 
      return
559 chandransh 8224 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
8225 
    if self.user_id != None:
8226 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
8227 
      oprot.writeI64(self.user_id)
130 ashish 8228 
      oprot.writeFieldEnd()
559 chandransh 8229 
    if self.item_id != None:
8230 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
8231 
      oprot.writeI64(self.item_id)
8232 
      oprot.writeFieldEnd()
130 ashish 8233 
    oprot.writeFieldStop()
8234 
    oprot.writeStructEnd()
8235 
 
8236 
  def __repr__(self):
8237 
    L = ['%s=%r' % (key, value)
8238 
      for key, value in self.__dict__.iteritems()]
8239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8240 
 
8241 
  def __eq__(self, other):
8242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8243 
 
8244 
  def __ne__(self, other):
8245 
    return not (self == other)
8246 
 
559 chandransh 8247 
class deleteItemFromMyResearch_result:
130 ashish 8248 
  """
8249 
  Attributes:
559 chandransh 8250 
   - scx
8251 
  """
8252 
 
8253 
  thrift_spec = (
8254 
    None, # 0
8255 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
8256 
  )
8257 
 
8258 
  def __init__(self, scx=None,):
8259 
    self.scx = scx
8260 
 
8261 
  def read(self, iprot):
8262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8264 
      return
8265 
    iprot.readStructBegin()
8266 
    while True:
8267 
      (fname, ftype, fid) = iprot.readFieldBegin()
8268 
      if ftype == TType.STOP:
8269 
        break
8270 
      if fid == 1:
8271 
        if ftype == TType.STRUCT:
8272 
          self.scx = WidgetException()
8273 
          self.scx.read(iprot)
8274 
        else:
8275 
          iprot.skip(ftype)
8276 
      else:
8277 
        iprot.skip(ftype)
8278 
      iprot.readFieldEnd()
8279 
    iprot.readStructEnd()
8280 
 
8281 
  def write(self, oprot):
8282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8284 
      return
8285 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
8286 
    if self.scx != None:
8287 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8288 
      self.scx.write(oprot)
8289 
      oprot.writeFieldEnd()
8290 
    oprot.writeFieldStop()
8291 
    oprot.writeStructEnd()
8292 
 
8293 
  def __repr__(self):
8294 
    L = ['%s=%r' % (key, value)
8295 
      for key, value in self.__dict__.iteritems()]
8296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8297 
 
8298 
  def __eq__(self, other):
8299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8300 
 
8301 
  def __ne__(self, other):
8302 
    return not (self == other)
8303 
 
8304 
class updateRatings_args:
8305 
  """
8306 
  Attributes:
8307 
   - item_id
8308 
   - type
8309 
   - rating
8310 
   - user_id
8311 
  """
8312 
 
8313 
  thrift_spec = (
8314 
    None, # 0
8315 
    (1, TType.I64, 'item_id', None, None, ), # 1
8316 
    (2, TType.I32, 'type', None, None, ), # 2
8317 
    (3, TType.DOUBLE, 'rating', None, None, ), # 3
8318 
    (4, TType.I64, 'user_id', None, None, ), # 4
8319 
  )
8320 
 
8321 
  def __init__(self, item_id=None, type=None, rating=None, user_id=None,):
8322 
    self.item_id = item_id
8323 
    self.type = type
8324 
    self.rating = rating
8325 
    self.user_id = user_id
8326 
 
8327 
  def read(self, iprot):
8328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8330 
      return
8331 
    iprot.readStructBegin()
8332 
    while True:
8333 
      (fname, ftype, fid) = iprot.readFieldBegin()
8334 
      if ftype == TType.STOP:
8335 
        break
8336 
      if fid == 1:
8337 
        if ftype == TType.I64:
8338 
          self.item_id = iprot.readI64();
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      elif fid == 2:
8342 
        if ftype == TType.I32:
8343 
          self.type = iprot.readI32();
8344 
        else:
8345 
          iprot.skip(ftype)
8346 
      elif fid == 3:
8347 
        if ftype == TType.DOUBLE:
8348 
          self.rating = iprot.readDouble();
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      elif fid == 4:
8352 
        if ftype == TType.I64:
8353 
          self.user_id = iprot.readI64();
8354 
        else:
8355 
          iprot.skip(ftype)
8356 
      else:
8357 
        iprot.skip(ftype)
8358 
      iprot.readFieldEnd()
8359 
    iprot.readStructEnd()
8360 
 
8361 
  def write(self, oprot):
8362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8364 
      return
8365 
    oprot.writeStructBegin('updateRatings_args')
8366 
    if self.item_id != None:
8367 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8368 
      oprot.writeI64(self.item_id)
8369 
      oprot.writeFieldEnd()
8370 
    if self.type != None:
8371 
      oprot.writeFieldBegin('type', TType.I32, 2)
8372 
      oprot.writeI32(self.type)
8373 
      oprot.writeFieldEnd()
8374 
    if self.rating != None:
8375 
      oprot.writeFieldBegin('rating', TType.DOUBLE, 3)
8376 
      oprot.writeDouble(self.rating)
8377 
      oprot.writeFieldEnd()
8378 
    if self.user_id != None:
8379 
      oprot.writeFieldBegin('user_id', TType.I64, 4)
8380 
      oprot.writeI64(self.user_id)
8381 
      oprot.writeFieldEnd()
8382 
    oprot.writeFieldStop()
8383 
    oprot.writeStructEnd()
8384 
 
8385 
  def __repr__(self):
8386 
    L = ['%s=%r' % (key, value)
8387 
      for key, value in self.__dict__.iteritems()]
8388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8389 
 
8390 
  def __eq__(self, other):
8391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8392 
 
8393 
  def __ne__(self, other):
8394 
    return not (self == other)
8395 
 
8396 
class updateRatings_result:
8397 
 
8398 
  thrift_spec = (
8399 
  )
8400 
 
8401 
  def read(self, iprot):
8402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8404 
      return
8405 
    iprot.readStructBegin()
8406 
    while True:
8407 
      (fname, ftype, fid) = iprot.readFieldBegin()
8408 
      if ftype == TType.STOP:
8409 
        break
8410 
      else:
8411 
        iprot.skip(ftype)
8412 
      iprot.readFieldEnd()
8413 
    iprot.readStructEnd()
8414 
 
8415 
  def write(self, oprot):
8416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8418 
      return
8419 
    oprot.writeStructBegin('updateRatings_result')
8420 
    oprot.writeFieldStop()
8421 
    oprot.writeStructEnd()
8422 
 
8423 
  def __repr__(self):
8424 
    L = ['%s=%r' % (key, value)
8425 
      for key, value in self.__dict__.iteritems()]
8426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8427 
 
8428 
  def __eq__(self, other):
8429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8430 
 
8431 
  def __ne__(self, other):
8432 
    return not (self == other)
8433 
 
8434 
class getRatings_args:
8435 
  """
8436 
  Attributes:
8437 
   - item_id
8438 
   - user_id
8439 
  """
8440 
 
8441 
  thrift_spec = (
8442 
    None, # 0
8443 
    (1, TType.I64, 'item_id', None, None, ), # 1
8444 
    (2, TType.I64, 'user_id', None, None, ), # 2
8445 
  )
8446 
 
8447 
  def __init__(self, item_id=None, user_id=None,):
8448 
    self.item_id = item_id
8449 
    self.user_id = user_id
8450 
 
8451 
  def read(self, iprot):
8452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8454 
      return
8455 
    iprot.readStructBegin()
8456 
    while True:
8457 
      (fname, ftype, fid) = iprot.readFieldBegin()
8458 
      if ftype == TType.STOP:
8459 
        break
8460 
      if fid == 1:
8461 
        if ftype == TType.I64:
8462 
          self.item_id = iprot.readI64();
8463 
        else:
8464 
          iprot.skip(ftype)
8465 
      elif fid == 2:
8466 
        if ftype == TType.I64:
8467 
          self.user_id = iprot.readI64();
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      else:
8471 
        iprot.skip(ftype)
8472 
      iprot.readFieldEnd()
8473 
    iprot.readStructEnd()
8474 
 
8475 
  def write(self, oprot):
8476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8478 
      return
8479 
    oprot.writeStructBegin('getRatings_args')
8480 
    if self.item_id != None:
8481 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8482 
      oprot.writeI64(self.item_id)
8483 
      oprot.writeFieldEnd()
8484 
    if self.user_id != None:
8485 
      oprot.writeFieldBegin('user_id', TType.I64, 2)
8486 
      oprot.writeI64(self.user_id)
8487 
      oprot.writeFieldEnd()
8488 
    oprot.writeFieldStop()
8489 
    oprot.writeStructEnd()
8490 
 
8491 
  def __repr__(self):
8492 
    L = ['%s=%r' % (key, value)
8493 
      for key, value in self.__dict__.iteritems()]
8494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8495 
 
8496 
  def __eq__(self, other):
8497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8498 
 
8499 
  def __ne__(self, other):
8500 
    return not (self == other)
8501 
 
8502 
class getRatings_result:
8503 
  """
8504 
  Attributes:
130 ashish 8505 
   - success
559 chandransh 8506 
   - scx
130 ashish 8507 
  """
8508 
 
8509 
  thrift_spec = (
559 chandransh 8510 
    (0, TType.STRUCT, 'success', (RatingsWidget, RatingsWidget.thrift_spec), None, ), # 0
8511 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 8512 
  )
8513 
 
559 chandransh 8514 
  def __init__(self, success=None, scx=None,):
130 ashish 8515 
    self.success = success
559 chandransh 8516 
    self.scx = scx
130 ashish 8517 
 
8518 
  def read(self, iprot):
8519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8521 
      return
8522 
    iprot.readStructBegin()
8523 
    while True:
8524 
      (fname, ftype, fid) = iprot.readFieldBegin()
8525 
      if ftype == TType.STOP:
8526 
        break
8527 
      if fid == 0:
559 chandransh 8528 
        if ftype == TType.STRUCT:
8529 
          self.success = RatingsWidget()
8530 
          self.success.read(iprot)
130 ashish 8531 
        else:
8532 
          iprot.skip(ftype)
8533 
      elif fid == 1:
8534 
        if ftype == TType.STRUCT:
559 chandransh 8535 
          self.scx = WidgetException()
8536 
          self.scx.read(iprot)
130 ashish 8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      else:
8540 
        iprot.skip(ftype)
8541 
      iprot.readFieldEnd()
8542 
    iprot.readStructEnd()
8543 
 
8544 
  def write(self, oprot):
8545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8547 
      return
559 chandransh 8548 
    oprot.writeStructBegin('getRatings_result')
130 ashish 8549 
    if self.success != None:
559 chandransh 8550 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8551 
      self.success.write(oprot)
130 ashish 8552 
      oprot.writeFieldEnd()
559 chandransh 8553 
    if self.scx != None:
8554 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8555 
      self.scx.write(oprot)
130 ashish 8556 
      oprot.writeFieldEnd()
8557 
    oprot.writeFieldStop()
8558 
    oprot.writeStructEnd()
8559 
 
8560 
  def __repr__(self):
8561 
    L = ['%s=%r' % (key, value)
8562 
      for key, value in self.__dict__.iteritems()]
8563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8564 
 
8565 
  def __eq__(self, other):
8566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8567 
 
8568 
  def __ne__(self, other):
8569 
    return not (self == other)
8570 
 
559 chandransh 8571 
class updateBrowseHistory_args:
130 ashish 8572 
  """
8573 
  Attributes:
559 chandransh 8574 
   - user_id
8575 
   - item_id
8576 
   - isSessionId
130 ashish 8577 
  """
8578 
 
8579 
  thrift_spec = (
8580 
    None, # 0
559 chandransh 8581 
    (1, TType.I64, 'user_id', None, None, ), # 1
8582 
    (2, TType.I64, 'item_id', None, None, ), # 2
8583 
    (3, TType.BOOL, 'isSessionId', None, None, ), # 3
130 ashish 8584 
  )
8585 
 
559 chandransh 8586 
  def __init__(self, user_id=None, item_id=None, isSessionId=None,):
8587 
    self.user_id = user_id
8588 
    self.item_id = item_id
8589 
    self.isSessionId = isSessionId
130 ashish 8590 
 
8591 
  def read(self, iprot):
8592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8594 
      return
8595 
    iprot.readStructBegin()
8596 
    while True:
8597 
      (fname, ftype, fid) = iprot.readFieldBegin()
8598 
      if ftype == TType.STOP:
8599 
        break
8600 
      if fid == 1:
559 chandransh 8601 
        if ftype == TType.I64:
8602 
          self.user_id = iprot.readI64();
130 ashish 8603 
        else:
8604 
          iprot.skip(ftype)
8605 
      elif fid == 2:
559 chandransh 8606 
        if ftype == TType.I64:
8607 
          self.item_id = iprot.readI64();
8608 
        else:
8609 
          iprot.skip(ftype)
8610 
      elif fid == 3:
130 ashish 8611 
        if ftype == TType.BOOL:
559 chandransh 8612 
          self.isSessionId = iprot.readBool();
130 ashish 8613 
        else:
8614 
          iprot.skip(ftype)
8615 
      else:
8616 
        iprot.skip(ftype)
8617 
      iprot.readFieldEnd()
8618 
    iprot.readStructEnd()
8619 
 
8620 
  def write(self, oprot):
8621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8623 
      return
559 chandransh 8624 
    oprot.writeStructBegin('updateBrowseHistory_args')
8625 
    if self.user_id != None:
8626 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
8627 
      oprot.writeI64(self.user_id)
130 ashish 8628 
      oprot.writeFieldEnd()
559 chandransh 8629 
    if self.item_id != None:
8630 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
8631 
      oprot.writeI64(self.item_id)
130 ashish 8632 
      oprot.writeFieldEnd()
559 chandransh 8633 
    if self.isSessionId != None:
8634 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 3)
8635 
      oprot.writeBool(self.isSessionId)
8636 
      oprot.writeFieldEnd()
130 ashish 8637 
    oprot.writeFieldStop()
8638 
    oprot.writeStructEnd()
8639 
 
8640 
  def __repr__(self):
8641 
    L = ['%s=%r' % (key, value)
8642 
      for key, value in self.__dict__.iteritems()]
8643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8644 
 
8645 
  def __eq__(self, other):
8646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8647 
 
8648 
  def __ne__(self, other):
8649 
    return not (self == other)
8650 
 
559 chandransh 8651 
class updateBrowseHistory_result:
8652 
 
8653 
  thrift_spec = (
8654 
  )
8655 
 
8656 
  def read(self, iprot):
8657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8659 
      return
8660 
    iprot.readStructBegin()
8661 
    while True:
8662 
      (fname, ftype, fid) = iprot.readFieldBegin()
8663 
      if ftype == TType.STOP:
8664 
        break
8665 
      else:
8666 
        iprot.skip(ftype)
8667 
      iprot.readFieldEnd()
8668 
    iprot.readStructEnd()
8669 
 
8670 
  def write(self, oprot):
8671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8673 
      return
8674 
    oprot.writeStructBegin('updateBrowseHistory_result')
8675 
    oprot.writeFieldStop()
8676 
    oprot.writeStructEnd()
8677 
 
8678 
  def __repr__(self):
8679 
    L = ['%s=%r' % (key, value)
8680 
      for key, value in self.__dict__.iteritems()]
8681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8682 
 
8683 
  def __eq__(self, other):
8684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8685 
 
8686 
  def __ne__(self, other):
8687 
    return not (self == other)
8688 
 
8689 
class getBrowseHistory_args:
130 ashish 8690 
  """
8691 
  Attributes:
559 chandransh 8692 
   - userId
8693 
   - isSessionId
8694 
  """
8695 
 
8696 
  thrift_spec = (
8697 
    None, # 0
8698 
    (1, TType.I64, 'userId', None, None, ), # 1
8699 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
8700 
  )
8701 
 
8702 
  def __init__(self, userId=None, isSessionId=None,):
8703 
    self.userId = userId
8704 
    self.isSessionId = isSessionId
8705 
 
8706 
  def read(self, iprot):
8707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8709 
      return
8710 
    iprot.readStructBegin()
8711 
    while True:
8712 
      (fname, ftype, fid) = iprot.readFieldBegin()
8713 
      if ftype == TType.STOP:
8714 
        break
8715 
      if fid == 1:
8716 
        if ftype == TType.I64:
8717 
          self.userId = iprot.readI64();
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      elif fid == 2:
8721 
        if ftype == TType.BOOL:
8722 
          self.isSessionId = iprot.readBool();
8723 
        else:
8724 
          iprot.skip(ftype)
8725 
      else:
8726 
        iprot.skip(ftype)
8727 
      iprot.readFieldEnd()
8728 
    iprot.readStructEnd()
8729 
 
8730 
  def write(self, oprot):
8731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8733 
      return
8734 
    oprot.writeStructBegin('getBrowseHistory_args')
8735 
    if self.userId != None:
8736 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8737 
      oprot.writeI64(self.userId)
8738 
      oprot.writeFieldEnd()
8739 
    if self.isSessionId != None:
8740 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
8741 
      oprot.writeBool(self.isSessionId)
8742 
      oprot.writeFieldEnd()
8743 
    oprot.writeFieldStop()
8744 
    oprot.writeStructEnd()
8745 
 
8746 
  def __repr__(self):
8747 
    L = ['%s=%r' % (key, value)
8748 
      for key, value in self.__dict__.iteritems()]
8749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8750 
 
8751 
  def __eq__(self, other):
8752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8753 
 
8754 
  def __ne__(self, other):
8755 
    return not (self == other)
8756 
 
8757 
class getBrowseHistory_result:
8758 
  """
8759 
  Attributes:
130 ashish 8760 
   - success
559 chandransh 8761 
   - scx
130 ashish 8762 
  """
8763 
 
8764 
  thrift_spec = (
559 chandransh 8765 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
8766 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 8767 
  )
8768 
 
559 chandransh 8769 
  def __init__(self, success=None, scx=None,):
130 ashish 8770 
    self.success = success
559 chandransh 8771 
    self.scx = scx
130 ashish 8772 
 
8773 
  def read(self, iprot):
8774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8776 
      return
8777 
    iprot.readStructBegin()
8778 
    while True:
8779 
      (fname, ftype, fid) = iprot.readFieldBegin()
8780 
      if ftype == TType.STOP:
8781 
        break
8782 
      if fid == 0:
559 chandransh 8783 
        if ftype == TType.STRUCT:
8784 
          self.success = Widget()
8785 
          self.success.read(iprot)
130 ashish 8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      elif fid == 1:
8789 
        if ftype == TType.STRUCT:
559 chandransh 8790 
          self.scx = WidgetException()
8791 
          self.scx.read(iprot)
130 ashish 8792 
        else:
8793 
          iprot.skip(ftype)
8794 
      else:
8795 
        iprot.skip(ftype)
8796 
      iprot.readFieldEnd()
8797 
    iprot.readStructEnd()
8798 
 
8799 
  def write(self, oprot):
8800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8802 
      return
559 chandransh 8803 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 8804 
    if self.success != None:
559 chandransh 8805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8806 
      self.success.write(oprot)
130 ashish 8807 
      oprot.writeFieldEnd()
559 chandransh 8808 
    if self.scx != None:
8809 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8810 
      self.scx.write(oprot)
130 ashish 8811 
      oprot.writeFieldEnd()
8812 
    oprot.writeFieldStop()
8813 
    oprot.writeStructEnd()
8814 
 
8815 
  def __repr__(self):
8816 
    L = ['%s=%r' % (key, value)
8817 
      for key, value in self.__dict__.iteritems()]
8818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8819 
 
8820 
  def __eq__(self, other):
8821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8822 
 
8823 
  def __ne__(self, other):
8824 
    return not (self == other)
8825 
 
8826