Subversion Repositories SmartDukaan

Rev

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

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