Subversion Repositories SmartDukaan

Rev

Rev 122 | Rev 504 | 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 
  """
22 
  def createContext(self, context, updateExisting):
23 
    """
24 
    Parameters:
25 
     - context
26 
     - updateExisting
27 
    """
28 
    pass
29 
 
122 ashish 30 
  def getContextFromId(self, userId, isSessionId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
122 ashish 34 
     - isSessionId
94 ashish 35 
    """
36 
    pass
37 
 
38 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
39 
    """
40 
    Parameters:
41 
     - emailorhandle
42 
     - isEmail
43 
    """
44 
    pass
45 
 
122 ashish 46 
  def getState(self, userId, isSessionId):
94 ashish 47 
    """
48 
    Parameters:
49 
     - userId
122 ashish 50 
     - isSessionId
94 ashish 51 
    """
52 
    pass
53 
 
122 ashish 54 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 55 
    """
56 
    Parameters:
57 
     - userId
122 ashish 58 
     - isSessionId
94 ashish 59 
    """
60 
    pass
61 
 
122 ashish 62 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 63 
    """
64 
    Parameters:
65 
     - userId
122 ashish 66 
     - isSessionId
94 ashish 67 
    """
68 
    pass
69 
 
70 
  def getContext(self, email, password):
71 
    """
72 
    Parameters:
73 
     - email
74 
     - password
75 
    """
76 
    pass
77 
 
122 ashish 78 
  def authenticateUser(self, handle, password, isEmail):
79 
    """
80 
    Parameters:
81 
     - handle
82 
     - password
83 
     - isEmail
84 
    """
85 
    pass
86 
 
94 ashish 87 
  def userExists(self, email):
88 
    """
89 
    Parameters:
90 
     - email
91 
    """
92 
    pass
93 
 
94 
  def addIpAdressForUser(self, ip, timestamp, userId):
95 
    """
96 
    Parameters:
97 
     - ip
98 
     - timestamp
99 
     - userId
100 
    """
101 
    pass
102 
 
103 
  def addAddressForUser(self, address, userid, timestamp):
104 
    """
105 
    Parameters:
106 
     - address
107 
     - userid
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def removeAddressForUser(self, userid, addressId):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - addressId
117 
    """
118 
    pass
119 
 
120 
  def setUserAsLoggedIn(self, userId, timestamp):
121 
    """
122 
    Parameters:
123 
     - userId
124 
     - timestamp
125 
    """
126 
    pass
127 
 
128 
  def setUserAsLoggedOut(self, userid, timestamp):
129 
    """
130 
    Parameters:
131 
     - userid
132 
     - timestamp
133 
    """
134 
    pass
135 
 
136 
  def updatePassword(self, userid, password):
137 
    """
138 
    Parameters:
139 
     - userid
140 
     - password
141 
    """
142 
    pass
143 
 
122 ashish 144 
  def deleteUser(self, userid, isSessionId):
94 ashish 145 
    """
146 
    Parameters:
147 
     - userid
122 ashish 148 
     - isSessionId
94 ashish 149 
    """
150 
    pass
151 
 
152 
  def sendEmailVerification(self, userid):
153 
    """
154 
    Parameters:
155 
     - userid
156 
    """
157 
    pass
158 
 
159 
  def sendSMSVerification(self, userid):
160 
    """
161 
    Parameters:
162 
     - userid
163 
    """
164 
    pass
165 
 
166 
  def confirmEmailVerification(self, userid):
167 
    """
168 
    Parameters:
169 
     - userid
170 
    """
171 
    pass
172 
 
173 
  def confirmSMSVerification(self, userid):
174 
    """
175 
    Parameters:
176 
     - userid
177 
    """
178 
    pass
179 
 
180 
  def addSocialhandle(self, userid, socialService, handle):
181 
    """
182 
    Parameters:
183 
     - userid
184 
     - socialService
185 
     - handle
186 
    """
187 
    pass
188 
 
130 ashish 189 
  def sendNewPasswordById(self, userid):
190 
    """
191 
    Parameters:
192 
     - userid
193 
    """
194 
    pass
94 ashish 195 
 
130 ashish 196 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
197 
    """
198 
    Parameters:
199 
     - emailOrHandle
200 
     - isEmail
201 
    """
202 
    pass
203 
 
204 
 
94 ashish 205 
class Client(Iface):
206 
  """
207 
  service
208 
  """
209 
  def __init__(self, iprot, oprot=None):
210 
    self._iprot = self._oprot = iprot
211 
    if oprot != None:
212 
      self._oprot = oprot
213 
    self._seqid = 0
214 
 
215 
  def createContext(self, context, updateExisting):
216 
    """
217 
    Parameters:
218 
     - context
219 
     - updateExisting
220 
    """
221 
    self.send_createContext(context, updateExisting)
222 
    return self.recv_createContext()
223 
 
224 
  def send_createContext(self, context, updateExisting):
225 
    self._oprot.writeMessageBegin('createContext', TMessageType.CALL, self._seqid)
226 
    args = createContext_args()
227 
    args.context = context
228 
    args.updateExisting = updateExisting
229 
    args.write(self._oprot)
230 
    self._oprot.writeMessageEnd()
231 
    self._oprot.trans.flush()
232 
 
233 
  def recv_createContext(self, ):
234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
235 
    if mtype == TMessageType.EXCEPTION:
236 
      x = TApplicationException()
237 
      x.read(self._iprot)
238 
      self._iprot.readMessageEnd()
239 
      raise x
240 
    result = createContext_result()
241 
    result.read(self._iprot)
242 
    self._iprot.readMessageEnd()
243 
    if result.success != None:
244 
      return result.success
245 
    if result.cex != None:
246 
      raise result.cex
247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createContext failed: unknown result");
248 
 
122 ashish 249 
  def getContextFromId(self, userId, isSessionId):
94 ashish 250 
    """
251 
    Parameters:
252 
     - userId
122 ashish 253 
     - isSessionId
94 ashish 254 
    """
122 ashish 255 
    self.send_getContextFromId(userId, isSessionId)
94 ashish 256 
    return self.recv_getContextFromId()
257 
 
122 ashish 258 
  def send_getContextFromId(self, userId, isSessionId):
94 ashish 259 
    self._oprot.writeMessageBegin('getContextFromId', TMessageType.CALL, self._seqid)
260 
    args = getContextFromId_args()
261 
    args.userId = userId
122 ashish 262 
    args.isSessionId = isSessionId
94 ashish 263 
    args.write(self._oprot)
264 
    self._oprot.writeMessageEnd()
265 
    self._oprot.trans.flush()
266 
 
267 
  def recv_getContextFromId(self, ):
268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
269 
    if mtype == TMessageType.EXCEPTION:
270 
      x = TApplicationException()
271 
      x.read(self._iprot)
272 
      self._iprot.readMessageEnd()
273 
      raise x
274 
    result = getContextFromId_result()
275 
    result.read(self._iprot)
276 
    self._iprot.readMessageEnd()
277 
    if result.success != None:
278 
      return result.success
279 
    if result.ucx != None:
280 
      raise result.ucx
281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromId failed: unknown result");
282 
 
283 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
284 
    """
285 
    Parameters:
286 
     - emailorhandle
287 
     - isEmail
288 
    """
289 
    self.send_getContextFromEmailOrHandle(emailorhandle, isEmail)
290 
    return self.recv_getContextFromEmailOrHandle()
291 
 
292 
  def send_getContextFromEmailOrHandle(self, emailorhandle, isEmail):
293 
    self._oprot.writeMessageBegin('getContextFromEmailOrHandle', TMessageType.CALL, self._seqid)
294 
    args = getContextFromEmailOrHandle_args()
295 
    args.emailorhandle = emailorhandle
296 
    args.isEmail = isEmail
297 
    args.write(self._oprot)
298 
    self._oprot.writeMessageEnd()
299 
    self._oprot.trans.flush()
300 
 
301 
  def recv_getContextFromEmailOrHandle(self, ):
302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
303 
    if mtype == TMessageType.EXCEPTION:
304 
      x = TApplicationException()
305 
      x.read(self._iprot)
306 
      self._iprot.readMessageEnd()
307 
      raise x
308 
    result = getContextFromEmailOrHandle_result()
309 
    result.read(self._iprot)
310 
    self._iprot.readMessageEnd()
311 
    if result.success != None:
312 
      return result.success
313 
    if result.ucx != None:
314 
      raise result.ucx
315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromEmailOrHandle failed: unknown result");
316 
 
122 ashish 317 
  def getState(self, userId, isSessionId):
94 ashish 318 
    """
319 
    Parameters:
320 
     - userId
122 ashish 321 
     - isSessionId
94 ashish 322 
    """
122 ashish 323 
    self.send_getState(userId, isSessionId)
94 ashish 324 
    return self.recv_getState()
325 
 
122 ashish 326 
  def send_getState(self, userId, isSessionId):
94 ashish 327 
    self._oprot.writeMessageBegin('getState', TMessageType.CALL, self._seqid)
328 
    args = getState_args()
329 
    args.userId = userId
122 ashish 330 
    args.isSessionId = isSessionId
94 ashish 331 
    args.write(self._oprot)
332 
    self._oprot.writeMessageEnd()
333 
    self._oprot.trans.flush()
334 
 
335 
  def recv_getState(self, ):
336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
337 
    if mtype == TMessageType.EXCEPTION:
338 
      x = TApplicationException()
339 
      x.read(self._iprot)
340 
      self._iprot.readMessageEnd()
341 
      raise x
342 
    result = getState_result()
343 
    result.read(self._iprot)
344 
    self._iprot.readMessageEnd()
345 
    if result.success != None:
346 
      return result.success
347 
    if result.ucx != None:
348 
      raise result.ucx
349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getState failed: unknown result");
350 
 
122 ashish 351 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 352 
    """
353 
    Parameters:
354 
     - userId
122 ashish 355 
     - isSessionId
94 ashish 356 
    """
122 ashish 357 
    self.send_getPrimaryInfo(userId, isSessionId)
94 ashish 358 
    return self.recv_getPrimaryInfo()
359 
 
122 ashish 360 
  def send_getPrimaryInfo(self, userId, isSessionId):
94 ashish 361 
    self._oprot.writeMessageBegin('getPrimaryInfo', TMessageType.CALL, self._seqid)
362 
    args = getPrimaryInfo_args()
363 
    args.userId = userId
122 ashish 364 
    args.isSessionId = isSessionId
94 ashish 365 
    args.write(self._oprot)
366 
    self._oprot.writeMessageEnd()
367 
    self._oprot.trans.flush()
368 
 
369 
  def recv_getPrimaryInfo(self, ):
370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
371 
    if mtype == TMessageType.EXCEPTION:
372 
      x = TApplicationException()
373 
      x.read(self._iprot)
374 
      self._iprot.readMessageEnd()
375 
      raise x
376 
    result = getPrimaryInfo_result()
377 
    result.read(self._iprot)
378 
    self._iprot.readMessageEnd()
379 
    if result.success != None:
380 
      return result.success
381 
    if result.ucx != None:
382 
      raise result.ucx
383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrimaryInfo failed: unknown result");
384 
 
122 ashish 385 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 386 
    """
387 
    Parameters:
388 
     - userId
122 ashish 389 
     - isSessionId
94 ashish 390 
    """
122 ashish 391 
    self.send_getInternalInfo(userId, isSessionId)
94 ashish 392 
    return self.recv_getInternalInfo()
393 
 
122 ashish 394 
  def send_getInternalInfo(self, userId, isSessionId):
94 ashish 395 
    self._oprot.writeMessageBegin('getInternalInfo', TMessageType.CALL, self._seqid)
396 
    args = getInternalInfo_args()
397 
    args.userId = userId
122 ashish 398 
    args.isSessionId = isSessionId
94 ashish 399 
    args.write(self._oprot)
400 
    self._oprot.writeMessageEnd()
401 
    self._oprot.trans.flush()
402 
 
403 
  def recv_getInternalInfo(self, ):
404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
405 
    if mtype == TMessageType.EXCEPTION:
406 
      x = TApplicationException()
407 
      x.read(self._iprot)
408 
      self._iprot.readMessageEnd()
409 
      raise x
410 
    result = getInternalInfo_result()
411 
    result.read(self._iprot)
412 
    self._iprot.readMessageEnd()
413 
    if result.success != None:
414 
      return result.success
415 
    if result.ucx != None:
416 
      raise result.ucx
417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInternalInfo failed: unknown result");
418 
 
419 
  def getContext(self, email, password):
420 
    """
421 
    Parameters:
422 
     - email
423 
     - password
424 
    """
425 
    self.send_getContext(email, password)
426 
    return self.recv_getContext()
427 
 
428 
  def send_getContext(self, email, password):
429 
    self._oprot.writeMessageBegin('getContext', TMessageType.CALL, self._seqid)
430 
    args = getContext_args()
431 
    args.email = email
432 
    args.password = password
433 
    args.write(self._oprot)
434 
    self._oprot.writeMessageEnd()
435 
    self._oprot.trans.flush()
436 
 
437 
  def recv_getContext(self, ):
438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
439 
    if mtype == TMessageType.EXCEPTION:
440 
      x = TApplicationException()
441 
      x.read(self._iprot)
442 
      self._iprot.readMessageEnd()
443 
      raise x
444 
    result = getContext_result()
445 
    result.read(self._iprot)
446 
    self._iprot.readMessageEnd()
447 
    if result.success != None:
448 
      return result.success
449 
    if result.ax != None:
450 
      raise result.ax
451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContext failed: unknown result");
452 
 
122 ashish 453 
  def authenticateUser(self, handle, password, isEmail):
454 
    """
455 
    Parameters:
456 
     - handle
457 
     - password
458 
     - isEmail
459 
    """
460 
    self.send_authenticateUser(handle, password, isEmail)
461 
    return self.recv_authenticateUser()
462 
 
463 
  def send_authenticateUser(self, handle, password, isEmail):
464 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
465 
    args = authenticateUser_args()
466 
    args.handle = handle
467 
    args.password = password
468 
    args.isEmail = isEmail
469 
    args.write(self._oprot)
470 
    self._oprot.writeMessageEnd()
471 
    self._oprot.trans.flush()
472 
 
473 
  def recv_authenticateUser(self, ):
474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
475 
    if mtype == TMessageType.EXCEPTION:
476 
      x = TApplicationException()
477 
      x.read(self._iprot)
478 
      self._iprot.readMessageEnd()
479 
      raise x
480 
    result = authenticateUser_result()
481 
    result.read(self._iprot)
482 
    self._iprot.readMessageEnd()
483 
    if result.success != None:
484 
      return result.success
485 
    if result.ax != None:
486 
      raise result.ax
487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
488 
 
94 ashish 489 
  def userExists(self, email):
490 
    """
491 
    Parameters:
492 
     - email
493 
    """
494 
    self.send_userExists(email)
495 
    return self.recv_userExists()
496 
 
497 
  def send_userExists(self, email):
498 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
499 
    args = userExists_args()
500 
    args.email = email
501 
    args.write(self._oprot)
502 
    self._oprot.writeMessageEnd()
503 
    self._oprot.trans.flush()
504 
 
505 
  def recv_userExists(self, ):
506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
507 
    if mtype == TMessageType.EXCEPTION:
508 
      x = TApplicationException()
509 
      x.read(self._iprot)
510 
      self._iprot.readMessageEnd()
511 
      raise x
512 
    result = userExists_result()
513 
    result.read(self._iprot)
514 
    self._iprot.readMessageEnd()
515 
    if result.success != None:
516 
      return result.success
517 
    if result.ucx != None:
518 
      raise result.ucx
519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
520 
 
521 
  def addIpAdressForUser(self, ip, timestamp, userId):
522 
    """
523 
    Parameters:
524 
     - ip
525 
     - timestamp
526 
     - userId
527 
    """
528 
    self.send_addIpAdressForUser(ip, timestamp, userId)
529 
    return self.recv_addIpAdressForUser()
530 
 
531 
  def send_addIpAdressForUser(self, ip, timestamp, userId):
532 
    self._oprot.writeMessageBegin('addIpAdressForUser', TMessageType.CALL, self._seqid)
533 
    args = addIpAdressForUser_args()
534 
    args.ip = ip
535 
    args.timestamp = timestamp
536 
    args.userId = userId
537 
    args.write(self._oprot)
538 
    self._oprot.writeMessageEnd()
539 
    self._oprot.trans.flush()
540 
 
541 
  def recv_addIpAdressForUser(self, ):
542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
543 
    if mtype == TMessageType.EXCEPTION:
544 
      x = TApplicationException()
545 
      x.read(self._iprot)
546 
      self._iprot.readMessageEnd()
547 
      raise x
548 
    result = addIpAdressForUser_result()
549 
    result.read(self._iprot)
550 
    self._iprot.readMessageEnd()
551 
    if result.success != None:
552 
      return result.success
553 
    if result.ucx != None:
554 
      raise result.ucx
555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addIpAdressForUser failed: unknown result");
556 
 
557 
  def addAddressForUser(self, address, userid, timestamp):
558 
    """
559 
    Parameters:
560 
     - address
561 
     - userid
562 
     - timestamp
563 
    """
564 
    self.send_addAddressForUser(address, userid, timestamp)
565 
    return self.recv_addAddressForUser()
566 
 
567 
  def send_addAddressForUser(self, address, userid, timestamp):
568 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
569 
    args = addAddressForUser_args()
570 
    args.address = address
571 
    args.userid = userid
572 
    args.timestamp = timestamp
573 
    args.write(self._oprot)
574 
    self._oprot.writeMessageEnd()
575 
    self._oprot.trans.flush()
576 
 
577 
  def recv_addAddressForUser(self, ):
578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
579 
    if mtype == TMessageType.EXCEPTION:
580 
      x = TApplicationException()
581 
      x.read(self._iprot)
582 
      self._iprot.readMessageEnd()
583 
      raise x
584 
    result = addAddressForUser_result()
585 
    result.read(self._iprot)
586 
    self._iprot.readMessageEnd()
587 
    if result.success != None:
588 
      return result.success
589 
    if result.ucx != None:
590 
      raise result.ucx
591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
592 
 
593 
  def removeAddressForUser(self, userid, addressId):
594 
    """
595 
    Parameters:
596 
     - userid
597 
     - addressId
598 
    """
599 
    self.send_removeAddressForUser(userid, addressId)
600 
    return self.recv_removeAddressForUser()
601 
 
602 
  def send_removeAddressForUser(self, userid, addressId):
603 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
604 
    args = removeAddressForUser_args()
605 
    args.userid = userid
606 
    args.addressId = addressId
607 
    args.write(self._oprot)
608 
    self._oprot.writeMessageEnd()
609 
    self._oprot.trans.flush()
610 
 
611 
  def recv_removeAddressForUser(self, ):
612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
613 
    if mtype == TMessageType.EXCEPTION:
614 
      x = TApplicationException()
615 
      x.read(self._iprot)
616 
      self._iprot.readMessageEnd()
617 
      raise x
618 
    result = removeAddressForUser_result()
619 
    result.read(self._iprot)
620 
    self._iprot.readMessageEnd()
621 
    if result.success != None:
622 
      return result.success
623 
    if result.ucx != None:
624 
      raise result.ucx
625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
626 
 
627 
  def setUserAsLoggedIn(self, userId, timestamp):
628 
    """
629 
    Parameters:
630 
     - userId
631 
     - timestamp
632 
    """
633 
    self.send_setUserAsLoggedIn(userId, timestamp)
634 
    return self.recv_setUserAsLoggedIn()
635 
 
636 
  def send_setUserAsLoggedIn(self, userId, timestamp):
637 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
638 
    args = setUserAsLoggedIn_args()
639 
    args.userId = userId
640 
    args.timestamp = timestamp
641 
    args.write(self._oprot)
642 
    self._oprot.writeMessageEnd()
643 
    self._oprot.trans.flush()
644 
 
645 
  def recv_setUserAsLoggedIn(self, ):
646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
647 
    if mtype == TMessageType.EXCEPTION:
648 
      x = TApplicationException()
649 
      x.read(self._iprot)
650 
      self._iprot.readMessageEnd()
651 
      raise x
652 
    result = setUserAsLoggedIn_result()
653 
    result.read(self._iprot)
654 
    self._iprot.readMessageEnd()
655 
    if result.success != None:
656 
      return result.success
657 
    if result.ucx != None:
658 
      raise result.ucx
659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
660 
 
661 
  def setUserAsLoggedOut(self, userid, timestamp):
662 
    """
663 
    Parameters:
664 
     - userid
665 
     - timestamp
666 
    """
667 
    self.send_setUserAsLoggedOut(userid, timestamp)
668 
    return self.recv_setUserAsLoggedOut()
669 
 
670 
  def send_setUserAsLoggedOut(self, userid, timestamp):
671 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
672 
    args = setUserAsLoggedOut_args()
673 
    args.userid = userid
674 
    args.timestamp = timestamp
675 
    args.write(self._oprot)
676 
    self._oprot.writeMessageEnd()
677 
    self._oprot.trans.flush()
678 
 
679 
  def recv_setUserAsLoggedOut(self, ):
680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
681 
    if mtype == TMessageType.EXCEPTION:
682 
      x = TApplicationException()
683 
      x.read(self._iprot)
684 
      self._iprot.readMessageEnd()
685 
      raise x
686 
    result = setUserAsLoggedOut_result()
687 
    result.read(self._iprot)
688 
    self._iprot.readMessageEnd()
689 
    if result.success != None:
690 
      return result.success
691 
    if result.ucx != None:
692 
      raise result.ucx
693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
694 
 
695 
  def updatePassword(self, userid, password):
696 
    """
697 
    Parameters:
698 
     - userid
699 
     - password
700 
    """
701 
    self.send_updatePassword(userid, password)
702 
    return self.recv_updatePassword()
703 
 
704 
  def send_updatePassword(self, userid, password):
705 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
706 
    args = updatePassword_args()
707 
    args.userid = userid
708 
    args.password = password
709 
    args.write(self._oprot)
710 
    self._oprot.writeMessageEnd()
711 
    self._oprot.trans.flush()
712 
 
713 
  def recv_updatePassword(self, ):
714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
715 
    if mtype == TMessageType.EXCEPTION:
716 
      x = TApplicationException()
717 
      x.read(self._iprot)
718 
      self._iprot.readMessageEnd()
719 
      raise x
720 
    result = updatePassword_result()
721 
    result.read(self._iprot)
722 
    self._iprot.readMessageEnd()
723 
    if result.success != None:
724 
      return result.success
725 
    if result.ucx != None:
726 
      raise result.ucx
727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
728 
 
122 ashish 729 
  def deleteUser(self, userid, isSessionId):
94 ashish 730 
    """
731 
    Parameters:
732 
     - userid
122 ashish 733 
     - isSessionId
94 ashish 734 
    """
122 ashish 735 
    self.send_deleteUser(userid, isSessionId)
94 ashish 736 
    return self.recv_deleteUser()
737 
 
122 ashish 738 
  def send_deleteUser(self, userid, isSessionId):
94 ashish 739 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
740 
    args = deleteUser_args()
741 
    args.userid = userid
122 ashish 742 
    args.isSessionId = isSessionId
94 ashish 743 
    args.write(self._oprot)
744 
    self._oprot.writeMessageEnd()
745 
    self._oprot.trans.flush()
746 
 
747 
  def recv_deleteUser(self, ):
748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
749 
    if mtype == TMessageType.EXCEPTION:
750 
      x = TApplicationException()
751 
      x.read(self._iprot)
752 
      self._iprot.readMessageEnd()
753 
      raise x
754 
    result = deleteUser_result()
755 
    result.read(self._iprot)
756 
    self._iprot.readMessageEnd()
757 
    if result.success != None:
758 
      return result.success
759 
    if result.ucx != None:
760 
      raise result.ucx
761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
762 
 
763 
  def sendEmailVerification(self, userid):
764 
    """
765 
    Parameters:
766 
     - userid
767 
    """
768 
    self.send_sendEmailVerification(userid)
769 
    return self.recv_sendEmailVerification()
770 
 
771 
  def send_sendEmailVerification(self, userid):
772 
    self._oprot.writeMessageBegin('sendEmailVerification', TMessageType.CALL, self._seqid)
773 
    args = sendEmailVerification_args()
774 
    args.userid = userid
775 
    args.write(self._oprot)
776 
    self._oprot.writeMessageEnd()
777 
    self._oprot.trans.flush()
778 
 
779 
  def recv_sendEmailVerification(self, ):
780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
781 
    if mtype == TMessageType.EXCEPTION:
782 
      x = TApplicationException()
783 
      x.read(self._iprot)
784 
      self._iprot.readMessageEnd()
785 
      raise x
786 
    result = sendEmailVerification_result()
787 
    result.read(self._iprot)
788 
    self._iprot.readMessageEnd()
789 
    if result.success != None:
790 
      return result.success
791 
    if result.ucx != None:
792 
      raise result.ucx
793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendEmailVerification failed: unknown result");
794 
 
795 
  def sendSMSVerification(self, userid):
796 
    """
797 
    Parameters:
798 
     - userid
799 
    """
800 
    self.send_sendSMSVerification(userid)
801 
    return self.recv_sendSMSVerification()
802 
 
803 
  def send_sendSMSVerification(self, userid):
804 
    self._oprot.writeMessageBegin('sendSMSVerification', TMessageType.CALL, self._seqid)
805 
    args = sendSMSVerification_args()
806 
    args.userid = userid
807 
    args.write(self._oprot)
808 
    self._oprot.writeMessageEnd()
809 
    self._oprot.trans.flush()
810 
 
811 
  def recv_sendSMSVerification(self, ):
812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
813 
    if mtype == TMessageType.EXCEPTION:
814 
      x = TApplicationException()
815 
      x.read(self._iprot)
816 
      self._iprot.readMessageEnd()
817 
      raise x
818 
    result = sendSMSVerification_result()
819 
    result.read(self._iprot)
820 
    self._iprot.readMessageEnd()
821 
    if result.success != None:
822 
      return result.success
823 
    if result.ucx != None:
824 
      raise result.ucx
825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendSMSVerification failed: unknown result");
826 
 
827 
  def confirmEmailVerification(self, userid):
828 
    """
829 
    Parameters:
830 
     - userid
831 
    """
832 
    self.send_confirmEmailVerification(userid)
833 
    return self.recv_confirmEmailVerification()
834 
 
835 
  def send_confirmEmailVerification(self, userid):
836 
    self._oprot.writeMessageBegin('confirmEmailVerification', TMessageType.CALL, self._seqid)
837 
    args = confirmEmailVerification_args()
838 
    args.userid = userid
839 
    args.write(self._oprot)
840 
    self._oprot.writeMessageEnd()
841 
    self._oprot.trans.flush()
842 
 
843 
  def recv_confirmEmailVerification(self, ):
844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
845 
    if mtype == TMessageType.EXCEPTION:
846 
      x = TApplicationException()
847 
      x.read(self._iprot)
848 
      self._iprot.readMessageEnd()
849 
      raise x
850 
    result = confirmEmailVerification_result()
851 
    result.read(self._iprot)
852 
    self._iprot.readMessageEnd()
853 
    if result.success != None:
854 
      return result.success
855 
    if result.ucx != None:
856 
      raise result.ucx
857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmEmailVerification failed: unknown result");
858 
 
859 
  def confirmSMSVerification(self, userid):
860 
    """
861 
    Parameters:
862 
     - userid
863 
    """
864 
    self.send_confirmSMSVerification(userid)
865 
    return self.recv_confirmSMSVerification()
866 
 
867 
  def send_confirmSMSVerification(self, userid):
868 
    self._oprot.writeMessageBegin('confirmSMSVerification', TMessageType.CALL, self._seqid)
869 
    args = confirmSMSVerification_args()
870 
    args.userid = userid
871 
    args.write(self._oprot)
872 
    self._oprot.writeMessageEnd()
873 
    self._oprot.trans.flush()
874 
 
875 
  def recv_confirmSMSVerification(self, ):
876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
877 
    if mtype == TMessageType.EXCEPTION:
878 
      x = TApplicationException()
879 
      x.read(self._iprot)
880 
      self._iprot.readMessageEnd()
881 
      raise x
882 
    result = confirmSMSVerification_result()
883 
    result.read(self._iprot)
884 
    self._iprot.readMessageEnd()
885 
    if result.success != None:
886 
      return result.success
887 
    if result.ucx != None:
888 
      raise result.ucx
889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmSMSVerification failed: unknown result");
890 
 
891 
  def addSocialhandle(self, userid, socialService, handle):
892 
    """
893 
    Parameters:
894 
     - userid
895 
     - socialService
896 
     - handle
897 
    """
898 
    self.send_addSocialhandle(userid, socialService, handle)
899 
    return self.recv_addSocialhandle()
900 
 
901 
  def send_addSocialhandle(self, userid, socialService, handle):
902 
    self._oprot.writeMessageBegin('addSocialhandle', TMessageType.CALL, self._seqid)
903 
    args = addSocialhandle_args()
904 
    args.userid = userid
905 
    args.socialService = socialService
906 
    args.handle = handle
907 
    args.write(self._oprot)
908 
    self._oprot.writeMessageEnd()
909 
    self._oprot.trans.flush()
910 
 
911 
  def recv_addSocialhandle(self, ):
912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
913 
    if mtype == TMessageType.EXCEPTION:
914 
      x = TApplicationException()
915 
      x.read(self._iprot)
916 
      self._iprot.readMessageEnd()
917 
      raise x
918 
    result = addSocialhandle_result()
919 
    result.read(self._iprot)
920 
    self._iprot.readMessageEnd()
921 
    if result.success != None:
922 
      return result.success
923 
    if result.ucx != None:
924 
      raise result.ucx
925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSocialhandle failed: unknown result");
926 
 
130 ashish 927 
  def sendNewPasswordById(self, userid):
928 
    """
929 
    Parameters:
930 
     - userid
931 
    """
932 
    self.send_sendNewPasswordById(userid)
933 
    return self.recv_sendNewPasswordById()
94 ashish 934 
 
130 ashish 935 
  def send_sendNewPasswordById(self, userid):
936 
    self._oprot.writeMessageBegin('sendNewPasswordById', TMessageType.CALL, self._seqid)
937 
    args = sendNewPasswordById_args()
938 
    args.userid = userid
939 
    args.write(self._oprot)
940 
    self._oprot.writeMessageEnd()
941 
    self._oprot.trans.flush()
942 
 
943 
  def recv_sendNewPasswordById(self, ):
944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
945 
    if mtype == TMessageType.EXCEPTION:
946 
      x = TApplicationException()
947 
      x.read(self._iprot)
948 
      self._iprot.readMessageEnd()
949 
      raise x
950 
    result = sendNewPasswordById_result()
951 
    result.read(self._iprot)
952 
    self._iprot.readMessageEnd()
953 
    if result.success != None:
954 
      return result.success
955 
    if result.ucx != None:
956 
      raise result.ucx
957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordById failed: unknown result");
958 
 
959 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
960 
    """
961 
    Parameters:
962 
     - emailOrHandle
963 
     - isEmail
964 
    """
965 
    self.send_sendNewPasswordByHandle(emailOrHandle, isEmail)
966 
    return self.recv_sendNewPasswordByHandle()
967 
 
968 
  def send_sendNewPasswordByHandle(self, emailOrHandle, isEmail):
969 
    self._oprot.writeMessageBegin('sendNewPasswordByHandle', TMessageType.CALL, self._seqid)
970 
    args = sendNewPasswordByHandle_args()
971 
    args.emailOrHandle = emailOrHandle
972 
    args.isEmail = isEmail
973 
    args.write(self._oprot)
974 
    self._oprot.writeMessageEnd()
975 
    self._oprot.trans.flush()
976 
 
977 
  def recv_sendNewPasswordByHandle(self, ):
978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
979 
    if mtype == TMessageType.EXCEPTION:
980 
      x = TApplicationException()
981 
      x.read(self._iprot)
982 
      self._iprot.readMessageEnd()
983 
      raise x
984 
    result = sendNewPasswordByHandle_result()
985 
    result.read(self._iprot)
986 
    self._iprot.readMessageEnd()
987 
    if result.success != None:
988 
      return result.success
989 
    if result.ucx != None:
990 
      raise result.ucx
991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordByHandle failed: unknown result");
992 
 
993 
 
94 ashish 994 
class Processor(Iface, TProcessor):
995 
  def __init__(self, handler):
996 
    self._handler = handler
997 
    self._processMap = {}
998 
    self._processMap["createContext"] = Processor.process_createContext
999 
    self._processMap["getContextFromId"] = Processor.process_getContextFromId
1000 
    self._processMap["getContextFromEmailOrHandle"] = Processor.process_getContextFromEmailOrHandle
1001 
    self._processMap["getState"] = Processor.process_getState
1002 
    self._processMap["getPrimaryInfo"] = Processor.process_getPrimaryInfo
1003 
    self._processMap["getInternalInfo"] = Processor.process_getInternalInfo
1004 
    self._processMap["getContext"] = Processor.process_getContext
122 ashish 1005 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 1006 
    self._processMap["userExists"] = Processor.process_userExists
1007 
    self._processMap["addIpAdressForUser"] = Processor.process_addIpAdressForUser
1008 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
1009 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
1010 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
1011 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
1012 
    self._processMap["updatePassword"] = Processor.process_updatePassword
1013 
    self._processMap["deleteUser"] = Processor.process_deleteUser
1014 
    self._processMap["sendEmailVerification"] = Processor.process_sendEmailVerification
1015 
    self._processMap["sendSMSVerification"] = Processor.process_sendSMSVerification
1016 
    self._processMap["confirmEmailVerification"] = Processor.process_confirmEmailVerification
1017 
    self._processMap["confirmSMSVerification"] = Processor.process_confirmSMSVerification
1018 
    self._processMap["addSocialhandle"] = Processor.process_addSocialhandle
130 ashish 1019 
    self._processMap["sendNewPasswordById"] = Processor.process_sendNewPasswordById
1020 
    self._processMap["sendNewPasswordByHandle"] = Processor.process_sendNewPasswordByHandle
94 ashish 1021 
 
1022 
  def process(self, iprot, oprot):
1023 
    (name, type, seqid) = iprot.readMessageBegin()
1024 
    if name not in self._processMap:
1025 
      iprot.skip(TType.STRUCT)
1026 
      iprot.readMessageEnd()
1027 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1028 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1029 
      x.write(oprot)
1030 
      oprot.writeMessageEnd()
1031 
      oprot.trans.flush()
1032 
      return
1033 
    else:
1034 
      self._processMap[name](self, seqid, iprot, oprot)
1035 
    return True
1036 
 
1037 
  def process_createContext(self, seqid, iprot, oprot):
1038 
    args = createContext_args()
1039 
    args.read(iprot)
1040 
    iprot.readMessageEnd()
1041 
    result = createContext_result()
1042 
    try:
1043 
      result.success = self._handler.createContext(args.context, args.updateExisting)
1044 
    except UserContextException, cex:
1045 
      result.cex = cex
1046 
    oprot.writeMessageBegin("createContext", TMessageType.REPLY, seqid)
1047 
    result.write(oprot)
1048 
    oprot.writeMessageEnd()
1049 
    oprot.trans.flush()
1050 
 
1051 
  def process_getContextFromId(self, seqid, iprot, oprot):
1052 
    args = getContextFromId_args()
1053 
    args.read(iprot)
1054 
    iprot.readMessageEnd()
1055 
    result = getContextFromId_result()
1056 
    try:
122 ashish 1057 
      result.success = self._handler.getContextFromId(args.userId, args.isSessionId)
94 ashish 1058 
    except UserContextException, ucx:
1059 
      result.ucx = ucx
1060 
    oprot.writeMessageBegin("getContextFromId", TMessageType.REPLY, seqid)
1061 
    result.write(oprot)
1062 
    oprot.writeMessageEnd()
1063 
    oprot.trans.flush()
1064 
 
1065 
  def process_getContextFromEmailOrHandle(self, seqid, iprot, oprot):
1066 
    args = getContextFromEmailOrHandle_args()
1067 
    args.read(iprot)
1068 
    iprot.readMessageEnd()
1069 
    result = getContextFromEmailOrHandle_result()
1070 
    try:
1071 
      result.success = self._handler.getContextFromEmailOrHandle(args.emailorhandle, args.isEmail)
1072 
    except UserContextException, ucx:
1073 
      result.ucx = ucx
1074 
    oprot.writeMessageBegin("getContextFromEmailOrHandle", TMessageType.REPLY, seqid)
1075 
    result.write(oprot)
1076 
    oprot.writeMessageEnd()
1077 
    oprot.trans.flush()
1078 
 
1079 
  def process_getState(self, seqid, iprot, oprot):
1080 
    args = getState_args()
1081 
    args.read(iprot)
1082 
    iprot.readMessageEnd()
1083 
    result = getState_result()
1084 
    try:
122 ashish 1085 
      result.success = self._handler.getState(args.userId, args.isSessionId)
94 ashish 1086 
    except UserContextException, ucx:
1087 
      result.ucx = ucx
1088 
    oprot.writeMessageBegin("getState", TMessageType.REPLY, seqid)
1089 
    result.write(oprot)
1090 
    oprot.writeMessageEnd()
1091 
    oprot.trans.flush()
1092 
 
1093 
  def process_getPrimaryInfo(self, seqid, iprot, oprot):
1094 
    args = getPrimaryInfo_args()
1095 
    args.read(iprot)
1096 
    iprot.readMessageEnd()
1097 
    result = getPrimaryInfo_result()
1098 
    try:
122 ashish 1099 
      result.success = self._handler.getPrimaryInfo(args.userId, args.isSessionId)
94 ashish 1100 
    except UserContextException, ucx:
1101 
      result.ucx = ucx
1102 
    oprot.writeMessageBegin("getPrimaryInfo", TMessageType.REPLY, seqid)
1103 
    result.write(oprot)
1104 
    oprot.writeMessageEnd()
1105 
    oprot.trans.flush()
1106 
 
1107 
  def process_getInternalInfo(self, seqid, iprot, oprot):
1108 
    args = getInternalInfo_args()
1109 
    args.read(iprot)
1110 
    iprot.readMessageEnd()
1111 
    result = getInternalInfo_result()
1112 
    try:
122 ashish 1113 
      result.success = self._handler.getInternalInfo(args.userId, args.isSessionId)
94 ashish 1114 
    except UserContextException, ucx:
1115 
      result.ucx = ucx
1116 
    oprot.writeMessageBegin("getInternalInfo", TMessageType.REPLY, seqid)
1117 
    result.write(oprot)
1118 
    oprot.writeMessageEnd()
1119 
    oprot.trans.flush()
1120 
 
1121 
  def process_getContext(self, seqid, iprot, oprot):
1122 
    args = getContext_args()
1123 
    args.read(iprot)
1124 
    iprot.readMessageEnd()
1125 
    result = getContext_result()
1126 
    try:
1127 
      result.success = self._handler.getContext(args.email, args.password)
1128 
    except AuthenticationException, ax:
1129 
      result.ax = ax
1130 
    oprot.writeMessageBegin("getContext", TMessageType.REPLY, seqid)
1131 
    result.write(oprot)
1132 
    oprot.writeMessageEnd()
1133 
    oprot.trans.flush()
1134 
 
122 ashish 1135 
  def process_authenticateUser(self, seqid, iprot, oprot):
1136 
    args = authenticateUser_args()
1137 
    args.read(iprot)
1138 
    iprot.readMessageEnd()
1139 
    result = authenticateUser_result()
1140 
    try:
1141 
      result.success = self._handler.authenticateUser(args.handle, args.password, args.isEmail)
1142 
    except AuthenticationException, ax:
1143 
      result.ax = ax
1144 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
1145 
    result.write(oprot)
1146 
    oprot.writeMessageEnd()
1147 
    oprot.trans.flush()
1148 
 
94 ashish 1149 
  def process_userExists(self, seqid, iprot, oprot):
1150 
    args = userExists_args()
1151 
    args.read(iprot)
1152 
    iprot.readMessageEnd()
1153 
    result = userExists_result()
1154 
    try:
1155 
      result.success = self._handler.userExists(args.email)
1156 
    except UserContextException, ucx:
1157 
      result.ucx = ucx
1158 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
1159 
    result.write(oprot)
1160 
    oprot.writeMessageEnd()
1161 
    oprot.trans.flush()
1162 
 
1163 
  def process_addIpAdressForUser(self, seqid, iprot, oprot):
1164 
    args = addIpAdressForUser_args()
1165 
    args.read(iprot)
1166 
    iprot.readMessageEnd()
1167 
    result = addIpAdressForUser_result()
1168 
    try:
1169 
      result.success = self._handler.addIpAdressForUser(args.ip, args.timestamp, args.userId)
1170 
    except UserContextException, ucx:
1171 
      result.ucx = ucx
1172 
    oprot.writeMessageBegin("addIpAdressForUser", TMessageType.REPLY, seqid)
1173 
    result.write(oprot)
1174 
    oprot.writeMessageEnd()
1175 
    oprot.trans.flush()
1176 
 
1177 
  def process_addAddressForUser(self, seqid, iprot, oprot):
1178 
    args = addAddressForUser_args()
1179 
    args.read(iprot)
1180 
    iprot.readMessageEnd()
1181 
    result = addAddressForUser_result()
1182 
    try:
1183 
      result.success = self._handler.addAddressForUser(args.address, args.userid, args.timestamp)
1184 
    except UserContextException, ucx:
1185 
      result.ucx = ucx
1186 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
1187 
    result.write(oprot)
1188 
    oprot.writeMessageEnd()
1189 
    oprot.trans.flush()
1190 
 
1191 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
1192 
    args = removeAddressForUser_args()
1193 
    args.read(iprot)
1194 
    iprot.readMessageEnd()
1195 
    result = removeAddressForUser_result()
1196 
    try:
1197 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
1198 
    except UserContextException, ucx:
1199 
      result.ucx = ucx
1200 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
1201 
    result.write(oprot)
1202 
    oprot.writeMessageEnd()
1203 
    oprot.trans.flush()
1204 
 
1205 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
1206 
    args = setUserAsLoggedIn_args()
1207 
    args.read(iprot)
1208 
    iprot.readMessageEnd()
1209 
    result = setUserAsLoggedIn_result()
1210 
    try:
1211 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
1212 
    except UserContextException, ucx:
1213 
      result.ucx = ucx
1214 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
1215 
    result.write(oprot)
1216 
    oprot.writeMessageEnd()
1217 
    oprot.trans.flush()
1218 
 
1219 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
1220 
    args = setUserAsLoggedOut_args()
1221 
    args.read(iprot)
1222 
    iprot.readMessageEnd()
1223 
    result = setUserAsLoggedOut_result()
1224 
    try:
1225 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
1226 
    except UserContextException, ucx:
1227 
      result.ucx = ucx
1228 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
1229 
    result.write(oprot)
1230 
    oprot.writeMessageEnd()
1231 
    oprot.trans.flush()
1232 
 
1233 
  def process_updatePassword(self, seqid, iprot, oprot):
1234 
    args = updatePassword_args()
1235 
    args.read(iprot)
1236 
    iprot.readMessageEnd()
1237 
    result = updatePassword_result()
1238 
    try:
1239 
      result.success = self._handler.updatePassword(args.userid, args.password)
1240 
    except UserContextException, ucx:
1241 
      result.ucx = ucx
1242 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
1243 
    result.write(oprot)
1244 
    oprot.writeMessageEnd()
1245 
    oprot.trans.flush()
1246 
 
1247 
  def process_deleteUser(self, seqid, iprot, oprot):
1248 
    args = deleteUser_args()
1249 
    args.read(iprot)
1250 
    iprot.readMessageEnd()
1251 
    result = deleteUser_result()
1252 
    try:
122 ashish 1253 
      result.success = self._handler.deleteUser(args.userid, args.isSessionId)
94 ashish 1254 
    except UserContextException, ucx:
1255 
      result.ucx = ucx
1256 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
1257 
    result.write(oprot)
1258 
    oprot.writeMessageEnd()
1259 
    oprot.trans.flush()
1260 
 
1261 
  def process_sendEmailVerification(self, seqid, iprot, oprot):
1262 
    args = sendEmailVerification_args()
1263 
    args.read(iprot)
1264 
    iprot.readMessageEnd()
1265 
    result = sendEmailVerification_result()
1266 
    try:
1267 
      result.success = self._handler.sendEmailVerification(args.userid)
1268 
    except UserContextException, ucx:
1269 
      result.ucx = ucx
1270 
    oprot.writeMessageBegin("sendEmailVerification", TMessageType.REPLY, seqid)
1271 
    result.write(oprot)
1272 
    oprot.writeMessageEnd()
1273 
    oprot.trans.flush()
1274 
 
1275 
  def process_sendSMSVerification(self, seqid, iprot, oprot):
1276 
    args = sendSMSVerification_args()
1277 
    args.read(iprot)
1278 
    iprot.readMessageEnd()
1279 
    result = sendSMSVerification_result()
1280 
    try:
1281 
      result.success = self._handler.sendSMSVerification(args.userid)
1282 
    except UserContextException, ucx:
1283 
      result.ucx = ucx
1284 
    oprot.writeMessageBegin("sendSMSVerification", TMessageType.REPLY, seqid)
1285 
    result.write(oprot)
1286 
    oprot.writeMessageEnd()
1287 
    oprot.trans.flush()
1288 
 
1289 
  def process_confirmEmailVerification(self, seqid, iprot, oprot):
1290 
    args = confirmEmailVerification_args()
1291 
    args.read(iprot)
1292 
    iprot.readMessageEnd()
1293 
    result = confirmEmailVerification_result()
1294 
    try:
1295 
      result.success = self._handler.confirmEmailVerification(args.userid)
1296 
    except UserContextException, ucx:
1297 
      result.ucx = ucx
1298 
    oprot.writeMessageBegin("confirmEmailVerification", TMessageType.REPLY, seqid)
1299 
    result.write(oprot)
1300 
    oprot.writeMessageEnd()
1301 
    oprot.trans.flush()
1302 
 
1303 
  def process_confirmSMSVerification(self, seqid, iprot, oprot):
1304 
    args = confirmSMSVerification_args()
1305 
    args.read(iprot)
1306 
    iprot.readMessageEnd()
1307 
    result = confirmSMSVerification_result()
1308 
    try:
1309 
      result.success = self._handler.confirmSMSVerification(args.userid)
1310 
    except UserContextException, ucx:
1311 
      result.ucx = ucx
1312 
    oprot.writeMessageBegin("confirmSMSVerification", TMessageType.REPLY, seqid)
1313 
    result.write(oprot)
1314 
    oprot.writeMessageEnd()
1315 
    oprot.trans.flush()
1316 
 
1317 
  def process_addSocialhandle(self, seqid, iprot, oprot):
1318 
    args = addSocialhandle_args()
1319 
    args.read(iprot)
1320 
    iprot.readMessageEnd()
1321 
    result = addSocialhandle_result()
1322 
    try:
1323 
      result.success = self._handler.addSocialhandle(args.userid, args.socialService, args.handle)
1324 
    except UserContextException, ucx:
1325 
      result.ucx = ucx
1326 
    oprot.writeMessageBegin("addSocialhandle", TMessageType.REPLY, seqid)
1327 
    result.write(oprot)
1328 
    oprot.writeMessageEnd()
1329 
    oprot.trans.flush()
1330 
 
130 ashish 1331 
  def process_sendNewPasswordById(self, seqid, iprot, oprot):
1332 
    args = sendNewPasswordById_args()
1333 
    args.read(iprot)
1334 
    iprot.readMessageEnd()
1335 
    result = sendNewPasswordById_result()
1336 
    try:
1337 
      result.success = self._handler.sendNewPasswordById(args.userid)
1338 
    except UserContextException, ucx:
1339 
      result.ucx = ucx
1340 
    oprot.writeMessageBegin("sendNewPasswordById", TMessageType.REPLY, seqid)
1341 
    result.write(oprot)
1342 
    oprot.writeMessageEnd()
1343 
    oprot.trans.flush()
94 ashish 1344 
 
130 ashish 1345 
  def process_sendNewPasswordByHandle(self, seqid, iprot, oprot):
1346 
    args = sendNewPasswordByHandle_args()
1347 
    args.read(iprot)
1348 
    iprot.readMessageEnd()
1349 
    result = sendNewPasswordByHandle_result()
1350 
    try:
1351 
      result.success = self._handler.sendNewPasswordByHandle(args.emailOrHandle, args.isEmail)
1352 
    except UserContextException, ucx:
1353 
      result.ucx = ucx
1354 
    oprot.writeMessageBegin("sendNewPasswordByHandle", TMessageType.REPLY, seqid)
1355 
    result.write(oprot)
1356 
    oprot.writeMessageEnd()
1357 
    oprot.trans.flush()
1358 
 
1359 
 
94 ashish 1360 
# HELPER FUNCTIONS AND STRUCTURES
1361 
 
1362 
class createContext_args:
1363 
  """
1364 
  Attributes:
1365 
   - context
1366 
   - updateExisting
1367 
  """
1368 
 
1369 
  thrift_spec = (
1370 
    None, # 0
122 ashish 1371 
    (1, TType.STRUCT, 'context', (UserContext, UserContext.thrift_spec), None, ), # 1
94 ashish 1372 
    (2, TType.BOOL, 'updateExisting', None, None, ), # 2
1373 
  )
1374 
 
1375 
  def __init__(self, context=None, updateExisting=None,):
1376 
    self.context = context
1377 
    self.updateExisting = updateExisting
1378 
 
1379 
  def read(self, iprot):
1380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1382 
      return
1383 
    iprot.readStructBegin()
1384 
    while True:
1385 
      (fname, ftype, fid) = iprot.readFieldBegin()
1386 
      if ftype == TType.STOP:
1387 
        break
1388 
      if fid == 1:
1389 
        if ftype == TType.STRUCT:
122 ashish 1390 
          self.context = UserContext()
94 ashish 1391 
          self.context.read(iprot)
1392 
        else:
1393 
          iprot.skip(ftype)
1394 
      elif fid == 2:
1395 
        if ftype == TType.BOOL:
1396 
          self.updateExisting = iprot.readBool();
1397 
        else:
1398 
          iprot.skip(ftype)
1399 
      else:
1400 
        iprot.skip(ftype)
1401 
      iprot.readFieldEnd()
1402 
    iprot.readStructEnd()
1403 
 
1404 
  def write(self, oprot):
1405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1407 
      return
1408 
    oprot.writeStructBegin('createContext_args')
1409 
    if self.context != None:
1410 
      oprot.writeFieldBegin('context', TType.STRUCT, 1)
1411 
      self.context.write(oprot)
1412 
      oprot.writeFieldEnd()
1413 
    if self.updateExisting != None:
1414 
      oprot.writeFieldBegin('updateExisting', TType.BOOL, 2)
1415 
      oprot.writeBool(self.updateExisting)
1416 
      oprot.writeFieldEnd()
1417 
    oprot.writeFieldStop()
1418 
    oprot.writeStructEnd()
1419 
 
1420 
  def __repr__(self):
1421 
    L = ['%s=%r' % (key, value)
1422 
      for key, value in self.__dict__.iteritems()]
1423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1424 
 
1425 
  def __eq__(self, other):
1426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1427 
 
1428 
  def __ne__(self, other):
1429 
    return not (self == other)
1430 
 
1431 
class createContext_result:
1432 
  """
1433 
  Attributes:
1434 
   - success
1435 
   - cex
1436 
  """
1437 
 
1438 
  thrift_spec = (
122 ashish 1439 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1440 
    (1, TType.STRUCT, 'cex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1441 
  )
1442 
 
1443 
  def __init__(self, success=None, cex=None,):
1444 
    self.success = success
1445 
    self.cex = cex
1446 
 
1447 
  def read(self, iprot):
1448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1450 
      return
1451 
    iprot.readStructBegin()
1452 
    while True:
1453 
      (fname, ftype, fid) = iprot.readFieldBegin()
1454 
      if ftype == TType.STOP:
1455 
        break
1456 
      if fid == 0:
1457 
        if ftype == TType.STRUCT:
122 ashish 1458 
          self.success = UserContext()
94 ashish 1459 
          self.success.read(iprot)
1460 
        else:
1461 
          iprot.skip(ftype)
1462 
      elif fid == 1:
1463 
        if ftype == TType.STRUCT:
1464 
          self.cex = UserContextException()
1465 
          self.cex.read(iprot)
1466 
        else:
1467 
          iprot.skip(ftype)
1468 
      else:
1469 
        iprot.skip(ftype)
1470 
      iprot.readFieldEnd()
1471 
    iprot.readStructEnd()
1472 
 
1473 
  def write(self, oprot):
1474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1476 
      return
1477 
    oprot.writeStructBegin('createContext_result')
1478 
    if self.success != None:
1479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1480 
      self.success.write(oprot)
1481 
      oprot.writeFieldEnd()
1482 
    if self.cex != None:
1483 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
1484 
      self.cex.write(oprot)
1485 
      oprot.writeFieldEnd()
1486 
    oprot.writeFieldStop()
1487 
    oprot.writeStructEnd()
1488 
 
1489 
  def __repr__(self):
1490 
    L = ['%s=%r' % (key, value)
1491 
      for key, value in self.__dict__.iteritems()]
1492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1493 
 
1494 
  def __eq__(self, other):
1495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1496 
 
1497 
  def __ne__(self, other):
1498 
    return not (self == other)
1499 
 
1500 
class getContextFromId_args:
1501 
  """
1502 
  Attributes:
1503 
   - userId
122 ashish 1504 
   - isSessionId
94 ashish 1505 
  """
1506 
 
1507 
  thrift_spec = (
1508 
    None, # 0
1509 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1510 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1511 
  )
1512 
 
122 ashish 1513 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1514 
    self.userId = userId
122 ashish 1515 
    self.isSessionId = isSessionId
94 ashish 1516 
 
1517 
  def read(self, iprot):
1518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1520 
      return
1521 
    iprot.readStructBegin()
1522 
    while True:
1523 
      (fname, ftype, fid) = iprot.readFieldBegin()
1524 
      if ftype == TType.STOP:
1525 
        break
1526 
      if fid == 1:
1527 
        if ftype == TType.I64:
1528 
          self.userId = iprot.readI64();
1529 
        else:
1530 
          iprot.skip(ftype)
122 ashish 1531 
      elif fid == 2:
1532 
        if ftype == TType.BOOL:
1533 
          self.isSessionId = iprot.readBool();
1534 
        else:
1535 
          iprot.skip(ftype)
94 ashish 1536 
      else:
1537 
        iprot.skip(ftype)
1538 
      iprot.readFieldEnd()
1539 
    iprot.readStructEnd()
1540 
 
1541 
  def write(self, oprot):
1542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1544 
      return
1545 
    oprot.writeStructBegin('getContextFromId_args')
1546 
    if self.userId != None:
1547 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1548 
      oprot.writeI64(self.userId)
1549 
      oprot.writeFieldEnd()
122 ashish 1550 
    if self.isSessionId != None:
1551 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1552 
      oprot.writeBool(self.isSessionId)
1553 
      oprot.writeFieldEnd()
94 ashish 1554 
    oprot.writeFieldStop()
1555 
    oprot.writeStructEnd()
1556 
 
1557 
  def __repr__(self):
1558 
    L = ['%s=%r' % (key, value)
1559 
      for key, value in self.__dict__.iteritems()]
1560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1561 
 
1562 
  def __eq__(self, other):
1563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1564 
 
1565 
  def __ne__(self, other):
1566 
    return not (self == other)
1567 
 
1568 
class getContextFromId_result:
1569 
  """
1570 
  Attributes:
1571 
   - success
1572 
   - ucx
1573 
  """
1574 
 
1575 
  thrift_spec = (
122 ashish 1576 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1577 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1578 
  )
1579 
 
1580 
  def __init__(self, success=None, ucx=None,):
1581 
    self.success = success
1582 
    self.ucx = ucx
1583 
 
1584 
  def read(self, iprot):
1585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1587 
      return
1588 
    iprot.readStructBegin()
1589 
    while True:
1590 
      (fname, ftype, fid) = iprot.readFieldBegin()
1591 
      if ftype == TType.STOP:
1592 
        break
1593 
      if fid == 0:
1594 
        if ftype == TType.STRUCT:
122 ashish 1595 
          self.success = UserContext()
94 ashish 1596 
          self.success.read(iprot)
1597 
        else:
1598 
          iprot.skip(ftype)
1599 
      elif fid == 1:
1600 
        if ftype == TType.STRUCT:
1601 
          self.ucx = UserContextException()
1602 
          self.ucx.read(iprot)
1603 
        else:
1604 
          iprot.skip(ftype)
1605 
      else:
1606 
        iprot.skip(ftype)
1607 
      iprot.readFieldEnd()
1608 
    iprot.readStructEnd()
1609 
 
1610 
  def write(self, oprot):
1611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1613 
      return
1614 
    oprot.writeStructBegin('getContextFromId_result')
1615 
    if self.success != None:
1616 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1617 
      self.success.write(oprot)
1618 
      oprot.writeFieldEnd()
1619 
    if self.ucx != None:
1620 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1621 
      self.ucx.write(oprot)
1622 
      oprot.writeFieldEnd()
1623 
    oprot.writeFieldStop()
1624 
    oprot.writeStructEnd()
1625 
 
1626 
  def __repr__(self):
1627 
    L = ['%s=%r' % (key, value)
1628 
      for key, value in self.__dict__.iteritems()]
1629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1630 
 
1631 
  def __eq__(self, other):
1632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1633 
 
1634 
  def __ne__(self, other):
1635 
    return not (self == other)
1636 
 
1637 
class getContextFromEmailOrHandle_args:
1638 
  """
1639 
  Attributes:
1640 
   - emailorhandle
1641 
   - isEmail
1642 
  """
1643 
 
1644 
  thrift_spec = (
1645 
    None, # 0
1646 
    (1, TType.STRING, 'emailorhandle', None, None, ), # 1
1647 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
1648 
  )
1649 
 
1650 
  def __init__(self, emailorhandle=None, isEmail=None,):
1651 
    self.emailorhandle = emailorhandle
1652 
    self.isEmail = isEmail
1653 
 
1654 
  def read(self, iprot):
1655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1657 
      return
1658 
    iprot.readStructBegin()
1659 
    while True:
1660 
      (fname, ftype, fid) = iprot.readFieldBegin()
1661 
      if ftype == TType.STOP:
1662 
        break
1663 
      if fid == 1:
1664 
        if ftype == TType.STRING:
1665 
          self.emailorhandle = iprot.readString();
1666 
        else:
1667 
          iprot.skip(ftype)
1668 
      elif fid == 2:
1669 
        if ftype == TType.BOOL:
1670 
          self.isEmail = iprot.readBool();
1671 
        else:
1672 
          iprot.skip(ftype)
1673 
      else:
1674 
        iprot.skip(ftype)
1675 
      iprot.readFieldEnd()
1676 
    iprot.readStructEnd()
1677 
 
1678 
  def write(self, oprot):
1679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1681 
      return
1682 
    oprot.writeStructBegin('getContextFromEmailOrHandle_args')
1683 
    if self.emailorhandle != None:
1684 
      oprot.writeFieldBegin('emailorhandle', TType.STRING, 1)
1685 
      oprot.writeString(self.emailorhandle)
1686 
      oprot.writeFieldEnd()
1687 
    if self.isEmail != None:
1688 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
1689 
      oprot.writeBool(self.isEmail)
1690 
      oprot.writeFieldEnd()
1691 
    oprot.writeFieldStop()
1692 
    oprot.writeStructEnd()
1693 
 
1694 
  def __repr__(self):
1695 
    L = ['%s=%r' % (key, value)
1696 
      for key, value in self.__dict__.iteritems()]
1697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1698 
 
1699 
  def __eq__(self, other):
1700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1701 
 
1702 
  def __ne__(self, other):
1703 
    return not (self == other)
1704 
 
1705 
class getContextFromEmailOrHandle_result:
1706 
  """
1707 
  Attributes:
1708 
   - success
1709 
   - ucx
1710 
  """
1711 
 
1712 
  thrift_spec = (
122 ashish 1713 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1714 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1715 
  )
1716 
 
1717 
  def __init__(self, success=None, ucx=None,):
1718 
    self.success = success
1719 
    self.ucx = ucx
1720 
 
1721 
  def read(self, iprot):
1722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1724 
      return
1725 
    iprot.readStructBegin()
1726 
    while True:
1727 
      (fname, ftype, fid) = iprot.readFieldBegin()
1728 
      if ftype == TType.STOP:
1729 
        break
1730 
      if fid == 0:
1731 
        if ftype == TType.STRUCT:
122 ashish 1732 
          self.success = UserContext()
94 ashish 1733 
          self.success.read(iprot)
1734 
        else:
1735 
          iprot.skip(ftype)
1736 
      elif fid == 1:
1737 
        if ftype == TType.STRUCT:
1738 
          self.ucx = UserContextException()
1739 
          self.ucx.read(iprot)
1740 
        else:
1741 
          iprot.skip(ftype)
1742 
      else:
1743 
        iprot.skip(ftype)
1744 
      iprot.readFieldEnd()
1745 
    iprot.readStructEnd()
1746 
 
1747 
  def write(self, oprot):
1748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1750 
      return
1751 
    oprot.writeStructBegin('getContextFromEmailOrHandle_result')
1752 
    if self.success != None:
1753 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1754 
      self.success.write(oprot)
1755 
      oprot.writeFieldEnd()
1756 
    if self.ucx != None:
1757 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1758 
      self.ucx.write(oprot)
1759 
      oprot.writeFieldEnd()
1760 
    oprot.writeFieldStop()
1761 
    oprot.writeStructEnd()
1762 
 
1763 
  def __repr__(self):
1764 
    L = ['%s=%r' % (key, value)
1765 
      for key, value in self.__dict__.iteritems()]
1766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1767 
 
1768 
  def __eq__(self, other):
1769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1770 
 
1771 
  def __ne__(self, other):
1772 
    return not (self == other)
1773 
 
1774 
class getState_args:
1775 
  """
1776 
  Attributes:
1777 
   - userId
122 ashish 1778 
   - isSessionId
94 ashish 1779 
  """
1780 
 
1781 
  thrift_spec = (
1782 
    None, # 0
1783 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1784 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1785 
  )
1786 
 
122 ashish 1787 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1788 
    self.userId = userId
122 ashish 1789 
    self.isSessionId = isSessionId
94 ashish 1790 
 
1791 
  def read(self, iprot):
1792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1794 
      return
1795 
    iprot.readStructBegin()
1796 
    while True:
1797 
      (fname, ftype, fid) = iprot.readFieldBegin()
1798 
      if ftype == TType.STOP:
1799 
        break
1800 
      if fid == 1:
1801 
        if ftype == TType.I64:
1802 
          self.userId = iprot.readI64();
1803 
        else:
1804 
          iprot.skip(ftype)
122 ashish 1805 
      elif fid == 2:
1806 
        if ftype == TType.BOOL:
1807 
          self.isSessionId = iprot.readBool();
1808 
        else:
1809 
          iprot.skip(ftype)
94 ashish 1810 
      else:
1811 
        iprot.skip(ftype)
1812 
      iprot.readFieldEnd()
1813 
    iprot.readStructEnd()
1814 
 
1815 
  def write(self, oprot):
1816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1818 
      return
1819 
    oprot.writeStructBegin('getState_args')
1820 
    if self.userId != None:
1821 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1822 
      oprot.writeI64(self.userId)
1823 
      oprot.writeFieldEnd()
122 ashish 1824 
    if self.isSessionId != None:
1825 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1826 
      oprot.writeBool(self.isSessionId)
1827 
      oprot.writeFieldEnd()
94 ashish 1828 
    oprot.writeFieldStop()
1829 
    oprot.writeStructEnd()
1830 
 
1831 
  def __repr__(self):
1832 
    L = ['%s=%r' % (key, value)
1833 
      for key, value in self.__dict__.iteritems()]
1834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1835 
 
1836 
  def __eq__(self, other):
1837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1838 
 
1839 
  def __ne__(self, other):
1840 
    return not (self == other)
1841 
 
1842 
class getState_result:
1843 
  """
1844 
  Attributes:
1845 
   - success
1846 
   - ucx
1847 
  """
1848 
 
1849 
  thrift_spec = (
122 ashish 1850 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
94 ashish 1851 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1852 
  )
1853 
 
1854 
  def __init__(self, success=None, ucx=None,):
1855 
    self.success = success
1856 
    self.ucx = ucx
1857 
 
1858 
  def read(self, iprot):
1859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1861 
      return
1862 
    iprot.readStructBegin()
1863 
    while True:
1864 
      (fname, ftype, fid) = iprot.readFieldBegin()
1865 
      if ftype == TType.STOP:
1866 
        break
1867 
      if fid == 0:
1868 
        if ftype == TType.STRUCT:
122 ashish 1869 
          self.success = UserState()
94 ashish 1870 
          self.success.read(iprot)
1871 
        else:
1872 
          iprot.skip(ftype)
1873 
      elif fid == 1:
1874 
        if ftype == TType.STRUCT:
1875 
          self.ucx = UserContextException()
1876 
          self.ucx.read(iprot)
1877 
        else:
1878 
          iprot.skip(ftype)
1879 
      else:
1880 
        iprot.skip(ftype)
1881 
      iprot.readFieldEnd()
1882 
    iprot.readStructEnd()
1883 
 
1884 
  def write(self, oprot):
1885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1887 
      return
1888 
    oprot.writeStructBegin('getState_result')
1889 
    if self.success != None:
1890 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1891 
      self.success.write(oprot)
1892 
      oprot.writeFieldEnd()
1893 
    if self.ucx != None:
1894 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1895 
      self.ucx.write(oprot)
1896 
      oprot.writeFieldEnd()
1897 
    oprot.writeFieldStop()
1898 
    oprot.writeStructEnd()
1899 
 
1900 
  def __repr__(self):
1901 
    L = ['%s=%r' % (key, value)
1902 
      for key, value in self.__dict__.iteritems()]
1903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1904 
 
1905 
  def __eq__(self, other):
1906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1907 
 
1908 
  def __ne__(self, other):
1909 
    return not (self == other)
1910 
 
1911 
class getPrimaryInfo_args:
1912 
  """
1913 
  Attributes:
1914 
   - userId
122 ashish 1915 
   - isSessionId
94 ashish 1916 
  """
1917 
 
1918 
  thrift_spec = (
1919 
    None, # 0
1920 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1921 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1922 
  )
1923 
 
122 ashish 1924 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1925 
    self.userId = userId
122 ashish 1926 
    self.isSessionId = isSessionId
94 ashish 1927 
 
1928 
  def read(self, iprot):
1929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1931 
      return
1932 
    iprot.readStructBegin()
1933 
    while True:
1934 
      (fname, ftype, fid) = iprot.readFieldBegin()
1935 
      if ftype == TType.STOP:
1936 
        break
1937 
      if fid == 1:
1938 
        if ftype == TType.I64:
1939 
          self.userId = iprot.readI64();
1940 
        else:
1941 
          iprot.skip(ftype)
122 ashish 1942 
      elif fid == 2:
1943 
        if ftype == TType.BOOL:
1944 
          self.isSessionId = iprot.readBool();
1945 
        else:
1946 
          iprot.skip(ftype)
94 ashish 1947 
      else:
1948 
        iprot.skip(ftype)
1949 
      iprot.readFieldEnd()
1950 
    iprot.readStructEnd()
1951 
 
1952 
  def write(self, oprot):
1953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1955 
      return
1956 
    oprot.writeStructBegin('getPrimaryInfo_args')
1957 
    if self.userId != None:
1958 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1959 
      oprot.writeI64(self.userId)
1960 
      oprot.writeFieldEnd()
122 ashish 1961 
    if self.isSessionId != None:
1962 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1963 
      oprot.writeBool(self.isSessionId)
1964 
      oprot.writeFieldEnd()
94 ashish 1965 
    oprot.writeFieldStop()
1966 
    oprot.writeStructEnd()
1967 
 
1968 
  def __repr__(self):
1969 
    L = ['%s=%r' % (key, value)
1970 
      for key, value in self.__dict__.iteritems()]
1971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1972 
 
1973 
  def __eq__(self, other):
1974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1975 
 
1976 
  def __ne__(self, other):
1977 
    return not (self == other)
1978 
 
1979 
class getPrimaryInfo_result:
1980 
  """
1981 
  Attributes:
1982 
   - success
1983 
   - ucx
1984 
  """
1985 
 
1986 
  thrift_spec = (
122 ashish 1987 
    (0, TType.STRUCT, 'success', (UserPrimaryInfo, UserPrimaryInfo.thrift_spec), None, ), # 0
94 ashish 1988 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1989 
  )
1990 
 
1991 
  def __init__(self, success=None, ucx=None,):
1992 
    self.success = success
1993 
    self.ucx = ucx
1994 
 
1995 
  def read(self, iprot):
1996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1998 
      return
1999 
    iprot.readStructBegin()
2000 
    while True:
2001 
      (fname, ftype, fid) = iprot.readFieldBegin()
2002 
      if ftype == TType.STOP:
2003 
        break
2004 
      if fid == 0:
2005 
        if ftype == TType.STRUCT:
122 ashish 2006 
          self.success = UserPrimaryInfo()
94 ashish 2007 
          self.success.read(iprot)
2008 
        else:
2009 
          iprot.skip(ftype)
2010 
      elif fid == 1:
2011 
        if ftype == TType.STRUCT:
2012 
          self.ucx = UserContextException()
2013 
          self.ucx.read(iprot)
2014 
        else:
2015 
          iprot.skip(ftype)
2016 
      else:
2017 
        iprot.skip(ftype)
2018 
      iprot.readFieldEnd()
2019 
    iprot.readStructEnd()
2020 
 
2021 
  def write(self, oprot):
2022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2024 
      return
2025 
    oprot.writeStructBegin('getPrimaryInfo_result')
2026 
    if self.success != None:
2027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2028 
      self.success.write(oprot)
2029 
      oprot.writeFieldEnd()
2030 
    if self.ucx != None:
2031 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2032 
      self.ucx.write(oprot)
2033 
      oprot.writeFieldEnd()
2034 
    oprot.writeFieldStop()
2035 
    oprot.writeStructEnd()
2036 
 
2037 
  def __repr__(self):
2038 
    L = ['%s=%r' % (key, value)
2039 
      for key, value in self.__dict__.iteritems()]
2040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2041 
 
2042 
  def __eq__(self, other):
2043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2044 
 
2045 
  def __ne__(self, other):
2046 
    return not (self == other)
2047 
 
2048 
class getInternalInfo_args:
2049 
  """
2050 
  Attributes:
2051 
   - userId
122 ashish 2052 
   - isSessionId
94 ashish 2053 
  """
2054 
 
2055 
  thrift_spec = (
2056 
    None, # 0
2057 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 2058 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 2059 
  )
2060 
 
122 ashish 2061 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 2062 
    self.userId = userId
122 ashish 2063 
    self.isSessionId = isSessionId
94 ashish 2064 
 
2065 
  def read(self, iprot):
2066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2068 
      return
2069 
    iprot.readStructBegin()
2070 
    while True:
2071 
      (fname, ftype, fid) = iprot.readFieldBegin()
2072 
      if ftype == TType.STOP:
2073 
        break
2074 
      if fid == 1:
2075 
        if ftype == TType.I64:
2076 
          self.userId = iprot.readI64();
2077 
        else:
2078 
          iprot.skip(ftype)
122 ashish 2079 
      elif fid == 2:
2080 
        if ftype == TType.BOOL:
2081 
          self.isSessionId = iprot.readBool();
2082 
        else:
2083 
          iprot.skip(ftype)
94 ashish 2084 
      else:
2085 
        iprot.skip(ftype)
2086 
      iprot.readFieldEnd()
2087 
    iprot.readStructEnd()
2088 
 
2089 
  def write(self, oprot):
2090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2092 
      return
2093 
    oprot.writeStructBegin('getInternalInfo_args')
2094 
    if self.userId != None:
2095 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2096 
      oprot.writeI64(self.userId)
2097 
      oprot.writeFieldEnd()
122 ashish 2098 
    if self.isSessionId != None:
2099 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
2100 
      oprot.writeBool(self.isSessionId)
2101 
      oprot.writeFieldEnd()
94 ashish 2102 
    oprot.writeFieldStop()
2103 
    oprot.writeStructEnd()
2104 
 
2105 
  def __repr__(self):
2106 
    L = ['%s=%r' % (key, value)
2107 
      for key, value in self.__dict__.iteritems()]
2108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2109 
 
2110 
  def __eq__(self, other):
2111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2112 
 
2113 
  def __ne__(self, other):
2114 
    return not (self == other)
2115 
 
2116 
class getInternalInfo_result:
2117 
  """
2118 
  Attributes:
2119 
   - success
2120 
   - ucx
2121 
  """
2122 
 
2123 
  thrift_spec = (
122 ashish 2124 
    (0, TType.STRUCT, 'success', (UserInternalInfo, UserInternalInfo.thrift_spec), None, ), # 0
94 ashish 2125 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2126 
  )
2127 
 
2128 
  def __init__(self, success=None, ucx=None,):
2129 
    self.success = success
2130 
    self.ucx = ucx
2131 
 
2132 
  def read(self, iprot):
2133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2135 
      return
2136 
    iprot.readStructBegin()
2137 
    while True:
2138 
      (fname, ftype, fid) = iprot.readFieldBegin()
2139 
      if ftype == TType.STOP:
2140 
        break
2141 
      if fid == 0:
2142 
        if ftype == TType.STRUCT:
122 ashish 2143 
          self.success = UserInternalInfo()
94 ashish 2144 
          self.success.read(iprot)
2145 
        else:
2146 
          iprot.skip(ftype)
2147 
      elif fid == 1:
2148 
        if ftype == TType.STRUCT:
2149 
          self.ucx = UserContextException()
2150 
          self.ucx.read(iprot)
2151 
        else:
2152 
          iprot.skip(ftype)
2153 
      else:
2154 
        iprot.skip(ftype)
2155 
      iprot.readFieldEnd()
2156 
    iprot.readStructEnd()
2157 
 
2158 
  def write(self, oprot):
2159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2161 
      return
2162 
    oprot.writeStructBegin('getInternalInfo_result')
2163 
    if self.success != None:
2164 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2165 
      self.success.write(oprot)
2166 
      oprot.writeFieldEnd()
2167 
    if self.ucx != None:
2168 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2169 
      self.ucx.write(oprot)
2170 
      oprot.writeFieldEnd()
2171 
    oprot.writeFieldStop()
2172 
    oprot.writeStructEnd()
2173 
 
2174 
  def __repr__(self):
2175 
    L = ['%s=%r' % (key, value)
2176 
      for key, value in self.__dict__.iteritems()]
2177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2178 
 
2179 
  def __eq__(self, other):
2180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2181 
 
2182 
  def __ne__(self, other):
2183 
    return not (self == other)
2184 
 
2185 
class getContext_args:
2186 
  """
2187 
  Attributes:
2188 
   - email
2189 
   - password
2190 
  """
2191 
 
2192 
  thrift_spec = (
2193 
    None, # 0
2194 
    (1, TType.STRING, 'email', None, None, ), # 1
2195 
    (2, TType.STRING, 'password', None, None, ), # 2
2196 
  )
2197 
 
2198 
  def __init__(self, email=None, password=None,):
2199 
    self.email = email
2200 
    self.password = password
2201 
 
2202 
  def read(self, iprot):
2203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2205 
      return
2206 
    iprot.readStructBegin()
2207 
    while True:
2208 
      (fname, ftype, fid) = iprot.readFieldBegin()
2209 
      if ftype == TType.STOP:
2210 
        break
2211 
      if fid == 1:
2212 
        if ftype == TType.STRING:
2213 
          self.email = iprot.readString();
2214 
        else:
2215 
          iprot.skip(ftype)
2216 
      elif fid == 2:
2217 
        if ftype == TType.STRING:
2218 
          self.password = iprot.readString();
2219 
        else:
2220 
          iprot.skip(ftype)
2221 
      else:
2222 
        iprot.skip(ftype)
2223 
      iprot.readFieldEnd()
2224 
    iprot.readStructEnd()
2225 
 
2226 
  def write(self, oprot):
2227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2229 
      return
2230 
    oprot.writeStructBegin('getContext_args')
2231 
    if self.email != None:
2232 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2233 
      oprot.writeString(self.email)
2234 
      oprot.writeFieldEnd()
2235 
    if self.password != None:
2236 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2237 
      oprot.writeString(self.password)
2238 
      oprot.writeFieldEnd()
2239 
    oprot.writeFieldStop()
2240 
    oprot.writeStructEnd()
2241 
 
2242 
  def __repr__(self):
2243 
    L = ['%s=%r' % (key, value)
2244 
      for key, value in self.__dict__.iteritems()]
2245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2246 
 
2247 
  def __eq__(self, other):
2248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2249 
 
2250 
  def __ne__(self, other):
2251 
    return not (self == other)
2252 
 
2253 
class getContext_result:
2254 
  """
2255 
  Attributes:
2256 
   - success
2257 
   - ax
2258 
  """
2259 
 
2260 
  thrift_spec = (
122 ashish 2261 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 2262 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2263 
  )
2264 
 
2265 
  def __init__(self, success=None, ax=None,):
2266 
    self.success = success
2267 
    self.ax = ax
2268 
 
2269 
  def read(self, iprot):
2270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2272 
      return
2273 
    iprot.readStructBegin()
2274 
    while True:
2275 
      (fname, ftype, fid) = iprot.readFieldBegin()
2276 
      if ftype == TType.STOP:
2277 
        break
2278 
      if fid == 0:
2279 
        if ftype == TType.STRUCT:
122 ashish 2280 
          self.success = UserContext()
94 ashish 2281 
          self.success.read(iprot)
2282 
        else:
2283 
          iprot.skip(ftype)
2284 
      elif fid == 1:
2285 
        if ftype == TType.STRUCT:
2286 
          self.ax = AuthenticationException()
2287 
          self.ax.read(iprot)
2288 
        else:
2289 
          iprot.skip(ftype)
2290 
      else:
2291 
        iprot.skip(ftype)
2292 
      iprot.readFieldEnd()
2293 
    iprot.readStructEnd()
2294 
 
2295 
  def write(self, oprot):
2296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2298 
      return
2299 
    oprot.writeStructBegin('getContext_result')
2300 
    if self.success != None:
2301 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2302 
      self.success.write(oprot)
2303 
      oprot.writeFieldEnd()
2304 
    if self.ax != None:
2305 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2306 
      self.ax.write(oprot)
2307 
      oprot.writeFieldEnd()
2308 
    oprot.writeFieldStop()
2309 
    oprot.writeStructEnd()
2310 
 
2311 
  def __repr__(self):
2312 
    L = ['%s=%r' % (key, value)
2313 
      for key, value in self.__dict__.iteritems()]
2314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2315 
 
2316 
  def __eq__(self, other):
2317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2318 
 
2319 
  def __ne__(self, other):
2320 
    return not (self == other)
2321 
 
122 ashish 2322 
class authenticateUser_args:
2323 
  """
2324 
  Attributes:
2325 
   - handle
2326 
   - password
2327 
   - isEmail
2328 
  """
2329 
 
2330 
  thrift_spec = (
2331 
    None, # 0
2332 
    (1, TType.STRING, 'handle', None, None, ), # 1
2333 
    (2, TType.STRING, 'password', None, None, ), # 2
2334 
    (3, TType.BOOL, 'isEmail', None, None, ), # 3
2335 
  )
2336 
 
2337 
  def __init__(self, handle=None, password=None, isEmail=None,):
2338 
    self.handle = handle
2339 
    self.password = password
2340 
    self.isEmail = isEmail
2341 
 
2342 
  def read(self, iprot):
2343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2345 
      return
2346 
    iprot.readStructBegin()
2347 
    while True:
2348 
      (fname, ftype, fid) = iprot.readFieldBegin()
2349 
      if ftype == TType.STOP:
2350 
        break
2351 
      if fid == 1:
2352 
        if ftype == TType.STRING:
2353 
          self.handle = iprot.readString();
2354 
        else:
2355 
          iprot.skip(ftype)
2356 
      elif fid == 2:
2357 
        if ftype == TType.STRING:
2358 
          self.password = iprot.readString();
2359 
        else:
2360 
          iprot.skip(ftype)
2361 
      elif fid == 3:
2362 
        if ftype == TType.BOOL:
2363 
          self.isEmail = iprot.readBool();
2364 
        else:
2365 
          iprot.skip(ftype)
2366 
      else:
2367 
        iprot.skip(ftype)
2368 
      iprot.readFieldEnd()
2369 
    iprot.readStructEnd()
2370 
 
2371 
  def write(self, oprot):
2372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2374 
      return
2375 
    oprot.writeStructBegin('authenticateUser_args')
2376 
    if self.handle != None:
2377 
      oprot.writeFieldBegin('handle', TType.STRING, 1)
2378 
      oprot.writeString(self.handle)
2379 
      oprot.writeFieldEnd()
2380 
    if self.password != None:
2381 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2382 
      oprot.writeString(self.password)
2383 
      oprot.writeFieldEnd()
2384 
    if self.isEmail != None:
2385 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 3)
2386 
      oprot.writeBool(self.isEmail)
2387 
      oprot.writeFieldEnd()
2388 
    oprot.writeFieldStop()
2389 
    oprot.writeStructEnd()
2390 
 
2391 
  def __repr__(self):
2392 
    L = ['%s=%r' % (key, value)
2393 
      for key, value in self.__dict__.iteritems()]
2394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2395 
 
2396 
  def __eq__(self, other):
2397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2398 
 
2399 
  def __ne__(self, other):
2400 
    return not (self == other)
2401 
 
2402 
class authenticateUser_result:
2403 
  """
2404 
  Attributes:
2405 
   - success
2406 
   - ax
2407 
  """
2408 
 
2409 
  thrift_spec = (
2410 
    (0, TType.BOOL, 'success', None, None, ), # 0
2411 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2412 
  )
2413 
 
2414 
  def __init__(self, success=None, ax=None,):
2415 
    self.success = success
2416 
    self.ax = ax
2417 
 
2418 
  def read(self, iprot):
2419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2421 
      return
2422 
    iprot.readStructBegin()
2423 
    while True:
2424 
      (fname, ftype, fid) = iprot.readFieldBegin()
2425 
      if ftype == TType.STOP:
2426 
        break
2427 
      if fid == 0:
2428 
        if ftype == TType.BOOL:
2429 
          self.success = iprot.readBool();
2430 
        else:
2431 
          iprot.skip(ftype)
2432 
      elif fid == 1:
2433 
        if ftype == TType.STRUCT:
2434 
          self.ax = AuthenticationException()
2435 
          self.ax.read(iprot)
2436 
        else:
2437 
          iprot.skip(ftype)
2438 
      else:
2439 
        iprot.skip(ftype)
2440 
      iprot.readFieldEnd()
2441 
    iprot.readStructEnd()
2442 
 
2443 
  def write(self, oprot):
2444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2446 
      return
2447 
    oprot.writeStructBegin('authenticateUser_result')
2448 
    if self.success != None:
2449 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2450 
      oprot.writeBool(self.success)
2451 
      oprot.writeFieldEnd()
2452 
    if self.ax != None:
2453 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2454 
      self.ax.write(oprot)
2455 
      oprot.writeFieldEnd()
2456 
    oprot.writeFieldStop()
2457 
    oprot.writeStructEnd()
2458 
 
2459 
  def __repr__(self):
2460 
    L = ['%s=%r' % (key, value)
2461 
      for key, value in self.__dict__.iteritems()]
2462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2463 
 
2464 
  def __eq__(self, other):
2465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2466 
 
2467 
  def __ne__(self, other):
2468 
    return not (self == other)
2469 
 
94 ashish 2470 
class userExists_args:
2471 
  """
2472 
  Attributes:
2473 
   - email
2474 
  """
2475 
 
2476 
  thrift_spec = (
2477 
    None, # 0
2478 
    (1, TType.STRING, 'email', None, None, ), # 1
2479 
  )
2480 
 
2481 
  def __init__(self, email=None,):
2482 
    self.email = email
2483 
 
2484 
  def read(self, iprot):
2485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2487 
      return
2488 
    iprot.readStructBegin()
2489 
    while True:
2490 
      (fname, ftype, fid) = iprot.readFieldBegin()
2491 
      if ftype == TType.STOP:
2492 
        break
2493 
      if fid == 1:
2494 
        if ftype == TType.STRING:
2495 
          self.email = iprot.readString();
2496 
        else:
2497 
          iprot.skip(ftype)
2498 
      else:
2499 
        iprot.skip(ftype)
2500 
      iprot.readFieldEnd()
2501 
    iprot.readStructEnd()
2502 
 
2503 
  def write(self, oprot):
2504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2506 
      return
2507 
    oprot.writeStructBegin('userExists_args')
2508 
    if self.email != None:
2509 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2510 
      oprot.writeString(self.email)
2511 
      oprot.writeFieldEnd()
2512 
    oprot.writeFieldStop()
2513 
    oprot.writeStructEnd()
2514 
 
2515 
  def __repr__(self):
2516 
    L = ['%s=%r' % (key, value)
2517 
      for key, value in self.__dict__.iteritems()]
2518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2519 
 
2520 
  def __eq__(self, other):
2521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2522 
 
2523 
  def __ne__(self, other):
2524 
    return not (self == other)
2525 
 
2526 
class userExists_result:
2527 
  """
2528 
  Attributes:
2529 
   - success
2530 
   - ucx
2531 
  """
2532 
 
2533 
  thrift_spec = (
2534 
    (0, TType.BOOL, 'success', None, None, ), # 0
2535 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2536 
  )
2537 
 
2538 
  def __init__(self, success=None, ucx=None,):
2539 
    self.success = success
2540 
    self.ucx = ucx
2541 
 
2542 
  def read(self, iprot):
2543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2545 
      return
2546 
    iprot.readStructBegin()
2547 
    while True:
2548 
      (fname, ftype, fid) = iprot.readFieldBegin()
2549 
      if ftype == TType.STOP:
2550 
        break
2551 
      if fid == 0:
2552 
        if ftype == TType.BOOL:
2553 
          self.success = iprot.readBool();
2554 
        else:
2555 
          iprot.skip(ftype)
2556 
      elif fid == 1:
2557 
        if ftype == TType.STRUCT:
2558 
          self.ucx = UserContextException()
2559 
          self.ucx.read(iprot)
2560 
        else:
2561 
          iprot.skip(ftype)
2562 
      else:
2563 
        iprot.skip(ftype)
2564 
      iprot.readFieldEnd()
2565 
    iprot.readStructEnd()
2566 
 
2567 
  def write(self, oprot):
2568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2570 
      return
2571 
    oprot.writeStructBegin('userExists_result')
2572 
    if self.success != None:
2573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2574 
      oprot.writeBool(self.success)
2575 
      oprot.writeFieldEnd()
2576 
    if self.ucx != None:
2577 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2578 
      self.ucx.write(oprot)
2579 
      oprot.writeFieldEnd()
2580 
    oprot.writeFieldStop()
2581 
    oprot.writeStructEnd()
2582 
 
2583 
  def __repr__(self):
2584 
    L = ['%s=%r' % (key, value)
2585 
      for key, value in self.__dict__.iteritems()]
2586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2587 
 
2588 
  def __eq__(self, other):
2589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2590 
 
2591 
  def __ne__(self, other):
2592 
    return not (self == other)
2593 
 
2594 
class addIpAdressForUser_args:
2595 
  """
2596 
  Attributes:
2597 
   - ip
2598 
   - timestamp
2599 
   - userId
2600 
  """
2601 
 
2602 
  thrift_spec = (
2603 
    None, # 0
2604 
    (1, TType.STRING, 'ip', None, None, ), # 1
2605 
    (2, TType.I64, 'timestamp', None, None, ), # 2
2606 
    (3, TType.I64, 'userId', None, None, ), # 3
2607 
  )
2608 
 
2609 
  def __init__(self, ip=None, timestamp=None, userId=None,):
2610 
    self.ip = ip
2611 
    self.timestamp = timestamp
2612 
    self.userId = userId
2613 
 
2614 
  def read(self, iprot):
2615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2617 
      return
2618 
    iprot.readStructBegin()
2619 
    while True:
2620 
      (fname, ftype, fid) = iprot.readFieldBegin()
2621 
      if ftype == TType.STOP:
2622 
        break
2623 
      if fid == 1:
2624 
        if ftype == TType.STRING:
2625 
          self.ip = iprot.readString();
2626 
        else:
2627 
          iprot.skip(ftype)
2628 
      elif fid == 2:
2629 
        if ftype == TType.I64:
2630 
          self.timestamp = iprot.readI64();
2631 
        else:
2632 
          iprot.skip(ftype)
2633 
      elif fid == 3:
2634 
        if ftype == TType.I64:
2635 
          self.userId = iprot.readI64();
2636 
        else:
2637 
          iprot.skip(ftype)
2638 
      else:
2639 
        iprot.skip(ftype)
2640 
      iprot.readFieldEnd()
2641 
    iprot.readStructEnd()
2642 
 
2643 
  def write(self, oprot):
2644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2646 
      return
2647 
    oprot.writeStructBegin('addIpAdressForUser_args')
2648 
    if self.ip != None:
2649 
      oprot.writeFieldBegin('ip', TType.STRING, 1)
2650 
      oprot.writeString(self.ip)
2651 
      oprot.writeFieldEnd()
2652 
    if self.timestamp != None:
2653 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
2654 
      oprot.writeI64(self.timestamp)
2655 
      oprot.writeFieldEnd()
2656 
    if self.userId != None:
2657 
      oprot.writeFieldBegin('userId', TType.I64, 3)
2658 
      oprot.writeI64(self.userId)
2659 
      oprot.writeFieldEnd()
2660 
    oprot.writeFieldStop()
2661 
    oprot.writeStructEnd()
2662 
 
2663 
  def __repr__(self):
2664 
    L = ['%s=%r' % (key, value)
2665 
      for key, value in self.__dict__.iteritems()]
2666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2667 
 
2668 
  def __eq__(self, other):
2669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2670 
 
2671 
  def __ne__(self, other):
2672 
    return not (self == other)
2673 
 
2674 
class addIpAdressForUser_result:
2675 
  """
2676 
  Attributes:
2677 
   - success
2678 
   - ucx
2679 
  """
2680 
 
2681 
  thrift_spec = (
2682 
    (0, TType.BOOL, 'success', None, None, ), # 0
2683 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2684 
  )
2685 
 
2686 
  def __init__(self, success=None, ucx=None,):
2687 
    self.success = success
2688 
    self.ucx = ucx
2689 
 
2690 
  def read(self, iprot):
2691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2693 
      return
2694 
    iprot.readStructBegin()
2695 
    while True:
2696 
      (fname, ftype, fid) = iprot.readFieldBegin()
2697 
      if ftype == TType.STOP:
2698 
        break
2699 
      if fid == 0:
2700 
        if ftype == TType.BOOL:
2701 
          self.success = iprot.readBool();
2702 
        else:
2703 
          iprot.skip(ftype)
2704 
      elif fid == 1:
2705 
        if ftype == TType.STRUCT:
2706 
          self.ucx = UserContextException()
2707 
          self.ucx.read(iprot)
2708 
        else:
2709 
          iprot.skip(ftype)
2710 
      else:
2711 
        iprot.skip(ftype)
2712 
      iprot.readFieldEnd()
2713 
    iprot.readStructEnd()
2714 
 
2715 
  def write(self, oprot):
2716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2718 
      return
2719 
    oprot.writeStructBegin('addIpAdressForUser_result')
2720 
    if self.success != None:
2721 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2722 
      oprot.writeBool(self.success)
2723 
      oprot.writeFieldEnd()
2724 
    if self.ucx != None:
2725 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2726 
      self.ucx.write(oprot)
2727 
      oprot.writeFieldEnd()
2728 
    oprot.writeFieldStop()
2729 
    oprot.writeStructEnd()
2730 
 
2731 
  def __repr__(self):
2732 
    L = ['%s=%r' % (key, value)
2733 
      for key, value in self.__dict__.iteritems()]
2734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2735 
 
2736 
  def __eq__(self, other):
2737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2738 
 
2739 
  def __ne__(self, other):
2740 
    return not (self == other)
2741 
 
2742 
class addAddressForUser_args:
2743 
  """
2744 
  Attributes:
2745 
   - address
2746 
   - userid
2747 
   - timestamp
2748 
  """
2749 
 
2750 
  thrift_spec = (
2751 
    None, # 0
122 ashish 2752 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
94 ashish 2753 
    (2, TType.I64, 'userid', None, None, ), # 2
2754 
    (3, TType.I64, 'timestamp', None, None, ), # 3
2755 
  )
2756 
 
2757 
  def __init__(self, address=None, userid=None, timestamp=None,):
2758 
    self.address = address
2759 
    self.userid = userid
2760 
    self.timestamp = timestamp
2761 
 
2762 
  def read(self, iprot):
2763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2765 
      return
2766 
    iprot.readStructBegin()
2767 
    while True:
2768 
      (fname, ftype, fid) = iprot.readFieldBegin()
2769 
      if ftype == TType.STOP:
2770 
        break
2771 
      if fid == 1:
2772 
        if ftype == TType.STRUCT:
122 ashish 2773 
          self.address = Address()
94 ashish 2774 
          self.address.read(iprot)
2775 
        else:
2776 
          iprot.skip(ftype)
2777 
      elif fid == 2:
2778 
        if ftype == TType.I64:
2779 
          self.userid = iprot.readI64();
2780 
        else:
2781 
          iprot.skip(ftype)
2782 
      elif fid == 3:
2783 
        if ftype == TType.I64:
2784 
          self.timestamp = iprot.readI64();
2785 
        else:
2786 
          iprot.skip(ftype)
2787 
      else:
2788 
        iprot.skip(ftype)
2789 
      iprot.readFieldEnd()
2790 
    iprot.readStructEnd()
2791 
 
2792 
  def write(self, oprot):
2793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2795 
      return
2796 
    oprot.writeStructBegin('addAddressForUser_args')
2797 
    if self.address != None:
2798 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
2799 
      self.address.write(oprot)
2800 
      oprot.writeFieldEnd()
2801 
    if self.userid != None:
2802 
      oprot.writeFieldBegin('userid', TType.I64, 2)
2803 
      oprot.writeI64(self.userid)
2804 
      oprot.writeFieldEnd()
2805 
    if self.timestamp != None:
2806 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
2807 
      oprot.writeI64(self.timestamp)
2808 
      oprot.writeFieldEnd()
2809 
    oprot.writeFieldStop()
2810 
    oprot.writeStructEnd()
2811 
 
2812 
  def __repr__(self):
2813 
    L = ['%s=%r' % (key, value)
2814 
      for key, value in self.__dict__.iteritems()]
2815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2816 
 
2817 
  def __eq__(self, other):
2818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2819 
 
2820 
  def __ne__(self, other):
2821 
    return not (self == other)
2822 
 
2823 
class addAddressForUser_result:
2824 
  """
2825 
  Attributes:
2826 
   - success
2827 
   - ucx
2828 
  """
2829 
 
2830 
  thrift_spec = (
2831 
    (0, TType.BOOL, 'success', None, None, ), # 0
2832 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2833 
  )
2834 
 
2835 
  def __init__(self, success=None, ucx=None,):
2836 
    self.success = success
2837 
    self.ucx = ucx
2838 
 
2839 
  def read(self, iprot):
2840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2842 
      return
2843 
    iprot.readStructBegin()
2844 
    while True:
2845 
      (fname, ftype, fid) = iprot.readFieldBegin()
2846 
      if ftype == TType.STOP:
2847 
        break
2848 
      if fid == 0:
2849 
        if ftype == TType.BOOL:
2850 
          self.success = iprot.readBool();
2851 
        else:
2852 
          iprot.skip(ftype)
2853 
      elif fid == 1:
2854 
        if ftype == TType.STRUCT:
2855 
          self.ucx = UserContextException()
2856 
          self.ucx.read(iprot)
2857 
        else:
2858 
          iprot.skip(ftype)
2859 
      else:
2860 
        iprot.skip(ftype)
2861 
      iprot.readFieldEnd()
2862 
    iprot.readStructEnd()
2863 
 
2864 
  def write(self, oprot):
2865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2867 
      return
2868 
    oprot.writeStructBegin('addAddressForUser_result')
2869 
    if self.success != None:
2870 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2871 
      oprot.writeBool(self.success)
2872 
      oprot.writeFieldEnd()
2873 
    if self.ucx != None:
2874 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2875 
      self.ucx.write(oprot)
2876 
      oprot.writeFieldEnd()
2877 
    oprot.writeFieldStop()
2878 
    oprot.writeStructEnd()
2879 
 
2880 
  def __repr__(self):
2881 
    L = ['%s=%r' % (key, value)
2882 
      for key, value in self.__dict__.iteritems()]
2883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2884 
 
2885 
  def __eq__(self, other):
2886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2887 
 
2888 
  def __ne__(self, other):
2889 
    return not (self == other)
2890 
 
2891 
class removeAddressForUser_args:
2892 
  """
2893 
  Attributes:
2894 
   - userid
2895 
   - addressId
2896 
  """
2897 
 
2898 
  thrift_spec = (
2899 
    None, # 0
2900 
    (1, TType.I64, 'userid', None, None, ), # 1
2901 
    (2, TType.I64, 'addressId', None, None, ), # 2
2902 
  )
2903 
 
2904 
  def __init__(self, userid=None, addressId=None,):
2905 
    self.userid = userid
2906 
    self.addressId = addressId
2907 
 
2908 
  def read(self, iprot):
2909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2911 
      return
2912 
    iprot.readStructBegin()
2913 
    while True:
2914 
      (fname, ftype, fid) = iprot.readFieldBegin()
2915 
      if ftype == TType.STOP:
2916 
        break
2917 
      if fid == 1:
2918 
        if ftype == TType.I64:
2919 
          self.userid = iprot.readI64();
2920 
        else:
2921 
          iprot.skip(ftype)
2922 
      elif fid == 2:
2923 
        if ftype == TType.I64:
2924 
          self.addressId = iprot.readI64();
2925 
        else:
2926 
          iprot.skip(ftype)
2927 
      else:
2928 
        iprot.skip(ftype)
2929 
      iprot.readFieldEnd()
2930 
    iprot.readStructEnd()
2931 
 
2932 
  def write(self, oprot):
2933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2935 
      return
2936 
    oprot.writeStructBegin('removeAddressForUser_args')
2937 
    if self.userid != None:
2938 
      oprot.writeFieldBegin('userid', TType.I64, 1)
2939 
      oprot.writeI64(self.userid)
2940 
      oprot.writeFieldEnd()
2941 
    if self.addressId != None:
2942 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
2943 
      oprot.writeI64(self.addressId)
2944 
      oprot.writeFieldEnd()
2945 
    oprot.writeFieldStop()
2946 
    oprot.writeStructEnd()
2947 
 
2948 
  def __repr__(self):
2949 
    L = ['%s=%r' % (key, value)
2950 
      for key, value in self.__dict__.iteritems()]
2951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2952 
 
2953 
  def __eq__(self, other):
2954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2955 
 
2956 
  def __ne__(self, other):
2957 
    return not (self == other)
2958 
 
2959 
class removeAddressForUser_result:
2960 
  """
2961 
  Attributes:
2962 
   - success
2963 
   - ucx
2964 
  """
2965 
 
2966 
  thrift_spec = (
2967 
    (0, TType.BOOL, 'success', None, None, ), # 0
2968 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2969 
  )
2970 
 
2971 
  def __init__(self, success=None, ucx=None,):
2972 
    self.success = success
2973 
    self.ucx = ucx
2974 
 
2975 
  def read(self, iprot):
2976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2978 
      return
2979 
    iprot.readStructBegin()
2980 
    while True:
2981 
      (fname, ftype, fid) = iprot.readFieldBegin()
2982 
      if ftype == TType.STOP:
2983 
        break
2984 
      if fid == 0:
2985 
        if ftype == TType.BOOL:
2986 
          self.success = iprot.readBool();
2987 
        else:
2988 
          iprot.skip(ftype)
2989 
      elif fid == 1:
2990 
        if ftype == TType.STRUCT:
2991 
          self.ucx = UserContextException()
2992 
          self.ucx.read(iprot)
2993 
        else:
2994 
          iprot.skip(ftype)
2995 
      else:
2996 
        iprot.skip(ftype)
2997 
      iprot.readFieldEnd()
2998 
    iprot.readStructEnd()
2999 
 
3000 
  def write(self, oprot):
3001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3003 
      return
3004 
    oprot.writeStructBegin('removeAddressForUser_result')
3005 
    if self.success != None:
3006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3007 
      oprot.writeBool(self.success)
3008 
      oprot.writeFieldEnd()
3009 
    if self.ucx != None:
3010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3011 
      self.ucx.write(oprot)
3012 
      oprot.writeFieldEnd()
3013 
    oprot.writeFieldStop()
3014 
    oprot.writeStructEnd()
3015 
 
3016 
  def __repr__(self):
3017 
    L = ['%s=%r' % (key, value)
3018 
      for key, value in self.__dict__.iteritems()]
3019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3020 
 
3021 
  def __eq__(self, other):
3022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3023 
 
3024 
  def __ne__(self, other):
3025 
    return not (self == other)
3026 
 
3027 
class setUserAsLoggedIn_args:
3028 
  """
3029 
  Attributes:
3030 
   - userId
3031 
   - timestamp
3032 
  """
3033 
 
3034 
  thrift_spec = (
3035 
    None, # 0
3036 
    (1, TType.I64, 'userId', None, None, ), # 1
3037 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3038 
  )
3039 
 
3040 
  def __init__(self, userId=None, timestamp=None,):
3041 
    self.userId = userId
3042 
    self.timestamp = timestamp
3043 
 
3044 
  def read(self, iprot):
3045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3047 
      return
3048 
    iprot.readStructBegin()
3049 
    while True:
3050 
      (fname, ftype, fid) = iprot.readFieldBegin()
3051 
      if ftype == TType.STOP:
3052 
        break
3053 
      if fid == 1:
3054 
        if ftype == TType.I64:
3055 
          self.userId = iprot.readI64();
3056 
        else:
3057 
          iprot.skip(ftype)
3058 
      elif fid == 2:
3059 
        if ftype == TType.I64:
3060 
          self.timestamp = iprot.readI64();
3061 
        else:
3062 
          iprot.skip(ftype)
3063 
      else:
3064 
        iprot.skip(ftype)
3065 
      iprot.readFieldEnd()
3066 
    iprot.readStructEnd()
3067 
 
3068 
  def write(self, oprot):
3069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3071 
      return
3072 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3073 
    if self.userId != None:
3074 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3075 
      oprot.writeI64(self.userId)
3076 
      oprot.writeFieldEnd()
3077 
    if self.timestamp != None:
3078 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3079 
      oprot.writeI64(self.timestamp)
3080 
      oprot.writeFieldEnd()
3081 
    oprot.writeFieldStop()
3082 
    oprot.writeStructEnd()
3083 
 
3084 
  def __repr__(self):
3085 
    L = ['%s=%r' % (key, value)
3086 
      for key, value in self.__dict__.iteritems()]
3087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3088 
 
3089 
  def __eq__(self, other):
3090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3091 
 
3092 
  def __ne__(self, other):
3093 
    return not (self == other)
3094 
 
3095 
class setUserAsLoggedIn_result:
3096 
  """
3097 
  Attributes:
3098 
   - success
3099 
   - ucx
3100 
  """
3101 
 
3102 
  thrift_spec = (
3103 
    (0, TType.BOOL, 'success', None, None, ), # 0
3104 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3105 
  )
3106 
 
3107 
  def __init__(self, success=None, ucx=None,):
3108 
    self.success = success
3109 
    self.ucx = ucx
3110 
 
3111 
  def read(self, iprot):
3112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3114 
      return
3115 
    iprot.readStructBegin()
3116 
    while True:
3117 
      (fname, ftype, fid) = iprot.readFieldBegin()
3118 
      if ftype == TType.STOP:
3119 
        break
3120 
      if fid == 0:
3121 
        if ftype == TType.BOOL:
3122 
          self.success = iprot.readBool();
3123 
        else:
3124 
          iprot.skip(ftype)
3125 
      elif fid == 1:
3126 
        if ftype == TType.STRUCT:
3127 
          self.ucx = UserContextException()
3128 
          self.ucx.read(iprot)
3129 
        else:
3130 
          iprot.skip(ftype)
3131 
      else:
3132 
        iprot.skip(ftype)
3133 
      iprot.readFieldEnd()
3134 
    iprot.readStructEnd()
3135 
 
3136 
  def write(self, oprot):
3137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3139 
      return
3140 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3141 
    if self.success != None:
3142 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3143 
      oprot.writeBool(self.success)
3144 
      oprot.writeFieldEnd()
3145 
    if self.ucx != None:
3146 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3147 
      self.ucx.write(oprot)
3148 
      oprot.writeFieldEnd()
3149 
    oprot.writeFieldStop()
3150 
    oprot.writeStructEnd()
3151 
 
3152 
  def __repr__(self):
3153 
    L = ['%s=%r' % (key, value)
3154 
      for key, value in self.__dict__.iteritems()]
3155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3156 
 
3157 
  def __eq__(self, other):
3158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3159 
 
3160 
  def __ne__(self, other):
3161 
    return not (self == other)
3162 
 
3163 
class setUserAsLoggedOut_args:
3164 
  """
3165 
  Attributes:
3166 
   - userid
3167 
   - timestamp
3168 
  """
3169 
 
3170 
  thrift_spec = (
3171 
    None, # 0
3172 
    (1, TType.I64, 'userid', None, None, ), # 1
3173 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3174 
  )
3175 
 
3176 
  def __init__(self, userid=None, timestamp=None,):
3177 
    self.userid = userid
3178 
    self.timestamp = timestamp
3179 
 
3180 
  def read(self, iprot):
3181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3183 
      return
3184 
    iprot.readStructBegin()
3185 
    while True:
3186 
      (fname, ftype, fid) = iprot.readFieldBegin()
3187 
      if ftype == TType.STOP:
3188 
        break
3189 
      if fid == 1:
3190 
        if ftype == TType.I64:
3191 
          self.userid = iprot.readI64();
3192 
        else:
3193 
          iprot.skip(ftype)
3194 
      elif fid == 2:
3195 
        if ftype == TType.I64:
3196 
          self.timestamp = iprot.readI64();
3197 
        else:
3198 
          iprot.skip(ftype)
3199 
      else:
3200 
        iprot.skip(ftype)
3201 
      iprot.readFieldEnd()
3202 
    iprot.readStructEnd()
3203 
 
3204 
  def write(self, oprot):
3205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3207 
      return
3208 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3209 
    if self.userid != None:
3210 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3211 
      oprot.writeI64(self.userid)
3212 
      oprot.writeFieldEnd()
3213 
    if self.timestamp != None:
3214 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3215 
      oprot.writeI64(self.timestamp)
3216 
      oprot.writeFieldEnd()
3217 
    oprot.writeFieldStop()
3218 
    oprot.writeStructEnd()
3219 
 
3220 
  def __repr__(self):
3221 
    L = ['%s=%r' % (key, value)
3222 
      for key, value in self.__dict__.iteritems()]
3223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3224 
 
3225 
  def __eq__(self, other):
3226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3227 
 
3228 
  def __ne__(self, other):
3229 
    return not (self == other)
3230 
 
3231 
class setUserAsLoggedOut_result:
3232 
  """
3233 
  Attributes:
3234 
   - success
3235 
   - ucx
3236 
  """
3237 
 
3238 
  thrift_spec = (
3239 
    (0, TType.BOOL, 'success', None, None, ), # 0
3240 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3241 
  )
3242 
 
3243 
  def __init__(self, success=None, ucx=None,):
3244 
    self.success = success
3245 
    self.ucx = ucx
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 == 0:
3257 
        if ftype == TType.BOOL:
3258 
          self.success = iprot.readBool();
3259 
        else:
3260 
          iprot.skip(ftype)
3261 
      elif fid == 1:
3262 
        if ftype == TType.STRUCT:
3263 
          self.ucx = UserContextException()
3264 
          self.ucx.read(iprot)
3265 
        else:
3266 
          iprot.skip(ftype)
3267 
      else:
3268 
        iprot.skip(ftype)
3269 
      iprot.readFieldEnd()
3270 
    iprot.readStructEnd()
3271 
 
3272 
  def write(self, oprot):
3273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3275 
      return
3276 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3277 
    if self.success != None:
3278 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3279 
      oprot.writeBool(self.success)
3280 
      oprot.writeFieldEnd()
3281 
    if self.ucx != None:
3282 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3283 
      self.ucx.write(oprot)
3284 
      oprot.writeFieldEnd()
3285 
    oprot.writeFieldStop()
3286 
    oprot.writeStructEnd()
3287 
 
3288 
  def __repr__(self):
3289 
    L = ['%s=%r' % (key, value)
3290 
      for key, value in self.__dict__.iteritems()]
3291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3292 
 
3293 
  def __eq__(self, other):
3294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3295 
 
3296 
  def __ne__(self, other):
3297 
    return not (self == other)
3298 
 
3299 
class updatePassword_args:
3300 
  """
3301 
  Attributes:
3302 
   - userid
3303 
   - password
3304 
  """
3305 
 
3306 
  thrift_spec = (
3307 
    None, # 0
3308 
    (1, TType.I64, 'userid', None, None, ), # 1
3309 
    (2, TType.STRING, 'password', None, None, ), # 2
3310 
  )
3311 
 
3312 
  def __init__(self, userid=None, password=None,):
3313 
    self.userid = userid
3314 
    self.password = password
3315 
 
3316 
  def read(self, iprot):
3317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3319 
      return
3320 
    iprot.readStructBegin()
3321 
    while True:
3322 
      (fname, ftype, fid) = iprot.readFieldBegin()
3323 
      if ftype == TType.STOP:
3324 
        break
3325 
      if fid == 1:
3326 
        if ftype == TType.I64:
3327 
          self.userid = iprot.readI64();
3328 
        else:
3329 
          iprot.skip(ftype)
3330 
      elif fid == 2:
3331 
        if ftype == TType.STRING:
3332 
          self.password = iprot.readString();
3333 
        else:
3334 
          iprot.skip(ftype)
3335 
      else:
3336 
        iprot.skip(ftype)
3337 
      iprot.readFieldEnd()
3338 
    iprot.readStructEnd()
3339 
 
3340 
  def write(self, oprot):
3341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3343 
      return
3344 
    oprot.writeStructBegin('updatePassword_args')
3345 
    if self.userid != None:
3346 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3347 
      oprot.writeI64(self.userid)
3348 
      oprot.writeFieldEnd()
3349 
    if self.password != None:
3350 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3351 
      oprot.writeString(self.password)
3352 
      oprot.writeFieldEnd()
3353 
    oprot.writeFieldStop()
3354 
    oprot.writeStructEnd()
3355 
 
3356 
  def __repr__(self):
3357 
    L = ['%s=%r' % (key, value)
3358 
      for key, value in self.__dict__.iteritems()]
3359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3360 
 
3361 
  def __eq__(self, other):
3362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3363 
 
3364 
  def __ne__(self, other):
3365 
    return not (self == other)
3366 
 
3367 
class updatePassword_result:
3368 
  """
3369 
  Attributes:
3370 
   - success
3371 
   - ucx
3372 
  """
3373 
 
3374 
  thrift_spec = (
3375 
    (0, TType.BOOL, 'success', None, None, ), # 0
3376 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3377 
  )
3378 
 
3379 
  def __init__(self, success=None, ucx=None,):
3380 
    self.success = success
3381 
    self.ucx = ucx
3382 
 
3383 
  def read(self, iprot):
3384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3386 
      return
3387 
    iprot.readStructBegin()
3388 
    while True:
3389 
      (fname, ftype, fid) = iprot.readFieldBegin()
3390 
      if ftype == TType.STOP:
3391 
        break
3392 
      if fid == 0:
3393 
        if ftype == TType.BOOL:
3394 
          self.success = iprot.readBool();
3395 
        else:
3396 
          iprot.skip(ftype)
3397 
      elif fid == 1:
3398 
        if ftype == TType.STRUCT:
3399 
          self.ucx = UserContextException()
3400 
          self.ucx.read(iprot)
3401 
        else:
3402 
          iprot.skip(ftype)
3403 
      else:
3404 
        iprot.skip(ftype)
3405 
      iprot.readFieldEnd()
3406 
    iprot.readStructEnd()
3407 
 
3408 
  def write(self, oprot):
3409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3411 
      return
3412 
    oprot.writeStructBegin('updatePassword_result')
3413 
    if self.success != None:
3414 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3415 
      oprot.writeBool(self.success)
3416 
      oprot.writeFieldEnd()
3417 
    if self.ucx != None:
3418 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3419 
      self.ucx.write(oprot)
3420 
      oprot.writeFieldEnd()
3421 
    oprot.writeFieldStop()
3422 
    oprot.writeStructEnd()
3423 
 
3424 
  def __repr__(self):
3425 
    L = ['%s=%r' % (key, value)
3426 
      for key, value in self.__dict__.iteritems()]
3427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3428 
 
3429 
  def __eq__(self, other):
3430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3431 
 
3432 
  def __ne__(self, other):
3433 
    return not (self == other)
3434 
 
3435 
class deleteUser_args:
3436 
  """
3437 
  Attributes:
3438 
   - userid
122 ashish 3439 
   - isSessionId
94 ashish 3440 
  """
3441 
 
3442 
  thrift_spec = (
3443 
    None, # 0
3444 
    (1, TType.I64, 'userid', None, None, ), # 1
122 ashish 3445 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 3446 
  )
3447 
 
122 ashish 3448 
  def __init__(self, userid=None, isSessionId=None,):
94 ashish 3449 
    self.userid = userid
122 ashish 3450 
    self.isSessionId = isSessionId
94 ashish 3451 
 
3452 
  def read(self, iprot):
3453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3455 
      return
3456 
    iprot.readStructBegin()
3457 
    while True:
3458 
      (fname, ftype, fid) = iprot.readFieldBegin()
3459 
      if ftype == TType.STOP:
3460 
        break
3461 
      if fid == 1:
3462 
        if ftype == TType.I64:
3463 
          self.userid = iprot.readI64();
3464 
        else:
3465 
          iprot.skip(ftype)
122 ashish 3466 
      elif fid == 2:
3467 
        if ftype == TType.BOOL:
3468 
          self.isSessionId = iprot.readBool();
3469 
        else:
3470 
          iprot.skip(ftype)
94 ashish 3471 
      else:
3472 
        iprot.skip(ftype)
3473 
      iprot.readFieldEnd()
3474 
    iprot.readStructEnd()
3475 
 
3476 
  def write(self, oprot):
3477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3479 
      return
3480 
    oprot.writeStructBegin('deleteUser_args')
3481 
    if self.userid != None:
3482 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3483 
      oprot.writeI64(self.userid)
3484 
      oprot.writeFieldEnd()
122 ashish 3485 
    if self.isSessionId != None:
3486 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
3487 
      oprot.writeBool(self.isSessionId)
3488 
      oprot.writeFieldEnd()
94 ashish 3489 
    oprot.writeFieldStop()
3490 
    oprot.writeStructEnd()
3491 
 
3492 
  def __repr__(self):
3493 
    L = ['%s=%r' % (key, value)
3494 
      for key, value in self.__dict__.iteritems()]
3495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3496 
 
3497 
  def __eq__(self, other):
3498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3499 
 
3500 
  def __ne__(self, other):
3501 
    return not (self == other)
3502 
 
3503 
class deleteUser_result:
3504 
  """
3505 
  Attributes:
3506 
   - success
3507 
   - ucx
3508 
  """
3509 
 
3510 
  thrift_spec = (
3511 
    (0, TType.BOOL, 'success', None, None, ), # 0
3512 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3513 
  )
3514 
 
3515 
  def __init__(self, success=None, ucx=None,):
3516 
    self.success = success
3517 
    self.ucx = ucx
3518 
 
3519 
  def read(self, iprot):
3520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3522 
      return
3523 
    iprot.readStructBegin()
3524 
    while True:
3525 
      (fname, ftype, fid) = iprot.readFieldBegin()
3526 
      if ftype == TType.STOP:
3527 
        break
3528 
      if fid == 0:
3529 
        if ftype == TType.BOOL:
3530 
          self.success = iprot.readBool();
3531 
        else:
3532 
          iprot.skip(ftype)
3533 
      elif fid == 1:
3534 
        if ftype == TType.STRUCT:
3535 
          self.ucx = UserContextException()
3536 
          self.ucx.read(iprot)
3537 
        else:
3538 
          iprot.skip(ftype)
3539 
      else:
3540 
        iprot.skip(ftype)
3541 
      iprot.readFieldEnd()
3542 
    iprot.readStructEnd()
3543 
 
3544 
  def write(self, oprot):
3545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3547 
      return
3548 
    oprot.writeStructBegin('deleteUser_result')
3549 
    if self.success != None:
3550 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3551 
      oprot.writeBool(self.success)
3552 
      oprot.writeFieldEnd()
3553 
    if self.ucx != None:
3554 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3555 
      self.ucx.write(oprot)
3556 
      oprot.writeFieldEnd()
3557 
    oprot.writeFieldStop()
3558 
    oprot.writeStructEnd()
3559 
 
3560 
  def __repr__(self):
3561 
    L = ['%s=%r' % (key, value)
3562 
      for key, value in self.__dict__.iteritems()]
3563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3564 
 
3565 
  def __eq__(self, other):
3566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3567 
 
3568 
  def __ne__(self, other):
3569 
    return not (self == other)
3570 
 
3571 
class sendEmailVerification_args:
3572 
  """
3573 
  Attributes:
3574 
   - userid
3575 
  """
3576 
 
3577 
  thrift_spec = (
3578 
    None, # 0
3579 
    (1, TType.I64, 'userid', None, None, ), # 1
3580 
  )
3581 
 
3582 
  def __init__(self, userid=None,):
3583 
    self.userid = userid
3584 
 
3585 
  def read(self, iprot):
3586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3588 
      return
3589 
    iprot.readStructBegin()
3590 
    while True:
3591 
      (fname, ftype, fid) = iprot.readFieldBegin()
3592 
      if ftype == TType.STOP:
3593 
        break
3594 
      if fid == 1:
3595 
        if ftype == TType.I64:
3596 
          self.userid = iprot.readI64();
3597 
        else:
3598 
          iprot.skip(ftype)
3599 
      else:
3600 
        iprot.skip(ftype)
3601 
      iprot.readFieldEnd()
3602 
    iprot.readStructEnd()
3603 
 
3604 
  def write(self, oprot):
3605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3607 
      return
3608 
    oprot.writeStructBegin('sendEmailVerification_args')
3609 
    if self.userid != None:
3610 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3611 
      oprot.writeI64(self.userid)
3612 
      oprot.writeFieldEnd()
3613 
    oprot.writeFieldStop()
3614 
    oprot.writeStructEnd()
3615 
 
3616 
  def __repr__(self):
3617 
    L = ['%s=%r' % (key, value)
3618 
      for key, value in self.__dict__.iteritems()]
3619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3620 
 
3621 
  def __eq__(self, other):
3622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3623 
 
3624 
  def __ne__(self, other):
3625 
    return not (self == other)
3626 
 
3627 
class sendEmailVerification_result:
3628 
  """
3629 
  Attributes:
3630 
   - success
3631 
   - ucx
3632 
  """
3633 
 
3634 
  thrift_spec = (
3635 
    (0, TType.BOOL, 'success', None, None, ), # 0
3636 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3637 
  )
3638 
 
3639 
  def __init__(self, success=None, ucx=None,):
3640 
    self.success = success
3641 
    self.ucx = ucx
3642 
 
3643 
  def read(self, iprot):
3644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3646 
      return
3647 
    iprot.readStructBegin()
3648 
    while True:
3649 
      (fname, ftype, fid) = iprot.readFieldBegin()
3650 
      if ftype == TType.STOP:
3651 
        break
3652 
      if fid == 0:
3653 
        if ftype == TType.BOOL:
3654 
          self.success = iprot.readBool();
3655 
        else:
3656 
          iprot.skip(ftype)
3657 
      elif fid == 1:
3658 
        if ftype == TType.STRUCT:
3659 
          self.ucx = UserContextException()
3660 
          self.ucx.read(iprot)
3661 
        else:
3662 
          iprot.skip(ftype)
3663 
      else:
3664 
        iprot.skip(ftype)
3665 
      iprot.readFieldEnd()
3666 
    iprot.readStructEnd()
3667 
 
3668 
  def write(self, oprot):
3669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3671 
      return
3672 
    oprot.writeStructBegin('sendEmailVerification_result')
3673 
    if self.success != None:
3674 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3675 
      oprot.writeBool(self.success)
3676 
      oprot.writeFieldEnd()
3677 
    if self.ucx != None:
3678 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3679 
      self.ucx.write(oprot)
3680 
      oprot.writeFieldEnd()
3681 
    oprot.writeFieldStop()
3682 
    oprot.writeStructEnd()
3683 
 
3684 
  def __repr__(self):
3685 
    L = ['%s=%r' % (key, value)
3686 
      for key, value in self.__dict__.iteritems()]
3687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3688 
 
3689 
  def __eq__(self, other):
3690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3691 
 
3692 
  def __ne__(self, other):
3693 
    return not (self == other)
3694 
 
3695 
class sendSMSVerification_args:
3696 
  """
3697 
  Attributes:
3698 
   - userid
3699 
  """
3700 
 
3701 
  thrift_spec = (
3702 
    None, # 0
3703 
    (1, TType.I64, 'userid', None, None, ), # 1
3704 
  )
3705 
 
3706 
  def __init__(self, userid=None,):
3707 
    self.userid = userid
3708 
 
3709 
  def read(self, iprot):
3710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3712 
      return
3713 
    iprot.readStructBegin()
3714 
    while True:
3715 
      (fname, ftype, fid) = iprot.readFieldBegin()
3716 
      if ftype == TType.STOP:
3717 
        break
3718 
      if fid == 1:
3719 
        if ftype == TType.I64:
3720 
          self.userid = iprot.readI64();
3721 
        else:
3722 
          iprot.skip(ftype)
3723 
      else:
3724 
        iprot.skip(ftype)
3725 
      iprot.readFieldEnd()
3726 
    iprot.readStructEnd()
3727 
 
3728 
  def write(self, oprot):
3729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3731 
      return
3732 
    oprot.writeStructBegin('sendSMSVerification_args')
3733 
    if self.userid != None:
3734 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3735 
      oprot.writeI64(self.userid)
3736 
      oprot.writeFieldEnd()
3737 
    oprot.writeFieldStop()
3738 
    oprot.writeStructEnd()
3739 
 
3740 
  def __repr__(self):
3741 
    L = ['%s=%r' % (key, value)
3742 
      for key, value in self.__dict__.iteritems()]
3743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3744 
 
3745 
  def __eq__(self, other):
3746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3747 
 
3748 
  def __ne__(self, other):
3749 
    return not (self == other)
3750 
 
3751 
class sendSMSVerification_result:
3752 
  """
3753 
  Attributes:
3754 
   - success
3755 
   - ucx
3756 
  """
3757 
 
3758 
  thrift_spec = (
3759 
    (0, TType.BOOL, 'success', None, None, ), # 0
3760 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3761 
  )
3762 
 
3763 
  def __init__(self, success=None, ucx=None,):
3764 
    self.success = success
3765 
    self.ucx = ucx
3766 
 
3767 
  def read(self, iprot):
3768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3770 
      return
3771 
    iprot.readStructBegin()
3772 
    while True:
3773 
      (fname, ftype, fid) = iprot.readFieldBegin()
3774 
      if ftype == TType.STOP:
3775 
        break
3776 
      if fid == 0:
3777 
        if ftype == TType.BOOL:
3778 
          self.success = iprot.readBool();
3779 
        else:
3780 
          iprot.skip(ftype)
3781 
      elif fid == 1:
3782 
        if ftype == TType.STRUCT:
3783 
          self.ucx = UserContextException()
3784 
          self.ucx.read(iprot)
3785 
        else:
3786 
          iprot.skip(ftype)
3787 
      else:
3788 
        iprot.skip(ftype)
3789 
      iprot.readFieldEnd()
3790 
    iprot.readStructEnd()
3791 
 
3792 
  def write(self, oprot):
3793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3795 
      return
3796 
    oprot.writeStructBegin('sendSMSVerification_result')
3797 
    if self.success != None:
3798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3799 
      oprot.writeBool(self.success)
3800 
      oprot.writeFieldEnd()
3801 
    if self.ucx != None:
3802 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3803 
      self.ucx.write(oprot)
3804 
      oprot.writeFieldEnd()
3805 
    oprot.writeFieldStop()
3806 
    oprot.writeStructEnd()
3807 
 
3808 
  def __repr__(self):
3809 
    L = ['%s=%r' % (key, value)
3810 
      for key, value in self.__dict__.iteritems()]
3811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3812 
 
3813 
  def __eq__(self, other):
3814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3815 
 
3816 
  def __ne__(self, other):
3817 
    return not (self == other)
3818 
 
3819 
class confirmEmailVerification_args:
3820 
  """
3821 
  Attributes:
3822 
   - userid
3823 
  """
3824 
 
3825 
  thrift_spec = (
3826 
    None, # 0
3827 
    (1, TType.I64, 'userid', None, None, ), # 1
3828 
  )
3829 
 
3830 
  def __init__(self, userid=None,):
3831 
    self.userid = userid
3832 
 
3833 
  def read(self, iprot):
3834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3836 
      return
3837 
    iprot.readStructBegin()
3838 
    while True:
3839 
      (fname, ftype, fid) = iprot.readFieldBegin()
3840 
      if ftype == TType.STOP:
3841 
        break
3842 
      if fid == 1:
3843 
        if ftype == TType.I64:
3844 
          self.userid = iprot.readI64();
3845 
        else:
3846 
          iprot.skip(ftype)
3847 
      else:
3848 
        iprot.skip(ftype)
3849 
      iprot.readFieldEnd()
3850 
    iprot.readStructEnd()
3851 
 
3852 
  def write(self, oprot):
3853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3855 
      return
3856 
    oprot.writeStructBegin('confirmEmailVerification_args')
3857 
    if self.userid != None:
3858 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3859 
      oprot.writeI64(self.userid)
3860 
      oprot.writeFieldEnd()
3861 
    oprot.writeFieldStop()
3862 
    oprot.writeStructEnd()
3863 
 
3864 
  def __repr__(self):
3865 
    L = ['%s=%r' % (key, value)
3866 
      for key, value in self.__dict__.iteritems()]
3867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3868 
 
3869 
  def __eq__(self, other):
3870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3871 
 
3872 
  def __ne__(self, other):
3873 
    return not (self == other)
3874 
 
3875 
class confirmEmailVerification_result:
3876 
  """
3877 
  Attributes:
3878 
   - success
3879 
   - ucx
3880 
  """
3881 
 
3882 
  thrift_spec = (
3883 
    (0, TType.BOOL, 'success', None, None, ), # 0
3884 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3885 
  )
3886 
 
3887 
  def __init__(self, success=None, ucx=None,):
3888 
    self.success = success
3889 
    self.ucx = ucx
3890 
 
3891 
  def read(self, iprot):
3892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3894 
      return
3895 
    iprot.readStructBegin()
3896 
    while True:
3897 
      (fname, ftype, fid) = iprot.readFieldBegin()
3898 
      if ftype == TType.STOP:
3899 
        break
3900 
      if fid == 0:
3901 
        if ftype == TType.BOOL:
3902 
          self.success = iprot.readBool();
3903 
        else:
3904 
          iprot.skip(ftype)
3905 
      elif fid == 1:
3906 
        if ftype == TType.STRUCT:
3907 
          self.ucx = UserContextException()
3908 
          self.ucx.read(iprot)
3909 
        else:
3910 
          iprot.skip(ftype)
3911 
      else:
3912 
        iprot.skip(ftype)
3913 
      iprot.readFieldEnd()
3914 
    iprot.readStructEnd()
3915 
 
3916 
  def write(self, oprot):
3917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3919 
      return
3920 
    oprot.writeStructBegin('confirmEmailVerification_result')
3921 
    if self.success != None:
3922 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3923 
      oprot.writeBool(self.success)
3924 
      oprot.writeFieldEnd()
3925 
    if self.ucx != None:
3926 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3927 
      self.ucx.write(oprot)
3928 
      oprot.writeFieldEnd()
3929 
    oprot.writeFieldStop()
3930 
    oprot.writeStructEnd()
3931 
 
3932 
  def __repr__(self):
3933 
    L = ['%s=%r' % (key, value)
3934 
      for key, value in self.__dict__.iteritems()]
3935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3936 
 
3937 
  def __eq__(self, other):
3938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3939 
 
3940 
  def __ne__(self, other):
3941 
    return not (self == other)
3942 
 
3943 
class confirmSMSVerification_args:
3944 
  """
3945 
  Attributes:
3946 
   - userid
3947 
  """
3948 
 
3949 
  thrift_spec = (
3950 
    None, # 0
3951 
    (1, TType.I64, 'userid', None, None, ), # 1
3952 
  )
3953 
 
3954 
  def __init__(self, userid=None,):
3955 
    self.userid = userid
3956 
 
3957 
  def read(self, iprot):
3958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3960 
      return
3961 
    iprot.readStructBegin()
3962 
    while True:
3963 
      (fname, ftype, fid) = iprot.readFieldBegin()
3964 
      if ftype == TType.STOP:
3965 
        break
3966 
      if fid == 1:
3967 
        if ftype == TType.I64:
3968 
          self.userid = iprot.readI64();
3969 
        else:
3970 
          iprot.skip(ftype)
3971 
      else:
3972 
        iprot.skip(ftype)
3973 
      iprot.readFieldEnd()
3974 
    iprot.readStructEnd()
3975 
 
3976 
  def write(self, oprot):
3977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3979 
      return
3980 
    oprot.writeStructBegin('confirmSMSVerification_args')
3981 
    if self.userid != None:
3982 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3983 
      oprot.writeI64(self.userid)
3984 
      oprot.writeFieldEnd()
3985 
    oprot.writeFieldStop()
3986 
    oprot.writeStructEnd()
3987 
 
3988 
  def __repr__(self):
3989 
    L = ['%s=%r' % (key, value)
3990 
      for key, value in self.__dict__.iteritems()]
3991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3992 
 
3993 
  def __eq__(self, other):
3994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3995 
 
3996 
  def __ne__(self, other):
3997 
    return not (self == other)
3998 
 
3999 
class confirmSMSVerification_result:
4000 
  """
4001 
  Attributes:
4002 
   - success
4003 
   - ucx
4004 
  """
4005 
 
4006 
  thrift_spec = (
4007 
    (0, TType.BOOL, 'success', None, None, ), # 0
4008 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4009 
  )
4010 
 
4011 
  def __init__(self, success=None, ucx=None,):
4012 
    self.success = success
4013 
    self.ucx = ucx
4014 
 
4015 
  def read(self, iprot):
4016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4018 
      return
4019 
    iprot.readStructBegin()
4020 
    while True:
4021 
      (fname, ftype, fid) = iprot.readFieldBegin()
4022 
      if ftype == TType.STOP:
4023 
        break
4024 
      if fid == 0:
4025 
        if ftype == TType.BOOL:
4026 
          self.success = iprot.readBool();
4027 
        else:
4028 
          iprot.skip(ftype)
4029 
      elif fid == 1:
4030 
        if ftype == TType.STRUCT:
4031 
          self.ucx = UserContextException()
4032 
          self.ucx.read(iprot)
4033 
        else:
4034 
          iprot.skip(ftype)
4035 
      else:
4036 
        iprot.skip(ftype)
4037 
      iprot.readFieldEnd()
4038 
    iprot.readStructEnd()
4039 
 
4040 
  def write(self, oprot):
4041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4043 
      return
4044 
    oprot.writeStructBegin('confirmSMSVerification_result')
4045 
    if self.success != None:
4046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4047 
      oprot.writeBool(self.success)
4048 
      oprot.writeFieldEnd()
4049 
    if self.ucx != None:
4050 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4051 
      self.ucx.write(oprot)
4052 
      oprot.writeFieldEnd()
4053 
    oprot.writeFieldStop()
4054 
    oprot.writeStructEnd()
4055 
 
4056 
  def __repr__(self):
4057 
    L = ['%s=%r' % (key, value)
4058 
      for key, value in self.__dict__.iteritems()]
4059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4060 
 
4061 
  def __eq__(self, other):
4062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4063 
 
4064 
  def __ne__(self, other):
4065 
    return not (self == other)
4066 
 
4067 
class addSocialhandle_args:
4068 
  """
4069 
  Attributes:
4070 
   - userid
4071 
   - socialService
4072 
   - handle
4073 
  """
4074 
 
4075 
  thrift_spec = (
4076 
    None, # 0
4077 
    (1, TType.I64, 'userid', None, None, ), # 1
4078 
    (2, TType.STRING, 'socialService', None, None, ), # 2
4079 
    (3, TType.STRING, 'handle', None, None, ), # 3
4080 
  )
4081 
 
4082 
  def __init__(self, userid=None, socialService=None, handle=None,):
4083 
    self.userid = userid
4084 
    self.socialService = socialService
4085 
    self.handle = handle
4086 
 
4087 
  def read(self, iprot):
4088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4090 
      return
4091 
    iprot.readStructBegin()
4092 
    while True:
4093 
      (fname, ftype, fid) = iprot.readFieldBegin()
4094 
      if ftype == TType.STOP:
4095 
        break
4096 
      if fid == 1:
4097 
        if ftype == TType.I64:
4098 
          self.userid = iprot.readI64();
4099 
        else:
4100 
          iprot.skip(ftype)
4101 
      elif fid == 2:
4102 
        if ftype == TType.STRING:
4103 
          self.socialService = iprot.readString();
4104 
        else:
4105 
          iprot.skip(ftype)
4106 
      elif fid == 3:
4107 
        if ftype == TType.STRING:
4108 
          self.handle = iprot.readString();
4109 
        else:
4110 
          iprot.skip(ftype)
4111 
      else:
4112 
        iprot.skip(ftype)
4113 
      iprot.readFieldEnd()
4114 
    iprot.readStructEnd()
4115 
 
4116 
  def write(self, oprot):
4117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4119 
      return
4120 
    oprot.writeStructBegin('addSocialhandle_args')
4121 
    if self.userid != None:
4122 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4123 
      oprot.writeI64(self.userid)
4124 
      oprot.writeFieldEnd()
4125 
    if self.socialService != None:
4126 
      oprot.writeFieldBegin('socialService', TType.STRING, 2)
4127 
      oprot.writeString(self.socialService)
4128 
      oprot.writeFieldEnd()
4129 
    if self.handle != None:
4130 
      oprot.writeFieldBegin('handle', TType.STRING, 3)
4131 
      oprot.writeString(self.handle)
4132 
      oprot.writeFieldEnd()
4133 
    oprot.writeFieldStop()
4134 
    oprot.writeStructEnd()
4135 
 
4136 
  def __repr__(self):
4137 
    L = ['%s=%r' % (key, value)
4138 
      for key, value in self.__dict__.iteritems()]
4139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4140 
 
4141 
  def __eq__(self, other):
4142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4143 
 
4144 
  def __ne__(self, other):
4145 
    return not (self == other)
4146 
 
4147 
class addSocialhandle_result:
4148 
  """
4149 
  Attributes:
4150 
   - success
4151 
   - ucx
4152 
  """
4153 
 
4154 
  thrift_spec = (
4155 
    (0, TType.BOOL, 'success', None, None, ), # 0
4156 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4157 
  )
4158 
 
4159 
  def __init__(self, success=None, ucx=None,):
4160 
    self.success = success
4161 
    self.ucx = ucx
4162 
 
4163 
  def read(self, iprot):
4164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4166 
      return
4167 
    iprot.readStructBegin()
4168 
    while True:
4169 
      (fname, ftype, fid) = iprot.readFieldBegin()
4170 
      if ftype == TType.STOP:
4171 
        break
4172 
      if fid == 0:
4173 
        if ftype == TType.BOOL:
4174 
          self.success = iprot.readBool();
4175 
        else:
4176 
          iprot.skip(ftype)
4177 
      elif fid == 1:
4178 
        if ftype == TType.STRUCT:
4179 
          self.ucx = UserContextException()
4180 
          self.ucx.read(iprot)
4181 
        else:
4182 
          iprot.skip(ftype)
4183 
      else:
4184 
        iprot.skip(ftype)
4185 
      iprot.readFieldEnd()
4186 
    iprot.readStructEnd()
4187 
 
4188 
  def write(self, oprot):
4189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4191 
      return
4192 
    oprot.writeStructBegin('addSocialhandle_result')
4193 
    if self.success != None:
4194 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4195 
      oprot.writeBool(self.success)
4196 
      oprot.writeFieldEnd()
4197 
    if self.ucx != None:
4198 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4199 
      self.ucx.write(oprot)
4200 
      oprot.writeFieldEnd()
4201 
    oprot.writeFieldStop()
4202 
    oprot.writeStructEnd()
4203 
 
4204 
  def __repr__(self):
4205 
    L = ['%s=%r' % (key, value)
4206 
      for key, value in self.__dict__.iteritems()]
4207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4208 
 
4209 
  def __eq__(self, other):
4210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4211 
 
4212 
  def __ne__(self, other):
4213 
    return not (self == other)
4214 
 
130 ashish 4215 
class sendNewPasswordById_args:
4216 
  """
4217 
  Attributes:
4218 
   - userid
4219 
  """
94 ashish 4220 
 
130 ashish 4221 
  thrift_spec = (
4222 
    None, # 0
4223 
    (1, TType.I64, 'userid', None, None, ), # 1
4224 
  )
4225 
 
4226 
  def __init__(self, userid=None,):
4227 
    self.userid = userid
4228 
 
4229 
  def read(self, iprot):
4230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4232 
      return
4233 
    iprot.readStructBegin()
4234 
    while True:
4235 
      (fname, ftype, fid) = iprot.readFieldBegin()
4236 
      if ftype == TType.STOP:
4237 
        break
4238 
      if fid == 1:
4239 
        if ftype == TType.I64:
4240 
          self.userid = iprot.readI64();
4241 
        else:
4242 
          iprot.skip(ftype)
4243 
      else:
4244 
        iprot.skip(ftype)
4245 
      iprot.readFieldEnd()
4246 
    iprot.readStructEnd()
4247 
 
4248 
  def write(self, oprot):
4249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4251 
      return
4252 
    oprot.writeStructBegin('sendNewPasswordById_args')
4253 
    if self.userid != None:
4254 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4255 
      oprot.writeI64(self.userid)
4256 
      oprot.writeFieldEnd()
4257 
    oprot.writeFieldStop()
4258 
    oprot.writeStructEnd()
4259 
 
4260 
  def __repr__(self):
4261 
    L = ['%s=%r' % (key, value)
4262 
      for key, value in self.__dict__.iteritems()]
4263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4264 
 
4265 
  def __eq__(self, other):
4266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4267 
 
4268 
  def __ne__(self, other):
4269 
    return not (self == other)
4270 
 
4271 
class sendNewPasswordById_result:
4272 
  """
4273 
  Attributes:
4274 
   - success
4275 
   - ucx
4276 
  """
4277 
 
4278 
  thrift_spec = (
4279 
    (0, TType.BOOL, 'success', None, None, ), # 0
4280 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4281 
  )
4282 
 
4283 
  def __init__(self, success=None, ucx=None,):
4284 
    self.success = success
4285 
    self.ucx = ucx
4286 
 
4287 
  def read(self, iprot):
4288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4290 
      return
4291 
    iprot.readStructBegin()
4292 
    while True:
4293 
      (fname, ftype, fid) = iprot.readFieldBegin()
4294 
      if ftype == TType.STOP:
4295 
        break
4296 
      if fid == 0:
4297 
        if ftype == TType.BOOL:
4298 
          self.success = iprot.readBool();
4299 
        else:
4300 
          iprot.skip(ftype)
4301 
      elif fid == 1:
4302 
        if ftype == TType.STRUCT:
4303 
          self.ucx = UserContextException()
4304 
          self.ucx.read(iprot)
4305 
        else:
4306 
          iprot.skip(ftype)
4307 
      else:
4308 
        iprot.skip(ftype)
4309 
      iprot.readFieldEnd()
4310 
    iprot.readStructEnd()
4311 
 
4312 
  def write(self, oprot):
4313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4315 
      return
4316 
    oprot.writeStructBegin('sendNewPasswordById_result')
4317 
    if self.success != None:
4318 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4319 
      oprot.writeBool(self.success)
4320 
      oprot.writeFieldEnd()
4321 
    if self.ucx != None:
4322 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4323 
      self.ucx.write(oprot)
4324 
      oprot.writeFieldEnd()
4325 
    oprot.writeFieldStop()
4326 
    oprot.writeStructEnd()
4327 
 
4328 
  def __repr__(self):
4329 
    L = ['%s=%r' % (key, value)
4330 
      for key, value in self.__dict__.iteritems()]
4331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4332 
 
4333 
  def __eq__(self, other):
4334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4335 
 
4336 
  def __ne__(self, other):
4337 
    return not (self == other)
4338 
 
4339 
class sendNewPasswordByHandle_args:
4340 
  """
4341 
  Attributes:
4342 
   - emailOrHandle
4343 
   - isEmail
4344 
  """
4345 
 
4346 
  thrift_spec = (
4347 
    None, # 0
4348 
    (1, TType.STRING, 'emailOrHandle', None, None, ), # 1
4349 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
4350 
  )
4351 
 
4352 
  def __init__(self, emailOrHandle=None, isEmail=None,):
4353 
    self.emailOrHandle = emailOrHandle
4354 
    self.isEmail = isEmail
4355 
 
4356 
  def read(self, iprot):
4357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4359 
      return
4360 
    iprot.readStructBegin()
4361 
    while True:
4362 
      (fname, ftype, fid) = iprot.readFieldBegin()
4363 
      if ftype == TType.STOP:
4364 
        break
4365 
      if fid == 1:
4366 
        if ftype == TType.STRING:
4367 
          self.emailOrHandle = iprot.readString();
4368 
        else:
4369 
          iprot.skip(ftype)
4370 
      elif fid == 2:
4371 
        if ftype == TType.BOOL:
4372 
          self.isEmail = iprot.readBool();
4373 
        else:
4374 
          iprot.skip(ftype)
4375 
      else:
4376 
        iprot.skip(ftype)
4377 
      iprot.readFieldEnd()
4378 
    iprot.readStructEnd()
4379 
 
4380 
  def write(self, oprot):
4381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4383 
      return
4384 
    oprot.writeStructBegin('sendNewPasswordByHandle_args')
4385 
    if self.emailOrHandle != None:
4386 
      oprot.writeFieldBegin('emailOrHandle', TType.STRING, 1)
4387 
      oprot.writeString(self.emailOrHandle)
4388 
      oprot.writeFieldEnd()
4389 
    if self.isEmail != None:
4390 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
4391 
      oprot.writeBool(self.isEmail)
4392 
      oprot.writeFieldEnd()
4393 
    oprot.writeFieldStop()
4394 
    oprot.writeStructEnd()
4395 
 
4396 
  def __repr__(self):
4397 
    L = ['%s=%r' % (key, value)
4398 
      for key, value in self.__dict__.iteritems()]
4399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4400 
 
4401 
  def __eq__(self, other):
4402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4403 
 
4404 
  def __ne__(self, other):
4405 
    return not (self == other)
4406 
 
4407 
class sendNewPasswordByHandle_result:
4408 
  """
4409 
  Attributes:
4410 
   - success
4411 
   - ucx
4412 
  """
4413 
 
4414 
  thrift_spec = (
4415 
    (0, TType.BOOL, 'success', None, None, ), # 0
4416 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4417 
  )
4418 
 
4419 
  def __init__(self, success=None, ucx=None,):
4420 
    self.success = success
4421 
    self.ucx = ucx
4422 
 
4423 
  def read(self, iprot):
4424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4426 
      return
4427 
    iprot.readStructBegin()
4428 
    while True:
4429 
      (fname, ftype, fid) = iprot.readFieldBegin()
4430 
      if ftype == TType.STOP:
4431 
        break
4432 
      if fid == 0:
4433 
        if ftype == TType.BOOL:
4434 
          self.success = iprot.readBool();
4435 
        else:
4436 
          iprot.skip(ftype)
4437 
      elif fid == 1:
4438 
        if ftype == TType.STRUCT:
4439 
          self.ucx = UserContextException()
4440 
          self.ucx.read(iprot)
4441 
        else:
4442 
          iprot.skip(ftype)
4443 
      else:
4444 
        iprot.skip(ftype)
4445 
      iprot.readFieldEnd()
4446 
    iprot.readStructEnd()
4447 
 
4448 
  def write(self, oprot):
4449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4451 
      return
4452 
    oprot.writeStructBegin('sendNewPasswordByHandle_result')
4453 
    if self.success != None:
4454 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4455 
      oprot.writeBool(self.success)
4456 
      oprot.writeFieldEnd()
4457 
    if self.ucx != None:
4458 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4459 
      self.ucx.write(oprot)
4460 
      oprot.writeFieldEnd()
4461 
    oprot.writeFieldStop()
4462 
    oprot.writeStructEnd()
4463 
 
4464 
  def __repr__(self):
4465 
    L = ['%s=%r' % (key, value)
4466 
      for key, value in self.__dict__.iteritems()]
4467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4468 
 
4469 
  def __eq__(self, other):
4470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4471 
 
4472 
  def __ne__(self, other):
4473 
    return not (self == other)
4474 
 
4475