Subversion Repositories SmartDukaan

Rev

Rev 494 | Rev 765 | 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:
19 
  def sendMail(self, mail):
20 
    """
21 
    Parameters:
22 
     - mail
23 
    """
24 
    pass
25 
 
26 
  def sendText(self, message):
27 
    """
28 
    Parameters:
29 
     - message
30 
    """
31 
    pass
32 
 
33 
  def addMessage(self, message):
34 
    """
35 
    Parameters:
36 
     - message
37 
    """
38 
    pass
39 
 
40 
  def updateMessage(self, id, message):
41 
    """
42 
    Parameters:
43 
     - id
44 
     - message
45 
    """
46 
    pass
47 
 
48 
  def getMessage(self, id):
49 
    """
50 
    Parameters:
51 
     - id
52 
    """
53 
    pass
54 
 
55 
  def getSubstitutedMessage(self, id, params):
56 
    """
57 
    Parameters:
58 
     - id
59 
     - params
60 
    """
61 
    pass
62 
 
494 rajveer 63 
  def addUser(self, username, password, warehouseId):
64 
    """
65 
    Parameters:
66 
     - username
67 
     - password
68 
     - warehouseId
69 
    """
70 
    pass
349 ashish 71 
 
494 rajveer 72 
  def deleteUser(self, username):
73 
    """
74 
    Parameters:
75 
     - username
76 
    """
77 
    pass
78 
 
79 
  def authenticateUser(self, username, password):
80 
    """
759 chandransh 81 
    Returns the warehouseId for the given user if the password matches. Returns -1 otherwise.
82 
    The loggedOn timestamp for the dashboard user is updated as a timestamp.
83 
    It's unclear to me when an exception is thrown : Chandranshu
84 
 
494 rajveer 85 
    Parameters:
86 
     - username
87 
     - password
88 
    """
89 
    pass
90 
 
91 
  def updatePassword(self, username, oldPassword, newPassword):
92 
    """
93 
    Parameters:
94 
     - username
95 
     - oldPassword
96 
     - newPassword
97 
    """
98 
    pass
99 
 
759 chandransh 100 
  def authenticateLogisticsUser(self, username, password):
101 
    """
102 
    Returns the LogisticsUser struct associated with the given username and password if they match.
103 
    Throws an exception otherwise.
104 
 
105 
    Parameters:
106 
     - username
107 
     - password
108 
    """
109 
    pass
494 rajveer 110 
 
759 chandransh 111 
 
349 ashish 112 
class Client(Iface):
113 
  def __init__(self, iprot, oprot=None):
114 
    self._iprot = self._oprot = iprot
115 
    if oprot != None:
116 
      self._oprot = oprot
117 
    self._seqid = 0
118 
 
119 
  def sendMail(self, mail):
120 
    """
121 
    Parameters:
122 
     - mail
123 
    """
124 
    self.send_sendMail(mail)
125 
    self.recv_sendMail()
126 
 
127 
  def send_sendMail(self, mail):
128 
    self._oprot.writeMessageBegin('sendMail', TMessageType.CALL, self._seqid)
129 
    args = sendMail_args()
130 
    args.mail = mail
131 
    args.write(self._oprot)
132 
    self._oprot.writeMessageEnd()
133 
    self._oprot.trans.flush()
134 
 
135 
  def recv_sendMail(self, ):
136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
137 
    if mtype == TMessageType.EXCEPTION:
138 
      x = TApplicationException()
139 
      x.read(self._iprot)
140 
      self._iprot.readMessageEnd()
141 
      raise x
142 
    result = sendMail_result()
143 
    result.read(self._iprot)
144 
    self._iprot.readMessageEnd()
145 
    if result.se != None:
146 
      raise result.se
147 
    return
148 
 
149 
  def sendText(self, message):
150 
    """
151 
    Parameters:
152 
     - message
153 
    """
154 
    self.send_sendText(message)
155 
    self.recv_sendText()
156 
 
157 
  def send_sendText(self, message):
158 
    self._oprot.writeMessageBegin('sendText', TMessageType.CALL, self._seqid)
159 
    args = sendText_args()
160 
    args.message = message
161 
    args.write(self._oprot)
162 
    self._oprot.writeMessageEnd()
163 
    self._oprot.trans.flush()
164 
 
165 
  def recv_sendText(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 = sendText_result()
173 
    result.read(self._iprot)
174 
    self._iprot.readMessageEnd()
175 
    if result.se != None:
176 
      raise result.se
177 
    return
178 
 
179 
  def addMessage(self, message):
180 
    """
181 
    Parameters:
182 
     - message
183 
    """
184 
    self.send_addMessage(message)
185 
    self.recv_addMessage()
186 
 
187 
  def send_addMessage(self, message):
188 
    self._oprot.writeMessageBegin('addMessage', TMessageType.CALL, self._seqid)
189 
    args = addMessage_args()
190 
    args.message = message
191 
    args.write(self._oprot)
192 
    self._oprot.writeMessageEnd()
193 
    self._oprot.trans.flush()
194 
 
195 
  def recv_addMessage(self, ):
196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
197 
    if mtype == TMessageType.EXCEPTION:
198 
      x = TApplicationException()
199 
      x.read(self._iprot)
200 
      self._iprot.readMessageEnd()
201 
      raise x
202 
    result = addMessage_result()
203 
    result.read(self._iprot)
204 
    self._iprot.readMessageEnd()
205 
    if result.se != None:
206 
      raise result.se
207 
    return
208 
 
209 
  def updateMessage(self, id, message):
210 
    """
211 
    Parameters:
212 
     - id
213 
     - message
214 
    """
215 
    self.send_updateMessage(id, message)
216 
    self.recv_updateMessage()
217 
 
218 
  def send_updateMessage(self, id, message):
219 
    self._oprot.writeMessageBegin('updateMessage', TMessageType.CALL, self._seqid)
220 
    args = updateMessage_args()
221 
    args.id = id
222 
    args.message = message
223 
    args.write(self._oprot)
224 
    self._oprot.writeMessageEnd()
225 
    self._oprot.trans.flush()
226 
 
227 
  def recv_updateMessage(self, ):
228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
229 
    if mtype == TMessageType.EXCEPTION:
230 
      x = TApplicationException()
231 
      x.read(self._iprot)
232 
      self._iprot.readMessageEnd()
233 
      raise x
234 
    result = updateMessage_result()
235 
    result.read(self._iprot)
236 
    self._iprot.readMessageEnd()
237 
    if result.se != None:
238 
      raise result.se
239 
    return
240 
 
241 
  def getMessage(self, id):
242 
    """
243 
    Parameters:
244 
     - id
245 
    """
246 
    self.send_getMessage(id)
353 ashish 247 
    return self.recv_getMessage()
349 ashish 248 
 
249 
  def send_getMessage(self, id):
250 
    self._oprot.writeMessageBegin('getMessage', TMessageType.CALL, self._seqid)
251 
    args = getMessage_args()
252 
    args.id = id
253 
    args.write(self._oprot)
254 
    self._oprot.writeMessageEnd()
255 
    self._oprot.trans.flush()
256 
 
257 
  def recv_getMessage(self, ):
258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
259 
    if mtype == TMessageType.EXCEPTION:
260 
      x = TApplicationException()
261 
      x.read(self._iprot)
262 
      self._iprot.readMessageEnd()
263 
      raise x
264 
    result = getMessage_result()
265 
    result.read(self._iprot)
266 
    self._iprot.readMessageEnd()
353 ashish 267 
    if result.success != None:
268 
      return result.success
349 ashish 269 
    if result.se != None:
270 
      raise result.se
353 ashish 271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMessage failed: unknown result");
349 ashish 272 
 
273 
  def getSubstitutedMessage(self, id, params):
274 
    """
275 
    Parameters:
276 
     - id
277 
     - params
278 
    """
279 
    self.send_getSubstitutedMessage(id, params)
353 ashish 280 
    return self.recv_getSubstitutedMessage()
349 ashish 281 
 
282 
  def send_getSubstitutedMessage(self, id, params):
283 
    self._oprot.writeMessageBegin('getSubstitutedMessage', TMessageType.CALL, self._seqid)
284 
    args = getSubstitutedMessage_args()
285 
    args.id = id
286 
    args.params = params
287 
    args.write(self._oprot)
288 
    self._oprot.writeMessageEnd()
289 
    self._oprot.trans.flush()
290 
 
291 
  def recv_getSubstitutedMessage(self, ):
292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
293 
    if mtype == TMessageType.EXCEPTION:
294 
      x = TApplicationException()
295 
      x.read(self._iprot)
296 
      self._iprot.readMessageEnd()
297 
      raise x
298 
    result = getSubstitutedMessage_result()
299 
    result.read(self._iprot)
300 
    self._iprot.readMessageEnd()
353 ashish 301 
    if result.success != None:
302 
      return result.success
349 ashish 303 
    if result.se != None:
304 
      raise result.se
353 ashish 305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSubstitutedMessage failed: unknown result");
349 ashish 306 
 
494 rajveer 307 
  def addUser(self, username, password, warehouseId):
308 
    """
309 
    Parameters:
310 
     - username
311 
     - password
312 
     - warehouseId
313 
    """
314 
    self.send_addUser(username, password, warehouseId)
315 
    return self.recv_addUser()
349 ashish 316 
 
494 rajveer 317 
  def send_addUser(self, username, password, warehouseId):
318 
    self._oprot.writeMessageBegin('addUser', TMessageType.CALL, self._seqid)
319 
    args = addUser_args()
320 
    args.username = username
321 
    args.password = password
322 
    args.warehouseId = warehouseId
323 
    args.write(self._oprot)
324 
    self._oprot.writeMessageEnd()
325 
    self._oprot.trans.flush()
326 
 
327 
  def recv_addUser(self, ):
328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
329 
    if mtype == TMessageType.EXCEPTION:
330 
      x = TApplicationException()
331 
      x.read(self._iprot)
332 
      self._iprot.readMessageEnd()
333 
      raise x
334 
    result = addUser_result()
335 
    result.read(self._iprot)
336 
    self._iprot.readMessageEnd()
337 
    if result.success != None:
338 
      return result.success
339 
    if result.se != None:
340 
      raise result.se
341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addUser failed: unknown result");
342 
 
343 
  def deleteUser(self, username):
344 
    """
345 
    Parameters:
346 
     - username
347 
    """
348 
    self.send_deleteUser(username)
349 
    return self.recv_deleteUser()
350 
 
351 
  def send_deleteUser(self, username):
352 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
353 
    args = deleteUser_args()
354 
    args.username = username
355 
    args.write(self._oprot)
356 
    self._oprot.writeMessageEnd()
357 
    self._oprot.trans.flush()
358 
 
359 
  def recv_deleteUser(self, ):
360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
361 
    if mtype == TMessageType.EXCEPTION:
362 
      x = TApplicationException()
363 
      x.read(self._iprot)
364 
      self._iprot.readMessageEnd()
365 
      raise x
366 
    result = deleteUser_result()
367 
    result.read(self._iprot)
368 
    self._iprot.readMessageEnd()
369 
    if result.success != None:
370 
      return result.success
371 
    if result.se != None:
372 
      raise result.se
373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
374 
 
375 
  def authenticateUser(self, username, password):
376 
    """
759 chandransh 377 
    Returns the warehouseId for the given user if the password matches. Returns -1 otherwise.
378 
    The loggedOn timestamp for the dashboard user is updated as a timestamp.
379 
    It's unclear to me when an exception is thrown : Chandranshu
380 
 
494 rajveer 381 
    Parameters:
382 
     - username
383 
     - password
384 
    """
385 
    self.send_authenticateUser(username, password)
386 
    return self.recv_authenticateUser()
387 
 
388 
  def send_authenticateUser(self, username, password):
389 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
390 
    args = authenticateUser_args()
391 
    args.username = username
392 
    args.password = password
393 
    args.write(self._oprot)
394 
    self._oprot.writeMessageEnd()
395 
    self._oprot.trans.flush()
396 
 
397 
  def recv_authenticateUser(self, ):
398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
399 
    if mtype == TMessageType.EXCEPTION:
400 
      x = TApplicationException()
401 
      x.read(self._iprot)
402 
      self._iprot.readMessageEnd()
403 
      raise x
404 
    result = authenticateUser_result()
405 
    result.read(self._iprot)
406 
    self._iprot.readMessageEnd()
407 
    if result.success != None:
408 
      return result.success
409 
    if result.se != None:
410 
      raise result.se
411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
412 
 
413 
  def updatePassword(self, username, oldPassword, newPassword):
414 
    """
415 
    Parameters:
416 
     - username
417 
     - oldPassword
418 
     - newPassword
419 
    """
420 
    self.send_updatePassword(username, oldPassword, newPassword)
421 
    return self.recv_updatePassword()
422 
 
423 
  def send_updatePassword(self, username, oldPassword, newPassword):
424 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
425 
    args = updatePassword_args()
426 
    args.username = username
427 
    args.oldPassword = oldPassword
428 
    args.newPassword = newPassword
429 
    args.write(self._oprot)
430 
    self._oprot.writeMessageEnd()
431 
    self._oprot.trans.flush()
432 
 
433 
  def recv_updatePassword(self, ):
434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
435 
    if mtype == TMessageType.EXCEPTION:
436 
      x = TApplicationException()
437 
      x.read(self._iprot)
438 
      self._iprot.readMessageEnd()
439 
      raise x
440 
    result = updatePassword_result()
441 
    result.read(self._iprot)
442 
    self._iprot.readMessageEnd()
443 
    if result.success != None:
444 
      return result.success
445 
    if result.se != None:
446 
      raise result.se
447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
448 
 
759 chandransh 449 
  def authenticateLogisticsUser(self, username, password):
450 
    """
451 
    Returns the LogisticsUser struct associated with the given username and password if they match.
452 
    Throws an exception otherwise.
453 
 
454 
    Parameters:
455 
     - username
456 
     - password
457 
    """
458 
    self.send_authenticateLogisticsUser(username, password)
459 
    return self.recv_authenticateLogisticsUser()
494 rajveer 460 
 
759 chandransh 461 
  def send_authenticateLogisticsUser(self, username, password):
462 
    self._oprot.writeMessageBegin('authenticateLogisticsUser', TMessageType.CALL, self._seqid)
463 
    args = authenticateLogisticsUser_args()
464 
    args.username = username
465 
    args.password = password
466 
    args.write(self._oprot)
467 
    self._oprot.writeMessageEnd()
468 
    self._oprot.trans.flush()
469 
 
470 
  def recv_authenticateLogisticsUser(self, ):
471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
472 
    if mtype == TMessageType.EXCEPTION:
473 
      x = TApplicationException()
474 
      x.read(self._iprot)
475 
      self._iprot.readMessageEnd()
476 
      raise x
477 
    result = authenticateLogisticsUser_result()
478 
    result.read(self._iprot)
479 
    self._iprot.readMessageEnd()
480 
    if result.success != None:
481 
      return result.success
482 
    if result.hse != None:
483 
      raise result.hse
484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateLogisticsUser failed: unknown result");
485 
 
486 
 
349 ashish 487 
class Processor(Iface, TProcessor):
488 
  def __init__(self, handler):
489 
    self._handler = handler
490 
    self._processMap = {}
491 
    self._processMap["sendMail"] = Processor.process_sendMail
492 
    self._processMap["sendText"] = Processor.process_sendText
493 
    self._processMap["addMessage"] = Processor.process_addMessage
494 
    self._processMap["updateMessage"] = Processor.process_updateMessage
495 
    self._processMap["getMessage"] = Processor.process_getMessage
496 
    self._processMap["getSubstitutedMessage"] = Processor.process_getSubstitutedMessage
494 rajveer 497 
    self._processMap["addUser"] = Processor.process_addUser
498 
    self._processMap["deleteUser"] = Processor.process_deleteUser
499 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
500 
    self._processMap["updatePassword"] = Processor.process_updatePassword
759 chandransh 501 
    self._processMap["authenticateLogisticsUser"] = Processor.process_authenticateLogisticsUser
349 ashish 502 
 
503 
  def process(self, iprot, oprot):
504 
    (name, type, seqid) = iprot.readMessageBegin()
505 
    if name not in self._processMap:
506 
      iprot.skip(TType.STRUCT)
507 
      iprot.readMessageEnd()
508 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
509 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
510 
      x.write(oprot)
511 
      oprot.writeMessageEnd()
512 
      oprot.trans.flush()
513 
      return
514 
    else:
515 
      self._processMap[name](self, seqid, iprot, oprot)
516 
    return True
517 
 
518 
  def process_sendMail(self, seqid, iprot, oprot):
519 
    args = sendMail_args()
520 
    args.read(iprot)
521 
    iprot.readMessageEnd()
522 
    result = sendMail_result()
523 
    try:
524 
      self._handler.sendMail(args.mail)
525 
    except HelperServiceException, se:
526 
      result.se = se
527 
    oprot.writeMessageBegin("sendMail", TMessageType.REPLY, seqid)
528 
    result.write(oprot)
529 
    oprot.writeMessageEnd()
530 
    oprot.trans.flush()
531 
 
532 
  def process_sendText(self, seqid, iprot, oprot):
533 
    args = sendText_args()
534 
    args.read(iprot)
535 
    iprot.readMessageEnd()
536 
    result = sendText_result()
537 
    try:
538 
      self._handler.sendText(args.message)
539 
    except HelperServiceException, se:
540 
      result.se = se
541 
    oprot.writeMessageBegin("sendText", TMessageType.REPLY, seqid)
542 
    result.write(oprot)
543 
    oprot.writeMessageEnd()
544 
    oprot.trans.flush()
545 
 
546 
  def process_addMessage(self, seqid, iprot, oprot):
547 
    args = addMessage_args()
548 
    args.read(iprot)
549 
    iprot.readMessageEnd()
550 
    result = addMessage_result()
551 
    try:
552 
      self._handler.addMessage(args.message)
553 
    except HelperServiceException, se:
554 
      result.se = se
555 
    oprot.writeMessageBegin("addMessage", TMessageType.REPLY, seqid)
556 
    result.write(oprot)
557 
    oprot.writeMessageEnd()
558 
    oprot.trans.flush()
559 
 
560 
  def process_updateMessage(self, seqid, iprot, oprot):
561 
    args = updateMessage_args()
562 
    args.read(iprot)
563 
    iprot.readMessageEnd()
564 
    result = updateMessage_result()
565 
    try:
566 
      self._handler.updateMessage(args.id, args.message)
567 
    except HelperServiceException, se:
568 
      result.se = se
569 
    oprot.writeMessageBegin("updateMessage", TMessageType.REPLY, seqid)
570 
    result.write(oprot)
571 
    oprot.writeMessageEnd()
572 
    oprot.trans.flush()
573 
 
574 
  def process_getMessage(self, seqid, iprot, oprot):
575 
    args = getMessage_args()
576 
    args.read(iprot)
577 
    iprot.readMessageEnd()
578 
    result = getMessage_result()
579 
    try:
353 ashish 580 
      result.success = self._handler.getMessage(args.id)
349 ashish 581 
    except HelperServiceException, se:
582 
      result.se = se
583 
    oprot.writeMessageBegin("getMessage", TMessageType.REPLY, seqid)
584 
    result.write(oprot)
585 
    oprot.writeMessageEnd()
586 
    oprot.trans.flush()
587 
 
588 
  def process_getSubstitutedMessage(self, seqid, iprot, oprot):
589 
    args = getSubstitutedMessage_args()
590 
    args.read(iprot)
591 
    iprot.readMessageEnd()
592 
    result = getSubstitutedMessage_result()
593 
    try:
353 ashish 594 
      result.success = self._handler.getSubstitutedMessage(args.id, args.params)
349 ashish 595 
    except HelperServiceException, se:
596 
      result.se = se
597 
    oprot.writeMessageBegin("getSubstitutedMessage", TMessageType.REPLY, seqid)
598 
    result.write(oprot)
599 
    oprot.writeMessageEnd()
600 
    oprot.trans.flush()
601 
 
494 rajveer 602 
  def process_addUser(self, seqid, iprot, oprot):
603 
    args = addUser_args()
604 
    args.read(iprot)
605 
    iprot.readMessageEnd()
606 
    result = addUser_result()
607 
    try:
608 
      result.success = self._handler.addUser(args.username, args.password, args.warehouseId)
609 
    except HelperServiceException, se:
610 
      result.se = se
611 
    oprot.writeMessageBegin("addUser", TMessageType.REPLY, seqid)
612 
    result.write(oprot)
613 
    oprot.writeMessageEnd()
614 
    oprot.trans.flush()
349 ashish 615 
 
494 rajveer 616 
  def process_deleteUser(self, seqid, iprot, oprot):
617 
    args = deleteUser_args()
618 
    args.read(iprot)
619 
    iprot.readMessageEnd()
620 
    result = deleteUser_result()
621 
    try:
622 
      result.success = self._handler.deleteUser(args.username)
623 
    except HelperServiceException, se:
624 
      result.se = se
625 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
626 
    result.write(oprot)
627 
    oprot.writeMessageEnd()
628 
    oprot.trans.flush()
629 
 
630 
  def process_authenticateUser(self, seqid, iprot, oprot):
631 
    args = authenticateUser_args()
632 
    args.read(iprot)
633 
    iprot.readMessageEnd()
634 
    result = authenticateUser_result()
635 
    try:
636 
      result.success = self._handler.authenticateUser(args.username, args.password)
637 
    except HelperServiceException, se:
638 
      result.se = se
639 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
640 
    result.write(oprot)
641 
    oprot.writeMessageEnd()
642 
    oprot.trans.flush()
643 
 
644 
  def process_updatePassword(self, seqid, iprot, oprot):
645 
    args = updatePassword_args()
646 
    args.read(iprot)
647 
    iprot.readMessageEnd()
648 
    result = updatePassword_result()
649 
    try:
650 
      result.success = self._handler.updatePassword(args.username, args.oldPassword, args.newPassword)
651 
    except HelperServiceException, se:
652 
      result.se = se
653 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
654 
    result.write(oprot)
655 
    oprot.writeMessageEnd()
656 
    oprot.trans.flush()
657 
 
759 chandransh 658 
  def process_authenticateLogisticsUser(self, seqid, iprot, oprot):
659 
    args = authenticateLogisticsUser_args()
660 
    args.read(iprot)
661 
    iprot.readMessageEnd()
662 
    result = authenticateLogisticsUser_result()
663 
    try:
664 
      result.success = self._handler.authenticateLogisticsUser(args.username, args.password)
665 
    except HelperServiceException, hse:
666 
      result.hse = hse
667 
    oprot.writeMessageBegin("authenticateLogisticsUser", TMessageType.REPLY, seqid)
668 
    result.write(oprot)
669 
    oprot.writeMessageEnd()
670 
    oprot.trans.flush()
494 rajveer 671 
 
759 chandransh 672 
 
349 ashish 673 
# HELPER FUNCTIONS AND STRUCTURES
674 
 
675 
class sendMail_args:
676 
  """
677 
  Attributes:
678 
   - mail
679 
  """
680 
 
681 
  thrift_spec = (
682 
    None, # 0
683 
    (1, TType.STRUCT, 'mail', (Mail, Mail.thrift_spec), None, ), # 1
684 
  )
685 
 
686 
  def __init__(self, mail=None,):
687 
    self.mail = mail
688 
 
689 
  def read(self, iprot):
690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
692 
      return
693 
    iprot.readStructBegin()
694 
    while True:
695 
      (fname, ftype, fid) = iprot.readFieldBegin()
696 
      if ftype == TType.STOP:
697 
        break
698 
      if fid == 1:
699 
        if ftype == TType.STRUCT:
700 
          self.mail = Mail()
701 
          self.mail.read(iprot)
702 
        else:
703 
          iprot.skip(ftype)
704 
      else:
705 
        iprot.skip(ftype)
706 
      iprot.readFieldEnd()
707 
    iprot.readStructEnd()
708 
 
709 
  def write(self, oprot):
710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
712 
      return
713 
    oprot.writeStructBegin('sendMail_args')
714 
    if self.mail != None:
715 
      oprot.writeFieldBegin('mail', TType.STRUCT, 1)
716 
      self.mail.write(oprot)
717 
      oprot.writeFieldEnd()
718 
    oprot.writeFieldStop()
719 
    oprot.writeStructEnd()
720 
 
721 
  def __repr__(self):
722 
    L = ['%s=%r' % (key, value)
723 
      for key, value in self.__dict__.iteritems()]
724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
725 
 
726 
  def __eq__(self, other):
727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
728 
 
729 
  def __ne__(self, other):
730 
    return not (self == other)
731 
 
732 
class sendMail_result:
733 
  """
734 
  Attributes:
735 
   - se
736 
  """
737 
 
738 
  thrift_spec = (
739 
    None, # 0
740 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
741 
  )
742 
 
743 
  def __init__(self, se=None,):
744 
    self.se = se
745 
 
746 
  def read(self, iprot):
747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
749 
      return
750 
    iprot.readStructBegin()
751 
    while True:
752 
      (fname, ftype, fid) = iprot.readFieldBegin()
753 
      if ftype == TType.STOP:
754 
        break
755 
      if fid == 1:
756 
        if ftype == TType.STRUCT:
757 
          self.se = HelperServiceException()
758 
          self.se.read(iprot)
759 
        else:
760 
          iprot.skip(ftype)
761 
      else:
762 
        iprot.skip(ftype)
763 
      iprot.readFieldEnd()
764 
    iprot.readStructEnd()
765 
 
766 
  def write(self, oprot):
767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
769 
      return
770 
    oprot.writeStructBegin('sendMail_result')
771 
    if self.se != None:
772 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
773 
      self.se.write(oprot)
774 
      oprot.writeFieldEnd()
775 
    oprot.writeFieldStop()
776 
    oprot.writeStructEnd()
777 
 
778 
  def __repr__(self):
779 
    L = ['%s=%r' % (key, value)
780 
      for key, value in self.__dict__.iteritems()]
781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
782 
 
783 
  def __eq__(self, other):
784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
785 
 
786 
  def __ne__(self, other):
787 
    return not (self == other)
788 
 
789 
class sendText_args:
790 
  """
791 
  Attributes:
792 
   - message
793 
  """
794 
 
795 
  thrift_spec = (
796 
    None, # 0
797 
    (1, TType.STRUCT, 'message', (TextMessage, TextMessage.thrift_spec), None, ), # 1
798 
  )
799 
 
800 
  def __init__(self, message=None,):
801 
    self.message = message
802 
 
803 
  def read(self, iprot):
804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
806 
      return
807 
    iprot.readStructBegin()
808 
    while True:
809 
      (fname, ftype, fid) = iprot.readFieldBegin()
810 
      if ftype == TType.STOP:
811 
        break
812 
      if fid == 1:
813 
        if ftype == TType.STRUCT:
814 
          self.message = TextMessage()
815 
          self.message.read(iprot)
816 
        else:
817 
          iprot.skip(ftype)
818 
      else:
819 
        iprot.skip(ftype)
820 
      iprot.readFieldEnd()
821 
    iprot.readStructEnd()
822 
 
823 
  def write(self, oprot):
824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
826 
      return
827 
    oprot.writeStructBegin('sendText_args')
828 
    if self.message != None:
829 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
830 
      self.message.write(oprot)
831 
      oprot.writeFieldEnd()
832 
    oprot.writeFieldStop()
833 
    oprot.writeStructEnd()
834 
 
835 
  def __repr__(self):
836 
    L = ['%s=%r' % (key, value)
837 
      for key, value in self.__dict__.iteritems()]
838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
839 
 
840 
  def __eq__(self, other):
841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
842 
 
843 
  def __ne__(self, other):
844 
    return not (self == other)
845 
 
846 
class sendText_result:
847 
  """
848 
  Attributes:
849 
   - se
850 
  """
851 
 
852 
  thrift_spec = (
853 
    None, # 0
854 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
855 
  )
856 
 
857 
  def __init__(self, se=None,):
858 
    self.se = se
859 
 
860 
  def read(self, iprot):
861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
863 
      return
864 
    iprot.readStructBegin()
865 
    while True:
866 
      (fname, ftype, fid) = iprot.readFieldBegin()
867 
      if ftype == TType.STOP:
868 
        break
869 
      if fid == 1:
870 
        if ftype == TType.STRUCT:
871 
          self.se = HelperServiceException()
872 
          self.se.read(iprot)
873 
        else:
874 
          iprot.skip(ftype)
875 
      else:
876 
        iprot.skip(ftype)
877 
      iprot.readFieldEnd()
878 
    iprot.readStructEnd()
879 
 
880 
  def write(self, oprot):
881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
883 
      return
884 
    oprot.writeStructBegin('sendText_result')
885 
    if self.se != None:
886 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
887 
      self.se.write(oprot)
888 
      oprot.writeFieldEnd()
889 
    oprot.writeFieldStop()
890 
    oprot.writeStructEnd()
891 
 
892 
  def __repr__(self):
893 
    L = ['%s=%r' % (key, value)
894 
      for key, value in self.__dict__.iteritems()]
895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
896 
 
897 
  def __eq__(self, other):
898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
899 
 
900 
  def __ne__(self, other):
901 
    return not (self == other)
902 
 
903 
class addMessage_args:
904 
  """
905 
  Attributes:
906 
   - message
907 
  """
908 
 
909 
  thrift_spec = (
910 
    None, # 0
911 
    (1, TType.STRUCT, 'message', (Message, Message.thrift_spec), None, ), # 1
912 
  )
913 
 
914 
  def __init__(self, message=None,):
915 
    self.message = message
916 
 
917 
  def read(self, iprot):
918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
920 
      return
921 
    iprot.readStructBegin()
922 
    while True:
923 
      (fname, ftype, fid) = iprot.readFieldBegin()
924 
      if ftype == TType.STOP:
925 
        break
926 
      if fid == 1:
927 
        if ftype == TType.STRUCT:
928 
          self.message = Message()
929 
          self.message.read(iprot)
930 
        else:
931 
          iprot.skip(ftype)
932 
      else:
933 
        iprot.skip(ftype)
934 
      iprot.readFieldEnd()
935 
    iprot.readStructEnd()
936 
 
937 
  def write(self, oprot):
938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
940 
      return
941 
    oprot.writeStructBegin('addMessage_args')
942 
    if self.message != None:
943 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
944 
      self.message.write(oprot)
945 
      oprot.writeFieldEnd()
946 
    oprot.writeFieldStop()
947 
    oprot.writeStructEnd()
948 
 
949 
  def __repr__(self):
950 
    L = ['%s=%r' % (key, value)
951 
      for key, value in self.__dict__.iteritems()]
952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
953 
 
954 
  def __eq__(self, other):
955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
956 
 
957 
  def __ne__(self, other):
958 
    return not (self == other)
959 
 
960 
class addMessage_result:
961 
  """
962 
  Attributes:
963 
   - se
964 
  """
965 
 
966 
  thrift_spec = (
967 
    None, # 0
968 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
969 
  )
970 
 
971 
  def __init__(self, se=None,):
972 
    self.se = se
973 
 
974 
  def read(self, iprot):
975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
977 
      return
978 
    iprot.readStructBegin()
979 
    while True:
980 
      (fname, ftype, fid) = iprot.readFieldBegin()
981 
      if ftype == TType.STOP:
982 
        break
983 
      if fid == 1:
984 
        if ftype == TType.STRUCT:
985 
          self.se = HelperServiceException()
986 
          self.se.read(iprot)
987 
        else:
988 
          iprot.skip(ftype)
989 
      else:
990 
        iprot.skip(ftype)
991 
      iprot.readFieldEnd()
992 
    iprot.readStructEnd()
993 
 
994 
  def write(self, oprot):
995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
997 
      return
998 
    oprot.writeStructBegin('addMessage_result')
999 
    if self.se != None:
1000 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1001 
      self.se.write(oprot)
1002 
      oprot.writeFieldEnd()
1003 
    oprot.writeFieldStop()
1004 
    oprot.writeStructEnd()
1005 
 
1006 
  def __repr__(self):
1007 
    L = ['%s=%r' % (key, value)
1008 
      for key, value in self.__dict__.iteritems()]
1009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1010 
 
1011 
  def __eq__(self, other):
1012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1013 
 
1014 
  def __ne__(self, other):
1015 
    return not (self == other)
1016 
 
1017 
class updateMessage_args:
1018 
  """
1019 
  Attributes:
1020 
   - id
1021 
   - message
1022 
  """
1023 
 
1024 
  thrift_spec = (
1025 
    None, # 0
1026 
    (1, TType.I64, 'id', None, None, ), # 1
1027 
    (2, TType.STRING, 'message', None, None, ), # 2
1028 
  )
1029 
 
1030 
  def __init__(self, id=None, message=None,):
1031 
    self.id = id
1032 
    self.message = message
1033 
 
1034 
  def read(self, iprot):
1035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1037 
      return
1038 
    iprot.readStructBegin()
1039 
    while True:
1040 
      (fname, ftype, fid) = iprot.readFieldBegin()
1041 
      if ftype == TType.STOP:
1042 
        break
1043 
      if fid == 1:
1044 
        if ftype == TType.I64:
1045 
          self.id = iprot.readI64();
1046 
        else:
1047 
          iprot.skip(ftype)
1048 
      elif fid == 2:
1049 
        if ftype == TType.STRING:
1050 
          self.message = iprot.readString();
1051 
        else:
1052 
          iprot.skip(ftype)
1053 
      else:
1054 
        iprot.skip(ftype)
1055 
      iprot.readFieldEnd()
1056 
    iprot.readStructEnd()
1057 
 
1058 
  def write(self, oprot):
1059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1061 
      return
1062 
    oprot.writeStructBegin('updateMessage_args')
1063 
    if self.id != None:
1064 
      oprot.writeFieldBegin('id', TType.I64, 1)
1065 
      oprot.writeI64(self.id)
1066 
      oprot.writeFieldEnd()
1067 
    if self.message != None:
1068 
      oprot.writeFieldBegin('message', TType.STRING, 2)
1069 
      oprot.writeString(self.message)
1070 
      oprot.writeFieldEnd()
1071 
    oprot.writeFieldStop()
1072 
    oprot.writeStructEnd()
1073 
 
1074 
  def __repr__(self):
1075 
    L = ['%s=%r' % (key, value)
1076 
      for key, value in self.__dict__.iteritems()]
1077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1078 
 
1079 
  def __eq__(self, other):
1080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1081 
 
1082 
  def __ne__(self, other):
1083 
    return not (self == other)
1084 
 
1085 
class updateMessage_result:
1086 
  """
1087 
  Attributes:
1088 
   - se
1089 
  """
1090 
 
1091 
  thrift_spec = (
1092 
    None, # 0
1093 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1094 
  )
1095 
 
1096 
  def __init__(self, se=None,):
1097 
    self.se = se
1098 
 
1099 
  def read(self, iprot):
1100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1102 
      return
1103 
    iprot.readStructBegin()
1104 
    while True:
1105 
      (fname, ftype, fid) = iprot.readFieldBegin()
1106 
      if ftype == TType.STOP:
1107 
        break
1108 
      if fid == 1:
1109 
        if ftype == TType.STRUCT:
1110 
          self.se = HelperServiceException()
1111 
          self.se.read(iprot)
1112 
        else:
1113 
          iprot.skip(ftype)
1114 
      else:
1115 
        iprot.skip(ftype)
1116 
      iprot.readFieldEnd()
1117 
    iprot.readStructEnd()
1118 
 
1119 
  def write(self, oprot):
1120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1122 
      return
1123 
    oprot.writeStructBegin('updateMessage_result')
1124 
    if self.se != None:
1125 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1126 
      self.se.write(oprot)
1127 
      oprot.writeFieldEnd()
1128 
    oprot.writeFieldStop()
1129 
    oprot.writeStructEnd()
1130 
 
1131 
  def __repr__(self):
1132 
    L = ['%s=%r' % (key, value)
1133 
      for key, value in self.__dict__.iteritems()]
1134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1135 
 
1136 
  def __eq__(self, other):
1137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1138 
 
1139 
  def __ne__(self, other):
1140 
    return not (self == other)
1141 
 
1142 
class getMessage_args:
1143 
  """
1144 
  Attributes:
1145 
   - id
1146 
  """
1147 
 
1148 
  thrift_spec = (
1149 
    None, # 0
1150 
    (1, TType.I64, 'id', None, None, ), # 1
1151 
  )
1152 
 
1153 
  def __init__(self, id=None,):
1154 
    self.id = id
1155 
 
1156 
  def read(self, iprot):
1157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1159 
      return
1160 
    iprot.readStructBegin()
1161 
    while True:
1162 
      (fname, ftype, fid) = iprot.readFieldBegin()
1163 
      if ftype == TType.STOP:
1164 
        break
1165 
      if fid == 1:
1166 
        if ftype == TType.I64:
1167 
          self.id = iprot.readI64();
1168 
        else:
1169 
          iprot.skip(ftype)
1170 
      else:
1171 
        iprot.skip(ftype)
1172 
      iprot.readFieldEnd()
1173 
    iprot.readStructEnd()
1174 
 
1175 
  def write(self, oprot):
1176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1178 
      return
1179 
    oprot.writeStructBegin('getMessage_args')
1180 
    if self.id != None:
1181 
      oprot.writeFieldBegin('id', TType.I64, 1)
1182 
      oprot.writeI64(self.id)
1183 
      oprot.writeFieldEnd()
1184 
    oprot.writeFieldStop()
1185 
    oprot.writeStructEnd()
1186 
 
1187 
  def __repr__(self):
1188 
    L = ['%s=%r' % (key, value)
1189 
      for key, value in self.__dict__.iteritems()]
1190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1191 
 
1192 
  def __eq__(self, other):
1193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1194 
 
1195 
  def __ne__(self, other):
1196 
    return not (self == other)
1197 
 
1198 
class getMessage_result:
1199 
  """
1200 
  Attributes:
353 ashish 1201 
   - success
349 ashish 1202 
   - se
1203 
  """
1204 
 
1205 
  thrift_spec = (
353 ashish 1206 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 1207 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1208 
  )
1209 
 
353 ashish 1210 
  def __init__(self, success=None, se=None,):
1211 
    self.success = success
349 ashish 1212 
    self.se = se
1213 
 
1214 
  def read(self, iprot):
1215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1217 
      return
1218 
    iprot.readStructBegin()
1219 
    while True:
1220 
      (fname, ftype, fid) = iprot.readFieldBegin()
1221 
      if ftype == TType.STOP:
1222 
        break
353 ashish 1223 
      if fid == 0:
349 ashish 1224 
        if ftype == TType.STRUCT:
353 ashish 1225 
          self.success = Message()
1226 
          self.success.read(iprot)
1227 
        else:
1228 
          iprot.skip(ftype)
1229 
      elif fid == 1:
1230 
        if ftype == TType.STRUCT:
349 ashish 1231 
          self.se = HelperServiceException()
1232 
          self.se.read(iprot)
1233 
        else:
1234 
          iprot.skip(ftype)
1235 
      else:
1236 
        iprot.skip(ftype)
1237 
      iprot.readFieldEnd()
1238 
    iprot.readStructEnd()
1239 
 
1240 
  def write(self, oprot):
1241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1243 
      return
1244 
    oprot.writeStructBegin('getMessage_result')
353 ashish 1245 
    if self.success != None:
1246 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1247 
      self.success.write(oprot)
1248 
      oprot.writeFieldEnd()
349 ashish 1249 
    if self.se != None:
1250 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1251 
      self.se.write(oprot)
1252 
      oprot.writeFieldEnd()
1253 
    oprot.writeFieldStop()
1254 
    oprot.writeStructEnd()
1255 
 
1256 
  def __repr__(self):
1257 
    L = ['%s=%r' % (key, value)
1258 
      for key, value in self.__dict__.iteritems()]
1259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1260 
 
1261 
  def __eq__(self, other):
1262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1263 
 
1264 
  def __ne__(self, other):
1265 
    return not (self == other)
1266 
 
1267 
class getSubstitutedMessage_args:
1268 
  """
1269 
  Attributes:
1270 
   - id
1271 
   - params
1272 
  """
1273 
 
1274 
  thrift_spec = (
1275 
    None, # 0
1276 
    (1, TType.I64, 'id', None, None, ), # 1
1277 
    (2, TType.MAP, 'params', (TType.STRING,None,TType.STRING,None), None, ), # 2
1278 
  )
1279 
 
1280 
  def __init__(self, id=None, params=None,):
1281 
    self.id = id
1282 
    self.params = params
1283 
 
1284 
  def read(self, iprot):
1285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1287 
      return
1288 
    iprot.readStructBegin()
1289 
    while True:
1290 
      (fname, ftype, fid) = iprot.readFieldBegin()
1291 
      if ftype == TType.STOP:
1292 
        break
1293 
      if fid == 1:
1294 
        if ftype == TType.I64:
1295 
          self.id = iprot.readI64();
1296 
        else:
1297 
          iprot.skip(ftype)
1298 
      elif fid == 2:
1299 
        if ftype == TType.MAP:
1300 
          self.params = {}
472 rajveer 1301 
          (_ktype15, _vtype16, _size14 ) = iprot.readMapBegin()
1302 
          for _i18 in xrange(_size14):
1303 
            _key19 = iprot.readString();
1304 
            _val20 = iprot.readString();
1305 
            self.params[_key19] = _val20
349 ashish 1306 
          iprot.readMapEnd()
1307 
        else:
1308 
          iprot.skip(ftype)
1309 
      else:
1310 
        iprot.skip(ftype)
1311 
      iprot.readFieldEnd()
1312 
    iprot.readStructEnd()
1313 
 
1314 
  def write(self, oprot):
1315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1317 
      return
1318 
    oprot.writeStructBegin('getSubstitutedMessage_args')
1319 
    if self.id != None:
1320 
      oprot.writeFieldBegin('id', TType.I64, 1)
1321 
      oprot.writeI64(self.id)
1322 
      oprot.writeFieldEnd()
1323 
    if self.params != None:
1324 
      oprot.writeFieldBegin('params', TType.MAP, 2)
1325 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.params))
472 rajveer 1326 
      for kiter21,viter22 in self.params.items():
1327 
        oprot.writeString(kiter21)
1328 
        oprot.writeString(viter22)
349 ashish 1329 
      oprot.writeMapEnd()
1330 
      oprot.writeFieldEnd()
1331 
    oprot.writeFieldStop()
1332 
    oprot.writeStructEnd()
1333 
 
1334 
  def __repr__(self):
1335 
    L = ['%s=%r' % (key, value)
1336 
      for key, value in self.__dict__.iteritems()]
1337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1338 
 
1339 
  def __eq__(self, other):
1340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1341 
 
1342 
  def __ne__(self, other):
1343 
    return not (self == other)
1344 
 
1345 
class getSubstitutedMessage_result:
1346 
  """
1347 
  Attributes:
353 ashish 1348 
   - success
349 ashish 1349 
   - se
1350 
  """
1351 
 
1352 
  thrift_spec = (
353 ashish 1353 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 1354 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1355 
  )
1356 
 
353 ashish 1357 
  def __init__(self, success=None, se=None,):
1358 
    self.success = success
349 ashish 1359 
    self.se = se
1360 
 
1361 
  def read(self, iprot):
1362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1364 
      return
1365 
    iprot.readStructBegin()
1366 
    while True:
1367 
      (fname, ftype, fid) = iprot.readFieldBegin()
1368 
      if ftype == TType.STOP:
1369 
        break
353 ashish 1370 
      if fid == 0:
349 ashish 1371 
        if ftype == TType.STRUCT:
353 ashish 1372 
          self.success = Message()
1373 
          self.success.read(iprot)
1374 
        else:
1375 
          iprot.skip(ftype)
1376 
      elif fid == 1:
1377 
        if ftype == TType.STRUCT:
349 ashish 1378 
          self.se = HelperServiceException()
1379 
          self.se.read(iprot)
1380 
        else:
1381 
          iprot.skip(ftype)
1382 
      else:
1383 
        iprot.skip(ftype)
1384 
      iprot.readFieldEnd()
1385 
    iprot.readStructEnd()
1386 
 
1387 
  def write(self, oprot):
1388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1390 
      return
1391 
    oprot.writeStructBegin('getSubstitutedMessage_result')
353 ashish 1392 
    if self.success != None:
1393 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1394 
      self.success.write(oprot)
1395 
      oprot.writeFieldEnd()
349 ashish 1396 
    if self.se != None:
1397 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1398 
      self.se.write(oprot)
1399 
      oprot.writeFieldEnd()
1400 
    oprot.writeFieldStop()
1401 
    oprot.writeStructEnd()
1402 
 
1403 
  def __repr__(self):
1404 
    L = ['%s=%r' % (key, value)
1405 
      for key, value in self.__dict__.iteritems()]
1406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1407 
 
1408 
  def __eq__(self, other):
1409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1410 
 
1411 
  def __ne__(self, other):
1412 
    return not (self == other)
1413 
 
494 rajveer 1414 
class addUser_args:
1415 
  """
1416 
  Attributes:
1417 
   - username
1418 
   - password
1419 
   - warehouseId
1420 
  """
349 ashish 1421 
 
494 rajveer 1422 
  thrift_spec = (
1423 
    None, # 0
1424 
    (1, TType.STRING, 'username', None, None, ), # 1
1425 
    (2, TType.STRING, 'password', None, None, ), # 2
1426 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
1427 
  )
1428 
 
1429 
  def __init__(self, username=None, password=None, warehouseId=None,):
1430 
    self.username = username
1431 
    self.password = password
1432 
    self.warehouseId = warehouseId
1433 
 
1434 
  def read(self, iprot):
1435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1437 
      return
1438 
    iprot.readStructBegin()
1439 
    while True:
1440 
      (fname, ftype, fid) = iprot.readFieldBegin()
1441 
      if ftype == TType.STOP:
1442 
        break
1443 
      if fid == 1:
1444 
        if ftype == TType.STRING:
1445 
          self.username = iprot.readString();
1446 
        else:
1447 
          iprot.skip(ftype)
1448 
      elif fid == 2:
1449 
        if ftype == TType.STRING:
1450 
          self.password = iprot.readString();
1451 
        else:
1452 
          iprot.skip(ftype)
1453 
      elif fid == 3:
1454 
        if ftype == TType.I64:
1455 
          self.warehouseId = iprot.readI64();
1456 
        else:
1457 
          iprot.skip(ftype)
1458 
      else:
1459 
        iprot.skip(ftype)
1460 
      iprot.readFieldEnd()
1461 
    iprot.readStructEnd()
1462 
 
1463 
  def write(self, oprot):
1464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1466 
      return
1467 
    oprot.writeStructBegin('addUser_args')
1468 
    if self.username != None:
1469 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1470 
      oprot.writeString(self.username)
1471 
      oprot.writeFieldEnd()
1472 
    if self.password != None:
1473 
      oprot.writeFieldBegin('password', TType.STRING, 2)
1474 
      oprot.writeString(self.password)
1475 
      oprot.writeFieldEnd()
1476 
    if self.warehouseId != None:
1477 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
1478 
      oprot.writeI64(self.warehouseId)
1479 
      oprot.writeFieldEnd()
1480 
    oprot.writeFieldStop()
1481 
    oprot.writeStructEnd()
1482 
 
1483 
  def __repr__(self):
1484 
    L = ['%s=%r' % (key, value)
1485 
      for key, value in self.__dict__.iteritems()]
1486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1487 
 
1488 
  def __eq__(self, other):
1489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1490 
 
1491 
  def __ne__(self, other):
1492 
    return not (self == other)
1493 
 
1494 
class addUser_result:
1495 
  """
1496 
  Attributes:
1497 
   - success
1498 
   - se
1499 
  """
1500 
 
1501 
  thrift_spec = (
1502 
    (0, TType.BOOL, 'success', None, None, ), # 0
1503 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1504 
  )
1505 
 
1506 
  def __init__(self, success=None, se=None,):
1507 
    self.success = success
1508 
    self.se = se
1509 
 
1510 
  def read(self, iprot):
1511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1513 
      return
1514 
    iprot.readStructBegin()
1515 
    while True:
1516 
      (fname, ftype, fid) = iprot.readFieldBegin()
1517 
      if ftype == TType.STOP:
1518 
        break
1519 
      if fid == 0:
1520 
        if ftype == TType.BOOL:
1521 
          self.success = iprot.readBool();
1522 
        else:
1523 
          iprot.skip(ftype)
1524 
      elif fid == 1:
1525 
        if ftype == TType.STRUCT:
1526 
          self.se = HelperServiceException()
1527 
          self.se.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('addUser_result')
1540 
    if self.success != None:
1541 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1542 
      oprot.writeBool(self.success)
1543 
      oprot.writeFieldEnd()
1544 
    if self.se != None:
1545 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1546 
      self.se.write(oprot)
1547 
      oprot.writeFieldEnd()
1548 
    oprot.writeFieldStop()
1549 
    oprot.writeStructEnd()
1550 
 
1551 
  def __repr__(self):
1552 
    L = ['%s=%r' % (key, value)
1553 
      for key, value in self.__dict__.iteritems()]
1554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1555 
 
1556 
  def __eq__(self, other):
1557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1558 
 
1559 
  def __ne__(self, other):
1560 
    return not (self == other)
1561 
 
1562 
class deleteUser_args:
1563 
  """
1564 
  Attributes:
1565 
   - username
1566 
  """
1567 
 
1568 
  thrift_spec = (
1569 
    None, # 0
1570 
    (1, TType.STRING, 'username', None, None, ), # 1
1571 
  )
1572 
 
1573 
  def __init__(self, username=None,):
1574 
    self.username = username
1575 
 
1576 
  def read(self, iprot):
1577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1579 
      return
1580 
    iprot.readStructBegin()
1581 
    while True:
1582 
      (fname, ftype, fid) = iprot.readFieldBegin()
1583 
      if ftype == TType.STOP:
1584 
        break
1585 
      if fid == 1:
1586 
        if ftype == TType.STRING:
1587 
          self.username = iprot.readString();
1588 
        else:
1589 
          iprot.skip(ftype)
1590 
      else:
1591 
        iprot.skip(ftype)
1592 
      iprot.readFieldEnd()
1593 
    iprot.readStructEnd()
1594 
 
1595 
  def write(self, oprot):
1596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1598 
      return
1599 
    oprot.writeStructBegin('deleteUser_args')
1600 
    if self.username != None:
1601 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1602 
      oprot.writeString(self.username)
1603 
      oprot.writeFieldEnd()
1604 
    oprot.writeFieldStop()
1605 
    oprot.writeStructEnd()
1606 
 
1607 
  def __repr__(self):
1608 
    L = ['%s=%r' % (key, value)
1609 
      for key, value in self.__dict__.iteritems()]
1610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1611 
 
1612 
  def __eq__(self, other):
1613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1614 
 
1615 
  def __ne__(self, other):
1616 
    return not (self == other)
1617 
 
1618 
class deleteUser_result:
1619 
  """
1620 
  Attributes:
1621 
   - success
1622 
   - se
1623 
  """
1624 
 
1625 
  thrift_spec = (
1626 
    (0, TType.BOOL, 'success', None, None, ), # 0
1627 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1628 
  )
1629 
 
1630 
  def __init__(self, success=None, se=None,):
1631 
    self.success = success
1632 
    self.se = se
1633 
 
1634 
  def read(self, iprot):
1635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1637 
      return
1638 
    iprot.readStructBegin()
1639 
    while True:
1640 
      (fname, ftype, fid) = iprot.readFieldBegin()
1641 
      if ftype == TType.STOP:
1642 
        break
1643 
      if fid == 0:
1644 
        if ftype == TType.BOOL:
1645 
          self.success = iprot.readBool();
1646 
        else:
1647 
          iprot.skip(ftype)
1648 
      elif fid == 1:
1649 
        if ftype == TType.STRUCT:
1650 
          self.se = HelperServiceException()
1651 
          self.se.read(iprot)
1652 
        else:
1653 
          iprot.skip(ftype)
1654 
      else:
1655 
        iprot.skip(ftype)
1656 
      iprot.readFieldEnd()
1657 
    iprot.readStructEnd()
1658 
 
1659 
  def write(self, oprot):
1660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1662 
      return
1663 
    oprot.writeStructBegin('deleteUser_result')
1664 
    if self.success != None:
1665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1666 
      oprot.writeBool(self.success)
1667 
      oprot.writeFieldEnd()
1668 
    if self.se != None:
1669 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1670 
      self.se.write(oprot)
1671 
      oprot.writeFieldEnd()
1672 
    oprot.writeFieldStop()
1673 
    oprot.writeStructEnd()
1674 
 
1675 
  def __repr__(self):
1676 
    L = ['%s=%r' % (key, value)
1677 
      for key, value in self.__dict__.iteritems()]
1678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1679 
 
1680 
  def __eq__(self, other):
1681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1682 
 
1683 
  def __ne__(self, other):
1684 
    return not (self == other)
1685 
 
1686 
class authenticateUser_args:
1687 
  """
1688 
  Attributes:
1689 
   - username
1690 
   - password
1691 
  """
1692 
 
1693 
  thrift_spec = (
1694 
    None, # 0
1695 
    (1, TType.STRING, 'username', None, None, ), # 1
1696 
    (2, TType.STRING, 'password', None, None, ), # 2
1697 
  )
1698 
 
1699 
  def __init__(self, username=None, password=None,):
1700 
    self.username = username
1701 
    self.password = password
1702 
 
1703 
  def read(self, iprot):
1704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1706 
      return
1707 
    iprot.readStructBegin()
1708 
    while True:
1709 
      (fname, ftype, fid) = iprot.readFieldBegin()
1710 
      if ftype == TType.STOP:
1711 
        break
1712 
      if fid == 1:
1713 
        if ftype == TType.STRING:
1714 
          self.username = iprot.readString();
1715 
        else:
1716 
          iprot.skip(ftype)
1717 
      elif fid == 2:
1718 
        if ftype == TType.STRING:
1719 
          self.password = iprot.readString();
1720 
        else:
1721 
          iprot.skip(ftype)
1722 
      else:
1723 
        iprot.skip(ftype)
1724 
      iprot.readFieldEnd()
1725 
    iprot.readStructEnd()
1726 
 
1727 
  def write(self, oprot):
1728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1730 
      return
1731 
    oprot.writeStructBegin('authenticateUser_args')
1732 
    if self.username != None:
1733 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1734 
      oprot.writeString(self.username)
1735 
      oprot.writeFieldEnd()
1736 
    if self.password != None:
1737 
      oprot.writeFieldBegin('password', TType.STRING, 2)
1738 
      oprot.writeString(self.password)
1739 
      oprot.writeFieldEnd()
1740 
    oprot.writeFieldStop()
1741 
    oprot.writeStructEnd()
1742 
 
1743 
  def __repr__(self):
1744 
    L = ['%s=%r' % (key, value)
1745 
      for key, value in self.__dict__.iteritems()]
1746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1747 
 
1748 
  def __eq__(self, other):
1749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1750 
 
1751 
  def __ne__(self, other):
1752 
    return not (self == other)
1753 
 
1754 
class authenticateUser_result:
1755 
  """
1756 
  Attributes:
1757 
   - success
1758 
   - se
1759 
  """
1760 
 
1761 
  thrift_spec = (
1762 
    (0, TType.I64, 'success', None, None, ), # 0
1763 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1764 
  )
1765 
 
1766 
  def __init__(self, success=None, se=None,):
1767 
    self.success = success
1768 
    self.se = se
1769 
 
1770 
  def read(self, iprot):
1771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1773 
      return
1774 
    iprot.readStructBegin()
1775 
    while True:
1776 
      (fname, ftype, fid) = iprot.readFieldBegin()
1777 
      if ftype == TType.STOP:
1778 
        break
1779 
      if fid == 0:
1780 
        if ftype == TType.I64:
1781 
          self.success = iprot.readI64();
1782 
        else:
1783 
          iprot.skip(ftype)
1784 
      elif fid == 1:
1785 
        if ftype == TType.STRUCT:
1786 
          self.se = HelperServiceException()
1787 
          self.se.read(iprot)
1788 
        else:
1789 
          iprot.skip(ftype)
1790 
      else:
1791 
        iprot.skip(ftype)
1792 
      iprot.readFieldEnd()
1793 
    iprot.readStructEnd()
1794 
 
1795 
  def write(self, oprot):
1796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1798 
      return
1799 
    oprot.writeStructBegin('authenticateUser_result')
1800 
    if self.success != None:
1801 
      oprot.writeFieldBegin('success', TType.I64, 0)
1802 
      oprot.writeI64(self.success)
1803 
      oprot.writeFieldEnd()
1804 
    if self.se != None:
1805 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1806 
      self.se.write(oprot)
1807 
      oprot.writeFieldEnd()
1808 
    oprot.writeFieldStop()
1809 
    oprot.writeStructEnd()
1810 
 
1811 
  def __repr__(self):
1812 
    L = ['%s=%r' % (key, value)
1813 
      for key, value in self.__dict__.iteritems()]
1814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1815 
 
1816 
  def __eq__(self, other):
1817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1818 
 
1819 
  def __ne__(self, other):
1820 
    return not (self == other)
1821 
 
1822 
class updatePassword_args:
1823 
  """
1824 
  Attributes:
1825 
   - username
1826 
   - oldPassword
1827 
   - newPassword
1828 
  """
1829 
 
1830 
  thrift_spec = (
1831 
    None, # 0
1832 
    (1, TType.STRING, 'username', None, None, ), # 1
1833 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
1834 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
1835 
  )
1836 
 
1837 
  def __init__(self, username=None, oldPassword=None, newPassword=None,):
1838 
    self.username = username
1839 
    self.oldPassword = oldPassword
1840 
    self.newPassword = newPassword
1841 
 
1842 
  def read(self, iprot):
1843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1845 
      return
1846 
    iprot.readStructBegin()
1847 
    while True:
1848 
      (fname, ftype, fid) = iprot.readFieldBegin()
1849 
      if ftype == TType.STOP:
1850 
        break
1851 
      if fid == 1:
1852 
        if ftype == TType.STRING:
1853 
          self.username = iprot.readString();
1854 
        else:
1855 
          iprot.skip(ftype)
1856 
      elif fid == 2:
1857 
        if ftype == TType.STRING:
1858 
          self.oldPassword = iprot.readString();
1859 
        else:
1860 
          iprot.skip(ftype)
1861 
      elif fid == 3:
1862 
        if ftype == TType.STRING:
1863 
          self.newPassword = iprot.readString();
1864 
        else:
1865 
          iprot.skip(ftype)
1866 
      else:
1867 
        iprot.skip(ftype)
1868 
      iprot.readFieldEnd()
1869 
    iprot.readStructEnd()
1870 
 
1871 
  def write(self, oprot):
1872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1874 
      return
1875 
    oprot.writeStructBegin('updatePassword_args')
1876 
    if self.username != None:
1877 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1878 
      oprot.writeString(self.username)
1879 
      oprot.writeFieldEnd()
1880 
    if self.oldPassword != None:
1881 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
1882 
      oprot.writeString(self.oldPassword)
1883 
      oprot.writeFieldEnd()
1884 
    if self.newPassword != None:
1885 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
1886 
      oprot.writeString(self.newPassword)
1887 
      oprot.writeFieldEnd()
1888 
    oprot.writeFieldStop()
1889 
    oprot.writeStructEnd()
1890 
 
1891 
  def __repr__(self):
1892 
    L = ['%s=%r' % (key, value)
1893 
      for key, value in self.__dict__.iteritems()]
1894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1895 
 
1896 
  def __eq__(self, other):
1897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1898 
 
1899 
  def __ne__(self, other):
1900 
    return not (self == other)
1901 
 
1902 
class updatePassword_result:
1903 
  """
1904 
  Attributes:
1905 
   - success
1906 
   - se
1907 
  """
1908 
 
1909 
  thrift_spec = (
1910 
    (0, TType.BOOL, 'success', None, None, ), # 0
1911 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1912 
  )
1913 
 
1914 
  def __init__(self, success=None, se=None,):
1915 
    self.success = success
1916 
    self.se = se
1917 
 
1918 
  def read(self, iprot):
1919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1921 
      return
1922 
    iprot.readStructBegin()
1923 
    while True:
1924 
      (fname, ftype, fid) = iprot.readFieldBegin()
1925 
      if ftype == TType.STOP:
1926 
        break
1927 
      if fid == 0:
1928 
        if ftype == TType.BOOL:
1929 
          self.success = iprot.readBool();
1930 
        else:
1931 
          iprot.skip(ftype)
1932 
      elif fid == 1:
1933 
        if ftype == TType.STRUCT:
1934 
          self.se = HelperServiceException()
1935 
          self.se.read(iprot)
1936 
        else:
1937 
          iprot.skip(ftype)
1938 
      else:
1939 
        iprot.skip(ftype)
1940 
      iprot.readFieldEnd()
1941 
    iprot.readStructEnd()
1942 
 
1943 
  def write(self, oprot):
1944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1946 
      return
1947 
    oprot.writeStructBegin('updatePassword_result')
1948 
    if self.success != None:
1949 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1950 
      oprot.writeBool(self.success)
1951 
      oprot.writeFieldEnd()
1952 
    if self.se != None:
1953 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1954 
      self.se.write(oprot)
1955 
      oprot.writeFieldEnd()
1956 
    oprot.writeFieldStop()
1957 
    oprot.writeStructEnd()
1958 
 
1959 
  def __repr__(self):
1960 
    L = ['%s=%r' % (key, value)
1961 
      for key, value in self.__dict__.iteritems()]
1962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1963 
 
1964 
  def __eq__(self, other):
1965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1966 
 
1967 
  def __ne__(self, other):
1968 
    return not (self == other)
1969 
 
759 chandransh 1970 
class authenticateLogisticsUser_args:
1971 
  """
1972 
  Attributes:
1973 
   - username
1974 
   - password
1975 
  """
494 rajveer 1976 
 
759 chandransh 1977 
  thrift_spec = (
1978 
    None, # 0
1979 
    (1, TType.STRING, 'username', None, None, ), # 1
1980 
    (2, TType.STRING, 'password', None, None, ), # 2
1981 
  )
1982 
 
1983 
  def __init__(self, username=None, password=None,):
1984 
    self.username = username
1985 
    self.password = password
1986 
 
1987 
  def read(self, iprot):
1988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1990 
      return
1991 
    iprot.readStructBegin()
1992 
    while True:
1993 
      (fname, ftype, fid) = iprot.readFieldBegin()
1994 
      if ftype == TType.STOP:
1995 
        break
1996 
      if fid == 1:
1997 
        if ftype == TType.STRING:
1998 
          self.username = iprot.readString();
1999 
        else:
2000 
          iprot.skip(ftype)
2001 
      elif fid == 2:
2002 
        if ftype == TType.STRING:
2003 
          self.password = iprot.readString();
2004 
        else:
2005 
          iprot.skip(ftype)
2006 
      else:
2007 
        iprot.skip(ftype)
2008 
      iprot.readFieldEnd()
2009 
    iprot.readStructEnd()
2010 
 
2011 
  def write(self, oprot):
2012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2014 
      return
2015 
    oprot.writeStructBegin('authenticateLogisticsUser_args')
2016 
    if self.username != None:
2017 
      oprot.writeFieldBegin('username', TType.STRING, 1)
2018 
      oprot.writeString(self.username)
2019 
      oprot.writeFieldEnd()
2020 
    if self.password != None:
2021 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2022 
      oprot.writeString(self.password)
2023 
      oprot.writeFieldEnd()
2024 
    oprot.writeFieldStop()
2025 
    oprot.writeStructEnd()
2026 
 
2027 
  def __repr__(self):
2028 
    L = ['%s=%r' % (key, value)
2029 
      for key, value in self.__dict__.iteritems()]
2030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2031 
 
2032 
  def __eq__(self, other):
2033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2034 
 
2035 
  def __ne__(self, other):
2036 
    return not (self == other)
2037 
 
2038 
class authenticateLogisticsUser_result:
2039 
  """
2040 
  Attributes:
2041 
   - success
2042 
   - hse
2043 
  """
2044 
 
2045 
  thrift_spec = (
2046 
    (0, TType.STRUCT, 'success', (LogisticsUser, LogisticsUser.thrift_spec), None, ), # 0
2047 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2048 
  )
2049 
 
2050 
  def __init__(self, success=None, hse=None,):
2051 
    self.success = success
2052 
    self.hse = hse
2053 
 
2054 
  def read(self, iprot):
2055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2057 
      return
2058 
    iprot.readStructBegin()
2059 
    while True:
2060 
      (fname, ftype, fid) = iprot.readFieldBegin()
2061 
      if ftype == TType.STOP:
2062 
        break
2063 
      if fid == 0:
2064 
        if ftype == TType.STRUCT:
2065 
          self.success = LogisticsUser()
2066 
          self.success.read(iprot)
2067 
        else:
2068 
          iprot.skip(ftype)
2069 
      elif fid == 1:
2070 
        if ftype == TType.STRUCT:
2071 
          self.hse = HelperServiceException()
2072 
          self.hse.read(iprot)
2073 
        else:
2074 
          iprot.skip(ftype)
2075 
      else:
2076 
        iprot.skip(ftype)
2077 
      iprot.readFieldEnd()
2078 
    iprot.readStructEnd()
2079 
 
2080 
  def write(self, oprot):
2081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2083 
      return
2084 
    oprot.writeStructBegin('authenticateLogisticsUser_result')
2085 
    if self.success != None:
2086 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2087 
      self.success.write(oprot)
2088 
      oprot.writeFieldEnd()
2089 
    if self.hse != None:
2090 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
2091 
      self.hse.write(oprot)
2092 
      oprot.writeFieldEnd()
2093 
    oprot.writeFieldStop()
2094 
    oprot.writeStructEnd()
2095 
 
2096 
  def __repr__(self):
2097 
    L = ['%s=%r' % (key, value)
2098 
      for key, value in self.__dict__.iteritems()]
2099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2100 
 
2101 
  def __eq__(self, other):
2102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2103 
 
2104 
  def __ne__(self, other):
2105 
    return not (self == other)
2106 
 
2107