Subversion Repositories SmartDukaan

Rev

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