Subversion Repositories SmartDukaan

Rev

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