Subversion Repositories SmartDukaan

Rev

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