Subversion Repositories SmartDukaan

Rev

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