Subversion Repositories SmartDukaan

Rev

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