Subversion Repositories SmartDukaan

Rev

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