Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
349 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:
765 rajveer 19 
  def closeSession(self, ):
20 
    """
21 
    For closing the open session in sqlalchemy
22 
    """
23 
    pass
24 
 
1395 varun.gupt 25 
  def saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType):
26 
    """
27 
    Parameters:
28 
     - emailTo
29 
     - emailFrom
30 
     - subject
31 
     - body
32 
     - source
33 
     - emailType
34 
    """
35 
    pass
36 
 
1422 varun.gupt 37 
  def getEmailsToBeSent(self, emailType):
38 
    """
39 
    Parameters:
40 
     - emailType
41 
    """
42 
    pass
43 
 
44 
  def markEmailAsSent(self, emailId):
45 
    """
46 
    Parameters:
47 
     - emailId
48 
    """
49 
    pass
50 
 
349 ashish 51 
  def sendMail(self, mail):
52 
    """
53 
    Parameters:
54 
     - mail
55 
    """
56 
    pass
57 
 
58 
  def sendText(self, message):
59 
    """
60 
    Parameters:
61 
     - message
62 
    """
63 
    pass
64 
 
65 
  def addMessage(self, message):
66 
    """
67 
    Parameters:
68 
     - message
69 
    """
70 
    pass
71 
 
72 
  def updateMessage(self, id, message):
73 
    """
74 
    Parameters:
75 
     - id
76 
     - message
77 
    """
78 
    pass
79 
 
80 
  def getMessage(self, id):
81 
    """
82 
    Parameters:
83 
     - id
84 
    """
85 
    pass
86 
 
87 
  def getSubstitutedMessage(self, id, params):
88 
    """
89 
    Parameters:
90 
     - id
91 
     - params
92 
    """
93 
    pass
94 
 
494 rajveer 95 
  def addUser(self, username, password, warehouseId):
96 
    """
97 
    Parameters:
98 
     - username
99 
     - password
100 
     - warehouseId
101 
    """
102 
    pass
349 ashish 103 
 
494 rajveer 104 
  def deleteUser(self, username):
105 
    """
106 
    Parameters:
107 
     - username
108 
    """
109 
    pass
110 
 
111 
  def authenticateUser(self, username, password):
112 
    """
759 chandransh 113 
    Returns the warehouseId for the given user if the password matches. Returns -1 otherwise.
114 
    The loggedOn timestamp for the dashboard user is updated as a timestamp.
115 
    It's unclear to me when an exception is thrown : Chandranshu
116 
 
494 rajveer 117 
    Parameters:
118 
     - username
119 
     - password
120 
    """
121 
    pass
122 
 
123 
  def updatePassword(self, username, oldPassword, newPassword):
124 
    """
125 
    Parameters:
126 
     - username
127 
     - oldPassword
128 
     - newPassword
129 
    """
130 
    pass
131 
 
759 chandransh 132 
  def authenticateLogisticsUser(self, username, password):
133 
    """
134 
    Returns the LogisticsUser struct associated with the given username and password if they match.
135 
    Throws an exception otherwise.
136 
 
137 
    Parameters:
138 
     - username
139 
     - password
140 
    """
141 
    pass
494 rajveer 142 
 
1610 ankur.sing 143 
  def authenticateStatisticsUser(self, username, password):
144 
    """
145 
    Returns the StatisticsUser struct associated with the given username and password if they match.
146 
    Throws an exception otherwise.
147 
 
148 
    Parameters:
149 
     - username
150 
     - password
151 
    """
152 
    pass
759 chandransh 153 
 
1891 ankur.sing 154 
  def authenticateReportUser(self, username, password):
155 
    """
156 
    Returns the ReportUser struct associated with the given username and password if they match.
157 
    Throws an exception otherwise.
158 
 
159 
    Parameters:
160 
     - username
161 
     - password
162 
    """
163 
    pass
1610 ankur.sing 164 
 
1891 ankur.sing 165 
  def getReports(self, role):
166 
    """
167 
    Returns list of reports which are configured for the given role.
168 
 
169 
    Parameters:
170 
     - role
171 
    """
172 
    pass
173 
 
2358 ankur.sing 174 
  def authenticateCatalogUser(self, username, password, role):
2025 ankur.sing 175 
    """
2358 ankur.sing 176 
    Returns the CatalogDashboardUser struct associated with the given username, password and role if they match.
2025 ankur.sing 177 
    Throws an exception otherwise.
178 
 
179 
    Parameters:
180 
     - username
181 
     - password
2358 ankur.sing 182 
     - role
2025 ankur.sing 183 
    """
184 
    pass
1891 ankur.sing 185 
 
2025 ankur.sing 186 
 
349 ashish 187 
class Client(Iface):
188 
  def __init__(self, iprot, oprot=None):
189 
    self._iprot = self._oprot = iprot
190 
    if oprot != None:
191 
      self._oprot = oprot
192 
    self._seqid = 0
193 
 
765 rajveer 194 
  def closeSession(self, ):
195 
    """
196 
    For closing the open session in sqlalchemy
197 
    """
198 
    self.send_closeSession()
199 
    self.recv_closeSession()
200 
 
201 
  def send_closeSession(self, ):
202 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
203 
    args = closeSession_args()
204 
    args.write(self._oprot)
205 
    self._oprot.writeMessageEnd()
206 
    self._oprot.trans.flush()
207 
 
208 
  def recv_closeSession(self, ):
209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
210 
    if mtype == TMessageType.EXCEPTION:
211 
      x = TApplicationException()
212 
      x.read(self._iprot)
213 
      self._iprot.readMessageEnd()
214 
      raise x
215 
    result = closeSession_result()
216 
    result.read(self._iprot)
217 
    self._iprot.readMessageEnd()
218 
    return
219 
 
1395 varun.gupt 220 
  def saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType):
221 
    """
222 
    Parameters:
223 
     - emailTo
224 
     - emailFrom
225 
     - subject
226 
     - body
227 
     - source
228 
     - emailType
229 
    """
230 
    self.send_saveUserEmailForSending(emailTo, emailFrom, subject, body, source, emailType)
231 
    self.recv_saveUserEmailForSending()
232 
 
233 
  def send_saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType):
234 
    self._oprot.writeMessageBegin('saveUserEmailForSending', TMessageType.CALL, self._seqid)
235 
    args = saveUserEmailForSending_args()
236 
    args.emailTo = emailTo
237 
    args.emailFrom = emailFrom
238 
    args.subject = subject
239 
    args.body = body
240 
    args.source = source
241 
    args.emailType = emailType
242 
    args.write(self._oprot)
243 
    self._oprot.writeMessageEnd()
244 
    self._oprot.trans.flush()
245 
 
246 
  def recv_saveUserEmailForSending(self, ):
247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
248 
    if mtype == TMessageType.EXCEPTION:
249 
      x = TApplicationException()
250 
      x.read(self._iprot)
251 
      self._iprot.readMessageEnd()
252 
      raise x
253 
    result = saveUserEmailForSending_result()
254 
    result.read(self._iprot)
255 
    self._iprot.readMessageEnd()
256 
    if result.se != None:
257 
      raise result.se
258 
    return
259 
 
1422 varun.gupt 260 
  def getEmailsToBeSent(self, emailType):
261 
    """
262 
    Parameters:
263 
     - emailType
264 
    """
265 
    self.send_getEmailsToBeSent(emailType)
266 
    return self.recv_getEmailsToBeSent()
267 
 
268 
  def send_getEmailsToBeSent(self, emailType):
269 
    self._oprot.writeMessageBegin('getEmailsToBeSent', TMessageType.CALL, self._seqid)
270 
    args = getEmailsToBeSent_args()
271 
    args.emailType = emailType
272 
    args.write(self._oprot)
273 
    self._oprot.writeMessageEnd()
274 
    self._oprot.trans.flush()
275 
 
276 
  def recv_getEmailsToBeSent(self, ):
277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
278 
    if mtype == TMessageType.EXCEPTION:
279 
      x = TApplicationException()
280 
      x.read(self._iprot)
281 
      self._iprot.readMessageEnd()
282 
      raise x
283 
    result = getEmailsToBeSent_result()
284 
    result.read(self._iprot)
285 
    self._iprot.readMessageEnd()
286 
    if result.success != None:
287 
      return result.success
288 
    if result.se != None:
289 
      raise result.se
290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmailsToBeSent failed: unknown result");
291 
 
292 
  def markEmailAsSent(self, emailId):
293 
    """
294 
    Parameters:
295 
     - emailId
296 
    """
297 
    self.send_markEmailAsSent(emailId)
298 
    self.recv_markEmailAsSent()
299 
 
300 
  def send_markEmailAsSent(self, emailId):
301 
    self._oprot.writeMessageBegin('markEmailAsSent', TMessageType.CALL, self._seqid)
302 
    args = markEmailAsSent_args()
303 
    args.emailId = emailId
304 
    args.write(self._oprot)
305 
    self._oprot.writeMessageEnd()
306 
    self._oprot.trans.flush()
307 
 
308 
  def recv_markEmailAsSent(self, ):
309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
310 
    if mtype == TMessageType.EXCEPTION:
311 
      x = TApplicationException()
312 
      x.read(self._iprot)
313 
      self._iprot.readMessageEnd()
314 
      raise x
315 
    result = markEmailAsSent_result()
316 
    result.read(self._iprot)
317 
    self._iprot.readMessageEnd()
318 
    if result.se != None:
319 
      raise result.se
320 
    return
321 
 
349 ashish 322 
  def sendMail(self, mail):
323 
    """
324 
    Parameters:
325 
     - mail
326 
    """
327 
    self.send_sendMail(mail)
328 
    self.recv_sendMail()
329 
 
330 
  def send_sendMail(self, mail):
331 
    self._oprot.writeMessageBegin('sendMail', TMessageType.CALL, self._seqid)
332 
    args = sendMail_args()
333 
    args.mail = mail
334 
    args.write(self._oprot)
335 
    self._oprot.writeMessageEnd()
336 
    self._oprot.trans.flush()
337 
 
338 
  def recv_sendMail(self, ):
339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
340 
    if mtype == TMessageType.EXCEPTION:
341 
      x = TApplicationException()
342 
      x.read(self._iprot)
343 
      self._iprot.readMessageEnd()
344 
      raise x
345 
    result = sendMail_result()
346 
    result.read(self._iprot)
347 
    self._iprot.readMessageEnd()
348 
    if result.se != None:
349 
      raise result.se
350 
    return
351 
 
352 
  def sendText(self, message):
353 
    """
354 
    Parameters:
355 
     - message
356 
    """
357 
    self.send_sendText(message)
358 
    self.recv_sendText()
359 
 
360 
  def send_sendText(self, message):
361 
    self._oprot.writeMessageBegin('sendText', TMessageType.CALL, self._seqid)
362 
    args = sendText_args()
363 
    args.message = message
364 
    args.write(self._oprot)
365 
    self._oprot.writeMessageEnd()
366 
    self._oprot.trans.flush()
367 
 
368 
  def recv_sendText(self, ):
369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
370 
    if mtype == TMessageType.EXCEPTION:
371 
      x = TApplicationException()
372 
      x.read(self._iprot)
373 
      self._iprot.readMessageEnd()
374 
      raise x
375 
    result = sendText_result()
376 
    result.read(self._iprot)
377 
    self._iprot.readMessageEnd()
378 
    if result.se != None:
379 
      raise result.se
380 
    return
381 
 
382 
  def addMessage(self, message):
383 
    """
384 
    Parameters:
385 
     - message
386 
    """
387 
    self.send_addMessage(message)
388 
    self.recv_addMessage()
389 
 
390 
  def send_addMessage(self, message):
391 
    self._oprot.writeMessageBegin('addMessage', TMessageType.CALL, self._seqid)
392 
    args = addMessage_args()
393 
    args.message = message
394 
    args.write(self._oprot)
395 
    self._oprot.writeMessageEnd()
396 
    self._oprot.trans.flush()
397 
 
398 
  def recv_addMessage(self, ):
399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
400 
    if mtype == TMessageType.EXCEPTION:
401 
      x = TApplicationException()
402 
      x.read(self._iprot)
403 
      self._iprot.readMessageEnd()
404 
      raise x
405 
    result = addMessage_result()
406 
    result.read(self._iprot)
407 
    self._iprot.readMessageEnd()
408 
    if result.se != None:
409 
      raise result.se
410 
    return
411 
 
412 
  def updateMessage(self, id, message):
413 
    """
414 
    Parameters:
415 
     - id
416 
     - message
417 
    """
418 
    self.send_updateMessage(id, message)
419 
    self.recv_updateMessage()
420 
 
421 
  def send_updateMessage(self, id, message):
422 
    self._oprot.writeMessageBegin('updateMessage', TMessageType.CALL, self._seqid)
423 
    args = updateMessage_args()
424 
    args.id = id
425 
    args.message = message
426 
    args.write(self._oprot)
427 
    self._oprot.writeMessageEnd()
428 
    self._oprot.trans.flush()
429 
 
430 
  def recv_updateMessage(self, ):
431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
432 
    if mtype == TMessageType.EXCEPTION:
433 
      x = TApplicationException()
434 
      x.read(self._iprot)
435 
      self._iprot.readMessageEnd()
436 
      raise x
437 
    result = updateMessage_result()
438 
    result.read(self._iprot)
439 
    self._iprot.readMessageEnd()
440 
    if result.se != None:
441 
      raise result.se
442 
    return
443 
 
444 
  def getMessage(self, id):
445 
    """
446 
    Parameters:
447 
     - id
448 
    """
449 
    self.send_getMessage(id)
353 ashish 450 
    return self.recv_getMessage()
349 ashish 451 
 
452 
  def send_getMessage(self, id):
453 
    self._oprot.writeMessageBegin('getMessage', TMessageType.CALL, self._seqid)
454 
    args = getMessage_args()
455 
    args.id = id
456 
    args.write(self._oprot)
457 
    self._oprot.writeMessageEnd()
458 
    self._oprot.trans.flush()
459 
 
460 
  def recv_getMessage(self, ):
461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
462 
    if mtype == TMessageType.EXCEPTION:
463 
      x = TApplicationException()
464 
      x.read(self._iprot)
465 
      self._iprot.readMessageEnd()
466 
      raise x
467 
    result = getMessage_result()
468 
    result.read(self._iprot)
469 
    self._iprot.readMessageEnd()
353 ashish 470 
    if result.success != None:
471 
      return result.success
349 ashish 472 
    if result.se != None:
473 
      raise result.se
353 ashish 474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMessage failed: unknown result");
349 ashish 475 
 
476 
  def getSubstitutedMessage(self, id, params):
477 
    """
478 
    Parameters:
479 
     - id
480 
     - params
481 
    """
482 
    self.send_getSubstitutedMessage(id, params)
353 ashish 483 
    return self.recv_getSubstitutedMessage()
349 ashish 484 
 
485 
  def send_getSubstitutedMessage(self, id, params):
486 
    self._oprot.writeMessageBegin('getSubstitutedMessage', TMessageType.CALL, self._seqid)
487 
    args = getSubstitutedMessage_args()
488 
    args.id = id
489 
    args.params = params
490 
    args.write(self._oprot)
491 
    self._oprot.writeMessageEnd()
492 
    self._oprot.trans.flush()
493 
 
494 
  def recv_getSubstitutedMessage(self, ):
495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
496 
    if mtype == TMessageType.EXCEPTION:
497 
      x = TApplicationException()
498 
      x.read(self._iprot)
499 
      self._iprot.readMessageEnd()
500 
      raise x
501 
    result = getSubstitutedMessage_result()
502 
    result.read(self._iprot)
503 
    self._iprot.readMessageEnd()
353 ashish 504 
    if result.success != None:
505 
      return result.success
349 ashish 506 
    if result.se != None:
507 
      raise result.se
353 ashish 508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSubstitutedMessage failed: unknown result");
349 ashish 509 
 
494 rajveer 510 
  def addUser(self, username, password, warehouseId):
511 
    """
512 
    Parameters:
513 
     - username
514 
     - password
515 
     - warehouseId
516 
    """
517 
    self.send_addUser(username, password, warehouseId)
518 
    return self.recv_addUser()
349 ashish 519 
 
494 rajveer 520 
  def send_addUser(self, username, password, warehouseId):
521 
    self._oprot.writeMessageBegin('addUser', TMessageType.CALL, self._seqid)
522 
    args = addUser_args()
523 
    args.username = username
524 
    args.password = password
525 
    args.warehouseId = warehouseId
526 
    args.write(self._oprot)
527 
    self._oprot.writeMessageEnd()
528 
    self._oprot.trans.flush()
529 
 
530 
  def recv_addUser(self, ):
531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
532 
    if mtype == TMessageType.EXCEPTION:
533 
      x = TApplicationException()
534 
      x.read(self._iprot)
535 
      self._iprot.readMessageEnd()
536 
      raise x
537 
    result = addUser_result()
538 
    result.read(self._iprot)
539 
    self._iprot.readMessageEnd()
540 
    if result.success != None:
541 
      return result.success
542 
    if result.se != None:
543 
      raise result.se
544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addUser failed: unknown result");
545 
 
546 
  def deleteUser(self, username):
547 
    """
548 
    Parameters:
549 
     - username
550 
    """
551 
    self.send_deleteUser(username)
552 
    return self.recv_deleteUser()
553 
 
554 
  def send_deleteUser(self, username):
555 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
556 
    args = deleteUser_args()
557 
    args.username = username
558 
    args.write(self._oprot)
559 
    self._oprot.writeMessageEnd()
560 
    self._oprot.trans.flush()
561 
 
562 
  def recv_deleteUser(self, ):
563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
564 
    if mtype == TMessageType.EXCEPTION:
565 
      x = TApplicationException()
566 
      x.read(self._iprot)
567 
      self._iprot.readMessageEnd()
568 
      raise x
569 
    result = deleteUser_result()
570 
    result.read(self._iprot)
571 
    self._iprot.readMessageEnd()
572 
    if result.success != None:
573 
      return result.success
574 
    if result.se != None:
575 
      raise result.se
576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
577 
 
578 
  def authenticateUser(self, username, password):
579 
    """
759 chandransh 580 
    Returns the warehouseId for the given user if the password matches. Returns -1 otherwise.
581 
    The loggedOn timestamp for the dashboard user is updated as a timestamp.
582 
    It's unclear to me when an exception is thrown : Chandranshu
583 
 
494 rajveer 584 
    Parameters:
585 
     - username
586 
     - password
587 
    """
588 
    self.send_authenticateUser(username, password)
589 
    return self.recv_authenticateUser()
590 
 
591 
  def send_authenticateUser(self, username, password):
592 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
593 
    args = authenticateUser_args()
594 
    args.username = username
595 
    args.password = password
596 
    args.write(self._oprot)
597 
    self._oprot.writeMessageEnd()
598 
    self._oprot.trans.flush()
599 
 
600 
  def recv_authenticateUser(self, ):
601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
602 
    if mtype == TMessageType.EXCEPTION:
603 
      x = TApplicationException()
604 
      x.read(self._iprot)
605 
      self._iprot.readMessageEnd()
606 
      raise x
607 
    result = authenticateUser_result()
608 
    result.read(self._iprot)
609 
    self._iprot.readMessageEnd()
610 
    if result.success != None:
611 
      return result.success
612 
    if result.se != None:
613 
      raise result.se
614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
615 
 
616 
  def updatePassword(self, username, oldPassword, newPassword):
617 
    """
618 
    Parameters:
619 
     - username
620 
     - oldPassword
621 
     - newPassword
622 
    """
623 
    self.send_updatePassword(username, oldPassword, newPassword)
624 
    return self.recv_updatePassword()
625 
 
626 
  def send_updatePassword(self, username, oldPassword, newPassword):
627 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
628 
    args = updatePassword_args()
629 
    args.username = username
630 
    args.oldPassword = oldPassword
631 
    args.newPassword = newPassword
632 
    args.write(self._oprot)
633 
    self._oprot.writeMessageEnd()
634 
    self._oprot.trans.flush()
635 
 
636 
  def recv_updatePassword(self, ):
637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
638 
    if mtype == TMessageType.EXCEPTION:
639 
      x = TApplicationException()
640 
      x.read(self._iprot)
641 
      self._iprot.readMessageEnd()
642 
      raise x
643 
    result = updatePassword_result()
644 
    result.read(self._iprot)
645 
    self._iprot.readMessageEnd()
646 
    if result.success != None:
647 
      return result.success
648 
    if result.se != None:
649 
      raise result.se
650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
651 
 
759 chandransh 652 
  def authenticateLogisticsUser(self, username, password):
653 
    """
654 
    Returns the LogisticsUser struct associated with the given username and password if they match.
655 
    Throws an exception otherwise.
656 
 
657 
    Parameters:
658 
     - username
659 
     - password
660 
    """
661 
    self.send_authenticateLogisticsUser(username, password)
662 
    return self.recv_authenticateLogisticsUser()
494 rajveer 663 
 
759 chandransh 664 
  def send_authenticateLogisticsUser(self, username, password):
665 
    self._oprot.writeMessageBegin('authenticateLogisticsUser', TMessageType.CALL, self._seqid)
666 
    args = authenticateLogisticsUser_args()
667 
    args.username = username
668 
    args.password = password
669 
    args.write(self._oprot)
670 
    self._oprot.writeMessageEnd()
671 
    self._oprot.trans.flush()
672 
 
673 
  def recv_authenticateLogisticsUser(self, ):
674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
675 
    if mtype == TMessageType.EXCEPTION:
676 
      x = TApplicationException()
677 
      x.read(self._iprot)
678 
      self._iprot.readMessageEnd()
679 
      raise x
680 
    result = authenticateLogisticsUser_result()
681 
    result.read(self._iprot)
682 
    self._iprot.readMessageEnd()
683 
    if result.success != None:
684 
      return result.success
685 
    if result.hse != None:
686 
      raise result.hse
687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateLogisticsUser failed: unknown result");
688 
 
1610 ankur.sing 689 
  def authenticateStatisticsUser(self, username, password):
690 
    """
691 
    Returns the StatisticsUser struct associated with the given username and password if they match.
692 
    Throws an exception otherwise.
693 
 
694 
    Parameters:
695 
     - username
696 
     - password
697 
    """
698 
    self.send_authenticateStatisticsUser(username, password)
699 
    return self.recv_authenticateStatisticsUser()
759 chandransh 700 
 
1610 ankur.sing 701 
  def send_authenticateStatisticsUser(self, username, password):
702 
    self._oprot.writeMessageBegin('authenticateStatisticsUser', TMessageType.CALL, self._seqid)
703 
    args = authenticateStatisticsUser_args()
704 
    args.username = username
705 
    args.password = password
706 
    args.write(self._oprot)
707 
    self._oprot.writeMessageEnd()
708 
    self._oprot.trans.flush()
709 
 
710 
  def recv_authenticateStatisticsUser(self, ):
711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
712 
    if mtype == TMessageType.EXCEPTION:
713 
      x = TApplicationException()
714 
      x.read(self._iprot)
715 
      self._iprot.readMessageEnd()
716 
      raise x
717 
    result = authenticateStatisticsUser_result()
718 
    result.read(self._iprot)
719 
    self._iprot.readMessageEnd()
720 
    if result.success != None:
721 
      return result.success
722 
    if result.hse != None:
723 
      raise result.hse
724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateStatisticsUser failed: unknown result");
725 
 
1891 ankur.sing 726 
  def authenticateReportUser(self, username, password):
727 
    """
728 
    Returns the ReportUser struct associated with the given username and password if they match.
729 
    Throws an exception otherwise.
730 
 
731 
    Parameters:
732 
     - username
733 
     - password
734 
    """
735 
    self.send_authenticateReportUser(username, password)
736 
    return self.recv_authenticateReportUser()
1610 ankur.sing 737 
 
1891 ankur.sing 738 
  def send_authenticateReportUser(self, username, password):
739 
    self._oprot.writeMessageBegin('authenticateReportUser', TMessageType.CALL, self._seqid)
740 
    args = authenticateReportUser_args()
741 
    args.username = username
742 
    args.password = password
743 
    args.write(self._oprot)
744 
    self._oprot.writeMessageEnd()
745 
    self._oprot.trans.flush()
746 
 
747 
  def recv_authenticateReportUser(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 = authenticateReportUser_result()
755 
    result.read(self._iprot)
756 
    self._iprot.readMessageEnd()
757 
    if result.success != None:
758 
      return result.success
759 
    if result.hse != None:
760 
      raise result.hse
761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateReportUser failed: unknown result");
762 
 
763 
  def getReports(self, role):
764 
    """
765 
    Returns list of reports which are configured for the given role.
766 
 
767 
    Parameters:
768 
     - role
769 
    """
770 
    self.send_getReports(role)
771 
    return self.recv_getReports()
772 
 
773 
  def send_getReports(self, role):
774 
    self._oprot.writeMessageBegin('getReports', TMessageType.CALL, self._seqid)
775 
    args = getReports_args()
776 
    args.role = role
777 
    args.write(self._oprot)
778 
    self._oprot.writeMessageEnd()
779 
    self._oprot.trans.flush()
780 
 
781 
  def recv_getReports(self, ):
782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
783 
    if mtype == TMessageType.EXCEPTION:
784 
      x = TApplicationException()
785 
      x.read(self._iprot)
786 
      self._iprot.readMessageEnd()
787 
      raise x
788 
    result = getReports_result()
789 
    result.read(self._iprot)
790 
    self._iprot.readMessageEnd()
791 
    if result.success != None:
792 
      return result.success
793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReports failed: unknown result");
794 
 
2358 ankur.sing 795 
  def authenticateCatalogUser(self, username, password, role):
2025 ankur.sing 796 
    """
2358 ankur.sing 797 
    Returns the CatalogDashboardUser struct associated with the given username, password and role if they match.
2025 ankur.sing 798 
    Throws an exception otherwise.
799 
 
800 
    Parameters:
801 
     - username
802 
     - password
2358 ankur.sing 803 
     - role
2025 ankur.sing 804 
    """
2358 ankur.sing 805 
    self.send_authenticateCatalogUser(username, password, role)
2025 ankur.sing 806 
    return self.recv_authenticateCatalogUser()
1891 ankur.sing 807 
 
2358 ankur.sing 808 
  def send_authenticateCatalogUser(self, username, password, role):
2025 ankur.sing 809 
    self._oprot.writeMessageBegin('authenticateCatalogUser', TMessageType.CALL, self._seqid)
810 
    args = authenticateCatalogUser_args()
811 
    args.username = username
812 
    args.password = password
2358 ankur.sing 813 
    args.role = role
2025 ankur.sing 814 
    args.write(self._oprot)
815 
    self._oprot.writeMessageEnd()
816 
    self._oprot.trans.flush()
817 
 
818 
  def recv_authenticateCatalogUser(self, ):
819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
820 
    if mtype == TMessageType.EXCEPTION:
821 
      x = TApplicationException()
822 
      x.read(self._iprot)
823 
      self._iprot.readMessageEnd()
824 
      raise x
825 
    result = authenticateCatalogUser_result()
826 
    result.read(self._iprot)
827 
    self._iprot.readMessageEnd()
828 
    if result.success != None:
829 
      return result.success
830 
    if result.hse != None:
831 
      raise result.hse
832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateCatalogUser failed: unknown result");
833 
 
834 
 
349 ashish 835 
class Processor(Iface, TProcessor):
836 
  def __init__(self, handler):
837 
    self._handler = handler
838 
    self._processMap = {}
765 rajveer 839 
    self._processMap["closeSession"] = Processor.process_closeSession
1395 varun.gupt 840 
    self._processMap["saveUserEmailForSending"] = Processor.process_saveUserEmailForSending
1422 varun.gupt 841 
    self._processMap["getEmailsToBeSent"] = Processor.process_getEmailsToBeSent
842 
    self._processMap["markEmailAsSent"] = Processor.process_markEmailAsSent
349 ashish 843 
    self._processMap["sendMail"] = Processor.process_sendMail
844 
    self._processMap["sendText"] = Processor.process_sendText
845 
    self._processMap["addMessage"] = Processor.process_addMessage
846 
    self._processMap["updateMessage"] = Processor.process_updateMessage
847 
    self._processMap["getMessage"] = Processor.process_getMessage
848 
    self._processMap["getSubstitutedMessage"] = Processor.process_getSubstitutedMessage
494 rajveer 849 
    self._processMap["addUser"] = Processor.process_addUser
850 
    self._processMap["deleteUser"] = Processor.process_deleteUser
851 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
852 
    self._processMap["updatePassword"] = Processor.process_updatePassword
759 chandransh 853 
    self._processMap["authenticateLogisticsUser"] = Processor.process_authenticateLogisticsUser
1610 ankur.sing 854 
    self._processMap["authenticateStatisticsUser"] = Processor.process_authenticateStatisticsUser
1891 ankur.sing 855 
    self._processMap["authenticateReportUser"] = Processor.process_authenticateReportUser
856 
    self._processMap["getReports"] = Processor.process_getReports
2025 ankur.sing 857 
    self._processMap["authenticateCatalogUser"] = Processor.process_authenticateCatalogUser
349 ashish 858 
 
859 
  def process(self, iprot, oprot):
860 
    (name, type, seqid) = iprot.readMessageBegin()
861 
    if name not in self._processMap:
862 
      iprot.skip(TType.STRUCT)
863 
      iprot.readMessageEnd()
864 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
865 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
866 
      x.write(oprot)
867 
      oprot.writeMessageEnd()
868 
      oprot.trans.flush()
869 
      return
870 
    else:
871 
      self._processMap[name](self, seqid, iprot, oprot)
872 
    return True
873 
 
765 rajveer 874 
  def process_closeSession(self, seqid, iprot, oprot):
875 
    args = closeSession_args()
876 
    args.read(iprot)
877 
    iprot.readMessageEnd()
878 
    result = closeSession_result()
879 
    self._handler.closeSession()
880 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
881 
    result.write(oprot)
882 
    oprot.writeMessageEnd()
883 
    oprot.trans.flush()
884 
 
1395 varun.gupt 885 
  def process_saveUserEmailForSending(self, seqid, iprot, oprot):
886 
    args = saveUserEmailForSending_args()
887 
    args.read(iprot)
888 
    iprot.readMessageEnd()
889 
    result = saveUserEmailForSending_result()
890 
    try:
891 
      self._handler.saveUserEmailForSending(args.emailTo, args.emailFrom, args.subject, args.body, args.source, args.emailType)
892 
    except HelperServiceException, se:
893 
      result.se = se
894 
    oprot.writeMessageBegin("saveUserEmailForSending", TMessageType.REPLY, seqid)
895 
    result.write(oprot)
896 
    oprot.writeMessageEnd()
897 
    oprot.trans.flush()
898 
 
1422 varun.gupt 899 
  def process_getEmailsToBeSent(self, seqid, iprot, oprot):
900 
    args = getEmailsToBeSent_args()
901 
    args.read(iprot)
902 
    iprot.readMessageEnd()
903 
    result = getEmailsToBeSent_result()
904 
    try:
905 
      result.success = self._handler.getEmailsToBeSent(args.emailType)
906 
    except HelperServiceException, se:
907 
      result.se = se
908 
    oprot.writeMessageBegin("getEmailsToBeSent", TMessageType.REPLY, seqid)
909 
    result.write(oprot)
910 
    oprot.writeMessageEnd()
911 
    oprot.trans.flush()
912 
 
913 
  def process_markEmailAsSent(self, seqid, iprot, oprot):
914 
    args = markEmailAsSent_args()
915 
    args.read(iprot)
916 
    iprot.readMessageEnd()
917 
    result = markEmailAsSent_result()
918 
    try:
919 
      self._handler.markEmailAsSent(args.emailId)
920 
    except HelperServiceException, se:
921 
      result.se = se
922 
    oprot.writeMessageBegin("markEmailAsSent", TMessageType.REPLY, seqid)
923 
    result.write(oprot)
924 
    oprot.writeMessageEnd()
925 
    oprot.trans.flush()
926 
 
349 ashish 927 
  def process_sendMail(self, seqid, iprot, oprot):
928 
    args = sendMail_args()
929 
    args.read(iprot)
930 
    iprot.readMessageEnd()
931 
    result = sendMail_result()
932 
    try:
933 
      self._handler.sendMail(args.mail)
934 
    except HelperServiceException, se:
935 
      result.se = se
936 
    oprot.writeMessageBegin("sendMail", TMessageType.REPLY, seqid)
937 
    result.write(oprot)
938 
    oprot.writeMessageEnd()
939 
    oprot.trans.flush()
940 
 
941 
  def process_sendText(self, seqid, iprot, oprot):
942 
    args = sendText_args()
943 
    args.read(iprot)
944 
    iprot.readMessageEnd()
945 
    result = sendText_result()
946 
    try:
947 
      self._handler.sendText(args.message)
948 
    except HelperServiceException, se:
949 
      result.se = se
950 
    oprot.writeMessageBegin("sendText", TMessageType.REPLY, seqid)
951 
    result.write(oprot)
952 
    oprot.writeMessageEnd()
953 
    oprot.trans.flush()
954 
 
955 
  def process_addMessage(self, seqid, iprot, oprot):
956 
    args = addMessage_args()
957 
    args.read(iprot)
958 
    iprot.readMessageEnd()
959 
    result = addMessage_result()
960 
    try:
961 
      self._handler.addMessage(args.message)
962 
    except HelperServiceException, se:
963 
      result.se = se
964 
    oprot.writeMessageBegin("addMessage", TMessageType.REPLY, seqid)
965 
    result.write(oprot)
966 
    oprot.writeMessageEnd()
967 
    oprot.trans.flush()
968 
 
969 
  def process_updateMessage(self, seqid, iprot, oprot):
970 
    args = updateMessage_args()
971 
    args.read(iprot)
972 
    iprot.readMessageEnd()
973 
    result = updateMessage_result()
974 
    try:
975 
      self._handler.updateMessage(args.id, args.message)
976 
    except HelperServiceException, se:
977 
      result.se = se
978 
    oprot.writeMessageBegin("updateMessage", TMessageType.REPLY, seqid)
979 
    result.write(oprot)
980 
    oprot.writeMessageEnd()
981 
    oprot.trans.flush()
982 
 
983 
  def process_getMessage(self, seqid, iprot, oprot):
984 
    args = getMessage_args()
985 
    args.read(iprot)
986 
    iprot.readMessageEnd()
987 
    result = getMessage_result()
988 
    try:
353 ashish 989 
      result.success = self._handler.getMessage(args.id)
349 ashish 990 
    except HelperServiceException, se:
991 
      result.se = se
992 
    oprot.writeMessageBegin("getMessage", TMessageType.REPLY, seqid)
993 
    result.write(oprot)
994 
    oprot.writeMessageEnd()
995 
    oprot.trans.flush()
996 
 
997 
  def process_getSubstitutedMessage(self, seqid, iprot, oprot):
998 
    args = getSubstitutedMessage_args()
999 
    args.read(iprot)
1000 
    iprot.readMessageEnd()
1001 
    result = getSubstitutedMessage_result()
1002 
    try:
353 ashish 1003 
      result.success = self._handler.getSubstitutedMessage(args.id, args.params)
349 ashish 1004 
    except HelperServiceException, se:
1005 
      result.se = se
1006 
    oprot.writeMessageBegin("getSubstitutedMessage", TMessageType.REPLY, seqid)
1007 
    result.write(oprot)
1008 
    oprot.writeMessageEnd()
1009 
    oprot.trans.flush()
1010 
 
494 rajveer 1011 
  def process_addUser(self, seqid, iprot, oprot):
1012 
    args = addUser_args()
1013 
    args.read(iprot)
1014 
    iprot.readMessageEnd()
1015 
    result = addUser_result()
1016 
    try:
1017 
      result.success = self._handler.addUser(args.username, args.password, args.warehouseId)
1018 
    except HelperServiceException, se:
1019 
      result.se = se
1020 
    oprot.writeMessageBegin("addUser", TMessageType.REPLY, seqid)
1021 
    result.write(oprot)
1022 
    oprot.writeMessageEnd()
1023 
    oprot.trans.flush()
349 ashish 1024 
 
494 rajveer 1025 
  def process_deleteUser(self, seqid, iprot, oprot):
1026 
    args = deleteUser_args()
1027 
    args.read(iprot)
1028 
    iprot.readMessageEnd()
1029 
    result = deleteUser_result()
1030 
    try:
1031 
      result.success = self._handler.deleteUser(args.username)
1032 
    except HelperServiceException, se:
1033 
      result.se = se
1034 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
1035 
    result.write(oprot)
1036 
    oprot.writeMessageEnd()
1037 
    oprot.trans.flush()
1038 
 
1039 
  def process_authenticateUser(self, seqid, iprot, oprot):
1040 
    args = authenticateUser_args()
1041 
    args.read(iprot)
1042 
    iprot.readMessageEnd()
1043 
    result = authenticateUser_result()
1044 
    try:
1045 
      result.success = self._handler.authenticateUser(args.username, args.password)
1046 
    except HelperServiceException, se:
1047 
      result.se = se
1048 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
1049 
    result.write(oprot)
1050 
    oprot.writeMessageEnd()
1051 
    oprot.trans.flush()
1052 
 
1053 
  def process_updatePassword(self, seqid, iprot, oprot):
1054 
    args = updatePassword_args()
1055 
    args.read(iprot)
1056 
    iprot.readMessageEnd()
1057 
    result = updatePassword_result()
1058 
    try:
1059 
      result.success = self._handler.updatePassword(args.username, args.oldPassword, args.newPassword)
1060 
    except HelperServiceException, se:
1061 
      result.se = se
1062 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
1063 
    result.write(oprot)
1064 
    oprot.writeMessageEnd()
1065 
    oprot.trans.flush()
1066 
 
759 chandransh 1067 
  def process_authenticateLogisticsUser(self, seqid, iprot, oprot):
1068 
    args = authenticateLogisticsUser_args()
1069 
    args.read(iprot)
1070 
    iprot.readMessageEnd()
1071 
    result = authenticateLogisticsUser_result()
1072 
    try:
1073 
      result.success = self._handler.authenticateLogisticsUser(args.username, args.password)
1074 
    except HelperServiceException, hse:
1075 
      result.hse = hse
1076 
    oprot.writeMessageBegin("authenticateLogisticsUser", TMessageType.REPLY, seqid)
1077 
    result.write(oprot)
1078 
    oprot.writeMessageEnd()
1079 
    oprot.trans.flush()
494 rajveer 1080 
 
1610 ankur.sing 1081 
  def process_authenticateStatisticsUser(self, seqid, iprot, oprot):
1082 
    args = authenticateStatisticsUser_args()
1083 
    args.read(iprot)
1084 
    iprot.readMessageEnd()
1085 
    result = authenticateStatisticsUser_result()
1086 
    try:
1087 
      result.success = self._handler.authenticateStatisticsUser(args.username, args.password)
1088 
    except HelperServiceException, hse:
1089 
      result.hse = hse
1090 
    oprot.writeMessageBegin("authenticateStatisticsUser", TMessageType.REPLY, seqid)
1091 
    result.write(oprot)
1092 
    oprot.writeMessageEnd()
1093 
    oprot.trans.flush()
759 chandransh 1094 
 
1891 ankur.sing 1095 
  def process_authenticateReportUser(self, seqid, iprot, oprot):
1096 
    args = authenticateReportUser_args()
1097 
    args.read(iprot)
1098 
    iprot.readMessageEnd()
1099 
    result = authenticateReportUser_result()
1100 
    try:
1101 
      result.success = self._handler.authenticateReportUser(args.username, args.password)
1102 
    except HelperServiceException, hse:
1103 
      result.hse = hse
1104 
    oprot.writeMessageBegin("authenticateReportUser", TMessageType.REPLY, seqid)
1105 
    result.write(oprot)
1106 
    oprot.writeMessageEnd()
1107 
    oprot.trans.flush()
1610 ankur.sing 1108 
 
1891 ankur.sing 1109 
  def process_getReports(self, seqid, iprot, oprot):
1110 
    args = getReports_args()
1111 
    args.read(iprot)
1112 
    iprot.readMessageEnd()
1113 
    result = getReports_result()
1114 
    result.success = self._handler.getReports(args.role)
1115 
    oprot.writeMessageBegin("getReports", TMessageType.REPLY, seqid)
1116 
    result.write(oprot)
1117 
    oprot.writeMessageEnd()
1118 
    oprot.trans.flush()
1119 
 
2025 ankur.sing 1120 
  def process_authenticateCatalogUser(self, seqid, iprot, oprot):
1121 
    args = authenticateCatalogUser_args()
1122 
    args.read(iprot)
1123 
    iprot.readMessageEnd()
1124 
    result = authenticateCatalogUser_result()
1125 
    try:
2358 ankur.sing 1126 
      result.success = self._handler.authenticateCatalogUser(args.username, args.password, args.role)
2025 ankur.sing 1127 
    except HelperServiceException, hse:
1128 
      result.hse = hse
1129 
    oprot.writeMessageBegin("authenticateCatalogUser", TMessageType.REPLY, seqid)
1130 
    result.write(oprot)
1131 
    oprot.writeMessageEnd()
1132 
    oprot.trans.flush()
1891 ankur.sing 1133 
 
2025 ankur.sing 1134 
 
349 ashish 1135 
# HELPER FUNCTIONS AND STRUCTURES
1136 
 
765 rajveer 1137 
class closeSession_args:
1138 
 
1139 
  thrift_spec = (
1140 
  )
1141 
 
1142 
  def read(self, iprot):
1143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1145 
      return
1146 
    iprot.readStructBegin()
1147 
    while True:
1148 
      (fname, ftype, fid) = iprot.readFieldBegin()
1149 
      if ftype == TType.STOP:
1150 
        break
1151 
      else:
1152 
        iprot.skip(ftype)
1153 
      iprot.readFieldEnd()
1154 
    iprot.readStructEnd()
1155 
 
1156 
  def write(self, oprot):
1157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1159 
      return
1160 
    oprot.writeStructBegin('closeSession_args')
1161 
    oprot.writeFieldStop()
1162 
    oprot.writeStructEnd()
1163 
 
1164 
  def __repr__(self):
1165 
    L = ['%s=%r' % (key, value)
1166 
      for key, value in self.__dict__.iteritems()]
1167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1168 
 
1169 
  def __eq__(self, other):
1170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1171 
 
1172 
  def __ne__(self, other):
1173 
    return not (self == other)
1174 
 
1175 
class closeSession_result:
1176 
 
1177 
  thrift_spec = (
1178 
  )
1179 
 
1180 
  def read(self, iprot):
1181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1183 
      return
1184 
    iprot.readStructBegin()
1185 
    while True:
1186 
      (fname, ftype, fid) = iprot.readFieldBegin()
1187 
      if ftype == TType.STOP:
1188 
        break
1189 
      else:
1190 
        iprot.skip(ftype)
1191 
      iprot.readFieldEnd()
1192 
    iprot.readStructEnd()
1193 
 
1194 
  def write(self, oprot):
1195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1197 
      return
1198 
    oprot.writeStructBegin('closeSession_result')
1199 
    oprot.writeFieldStop()
1200 
    oprot.writeStructEnd()
1201 
 
1202 
  def __repr__(self):
1203 
    L = ['%s=%r' % (key, value)
1204 
      for key, value in self.__dict__.iteritems()]
1205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1206 
 
1207 
  def __eq__(self, other):
1208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1209 
 
1210 
  def __ne__(self, other):
1211 
    return not (self == other)
1212 
 
1395 varun.gupt 1213 
class saveUserEmailForSending_args:
1214 
  """
1215 
  Attributes:
1216 
   - emailTo
1217 
   - emailFrom
1218 
   - subject
1219 
   - body
1220 
   - source
1221 
   - emailType
1222 
  """
1223 
 
1224 
  thrift_spec = (
1225 
    None, # 0
1226 
    (1, TType.STRING, 'emailTo', None, None, ), # 1
1227 
    (2, TType.STRING, 'emailFrom', None, None, ), # 2
1228 
    (3, TType.STRING, 'subject', None, None, ), # 3
1229 
    (4, TType.STRING, 'body', None, None, ), # 4
1230 
    (5, TType.STRING, 'source', None, None, ), # 5
1231 
    (6, TType.STRING, 'emailType', None, None, ), # 6
1232 
  )
1233 
 
1234 
  def __init__(self, emailTo=None, emailFrom=None, subject=None, body=None, source=None, emailType=None,):
1235 
    self.emailTo = emailTo
1236 
    self.emailFrom = emailFrom
1237 
    self.subject = subject
1238 
    self.body = body
1239 
    self.source = source
1240 
    self.emailType = emailType
1241 
 
1242 
  def read(self, iprot):
1243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1245 
      return
1246 
    iprot.readStructBegin()
1247 
    while True:
1248 
      (fname, ftype, fid) = iprot.readFieldBegin()
1249 
      if ftype == TType.STOP:
1250 
        break
1251 
      if fid == 1:
1252 
        if ftype == TType.STRING:
1253 
          self.emailTo = iprot.readString();
1254 
        else:
1255 
          iprot.skip(ftype)
1256 
      elif fid == 2:
1257 
        if ftype == TType.STRING:
1258 
          self.emailFrom = iprot.readString();
1259 
        else:
1260 
          iprot.skip(ftype)
1261 
      elif fid == 3:
1262 
        if ftype == TType.STRING:
1263 
          self.subject = iprot.readString();
1264 
        else:
1265 
          iprot.skip(ftype)
1266 
      elif fid == 4:
1267 
        if ftype == TType.STRING:
1268 
          self.body = iprot.readString();
1269 
        else:
1270 
          iprot.skip(ftype)
1271 
      elif fid == 5:
1272 
        if ftype == TType.STRING:
1273 
          self.source = iprot.readString();
1274 
        else:
1275 
          iprot.skip(ftype)
1276 
      elif fid == 6:
1277 
        if ftype == TType.STRING:
1278 
          self.emailType = iprot.readString();
1279 
        else:
1280 
          iprot.skip(ftype)
1281 
      else:
1282 
        iprot.skip(ftype)
1283 
      iprot.readFieldEnd()
1284 
    iprot.readStructEnd()
1285 
 
1286 
  def write(self, oprot):
1287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1289 
      return
1290 
    oprot.writeStructBegin('saveUserEmailForSending_args')
1291 
    if self.emailTo != None:
1292 
      oprot.writeFieldBegin('emailTo', TType.STRING, 1)
1293 
      oprot.writeString(self.emailTo)
1294 
      oprot.writeFieldEnd()
1295 
    if self.emailFrom != None:
1296 
      oprot.writeFieldBegin('emailFrom', TType.STRING, 2)
1297 
      oprot.writeString(self.emailFrom)
1298 
      oprot.writeFieldEnd()
1299 
    if self.subject != None:
1300 
      oprot.writeFieldBegin('subject', TType.STRING, 3)
1301 
      oprot.writeString(self.subject)
1302 
      oprot.writeFieldEnd()
1303 
    if self.body != None:
1304 
      oprot.writeFieldBegin('body', TType.STRING, 4)
1305 
      oprot.writeString(self.body)
1306 
      oprot.writeFieldEnd()
1307 
    if self.source != None:
1308 
      oprot.writeFieldBegin('source', TType.STRING, 5)
1309 
      oprot.writeString(self.source)
1310 
      oprot.writeFieldEnd()
1311 
    if self.emailType != None:
1312 
      oprot.writeFieldBegin('emailType', TType.STRING, 6)
1313 
      oprot.writeString(self.emailType)
1314 
      oprot.writeFieldEnd()
1315 
    oprot.writeFieldStop()
1316 
    oprot.writeStructEnd()
1317 
 
1318 
  def __repr__(self):
1319 
    L = ['%s=%r' % (key, value)
1320 
      for key, value in self.__dict__.iteritems()]
1321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1322 
 
1323 
  def __eq__(self, other):
1324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1325 
 
1326 
  def __ne__(self, other):
1327 
    return not (self == other)
1328 
 
1329 
class saveUserEmailForSending_result:
1330 
  """
1331 
  Attributes:
1332 
   - se
1333 
  """
1334 
 
1335 
  thrift_spec = (
1336 
    None, # 0
1337 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1338 
  )
1339 
 
1340 
  def __init__(self, se=None,):
1341 
    self.se = se
1342 
 
1343 
  def read(self, iprot):
1344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1346 
      return
1347 
    iprot.readStructBegin()
1348 
    while True:
1349 
      (fname, ftype, fid) = iprot.readFieldBegin()
1350 
      if ftype == TType.STOP:
1351 
        break
1352 
      if fid == 1:
1353 
        if ftype == TType.STRUCT:
1354 
          self.se = HelperServiceException()
1355 
          self.se.read(iprot)
1356 
        else:
1357 
          iprot.skip(ftype)
1358 
      else:
1359 
        iprot.skip(ftype)
1360 
      iprot.readFieldEnd()
1361 
    iprot.readStructEnd()
1362 
 
1363 
  def write(self, oprot):
1364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1366 
      return
1367 
    oprot.writeStructBegin('saveUserEmailForSending_result')
1368 
    if self.se != None:
1369 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1370 
      self.se.write(oprot)
1371 
      oprot.writeFieldEnd()
1372 
    oprot.writeFieldStop()
1373 
    oprot.writeStructEnd()
1374 
 
1375 
  def __repr__(self):
1376 
    L = ['%s=%r' % (key, value)
1377 
      for key, value in self.__dict__.iteritems()]
1378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1379 
 
1380 
  def __eq__(self, other):
1381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1382 
 
1383 
  def __ne__(self, other):
1384 
    return not (self == other)
1385 
 
1422 varun.gupt 1386 
class getEmailsToBeSent_args:
1387 
  """
1388 
  Attributes:
1389 
   - emailType
1390 
  """
1391 
 
1392 
  thrift_spec = (
1393 
    None, # 0
1394 
    (1, TType.STRING, 'emailType', None, None, ), # 1
1395 
  )
1396 
 
1397 
  def __init__(self, emailType=None,):
1398 
    self.emailType = emailType
1399 
 
1400 
  def read(self, iprot):
1401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1403 
      return
1404 
    iprot.readStructBegin()
1405 
    while True:
1406 
      (fname, ftype, fid) = iprot.readFieldBegin()
1407 
      if ftype == TType.STOP:
1408 
        break
1409 
      if fid == 1:
1410 
        if ftype == TType.STRING:
1411 
          self.emailType = iprot.readString();
1412 
        else:
1413 
          iprot.skip(ftype)
1414 
      else:
1415 
        iprot.skip(ftype)
1416 
      iprot.readFieldEnd()
1417 
    iprot.readStructEnd()
1418 
 
1419 
  def write(self, oprot):
1420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1422 
      return
1423 
    oprot.writeStructBegin('getEmailsToBeSent_args')
1424 
    if self.emailType != None:
1425 
      oprot.writeFieldBegin('emailType', TType.STRING, 1)
1426 
      oprot.writeString(self.emailType)
1427 
      oprot.writeFieldEnd()
1428 
    oprot.writeFieldStop()
1429 
    oprot.writeStructEnd()
1430 
 
1431 
  def __repr__(self):
1432 
    L = ['%s=%r' % (key, value)
1433 
      for key, value in self.__dict__.iteritems()]
1434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1435 
 
1436 
  def __eq__(self, other):
1437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1438 
 
1439 
  def __ne__(self, other):
1440 
    return not (self == other)
1441 
 
1442 
class getEmailsToBeSent_result:
1443 
  """
1444 
  Attributes:
1445 
   - success
1446 
   - se
1447 
  """
1448 
 
1449 
  thrift_spec = (
1450 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserEmail, UserEmail.thrift_spec)), None, ), # 0
1451 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1452 
  )
1453 
 
1454 
  def __init__(self, success=None, se=None,):
1455 
    self.success = success
1456 
    self.se = se
1457 
 
1458 
  def read(self, iprot):
1459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1461 
      return
1462 
    iprot.readStructBegin()
1463 
    while True:
1464 
      (fname, ftype, fid) = iprot.readFieldBegin()
1465 
      if ftype == TType.STOP:
1466 
        break
1467 
      if fid == 0:
1468 
        if ftype == TType.LIST:
1469 
          self.success = []
1470 
          (_etype17, _size14) = iprot.readListBegin()
1471 
          for _i18 in xrange(_size14):
1472 
            _elem19 = UserEmail()
1473 
            _elem19.read(iprot)
1474 
            self.success.append(_elem19)
1475 
          iprot.readListEnd()
1476 
        else:
1477 
          iprot.skip(ftype)
1478 
      elif fid == 1:
1479 
        if ftype == TType.STRUCT:
1480 
          self.se = HelperServiceException()
1481 
          self.se.read(iprot)
1482 
        else:
1483 
          iprot.skip(ftype)
1484 
      else:
1485 
        iprot.skip(ftype)
1486 
      iprot.readFieldEnd()
1487 
    iprot.readStructEnd()
1488 
 
1489 
  def write(self, oprot):
1490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1492 
      return
1493 
    oprot.writeStructBegin('getEmailsToBeSent_result')
1494 
    if self.success != None:
1495 
      oprot.writeFieldBegin('success', TType.LIST, 0)
1496 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1497 
      for iter20 in self.success:
1498 
        iter20.write(oprot)
1499 
      oprot.writeListEnd()
1500 
      oprot.writeFieldEnd()
1501 
    if self.se != None:
1502 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1503 
      self.se.write(oprot)
1504 
      oprot.writeFieldEnd()
1505 
    oprot.writeFieldStop()
1506 
    oprot.writeStructEnd()
1507 
 
1508 
  def __repr__(self):
1509 
    L = ['%s=%r' % (key, value)
1510 
      for key, value in self.__dict__.iteritems()]
1511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1512 
 
1513 
  def __eq__(self, other):
1514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1515 
 
1516 
  def __ne__(self, other):
1517 
    return not (self == other)
1518 
 
1519 
class markEmailAsSent_args:
1520 
  """
1521 
  Attributes:
1522 
   - emailId
1523 
  """
1524 
 
1525 
  thrift_spec = (
1526 
    None, # 0
1527 
    (1, TType.I64, 'emailId', None, None, ), # 1
1528 
  )
1529 
 
1530 
  def __init__(self, emailId=None,):
1531 
    self.emailId = emailId
1532 
 
1533 
  def read(self, iprot):
1534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1536 
      return
1537 
    iprot.readStructBegin()
1538 
    while True:
1539 
      (fname, ftype, fid) = iprot.readFieldBegin()
1540 
      if ftype == TType.STOP:
1541 
        break
1542 
      if fid == 1:
1543 
        if ftype == TType.I64:
1544 
          self.emailId = iprot.readI64();
1545 
        else:
1546 
          iprot.skip(ftype)
1547 
      else:
1548 
        iprot.skip(ftype)
1549 
      iprot.readFieldEnd()
1550 
    iprot.readStructEnd()
1551 
 
1552 
  def write(self, oprot):
1553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1555 
      return
1556 
    oprot.writeStructBegin('markEmailAsSent_args')
1557 
    if self.emailId != None:
1558 
      oprot.writeFieldBegin('emailId', TType.I64, 1)
1559 
      oprot.writeI64(self.emailId)
1560 
      oprot.writeFieldEnd()
1561 
    oprot.writeFieldStop()
1562 
    oprot.writeStructEnd()
1563 
 
1564 
  def __repr__(self):
1565 
    L = ['%s=%r' % (key, value)
1566 
      for key, value in self.__dict__.iteritems()]
1567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1568 
 
1569 
  def __eq__(self, other):
1570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1571 
 
1572 
  def __ne__(self, other):
1573 
    return not (self == other)
1574 
 
1575 
class markEmailAsSent_result:
1576 
  """
1577 
  Attributes:
1578 
   - se
1579 
  """
1580 
 
1581 
  thrift_spec = (
1582 
    None, # 0
1583 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1584 
  )
1585 
 
1586 
  def __init__(self, se=None,):
1587 
    self.se = se
1588 
 
1589 
  def read(self, iprot):
1590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1592 
      return
1593 
    iprot.readStructBegin()
1594 
    while True:
1595 
      (fname, ftype, fid) = iprot.readFieldBegin()
1596 
      if ftype == TType.STOP:
1597 
        break
1598 
      if fid == 1:
1599 
        if ftype == TType.STRUCT:
1600 
          self.se = HelperServiceException()
1601 
          self.se.read(iprot)
1602 
        else:
1603 
          iprot.skip(ftype)
1604 
      else:
1605 
        iprot.skip(ftype)
1606 
      iprot.readFieldEnd()
1607 
    iprot.readStructEnd()
1608 
 
1609 
  def write(self, oprot):
1610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1612 
      return
1613 
    oprot.writeStructBegin('markEmailAsSent_result')
1614 
    if self.se != None:
1615 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1616 
      self.se.write(oprot)
1617 
      oprot.writeFieldEnd()
1618 
    oprot.writeFieldStop()
1619 
    oprot.writeStructEnd()
1620 
 
1621 
  def __repr__(self):
1622 
    L = ['%s=%r' % (key, value)
1623 
      for key, value in self.__dict__.iteritems()]
1624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1625 
 
1626 
  def __eq__(self, other):
1627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1628 
 
1629 
  def __ne__(self, other):
1630 
    return not (self == other)
1631 
 
349 ashish 1632 
class sendMail_args:
1633 
  """
1634 
  Attributes:
1635 
   - mail
1636 
  """
1637 
 
1638 
  thrift_spec = (
1639 
    None, # 0
1640 
    (1, TType.STRUCT, 'mail', (Mail, Mail.thrift_spec), None, ), # 1
1641 
  )
1642 
 
1643 
  def __init__(self, mail=None,):
1644 
    self.mail = mail
1645 
 
1646 
  def read(self, iprot):
1647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1649 
      return
1650 
    iprot.readStructBegin()
1651 
    while True:
1652 
      (fname, ftype, fid) = iprot.readFieldBegin()
1653 
      if ftype == TType.STOP:
1654 
        break
1655 
      if fid == 1:
1656 
        if ftype == TType.STRUCT:
1657 
          self.mail = Mail()
1658 
          self.mail.read(iprot)
1659 
        else:
1660 
          iprot.skip(ftype)
1661 
      else:
1662 
        iprot.skip(ftype)
1663 
      iprot.readFieldEnd()
1664 
    iprot.readStructEnd()
1665 
 
1666 
  def write(self, oprot):
1667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1669 
      return
1670 
    oprot.writeStructBegin('sendMail_args')
1671 
    if self.mail != None:
1672 
      oprot.writeFieldBegin('mail', TType.STRUCT, 1)
1673 
      self.mail.write(oprot)
1674 
      oprot.writeFieldEnd()
1675 
    oprot.writeFieldStop()
1676 
    oprot.writeStructEnd()
1677 
 
1678 
  def __repr__(self):
1679 
    L = ['%s=%r' % (key, value)
1680 
      for key, value in self.__dict__.iteritems()]
1681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1682 
 
1683 
  def __eq__(self, other):
1684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1685 
 
1686 
  def __ne__(self, other):
1687 
    return not (self == other)
1688 
 
1689 
class sendMail_result:
1690 
  """
1691 
  Attributes:
1692 
   - se
1693 
  """
1694 
 
1695 
  thrift_spec = (
1696 
    None, # 0
1697 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1698 
  )
1699 
 
1700 
  def __init__(self, se=None,):
1701 
    self.se = se
1702 
 
1703 
  def read(self, iprot):
1704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1706 
      return
1707 
    iprot.readStructBegin()
1708 
    while True:
1709 
      (fname, ftype, fid) = iprot.readFieldBegin()
1710 
      if ftype == TType.STOP:
1711 
        break
1712 
      if fid == 1:
1713 
        if ftype == TType.STRUCT:
1714 
          self.se = HelperServiceException()
1715 
          self.se.read(iprot)
1716 
        else:
1717 
          iprot.skip(ftype)
1718 
      else:
1719 
        iprot.skip(ftype)
1720 
      iprot.readFieldEnd()
1721 
    iprot.readStructEnd()
1722 
 
1723 
  def write(self, oprot):
1724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1726 
      return
1727 
    oprot.writeStructBegin('sendMail_result')
1728 
    if self.se != None:
1729 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1730 
      self.se.write(oprot)
1731 
      oprot.writeFieldEnd()
1732 
    oprot.writeFieldStop()
1733 
    oprot.writeStructEnd()
1734 
 
1735 
  def __repr__(self):
1736 
    L = ['%s=%r' % (key, value)
1737 
      for key, value in self.__dict__.iteritems()]
1738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1739 
 
1740 
  def __eq__(self, other):
1741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1742 
 
1743 
  def __ne__(self, other):
1744 
    return not (self == other)
1745 
 
1746 
class sendText_args:
1747 
  """
1748 
  Attributes:
1749 
   - message
1750 
  """
1751 
 
1752 
  thrift_spec = (
1753 
    None, # 0
1754 
    (1, TType.STRUCT, 'message', (TextMessage, TextMessage.thrift_spec), None, ), # 1
1755 
  )
1756 
 
1757 
  def __init__(self, message=None,):
1758 
    self.message = message
1759 
 
1760 
  def read(self, iprot):
1761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1763 
      return
1764 
    iprot.readStructBegin()
1765 
    while True:
1766 
      (fname, ftype, fid) = iprot.readFieldBegin()
1767 
      if ftype == TType.STOP:
1768 
        break
1769 
      if fid == 1:
1770 
        if ftype == TType.STRUCT:
1771 
          self.message = TextMessage()
1772 
          self.message.read(iprot)
1773 
        else:
1774 
          iprot.skip(ftype)
1775 
      else:
1776 
        iprot.skip(ftype)
1777 
      iprot.readFieldEnd()
1778 
    iprot.readStructEnd()
1779 
 
1780 
  def write(self, oprot):
1781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1783 
      return
1784 
    oprot.writeStructBegin('sendText_args')
1785 
    if self.message != None:
1786 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
1787 
      self.message.write(oprot)
1788 
      oprot.writeFieldEnd()
1789 
    oprot.writeFieldStop()
1790 
    oprot.writeStructEnd()
1791 
 
1792 
  def __repr__(self):
1793 
    L = ['%s=%r' % (key, value)
1794 
      for key, value in self.__dict__.iteritems()]
1795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1796 
 
1797 
  def __eq__(self, other):
1798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1799 
 
1800 
  def __ne__(self, other):
1801 
    return not (self == other)
1802 
 
1803 
class sendText_result:
1804 
  """
1805 
  Attributes:
1806 
   - se
1807 
  """
1808 
 
1809 
  thrift_spec = (
1810 
    None, # 0
1811 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1812 
  )
1813 
 
1814 
  def __init__(self, se=None,):
1815 
    self.se = se
1816 
 
1817 
  def read(self, iprot):
1818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1820 
      return
1821 
    iprot.readStructBegin()
1822 
    while True:
1823 
      (fname, ftype, fid) = iprot.readFieldBegin()
1824 
      if ftype == TType.STOP:
1825 
        break
1826 
      if fid == 1:
1827 
        if ftype == TType.STRUCT:
1828 
          self.se = HelperServiceException()
1829 
          self.se.read(iprot)
1830 
        else:
1831 
          iprot.skip(ftype)
1832 
      else:
1833 
        iprot.skip(ftype)
1834 
      iprot.readFieldEnd()
1835 
    iprot.readStructEnd()
1836 
 
1837 
  def write(self, oprot):
1838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1840 
      return
1841 
    oprot.writeStructBegin('sendText_result')
1842 
    if self.se != None:
1843 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1844 
      self.se.write(oprot)
1845 
      oprot.writeFieldEnd()
1846 
    oprot.writeFieldStop()
1847 
    oprot.writeStructEnd()
1848 
 
1849 
  def __repr__(self):
1850 
    L = ['%s=%r' % (key, value)
1851 
      for key, value in self.__dict__.iteritems()]
1852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1853 
 
1854 
  def __eq__(self, other):
1855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1856 
 
1857 
  def __ne__(self, other):
1858 
    return not (self == other)
1859 
 
1860 
class addMessage_args:
1861 
  """
1862 
  Attributes:
1863 
   - message
1864 
  """
1865 
 
1866 
  thrift_spec = (
1867 
    None, # 0
1868 
    (1, TType.STRUCT, 'message', (Message, Message.thrift_spec), None, ), # 1
1869 
  )
1870 
 
1871 
  def __init__(self, message=None,):
1872 
    self.message = message
1873 
 
1874 
  def read(self, iprot):
1875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1877 
      return
1878 
    iprot.readStructBegin()
1879 
    while True:
1880 
      (fname, ftype, fid) = iprot.readFieldBegin()
1881 
      if ftype == TType.STOP:
1882 
        break
1883 
      if fid == 1:
1884 
        if ftype == TType.STRUCT:
1885 
          self.message = Message()
1886 
          self.message.read(iprot)
1887 
        else:
1888 
          iprot.skip(ftype)
1889 
      else:
1890 
        iprot.skip(ftype)
1891 
      iprot.readFieldEnd()
1892 
    iprot.readStructEnd()
1893 
 
1894 
  def write(self, oprot):
1895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1897 
      return
1898 
    oprot.writeStructBegin('addMessage_args')
1899 
    if self.message != None:
1900 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
1901 
      self.message.write(oprot)
1902 
      oprot.writeFieldEnd()
1903 
    oprot.writeFieldStop()
1904 
    oprot.writeStructEnd()
1905 
 
1906 
  def __repr__(self):
1907 
    L = ['%s=%r' % (key, value)
1908 
      for key, value in self.__dict__.iteritems()]
1909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1910 
 
1911 
  def __eq__(self, other):
1912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1913 
 
1914 
  def __ne__(self, other):
1915 
    return not (self == other)
1916 
 
1917 
class addMessage_result:
1918 
  """
1919 
  Attributes:
1920 
   - se
1921 
  """
1922 
 
1923 
  thrift_spec = (
1924 
    None, # 0
1925 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1926 
  )
1927 
 
1928 
  def __init__(self, se=None,):
1929 
    self.se = se
1930 
 
1931 
  def read(self, iprot):
1932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1934 
      return
1935 
    iprot.readStructBegin()
1936 
    while True:
1937 
      (fname, ftype, fid) = iprot.readFieldBegin()
1938 
      if ftype == TType.STOP:
1939 
        break
1940 
      if fid == 1:
1941 
        if ftype == TType.STRUCT:
1942 
          self.se = HelperServiceException()
1943 
          self.se.read(iprot)
1944 
        else:
1945 
          iprot.skip(ftype)
1946 
      else:
1947 
        iprot.skip(ftype)
1948 
      iprot.readFieldEnd()
1949 
    iprot.readStructEnd()
1950 
 
1951 
  def write(self, oprot):
1952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1954 
      return
1955 
    oprot.writeStructBegin('addMessage_result')
1956 
    if self.se != None:
1957 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1958 
      self.se.write(oprot)
1959 
      oprot.writeFieldEnd()
1960 
    oprot.writeFieldStop()
1961 
    oprot.writeStructEnd()
1962 
 
1963 
  def __repr__(self):
1964 
    L = ['%s=%r' % (key, value)
1965 
      for key, value in self.__dict__.iteritems()]
1966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1967 
 
1968 
  def __eq__(self, other):
1969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1970 
 
1971 
  def __ne__(self, other):
1972 
    return not (self == other)
1973 
 
1974 
class updateMessage_args:
1975 
  """
1976 
  Attributes:
1977 
   - id
1978 
   - message
1979 
  """
1980 
 
1981 
  thrift_spec = (
1982 
    None, # 0
1983 
    (1, TType.I64, 'id', None, None, ), # 1
1984 
    (2, TType.STRING, 'message', None, None, ), # 2
1985 
  )
1986 
 
1987 
  def __init__(self, id=None, message=None,):
1988 
    self.id = id
1989 
    self.message = message
1990 
 
1991 
  def read(self, iprot):
1992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1994 
      return
1995 
    iprot.readStructBegin()
1996 
    while True:
1997 
      (fname, ftype, fid) = iprot.readFieldBegin()
1998 
      if ftype == TType.STOP:
1999 
        break
2000 
      if fid == 1:
2001 
        if ftype == TType.I64:
2002 
          self.id = iprot.readI64();
2003 
        else:
2004 
          iprot.skip(ftype)
2005 
      elif fid == 2:
2006 
        if ftype == TType.STRING:
2007 
          self.message = iprot.readString();
2008 
        else:
2009 
          iprot.skip(ftype)
2010 
      else:
2011 
        iprot.skip(ftype)
2012 
      iprot.readFieldEnd()
2013 
    iprot.readStructEnd()
2014 
 
2015 
  def write(self, oprot):
2016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2018 
      return
2019 
    oprot.writeStructBegin('updateMessage_args')
2020 
    if self.id != None:
2021 
      oprot.writeFieldBegin('id', TType.I64, 1)
2022 
      oprot.writeI64(self.id)
2023 
      oprot.writeFieldEnd()
2024 
    if self.message != None:
2025 
      oprot.writeFieldBegin('message', TType.STRING, 2)
2026 
      oprot.writeString(self.message)
2027 
      oprot.writeFieldEnd()
2028 
    oprot.writeFieldStop()
2029 
    oprot.writeStructEnd()
2030 
 
2031 
  def __repr__(self):
2032 
    L = ['%s=%r' % (key, value)
2033 
      for key, value in self.__dict__.iteritems()]
2034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2035 
 
2036 
  def __eq__(self, other):
2037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2038 
 
2039 
  def __ne__(self, other):
2040 
    return not (self == other)
2041 
 
2042 
class updateMessage_result:
2043 
  """
2044 
  Attributes:
2045 
   - se
2046 
  """
2047 
 
2048 
  thrift_spec = (
2049 
    None, # 0
2050 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2051 
  )
2052 
 
2053 
  def __init__(self, se=None,):
2054 
    self.se = se
2055 
 
2056 
  def read(self, iprot):
2057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2059 
      return
2060 
    iprot.readStructBegin()
2061 
    while True:
2062 
      (fname, ftype, fid) = iprot.readFieldBegin()
2063 
      if ftype == TType.STOP:
2064 
        break
2065 
      if fid == 1:
2066 
        if ftype == TType.STRUCT:
2067 
          self.se = HelperServiceException()
2068 
          self.se.read(iprot)
2069 
        else:
2070 
          iprot.skip(ftype)
2071 
      else:
2072 
        iprot.skip(ftype)
2073 
      iprot.readFieldEnd()
2074 
    iprot.readStructEnd()
2075 
 
2076 
  def write(self, oprot):
2077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2079 
      return
2080 
    oprot.writeStructBegin('updateMessage_result')
2081 
    if self.se != None:
2082 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2083 
      self.se.write(oprot)
2084 
      oprot.writeFieldEnd()
2085 
    oprot.writeFieldStop()
2086 
    oprot.writeStructEnd()
2087 
 
2088 
  def __repr__(self):
2089 
    L = ['%s=%r' % (key, value)
2090 
      for key, value in self.__dict__.iteritems()]
2091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2092 
 
2093 
  def __eq__(self, other):
2094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2095 
 
2096 
  def __ne__(self, other):
2097 
    return not (self == other)
2098 
 
2099 
class getMessage_args:
2100 
  """
2101 
  Attributes:
2102 
   - id
2103 
  """
2104 
 
2105 
  thrift_spec = (
2106 
    None, # 0
2107 
    (1, TType.I64, 'id', None, None, ), # 1
2108 
  )
2109 
 
2110 
  def __init__(self, id=None,):
2111 
    self.id = id
2112 
 
2113 
  def read(self, iprot):
2114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2116 
      return
2117 
    iprot.readStructBegin()
2118 
    while True:
2119 
      (fname, ftype, fid) = iprot.readFieldBegin()
2120 
      if ftype == TType.STOP:
2121 
        break
2122 
      if fid == 1:
2123 
        if ftype == TType.I64:
2124 
          self.id = iprot.readI64();
2125 
        else:
2126 
          iprot.skip(ftype)
2127 
      else:
2128 
        iprot.skip(ftype)
2129 
      iprot.readFieldEnd()
2130 
    iprot.readStructEnd()
2131 
 
2132 
  def write(self, oprot):
2133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2135 
      return
2136 
    oprot.writeStructBegin('getMessage_args')
2137 
    if self.id != None:
2138 
      oprot.writeFieldBegin('id', TType.I64, 1)
2139 
      oprot.writeI64(self.id)
2140 
      oprot.writeFieldEnd()
2141 
    oprot.writeFieldStop()
2142 
    oprot.writeStructEnd()
2143 
 
2144 
  def __repr__(self):
2145 
    L = ['%s=%r' % (key, value)
2146 
      for key, value in self.__dict__.iteritems()]
2147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2148 
 
2149 
  def __eq__(self, other):
2150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2151 
 
2152 
  def __ne__(self, other):
2153 
    return not (self == other)
2154 
 
2155 
class getMessage_result:
2156 
  """
2157 
  Attributes:
353 ashish 2158 
   - success
349 ashish 2159 
   - se
2160 
  """
2161 
 
2162 
  thrift_spec = (
353 ashish 2163 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 2164 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2165 
  )
2166 
 
353 ashish 2167 
  def __init__(self, success=None, se=None,):
2168 
    self.success = success
349 ashish 2169 
    self.se = se
2170 
 
2171 
  def read(self, iprot):
2172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2174 
      return
2175 
    iprot.readStructBegin()
2176 
    while True:
2177 
      (fname, ftype, fid) = iprot.readFieldBegin()
2178 
      if ftype == TType.STOP:
2179 
        break
353 ashish 2180 
      if fid == 0:
349 ashish 2181 
        if ftype == TType.STRUCT:
353 ashish 2182 
          self.success = Message()
2183 
          self.success.read(iprot)
2184 
        else:
2185 
          iprot.skip(ftype)
2186 
      elif fid == 1:
2187 
        if ftype == TType.STRUCT:
349 ashish 2188 
          self.se = HelperServiceException()
2189 
          self.se.read(iprot)
2190 
        else:
2191 
          iprot.skip(ftype)
2192 
      else:
2193 
        iprot.skip(ftype)
2194 
      iprot.readFieldEnd()
2195 
    iprot.readStructEnd()
2196 
 
2197 
  def write(self, oprot):
2198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2200 
      return
2201 
    oprot.writeStructBegin('getMessage_result')
353 ashish 2202 
    if self.success != None:
2203 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2204 
      self.success.write(oprot)
2205 
      oprot.writeFieldEnd()
349 ashish 2206 
    if self.se != None:
2207 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2208 
      self.se.write(oprot)
2209 
      oprot.writeFieldEnd()
2210 
    oprot.writeFieldStop()
2211 
    oprot.writeStructEnd()
2212 
 
2213 
  def __repr__(self):
2214 
    L = ['%s=%r' % (key, value)
2215 
      for key, value in self.__dict__.iteritems()]
2216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2217 
 
2218 
  def __eq__(self, other):
2219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2220 
 
2221 
  def __ne__(self, other):
2222 
    return not (self == other)
2223 
 
2224 
class getSubstitutedMessage_args:
2225 
  """
2226 
  Attributes:
2227 
   - id
2228 
   - params
2229 
  """
2230 
 
2231 
  thrift_spec = (
2232 
    None, # 0
2233 
    (1, TType.I64, 'id', None, None, ), # 1
2234 
    (2, TType.MAP, 'params', (TType.STRING,None,TType.STRING,None), None, ), # 2
2235 
  )
2236 
 
2237 
  def __init__(self, id=None, params=None,):
2238 
    self.id = id
2239 
    self.params = params
2240 
 
2241 
  def read(self, iprot):
2242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2244 
      return
2245 
    iprot.readStructBegin()
2246 
    while True:
2247 
      (fname, ftype, fid) = iprot.readFieldBegin()
2248 
      if ftype == TType.STOP:
2249 
        break
2250 
      if fid == 1:
2251 
        if ftype == TType.I64:
2252 
          self.id = iprot.readI64();
2253 
        else:
2254 
          iprot.skip(ftype)
2255 
      elif fid == 2:
2256 
        if ftype == TType.MAP:
2257 
          self.params = {}
1422 varun.gupt 2258 
          (_ktype22, _vtype23, _size21 ) = iprot.readMapBegin()
2259 
          for _i25 in xrange(_size21):
2260 
            _key26 = iprot.readString();
2261 
            _val27 = iprot.readString();
2262 
            self.params[_key26] = _val27
349 ashish 2263 
          iprot.readMapEnd()
2264 
        else:
2265 
          iprot.skip(ftype)
2266 
      else:
2267 
        iprot.skip(ftype)
2268 
      iprot.readFieldEnd()
2269 
    iprot.readStructEnd()
2270 
 
2271 
  def write(self, oprot):
2272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2274 
      return
2275 
    oprot.writeStructBegin('getSubstitutedMessage_args')
2276 
    if self.id != None:
2277 
      oprot.writeFieldBegin('id', TType.I64, 1)
2278 
      oprot.writeI64(self.id)
2279 
      oprot.writeFieldEnd()
2280 
    if self.params != None:
2281 
      oprot.writeFieldBegin('params', TType.MAP, 2)
2282 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.params))
1422 varun.gupt 2283 
      for kiter28,viter29 in self.params.items():
2284 
        oprot.writeString(kiter28)
2285 
        oprot.writeString(viter29)
349 ashish 2286 
      oprot.writeMapEnd()
2287 
      oprot.writeFieldEnd()
2288 
    oprot.writeFieldStop()
2289 
    oprot.writeStructEnd()
2290 
 
2291 
  def __repr__(self):
2292 
    L = ['%s=%r' % (key, value)
2293 
      for key, value in self.__dict__.iteritems()]
2294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2295 
 
2296 
  def __eq__(self, other):
2297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2298 
 
2299 
  def __ne__(self, other):
2300 
    return not (self == other)
2301 
 
2302 
class getSubstitutedMessage_result:
2303 
  """
2304 
  Attributes:
353 ashish 2305 
   - success
349 ashish 2306 
   - se
2307 
  """
2308 
 
2309 
  thrift_spec = (
353 ashish 2310 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 2311 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2312 
  )
2313 
 
353 ashish 2314 
  def __init__(self, success=None, se=None,):
2315 
    self.success = success
349 ashish 2316 
    self.se = se
2317 
 
2318 
  def read(self, iprot):
2319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2321 
      return
2322 
    iprot.readStructBegin()
2323 
    while True:
2324 
      (fname, ftype, fid) = iprot.readFieldBegin()
2325 
      if ftype == TType.STOP:
2326 
        break
353 ashish 2327 
      if fid == 0:
349 ashish 2328 
        if ftype == TType.STRUCT:
353 ashish 2329 
          self.success = Message()
2330 
          self.success.read(iprot)
2331 
        else:
2332 
          iprot.skip(ftype)
2333 
      elif fid == 1:
2334 
        if ftype == TType.STRUCT:
349 ashish 2335 
          self.se = HelperServiceException()
2336 
          self.se.read(iprot)
2337 
        else:
2338 
          iprot.skip(ftype)
2339 
      else:
2340 
        iprot.skip(ftype)
2341 
      iprot.readFieldEnd()
2342 
    iprot.readStructEnd()
2343 
 
2344 
  def write(self, oprot):
2345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2347 
      return
2348 
    oprot.writeStructBegin('getSubstitutedMessage_result')
353 ashish 2349 
    if self.success != None:
2350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2351 
      self.success.write(oprot)
2352 
      oprot.writeFieldEnd()
349 ashish 2353 
    if self.se != None:
2354 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2355 
      self.se.write(oprot)
2356 
      oprot.writeFieldEnd()
2357 
    oprot.writeFieldStop()
2358 
    oprot.writeStructEnd()
2359 
 
2360 
  def __repr__(self):
2361 
    L = ['%s=%r' % (key, value)
2362 
      for key, value in self.__dict__.iteritems()]
2363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2364 
 
2365 
  def __eq__(self, other):
2366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2367 
 
2368 
  def __ne__(self, other):
2369 
    return not (self == other)
2370 
 
494 rajveer 2371 
class addUser_args:
2372 
  """
2373 
  Attributes:
2374 
   - username
2375 
   - password
2376 
   - warehouseId
2377 
  """
349 ashish 2378 
 
494 rajveer 2379 
  thrift_spec = (
2380 
    None, # 0
2381 
    (1, TType.STRING, 'username', None, None, ), # 1
2382 
    (2, TType.STRING, 'password', None, None, ), # 2
2383 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
2384 
  )
2385 
 
2386 
  def __init__(self, username=None, password=None, warehouseId=None,):
2387 
    self.username = username
2388 
    self.password = password
2389 
    self.warehouseId = warehouseId
2390 
 
2391 
  def read(self, iprot):
2392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2394 
      return
2395 
    iprot.readStructBegin()
2396 
    while True:
2397 
      (fname, ftype, fid) = iprot.readFieldBegin()
2398 
      if ftype == TType.STOP:
2399 
        break
2400 
      if fid == 1:
2401 
        if ftype == TType.STRING:
2402 
          self.username = iprot.readString();
2403 
        else:
2404 
          iprot.skip(ftype)
2405 
      elif fid == 2:
2406 
        if ftype == TType.STRING:
2407 
          self.password = iprot.readString();
2408 
        else:
2409 
          iprot.skip(ftype)
2410 
      elif fid == 3:
2411 
        if ftype == TType.I64:
2412 
          self.warehouseId = iprot.readI64();
2413 
        else:
2414 
          iprot.skip(ftype)
2415 
      else:
2416 
        iprot.skip(ftype)
2417 
      iprot.readFieldEnd()
2418 
    iprot.readStructEnd()
2419 
 
2420 
  def write(self, oprot):
2421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2423 
      return
2424 
    oprot.writeStructBegin('addUser_args')
2425 
    if self.username != None:
2426 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2427 
      oprot.writeString(self.username)
2428 
      oprot.writeFieldEnd()
2429 
    if self.password != None:
2430 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2431 
      oprot.writeString(self.password)
2432 
      oprot.writeFieldEnd()
2433 
    if self.warehouseId != None:
2434 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
2435 
      oprot.writeI64(self.warehouseId)
2436 
      oprot.writeFieldEnd()
2437 
    oprot.writeFieldStop()
2438 
    oprot.writeStructEnd()
2439 
 
2440 
  def __repr__(self):
2441 
    L = ['%s=%r' % (key, value)
2442 
      for key, value in self.__dict__.iteritems()]
2443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2444 
 
2445 
  def __eq__(self, other):
2446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2447 
 
2448 
  def __ne__(self, other):
2449 
    return not (self == other)
2450 
 
2451 
class addUser_result:
2452 
  """
2453 
  Attributes:
2454 
   - success
2455 
   - se
2456 
  """
2457 
 
2458 
  thrift_spec = (
2459 
    (0, TType.BOOL, 'success', None, None, ), # 0
2460 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2461 
  )
2462 
 
2463 
  def __init__(self, success=None, se=None,):
2464 
    self.success = success
2465 
    self.se = se
2466 
 
2467 
  def read(self, iprot):
2468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2470 
      return
2471 
    iprot.readStructBegin()
2472 
    while True:
2473 
      (fname, ftype, fid) = iprot.readFieldBegin()
2474 
      if ftype == TType.STOP:
2475 
        break
2476 
      if fid == 0:
2477 
        if ftype == TType.BOOL:
2478 
          self.success = iprot.readBool();
2479 
        else:
2480 
          iprot.skip(ftype)
2481 
      elif fid == 1:
2482 
        if ftype == TType.STRUCT:
2483 
          self.se = HelperServiceException()
2484 
          self.se.read(iprot)
2485 
        else:
2486 
          iprot.skip(ftype)
2487 
      else:
2488 
        iprot.skip(ftype)
2489 
      iprot.readFieldEnd()
2490 
    iprot.readStructEnd()
2491 
 
2492 
  def write(self, oprot):
2493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2495 
      return
2496 
    oprot.writeStructBegin('addUser_result')
2497 
    if self.success != None:
2498 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2499 
      oprot.writeBool(self.success)
2500 
      oprot.writeFieldEnd()
2501 
    if self.se != None:
2502 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2503 
      self.se.write(oprot)
2504 
      oprot.writeFieldEnd()
2505 
    oprot.writeFieldStop()
2506 
    oprot.writeStructEnd()
2507 
 
2508 
  def __repr__(self):
2509 
    L = ['%s=%r' % (key, value)
2510 
      for key, value in self.__dict__.iteritems()]
2511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2512 
 
2513 
  def __eq__(self, other):
2514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2515 
 
2516 
  def __ne__(self, other):
2517 
    return not (self == other)
2518 
 
2519 
class deleteUser_args:
2520 
  """
2521 
  Attributes:
2522 
   - username
2523 
  """
2524 
 
2525 
  thrift_spec = (
2526 
    None, # 0
2527 
    (1, TType.STRING, 'username', None, None, ), # 1
2528 
  )
2529 
 
2530 
  def __init__(self, username=None,):
2531 
    self.username = username
2532 
 
2533 
  def read(self, iprot):
2534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2536 
      return
2537 
    iprot.readStructBegin()
2538 
    while True:
2539 
      (fname, ftype, fid) = iprot.readFieldBegin()
2540 
      if ftype == TType.STOP:
2541 
        break
2542 
      if fid == 1:
2543 
        if ftype == TType.STRING:
2544 
          self.username = iprot.readString();
2545 
        else:
2546 
          iprot.skip(ftype)
2547 
      else:
2548 
        iprot.skip(ftype)
2549 
      iprot.readFieldEnd()
2550 
    iprot.readStructEnd()
2551 
 
2552 
  def write(self, oprot):
2553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2555 
      return
2556 
    oprot.writeStructBegin('deleteUser_args')
2557 
    if self.username != None:
2558 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2559 
      oprot.writeString(self.username)
2560 
      oprot.writeFieldEnd()
2561 
    oprot.writeFieldStop()
2562 
    oprot.writeStructEnd()
2563 
 
2564 
  def __repr__(self):
2565 
    L = ['%s=%r' % (key, value)
2566 
      for key, value in self.__dict__.iteritems()]
2567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2568 
 
2569 
  def __eq__(self, other):
2570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2571 
 
2572 
  def __ne__(self, other):
2573 
    return not (self == other)
2574 
 
2575 
class deleteUser_result:
2576 
  """
2577 
  Attributes:
2578 
   - success
2579 
   - se
2580 
  """
2581 
 
2582 
  thrift_spec = (
2583 
    (0, TType.BOOL, 'success', None, None, ), # 0
2584 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2585 
  )
2586 
 
2587 
  def __init__(self, success=None, se=None,):
2588 
    self.success = success
2589 
    self.se = se
2590 
 
2591 
  def read(self, iprot):
2592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2594 
      return
2595 
    iprot.readStructBegin()
2596 
    while True:
2597 
      (fname, ftype, fid) = iprot.readFieldBegin()
2598 
      if ftype == TType.STOP:
2599 
        break
2600 
      if fid == 0:
2601 
        if ftype == TType.BOOL:
2602 
          self.success = iprot.readBool();
2603 
        else:
2604 
          iprot.skip(ftype)
2605 
      elif fid == 1:
2606 
        if ftype == TType.STRUCT:
2607 
          self.se = HelperServiceException()
2608 
          self.se.read(iprot)
2609 
        else:
2610 
          iprot.skip(ftype)
2611 
      else:
2612 
        iprot.skip(ftype)
2613 
      iprot.readFieldEnd()
2614 
    iprot.readStructEnd()
2615 
 
2616 
  def write(self, oprot):
2617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2619 
      return
2620 
    oprot.writeStructBegin('deleteUser_result')
2621 
    if self.success != None:
2622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2623 
      oprot.writeBool(self.success)
2624 
      oprot.writeFieldEnd()
2625 
    if self.se != None:
2626 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2627 
      self.se.write(oprot)
2628 
      oprot.writeFieldEnd()
2629 
    oprot.writeFieldStop()
2630 
    oprot.writeStructEnd()
2631 
 
2632 
  def __repr__(self):
2633 
    L = ['%s=%r' % (key, value)
2634 
      for key, value in self.__dict__.iteritems()]
2635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2636 
 
2637 
  def __eq__(self, other):
2638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2639 
 
2640 
  def __ne__(self, other):
2641 
    return not (self == other)
2642 
 
2643 
class authenticateUser_args:
2644 
  """
2645 
  Attributes:
2646 
   - username
2647 
   - password
2648 
  """
2649 
 
2650 
  thrift_spec = (
2651 
    None, # 0
2652 
    (1, TType.STRING, 'username', None, None, ), # 1
2653 
    (2, TType.STRING, 'password', None, None, ), # 2
2654 
  )
2655 
 
2656 
  def __init__(self, username=None, password=None,):
2657 
    self.username = username
2658 
    self.password = password
2659 
 
2660 
  def read(self, iprot):
2661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2663 
      return
2664 
    iprot.readStructBegin()
2665 
    while True:
2666 
      (fname, ftype, fid) = iprot.readFieldBegin()
2667 
      if ftype == TType.STOP:
2668 
        break
2669 
      if fid == 1:
2670 
        if ftype == TType.STRING:
2671 
          self.username = iprot.readString();
2672 
        else:
2673 
          iprot.skip(ftype)
2674 
      elif fid == 2:
2675 
        if ftype == TType.STRING:
2676 
          self.password = iprot.readString();
2677 
        else:
2678 
          iprot.skip(ftype)
2679 
      else:
2680 
        iprot.skip(ftype)
2681 
      iprot.readFieldEnd()
2682 
    iprot.readStructEnd()
2683 
 
2684 
  def write(self, oprot):
2685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2687 
      return
2688 
    oprot.writeStructBegin('authenticateUser_args')
2689 
    if self.username != None:
2690 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2691 
      oprot.writeString(self.username)
2692 
      oprot.writeFieldEnd()
2693 
    if self.password != None:
2694 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2695 
      oprot.writeString(self.password)
2696 
      oprot.writeFieldEnd()
2697 
    oprot.writeFieldStop()
2698 
    oprot.writeStructEnd()
2699 
 
2700 
  def __repr__(self):
2701 
    L = ['%s=%r' % (key, value)
2702 
      for key, value in self.__dict__.iteritems()]
2703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2704 
 
2705 
  def __eq__(self, other):
2706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2707 
 
2708 
  def __ne__(self, other):
2709 
    return not (self == other)
2710 
 
2711 
class authenticateUser_result:
2712 
  """
2713 
  Attributes:
2714 
   - success
2715 
   - se
2716 
  """
2717 
 
2718 
  thrift_spec = (
2719 
    (0, TType.I64, 'success', None, None, ), # 0
2720 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2721 
  )
2722 
 
2723 
  def __init__(self, success=None, se=None,):
2724 
    self.success = success
2725 
    self.se = se
2726 
 
2727 
  def read(self, iprot):
2728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2730 
      return
2731 
    iprot.readStructBegin()
2732 
    while True:
2733 
      (fname, ftype, fid) = iprot.readFieldBegin()
2734 
      if ftype == TType.STOP:
2735 
        break
2736 
      if fid == 0:
2737 
        if ftype == TType.I64:
2738 
          self.success = iprot.readI64();
2739 
        else:
2740 
          iprot.skip(ftype)
2741 
      elif fid == 1:
2742 
        if ftype == TType.STRUCT:
2743 
          self.se = HelperServiceException()
2744 
          self.se.read(iprot)
2745 
        else:
2746 
          iprot.skip(ftype)
2747 
      else:
2748 
        iprot.skip(ftype)
2749 
      iprot.readFieldEnd()
2750 
    iprot.readStructEnd()
2751 
 
2752 
  def write(self, oprot):
2753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2755 
      return
2756 
    oprot.writeStructBegin('authenticateUser_result')
2757 
    if self.success != None:
2758 
      oprot.writeFieldBegin('success', TType.I64, 0)
2759 
      oprot.writeI64(self.success)
2760 
      oprot.writeFieldEnd()
2761 
    if self.se != None:
2762 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2763 
      self.se.write(oprot)
2764 
      oprot.writeFieldEnd()
2765 
    oprot.writeFieldStop()
2766 
    oprot.writeStructEnd()
2767 
 
2768 
  def __repr__(self):
2769 
    L = ['%s=%r' % (key, value)
2770 
      for key, value in self.__dict__.iteritems()]
2771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2772 
 
2773 
  def __eq__(self, other):
2774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2775 
 
2776 
  def __ne__(self, other):
2777 
    return not (self == other)
2778 
 
2779 
class updatePassword_args:
2780 
  """
2781 
  Attributes:
2782 
   - username
2783 
   - oldPassword
2784 
   - newPassword
2785 
  """
2786 
 
2787 
  thrift_spec = (
2788 
    None, # 0
2789 
    (1, TType.STRING, 'username', None, None, ), # 1
2790 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
2791 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
2792 
  )
2793 
 
2794 
  def __init__(self, username=None, oldPassword=None, newPassword=None,):
2795 
    self.username = username
2796 
    self.oldPassword = oldPassword
2797 
    self.newPassword = newPassword
2798 
 
2799 
  def read(self, iprot):
2800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2802 
      return
2803 
    iprot.readStructBegin()
2804 
    while True:
2805 
      (fname, ftype, fid) = iprot.readFieldBegin()
2806 
      if ftype == TType.STOP:
2807 
        break
2808 
      if fid == 1:
2809 
        if ftype == TType.STRING:
2810 
          self.username = iprot.readString();
2811 
        else:
2812 
          iprot.skip(ftype)
2813 
      elif fid == 2:
2814 
        if ftype == TType.STRING:
2815 
          self.oldPassword = iprot.readString();
2816 
        else:
2817 
          iprot.skip(ftype)
2818 
      elif fid == 3:
2819 
        if ftype == TType.STRING:
2820 
          self.newPassword = iprot.readString();
2821 
        else:
2822 
          iprot.skip(ftype)
2823 
      else:
2824 
        iprot.skip(ftype)
2825 
      iprot.readFieldEnd()
2826 
    iprot.readStructEnd()
2827 
 
2828 
  def write(self, oprot):
2829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2831 
      return
2832 
    oprot.writeStructBegin('updatePassword_args')
2833 
    if self.username != None:
2834 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2835 
      oprot.writeString(self.username)
2836 
      oprot.writeFieldEnd()
2837 
    if self.oldPassword != None:
2838 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
2839 
      oprot.writeString(self.oldPassword)
2840 
      oprot.writeFieldEnd()
2841 
    if self.newPassword != None:
2842 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
2843 
      oprot.writeString(self.newPassword)
2844 
      oprot.writeFieldEnd()
2845 
    oprot.writeFieldStop()
2846 
    oprot.writeStructEnd()
2847 
 
2848 
  def __repr__(self):
2849 
    L = ['%s=%r' % (key, value)
2850 
      for key, value in self.__dict__.iteritems()]
2851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2852 
 
2853 
  def __eq__(self, other):
2854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2855 
 
2856 
  def __ne__(self, other):
2857 
    return not (self == other)
2858 
 
2859 
class updatePassword_result:
2860 
  """
2861 
  Attributes:
2862 
   - success
2863 
   - se
2864 
  """
2865 
 
2866 
  thrift_spec = (
2867 
    (0, TType.BOOL, 'success', None, None, ), # 0
2868 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2869 
  )
2870 
 
2871 
  def __init__(self, success=None, se=None,):
2872 
    self.success = success
2873 
    self.se = se
2874 
 
2875 
  def read(self, iprot):
2876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2878 
      return
2879 
    iprot.readStructBegin()
2880 
    while True:
2881 
      (fname, ftype, fid) = iprot.readFieldBegin()
2882 
      if ftype == TType.STOP:
2883 
        break
2884 
      if fid == 0:
2885 
        if ftype == TType.BOOL:
2886 
          self.success = iprot.readBool();
2887 
        else:
2888 
          iprot.skip(ftype)
2889 
      elif fid == 1:
2890 
        if ftype == TType.STRUCT:
2891 
          self.se = HelperServiceException()
2892 
          self.se.read(iprot)
2893 
        else:
2894 
          iprot.skip(ftype)
2895 
      else:
2896 
        iprot.skip(ftype)
2897 
      iprot.readFieldEnd()
2898 
    iprot.readStructEnd()
2899 
 
2900 
  def write(self, oprot):
2901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2903 
      return
2904 
    oprot.writeStructBegin('updatePassword_result')
2905 
    if self.success != None:
2906 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2907 
      oprot.writeBool(self.success)
2908 
      oprot.writeFieldEnd()
2909 
    if self.se != None:
2910 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2911 
      self.se.write(oprot)
2912 
      oprot.writeFieldEnd()
2913 
    oprot.writeFieldStop()
2914 
    oprot.writeStructEnd()
2915 
 
2916 
  def __repr__(self):
2917 
    L = ['%s=%r' % (key, value)
2918 
      for key, value in self.__dict__.iteritems()]
2919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2920 
 
2921 
  def __eq__(self, other):
2922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2923 
 
2924 
  def __ne__(self, other):
2925 
    return not (self == other)
2926 
 
759 chandransh 2927 
class authenticateLogisticsUser_args:
2928 
  """
2929 
  Attributes:
2930 
   - username
2931 
   - password
2932 
  """
494 rajveer 2933 
 
759 chandransh 2934 
  thrift_spec = (
2935 
    None, # 0
2936 
    (1, TType.STRING, 'username', None, None, ), # 1
2937 
    (2, TType.STRING, 'password', None, None, ), # 2
2938 
  )
2939 
 
2940 
  def __init__(self, username=None, password=None,):
2941 
    self.username = username
2942 
    self.password = password
2943 
 
2944 
  def read(self, iprot):
2945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2947 
      return
2948 
    iprot.readStructBegin()
2949 
    while True:
2950 
      (fname, ftype, fid) = iprot.readFieldBegin()
2951 
      if ftype == TType.STOP:
2952 
        break
2953 
      if fid == 1:
2954 
        if ftype == TType.STRING:
2955 
          self.username = iprot.readString();
2956 
        else:
2957 
          iprot.skip(ftype)
2958 
      elif fid == 2:
2959 
        if ftype == TType.STRING:
2960 
          self.password = iprot.readString();
2961 
        else:
2962 
          iprot.skip(ftype)
2963 
      else:
2964 
        iprot.skip(ftype)
2965 
      iprot.readFieldEnd()
2966 
    iprot.readStructEnd()
2967 
 
2968 
  def write(self, oprot):
2969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2971 
      return
2972 
    oprot.writeStructBegin('authenticateLogisticsUser_args')
2973 
    if self.username != None:
2974 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2975 
      oprot.writeString(self.username)
2976 
      oprot.writeFieldEnd()
2977 
    if self.password != None:
2978 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2979 
      oprot.writeString(self.password)
2980 
      oprot.writeFieldEnd()
2981 
    oprot.writeFieldStop()
2982 
    oprot.writeStructEnd()
2983 
 
2984 
  def __repr__(self):
2985 
    L = ['%s=%r' % (key, value)
2986 
      for key, value in self.__dict__.iteritems()]
2987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2988 
 
2989 
  def __eq__(self, other):
2990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2991 
 
2992 
  def __ne__(self, other):
2993 
    return not (self == other)
2994 
 
2995 
class authenticateLogisticsUser_result:
2996 
  """
2997 
  Attributes:
2998 
   - success
2999 
   - hse
3000 
  """
3001 
 
3002 
  thrift_spec = (
3003 
    (0, TType.STRUCT, 'success', (LogisticsUser, LogisticsUser.thrift_spec), None, ), # 0
3004 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3005 
  )
3006 
 
3007 
  def __init__(self, success=None, hse=None,):
3008 
    self.success = success
3009 
    self.hse = hse
3010 
 
3011 
  def read(self, iprot):
3012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3014 
      return
3015 
    iprot.readStructBegin()
3016 
    while True:
3017 
      (fname, ftype, fid) = iprot.readFieldBegin()
3018 
      if ftype == TType.STOP:
3019 
        break
3020 
      if fid == 0:
3021 
        if ftype == TType.STRUCT:
3022 
          self.success = LogisticsUser()
3023 
          self.success.read(iprot)
3024 
        else:
3025 
          iprot.skip(ftype)
3026 
      elif fid == 1:
3027 
        if ftype == TType.STRUCT:
3028 
          self.hse = HelperServiceException()
3029 
          self.hse.read(iprot)
3030 
        else:
3031 
          iprot.skip(ftype)
3032 
      else:
3033 
        iprot.skip(ftype)
3034 
      iprot.readFieldEnd()
3035 
    iprot.readStructEnd()
3036 
 
3037 
  def write(self, oprot):
3038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3040 
      return
3041 
    oprot.writeStructBegin('authenticateLogisticsUser_result')
3042 
    if self.success != None:
3043 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3044 
      self.success.write(oprot)
3045 
      oprot.writeFieldEnd()
3046 
    if self.hse != None:
3047 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3048 
      self.hse.write(oprot)
3049 
      oprot.writeFieldEnd()
3050 
    oprot.writeFieldStop()
3051 
    oprot.writeStructEnd()
3052 
 
3053 
  def __repr__(self):
3054 
    L = ['%s=%r' % (key, value)
3055 
      for key, value in self.__dict__.iteritems()]
3056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3057 
 
3058 
  def __eq__(self, other):
3059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3060 
 
3061 
  def __ne__(self, other):
3062 
    return not (self == other)
3063 
 
1610 ankur.sing 3064 
class authenticateStatisticsUser_args:
3065 
  """
3066 
  Attributes:
3067 
   - username
3068 
   - password
3069 
  """
759 chandransh 3070 
 
1610 ankur.sing 3071 
  thrift_spec = (
3072 
    None, # 0
3073 
    (1, TType.STRING, 'username', None, None, ), # 1
3074 
    (2, TType.STRING, 'password', None, None, ), # 2
3075 
  )
3076 
 
3077 
  def __init__(self, username=None, password=None,):
3078 
    self.username = username
3079 
    self.password = password
3080 
 
3081 
  def read(self, iprot):
3082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3084 
      return
3085 
    iprot.readStructBegin()
3086 
    while True:
3087 
      (fname, ftype, fid) = iprot.readFieldBegin()
3088 
      if ftype == TType.STOP:
3089 
        break
3090 
      if fid == 1:
3091 
        if ftype == TType.STRING:
3092 
          self.username = iprot.readString();
3093 
        else:
3094 
          iprot.skip(ftype)
3095 
      elif fid == 2:
3096 
        if ftype == TType.STRING:
3097 
          self.password = iprot.readString();
3098 
        else:
3099 
          iprot.skip(ftype)
3100 
      else:
3101 
        iprot.skip(ftype)
3102 
      iprot.readFieldEnd()
3103 
    iprot.readStructEnd()
3104 
 
3105 
  def write(self, oprot):
3106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3108 
      return
3109 
    oprot.writeStructBegin('authenticateStatisticsUser_args')
3110 
    if self.username != None:
3111 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3112 
      oprot.writeString(self.username)
3113 
      oprot.writeFieldEnd()
3114 
    if self.password != None:
3115 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3116 
      oprot.writeString(self.password)
3117 
      oprot.writeFieldEnd()
3118 
    oprot.writeFieldStop()
3119 
    oprot.writeStructEnd()
3120 
 
3121 
  def __repr__(self):
3122 
    L = ['%s=%r' % (key, value)
3123 
      for key, value in self.__dict__.iteritems()]
3124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3125 
 
3126 
  def __eq__(self, other):
3127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3128 
 
3129 
  def __ne__(self, other):
3130 
    return not (self == other)
3131 
 
3132 
class authenticateStatisticsUser_result:
3133 
  """
3134 
  Attributes:
3135 
   - success
3136 
   - hse
3137 
  """
3138 
 
3139 
  thrift_spec = (
3140 
    (0, TType.STRUCT, 'success', (StatisticsUser, StatisticsUser.thrift_spec), None, ), # 0
3141 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3142 
  )
3143 
 
3144 
  def __init__(self, success=None, hse=None,):
3145 
    self.success = success
3146 
    self.hse = hse
3147 
 
3148 
  def read(self, iprot):
3149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3151 
      return
3152 
    iprot.readStructBegin()
3153 
    while True:
3154 
      (fname, ftype, fid) = iprot.readFieldBegin()
3155 
      if ftype == TType.STOP:
3156 
        break
3157 
      if fid == 0:
3158 
        if ftype == TType.STRUCT:
3159 
          self.success = StatisticsUser()
3160 
          self.success.read(iprot)
3161 
        else:
3162 
          iprot.skip(ftype)
3163 
      elif fid == 1:
3164 
        if ftype == TType.STRUCT:
3165 
          self.hse = HelperServiceException()
3166 
          self.hse.read(iprot)
3167 
        else:
3168 
          iprot.skip(ftype)
3169 
      else:
3170 
        iprot.skip(ftype)
3171 
      iprot.readFieldEnd()
3172 
    iprot.readStructEnd()
3173 
 
3174 
  def write(self, oprot):
3175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3177 
      return
3178 
    oprot.writeStructBegin('authenticateStatisticsUser_result')
3179 
    if self.success != None:
3180 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3181 
      self.success.write(oprot)
3182 
      oprot.writeFieldEnd()
3183 
    if self.hse != None:
3184 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3185 
      self.hse.write(oprot)
3186 
      oprot.writeFieldEnd()
3187 
    oprot.writeFieldStop()
3188 
    oprot.writeStructEnd()
3189 
 
3190 
  def __repr__(self):
3191 
    L = ['%s=%r' % (key, value)
3192 
      for key, value in self.__dict__.iteritems()]
3193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3194 
 
3195 
  def __eq__(self, other):
3196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3197 
 
3198 
  def __ne__(self, other):
3199 
    return not (self == other)
3200 
 
1891 ankur.sing 3201 
class authenticateReportUser_args:
3202 
  """
3203 
  Attributes:
3204 
   - username
3205 
   - password
3206 
  """
1610 ankur.sing 3207 
 
1891 ankur.sing 3208 
  thrift_spec = (
3209 
    None, # 0
3210 
    (1, TType.STRING, 'username', None, None, ), # 1
3211 
    (2, TType.STRING, 'password', None, None, ), # 2
3212 
  )
3213 
 
3214 
  def __init__(self, username=None, password=None,):
3215 
    self.username = username
3216 
    self.password = password
3217 
 
3218 
  def read(self, iprot):
3219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3221 
      return
3222 
    iprot.readStructBegin()
3223 
    while True:
3224 
      (fname, ftype, fid) = iprot.readFieldBegin()
3225 
      if ftype == TType.STOP:
3226 
        break
3227 
      if fid == 1:
3228 
        if ftype == TType.STRING:
3229 
          self.username = iprot.readString();
3230 
        else:
3231 
          iprot.skip(ftype)
3232 
      elif fid == 2:
3233 
        if ftype == TType.STRING:
3234 
          self.password = iprot.readString();
3235 
        else:
3236 
          iprot.skip(ftype)
3237 
      else:
3238 
        iprot.skip(ftype)
3239 
      iprot.readFieldEnd()
3240 
    iprot.readStructEnd()
3241 
 
3242 
  def write(self, oprot):
3243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3245 
      return
3246 
    oprot.writeStructBegin('authenticateReportUser_args')
3247 
    if self.username != None:
3248 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3249 
      oprot.writeString(self.username)
3250 
      oprot.writeFieldEnd()
3251 
    if self.password != None:
3252 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3253 
      oprot.writeString(self.password)
3254 
      oprot.writeFieldEnd()
3255 
    oprot.writeFieldStop()
3256 
    oprot.writeStructEnd()
3257 
 
3258 
  def __repr__(self):
3259 
    L = ['%s=%r' % (key, value)
3260 
      for key, value in self.__dict__.iteritems()]
3261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3262 
 
3263 
  def __eq__(self, other):
3264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3265 
 
3266 
  def __ne__(self, other):
3267 
    return not (self == other)
3268 
 
3269 
class authenticateReportUser_result:
3270 
  """
3271 
  Attributes:
3272 
   - success
3273 
   - hse
3274 
  """
3275 
 
3276 
  thrift_spec = (
3277 
    (0, TType.STRUCT, 'success', (ReportUser, ReportUser.thrift_spec), None, ), # 0
3278 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3279 
  )
3280 
 
3281 
  def __init__(self, success=None, hse=None,):
3282 
    self.success = success
3283 
    self.hse = hse
3284 
 
3285 
  def read(self, iprot):
3286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3288 
      return
3289 
    iprot.readStructBegin()
3290 
    while True:
3291 
      (fname, ftype, fid) = iprot.readFieldBegin()
3292 
      if ftype == TType.STOP:
3293 
        break
3294 
      if fid == 0:
3295 
        if ftype == TType.STRUCT:
3296 
          self.success = ReportUser()
3297 
          self.success.read(iprot)
3298 
        else:
3299 
          iprot.skip(ftype)
3300 
      elif fid == 1:
3301 
        if ftype == TType.STRUCT:
3302 
          self.hse = HelperServiceException()
3303 
          self.hse.read(iprot)
3304 
        else:
3305 
          iprot.skip(ftype)
3306 
      else:
3307 
        iprot.skip(ftype)
3308 
      iprot.readFieldEnd()
3309 
    iprot.readStructEnd()
3310 
 
3311 
  def write(self, oprot):
3312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3314 
      return
3315 
    oprot.writeStructBegin('authenticateReportUser_result')
3316 
    if self.success != None:
3317 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3318 
      self.success.write(oprot)
3319 
      oprot.writeFieldEnd()
3320 
    if self.hse != None:
3321 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3322 
      self.hse.write(oprot)
3323 
      oprot.writeFieldEnd()
3324 
    oprot.writeFieldStop()
3325 
    oprot.writeStructEnd()
3326 
 
3327 
  def __repr__(self):
3328 
    L = ['%s=%r' % (key, value)
3329 
      for key, value in self.__dict__.iteritems()]
3330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3331 
 
3332 
  def __eq__(self, other):
3333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3334 
 
3335 
  def __ne__(self, other):
3336 
    return not (self == other)
3337 
 
3338 
class getReports_args:
3339 
  """
3340 
  Attributes:
3341 
   - role
3342 
  """
3343 
 
3344 
  thrift_spec = (
3345 
    None, # 0
3346 
    (1, TType.I64, 'role', None, None, ), # 1
3347 
  )
3348 
 
3349 
  def __init__(self, role=None,):
3350 
    self.role = role
3351 
 
3352 
  def read(self, iprot):
3353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3355 
      return
3356 
    iprot.readStructBegin()
3357 
    while True:
3358 
      (fname, ftype, fid) = iprot.readFieldBegin()
3359 
      if ftype == TType.STOP:
3360 
        break
3361 
      if fid == 1:
3362 
        if ftype == TType.I64:
3363 
          self.role = iprot.readI64();
3364 
        else:
3365 
          iprot.skip(ftype)
3366 
      else:
3367 
        iprot.skip(ftype)
3368 
      iprot.readFieldEnd()
3369 
    iprot.readStructEnd()
3370 
 
3371 
  def write(self, oprot):
3372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3374 
      return
3375 
    oprot.writeStructBegin('getReports_args')
3376 
    if self.role != None:
3377 
      oprot.writeFieldBegin('role', TType.I64, 1)
3378 
      oprot.writeI64(self.role)
3379 
      oprot.writeFieldEnd()
3380 
    oprot.writeFieldStop()
3381 
    oprot.writeStructEnd()
3382 
 
3383 
  def __repr__(self):
3384 
    L = ['%s=%r' % (key, value)
3385 
      for key, value in self.__dict__.iteritems()]
3386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3387 
 
3388 
  def __eq__(self, other):
3389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3390 
 
3391 
  def __ne__(self, other):
3392 
    return not (self == other)
3393 
 
3394 
class getReports_result:
3395 
  """
3396 
  Attributes:
3397 
   - success
3398 
  """
3399 
 
3400 
  thrift_spec = (
3401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Report, Report.thrift_spec)), None, ), # 0
3402 
  )
3403 
 
3404 
  def __init__(self, success=None,):
3405 
    self.success = success
3406 
 
3407 
  def read(self, iprot):
3408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3410 
      return
3411 
    iprot.readStructBegin()
3412 
    while True:
3413 
      (fname, ftype, fid) = iprot.readFieldBegin()
3414 
      if ftype == TType.STOP:
3415 
        break
3416 
      if fid == 0:
3417 
        if ftype == TType.LIST:
3418 
          self.success = []
3419 
          (_etype33, _size30) = iprot.readListBegin()
3420 
          for _i34 in xrange(_size30):
3421 
            _elem35 = Report()
3422 
            _elem35.read(iprot)
3423 
            self.success.append(_elem35)
3424 
          iprot.readListEnd()
3425 
        else:
3426 
          iprot.skip(ftype)
3427 
      else:
3428 
        iprot.skip(ftype)
3429 
      iprot.readFieldEnd()
3430 
    iprot.readStructEnd()
3431 
 
3432 
  def write(self, oprot):
3433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3435 
      return
3436 
    oprot.writeStructBegin('getReports_result')
3437 
    if self.success != None:
3438 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3439 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3440 
      for iter36 in self.success:
3441 
        iter36.write(oprot)
3442 
      oprot.writeListEnd()
3443 
      oprot.writeFieldEnd()
3444 
    oprot.writeFieldStop()
3445 
    oprot.writeStructEnd()
3446 
 
3447 
  def __repr__(self):
3448 
    L = ['%s=%r' % (key, value)
3449 
      for key, value in self.__dict__.iteritems()]
3450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3451 
 
3452 
  def __eq__(self, other):
3453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3454 
 
3455 
  def __ne__(self, other):
3456 
    return not (self == other)
3457 
 
2025 ankur.sing 3458 
class authenticateCatalogUser_args:
3459 
  """
3460 
  Attributes:
3461 
   - username
3462 
   - password
2358 ankur.sing 3463 
   - role
2025 ankur.sing 3464 
  """
1891 ankur.sing 3465 
 
2025 ankur.sing 3466 
  thrift_spec = (
3467 
    None, # 0
3468 
    (1, TType.STRING, 'username', None, None, ), # 1
3469 
    (2, TType.STRING, 'password', None, None, ), # 2
2358 ankur.sing 3470 
    (3, TType.I64, 'role', None, None, ), # 3
2025 ankur.sing 3471 
  )
3472 
 
2358 ankur.sing 3473 
  def __init__(self, username=None, password=None, role=None,):
2025 ankur.sing 3474 
    self.username = username
3475 
    self.password = password
2358 ankur.sing 3476 
    self.role = role
2025 ankur.sing 3477 
 
3478 
  def read(self, iprot):
3479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3481 
      return
3482 
    iprot.readStructBegin()
3483 
    while True:
3484 
      (fname, ftype, fid) = iprot.readFieldBegin()
3485 
      if ftype == TType.STOP:
3486 
        break
3487 
      if fid == 1:
3488 
        if ftype == TType.STRING:
3489 
          self.username = iprot.readString();
3490 
        else:
3491 
          iprot.skip(ftype)
3492 
      elif fid == 2:
3493 
        if ftype == TType.STRING:
3494 
          self.password = iprot.readString();
3495 
        else:
3496 
          iprot.skip(ftype)
2358 ankur.sing 3497 
      elif fid == 3:
3498 
        if ftype == TType.I64:
3499 
          self.role = iprot.readI64();
3500 
        else:
3501 
          iprot.skip(ftype)
2025 ankur.sing 3502 
      else:
3503 
        iprot.skip(ftype)
3504 
      iprot.readFieldEnd()
3505 
    iprot.readStructEnd()
3506 
 
3507 
  def write(self, oprot):
3508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3510 
      return
3511 
    oprot.writeStructBegin('authenticateCatalogUser_args')
3512 
    if self.username != None:
3513 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3514 
      oprot.writeString(self.username)
3515 
      oprot.writeFieldEnd()
3516 
    if self.password != None:
3517 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3518 
      oprot.writeString(self.password)
3519 
      oprot.writeFieldEnd()
2358 ankur.sing 3520 
    if self.role != None:
3521 
      oprot.writeFieldBegin('role', TType.I64, 3)
3522 
      oprot.writeI64(self.role)
3523 
      oprot.writeFieldEnd()
2025 ankur.sing 3524 
    oprot.writeFieldStop()
3525 
    oprot.writeStructEnd()
3526 
 
3527 
  def __repr__(self):
3528 
    L = ['%s=%r' % (key, value)
3529 
      for key, value in self.__dict__.iteritems()]
3530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3531 
 
3532 
  def __eq__(self, other):
3533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3534 
 
3535 
  def __ne__(self, other):
3536 
    return not (self == other)
3537 
 
3538 
class authenticateCatalogUser_result:
3539 
  """
3540 
  Attributes:
3541 
   - success
3542 
   - hse
3543 
  """
3544 
 
3545 
  thrift_spec = (
3546 
    (0, TType.STRUCT, 'success', (CatalogDashboardUser, CatalogDashboardUser.thrift_spec), None, ), # 0
3547 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3548 
  )
3549 
 
3550 
  def __init__(self, success=None, hse=None,):
3551 
    self.success = success
3552 
    self.hse = hse
3553 
 
3554 
  def read(self, iprot):
3555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3557 
      return
3558 
    iprot.readStructBegin()
3559 
    while True:
3560 
      (fname, ftype, fid) = iprot.readFieldBegin()
3561 
      if ftype == TType.STOP:
3562 
        break
3563 
      if fid == 0:
3564 
        if ftype == TType.STRUCT:
3565 
          self.success = CatalogDashboardUser()
3566 
          self.success.read(iprot)
3567 
        else:
3568 
          iprot.skip(ftype)
3569 
      elif fid == 1:
3570 
        if ftype == TType.STRUCT:
3571 
          self.hse = HelperServiceException()
3572 
          self.hse.read(iprot)
3573 
        else:
3574 
          iprot.skip(ftype)
3575 
      else:
3576 
        iprot.skip(ftype)
3577 
      iprot.readFieldEnd()
3578 
    iprot.readStructEnd()
3579 
 
3580 
  def write(self, oprot):
3581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3583 
      return
3584 
    oprot.writeStructBegin('authenticateCatalogUser_result')
3585 
    if self.success != None:
3586 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3587 
      self.success.write(oprot)
3588 
      oprot.writeFieldEnd()
3589 
    if self.hse != None:
3590 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3591 
      self.hse.write(oprot)
3592 
      oprot.writeFieldEnd()
3593 
    oprot.writeFieldStop()
3594 
    oprot.writeStructEnd()
3595 
 
3596 
  def __repr__(self):
3597 
    L = ['%s=%r' % (key, value)
3598 
      for key, value in self.__dict__.iteritems()]
3599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3600 
 
3601 
  def __eq__(self, other):
3602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3603 
 
3604 
  def __ne__(self, other):
3605 
    return not (self == other)
3606 
 
3607