Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
349 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
349 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
349 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
349 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
5864 rajveer 20 
  def saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType, cc, bcc):
1395 varun.gupt 21 
    """
3206 mandeep.dh 22 
    Save email details, to be sent later; Also returns its identifier.
3431 rajveer 23 
 
1395 varun.gupt 24 
    Parameters:
25 
     - emailTo
26 
     - emailFrom
27 
     - subject
28 
     - body
29 
     - source
30 
     - emailType
5864 rajveer 31 
     - cc
32 
     - bcc
1395 varun.gupt 33 
    """
34 
    pass
35 
 
3086 rajveer 36 
  def getEmailsToBeSent(self, ):
1422 varun.gupt 37 
    """
2783 chandransh 38 
    Retreives all the emails pending for dispatch
1422 varun.gupt 39 
    """
40 
    pass
41 
 
42 
  def markEmailAsSent(self, emailId):
43 
    """
2783 chandransh 44 
    Marks email as sent after successful dispatch
3431 rajveer 45 
 
1422 varun.gupt 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 
 
2447 chandransh 111 
  def authenticateDashboardUser(self, username, password):
494 rajveer 112 
    """
2447 chandransh 113 
    Returns the dashboard user if the supplied username and password match. Raises an exception otherwise.
114 
    The loggedOn timestamp for the dashboard user is updated .
3431 rajveer 115 
 
494 rajveer 116 
    Parameters:
117 
     - username
118 
     - password
119 
    """
120 
    pass
121 
 
122 
  def updatePassword(self, username, oldPassword, newPassword):
123 
    """
2447 chandransh 124 
    Update the password of the dashboard user. Currently, there is no place where this method is called.
3431 rajveer 125 
 
494 rajveer 126 
    Parameters:
127 
     - username
128 
     - oldPassword
129 
     - newPassword
130 
    """
131 
    pass
132 
 
759 chandransh 133 
  def authenticateLogisticsUser(self, username, password):
134 
    """
135 
    Returns the LogisticsUser struct associated with the given username and password if they match.
136 
    Throws an exception otherwise.
3431 rajveer 137 
 
759 chandransh 138 
    Parameters:
139 
     - username
140 
     - password
141 
    """
142 
    pass
494 rajveer 143 
 
1610 ankur.sing 144 
  def authenticateStatisticsUser(self, username, password):
145 
    """
146 
    Returns the StatisticsUser struct associated with the given username and password if they match.
147 
    Throws an exception otherwise.
3431 rajveer 148 
 
1610 ankur.sing 149 
    Parameters:
150 
     - username
151 
     - password
152 
    """
153 
    pass
759 chandransh 154 
 
1891 ankur.sing 155 
  def authenticateReportUser(self, username, password):
156 
    """
157 
    Returns the ReportUser struct associated with the given username and password if they match.
158 
    Throws an exception otherwise.
3431 rajveer 159 
 
1891 ankur.sing 160 
    Parameters:
161 
     - username
162 
     - password
163 
    """
164 
    pass
1610 ankur.sing 165 
 
1891 ankur.sing 166 
  def getReports(self, role):
167 
    """
168 
    Returns list of reports which are configured for the given role.
3431 rajveer 169 
 
1891 ankur.sing 170 
    Parameters:
171 
     - role
172 
    """
173 
    pass
174 
 
6788 rajveer 175 
  def authenticateCatalogUser(self, username, password):
2025 ankur.sing 176 
    """
2358 ankur.sing 177 
    Returns the CatalogDashboardUser struct associated with the given username, password and role if they match.
2025 ankur.sing 178 
    Throws an exception otherwise.
3431 rajveer 179 
 
2025 ankur.sing 180 
    Parameters:
181 
     - username
182 
     - password
183 
    """
184 
    pass
1891 ankur.sing 185 
 
4544 varun.gupt 186 
  def shareEntities(self, entityIds, email):
187 
    """
188 
    Saves the list of entity Ids to be shared with an email address
2025 ankur.sing 189 
 
4544 varun.gupt 190 
    Parameters:
191 
     - entityIds
192 
     - email
193 
    """
194 
    pass
195 
 
4691 mandeep.dh 196 
  def getAgents(self, ):
197 
    pass
4544 varun.gupt 198 
 
4691 mandeep.dh 199 
  def validateLogIn(self, emailId, password):
200 
    """
201 
    Parameters:
202 
     - emailId
203 
     - password
204 
    """
205 
    pass
206 
 
207 
  def updatePasswordForAgent(self, agentEmailId, password):
208 
    """
209 
    Parameters:
210 
     - agentEmailId
211 
     - password
212 
    """
213 
    pass
214 
 
215 
  def getRoleNamesForAgent(self, agentEmailId):
216 
    """
217 
    Parameters:
218 
     - agentEmailId
219 
    """
220 
    pass
221 
 
222 
  def getPermissionsForRoleName(self, roleName):
223 
    """
224 
    Parameters:
225 
     - roleName
226 
    """
227 
    pass
228 
 
4806 varun.gupt 229 
  def saveQuickLink(self, url, text):
230 
    """
231 
    Parameters:
232 
     - url
233 
     - text
234 
    """
235 
    pass
4691 mandeep.dh 236 
 
4806 varun.gupt 237 
  def getQuickLinks(self, ):
238 
    pass
239 
 
4996 varun.gupt 240 
  def updateQuickLink(self, id, url, text):
241 
    """
242 
    Parameters:
243 
     - id
244 
     - url
245 
     - text
246 
    """
247 
    pass
4806 varun.gupt 248 
 
5055 varun.gupt 249 
  def getEmailsForNotificationsSent(self, startDatetime, endDatetime):
250 
    """
251 
    Returns a list of emails to which product notifications have been sent in a given date range
4996 varun.gupt 252 
 
5055 varun.gupt 253 
    Parameters:
254 
     - startDatetime
255 
     - endDatetime
256 
    """
257 
    pass
258 
 
6322 amar.kumar 259 
  def getOrderConfirmationMail(self, orderId):
260 
    """
261 
    Parameters:
262 
     - orderId
263 
    """
264 
    pass
5055 varun.gupt 265 
 
7221 kshitij.so 266 
  def getOrderDeliveryMail(self, orderId):
267 
    """
268 
    Parameters:
269 
     - orderId
270 
    """
271 
    pass
6322 amar.kumar 272 
 
7221 kshitij.so 273 
 
3376 rajveer 274 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
349 ashish 275 
  def __init__(self, iprot, oprot=None):
3376 rajveer 276 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
349 ashish 277 
 
5864 rajveer 278 
  def saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType, cc, bcc):
1395 varun.gupt 279 
    """
3206 mandeep.dh 280 
    Save email details, to be sent later; Also returns its identifier.
3431 rajveer 281 
 
1395 varun.gupt 282 
    Parameters:
283 
     - emailTo
284 
     - emailFrom
285 
     - subject
286 
     - body
287 
     - source
288 
     - emailType
5864 rajveer 289 
     - cc
290 
     - bcc
1395 varun.gupt 291 
    """
5864 rajveer 292 
    self.send_saveUserEmailForSending(emailTo, emailFrom, subject, body, source, emailType, cc, bcc)
3206 mandeep.dh 293 
    return self.recv_saveUserEmailForSending()
1395 varun.gupt 294 
 
5864 rajveer 295 
  def send_saveUserEmailForSending(self, emailTo, emailFrom, subject, body, source, emailType, cc, bcc):
1395 varun.gupt 296 
    self._oprot.writeMessageBegin('saveUserEmailForSending', TMessageType.CALL, self._seqid)
297 
    args = saveUserEmailForSending_args()
298 
    args.emailTo = emailTo
299 
    args.emailFrom = emailFrom
300 
    args.subject = subject
301 
    args.body = body
302 
    args.source = source
303 
    args.emailType = emailType
5864 rajveer 304 
    args.cc = cc
305 
    args.bcc = bcc
1395 varun.gupt 306 
    args.write(self._oprot)
307 
    self._oprot.writeMessageEnd()
308 
    self._oprot.trans.flush()
309 
 
310 
  def recv_saveUserEmailForSending(self, ):
311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
312 
    if mtype == TMessageType.EXCEPTION:
313 
      x = TApplicationException()
314 
      x.read(self._iprot)
315 
      self._iprot.readMessageEnd()
316 
      raise x
317 
    result = saveUserEmailForSending_result()
318 
    result.read(self._iprot)
319 
    self._iprot.readMessageEnd()
3431 rajveer 320 
    if result.success is not None:
3206 mandeep.dh 321 
      return result.success
3431 rajveer 322 
    if result.se is not None:
1395 varun.gupt 323 
      raise result.se
3206 mandeep.dh 324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserEmailForSending failed: unknown result");
1395 varun.gupt 325 
 
3086 rajveer 326 
  def getEmailsToBeSent(self, ):
1422 varun.gupt 327 
    """
2783 chandransh 328 
    Retreives all the emails pending for dispatch
1422 varun.gupt 329 
    """
3086 rajveer 330 
    self.send_getEmailsToBeSent()
1422 varun.gupt 331 
    return self.recv_getEmailsToBeSent()
332 
 
3086 rajveer 333 
  def send_getEmailsToBeSent(self, ):
1422 varun.gupt 334 
    self._oprot.writeMessageBegin('getEmailsToBeSent', TMessageType.CALL, self._seqid)
335 
    args = getEmailsToBeSent_args()
336 
    args.write(self._oprot)
337 
    self._oprot.writeMessageEnd()
338 
    self._oprot.trans.flush()
339 
 
340 
  def recv_getEmailsToBeSent(self, ):
341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
342 
    if mtype == TMessageType.EXCEPTION:
343 
      x = TApplicationException()
344 
      x.read(self._iprot)
345 
      self._iprot.readMessageEnd()
346 
      raise x
347 
    result = getEmailsToBeSent_result()
348 
    result.read(self._iprot)
349 
    self._iprot.readMessageEnd()
3431 rajveer 350 
    if result.success is not None:
1422 varun.gupt 351 
      return result.success
3431 rajveer 352 
    if result.se is not None:
1422 varun.gupt 353 
      raise result.se
354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmailsToBeSent failed: unknown result");
355 
 
356 
  def markEmailAsSent(self, emailId):
357 
    """
2783 chandransh 358 
    Marks email as sent after successful dispatch
3431 rajveer 359 
 
1422 varun.gupt 360 
    Parameters:
361 
     - emailId
362 
    """
363 
    self.send_markEmailAsSent(emailId)
364 
    self.recv_markEmailAsSent()
365 
 
366 
  def send_markEmailAsSent(self, emailId):
367 
    self._oprot.writeMessageBegin('markEmailAsSent', TMessageType.CALL, self._seqid)
368 
    args = markEmailAsSent_args()
369 
    args.emailId = emailId
370 
    args.write(self._oprot)
371 
    self._oprot.writeMessageEnd()
372 
    self._oprot.trans.flush()
373 
 
374 
  def recv_markEmailAsSent(self, ):
375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
376 
    if mtype == TMessageType.EXCEPTION:
377 
      x = TApplicationException()
378 
      x.read(self._iprot)
379 
      self._iprot.readMessageEnd()
380 
      raise x
381 
    result = markEmailAsSent_result()
382 
    result.read(self._iprot)
383 
    self._iprot.readMessageEnd()
3431 rajveer 384 
    if result.se is not None:
1422 varun.gupt 385 
      raise result.se
386 
    return
387 
 
349 ashish 388 
  def sendMail(self, mail):
389 
    """
390 
    Parameters:
391 
     - mail
392 
    """
393 
    self.send_sendMail(mail)
394 
    self.recv_sendMail()
395 
 
396 
  def send_sendMail(self, mail):
397 
    self._oprot.writeMessageBegin('sendMail', TMessageType.CALL, self._seqid)
398 
    args = sendMail_args()
399 
    args.mail = mail
400 
    args.write(self._oprot)
401 
    self._oprot.writeMessageEnd()
402 
    self._oprot.trans.flush()
403 
 
404 
  def recv_sendMail(self, ):
405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
406 
    if mtype == TMessageType.EXCEPTION:
407 
      x = TApplicationException()
408 
      x.read(self._iprot)
409 
      self._iprot.readMessageEnd()
410 
      raise x
411 
    result = sendMail_result()
412 
    result.read(self._iprot)
413 
    self._iprot.readMessageEnd()
3431 rajveer 414 
    if result.se is not None:
349 ashish 415 
      raise result.se
416 
    return
417 
 
418 
  def sendText(self, message):
419 
    """
420 
    Parameters:
421 
     - message
422 
    """
423 
    self.send_sendText(message)
424 
    self.recv_sendText()
425 
 
426 
  def send_sendText(self, message):
427 
    self._oprot.writeMessageBegin('sendText', TMessageType.CALL, self._seqid)
428 
    args = sendText_args()
429 
    args.message = message
430 
    args.write(self._oprot)
431 
    self._oprot.writeMessageEnd()
432 
    self._oprot.trans.flush()
433 
 
434 
  def recv_sendText(self, ):
435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
436 
    if mtype == TMessageType.EXCEPTION:
437 
      x = TApplicationException()
438 
      x.read(self._iprot)
439 
      self._iprot.readMessageEnd()
440 
      raise x
441 
    result = sendText_result()
442 
    result.read(self._iprot)
443 
    self._iprot.readMessageEnd()
3431 rajveer 444 
    if result.se is not None:
349 ashish 445 
      raise result.se
446 
    return
447 
 
448 
  def addMessage(self, message):
449 
    """
450 
    Parameters:
451 
     - message
452 
    """
453 
    self.send_addMessage(message)
454 
    self.recv_addMessage()
455 
 
456 
  def send_addMessage(self, message):
457 
    self._oprot.writeMessageBegin('addMessage', TMessageType.CALL, self._seqid)
458 
    args = addMessage_args()
459 
    args.message = message
460 
    args.write(self._oprot)
461 
    self._oprot.writeMessageEnd()
462 
    self._oprot.trans.flush()
463 
 
464 
  def recv_addMessage(self, ):
465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
466 
    if mtype == TMessageType.EXCEPTION:
467 
      x = TApplicationException()
468 
      x.read(self._iprot)
469 
      self._iprot.readMessageEnd()
470 
      raise x
471 
    result = addMessage_result()
472 
    result.read(self._iprot)
473 
    self._iprot.readMessageEnd()
3431 rajveer 474 
    if result.se is not None:
349 ashish 475 
      raise result.se
476 
    return
477 
 
478 
  def updateMessage(self, id, message):
479 
    """
480 
    Parameters:
481 
     - id
482 
     - message
483 
    """
484 
    self.send_updateMessage(id, message)
485 
    self.recv_updateMessage()
486 
 
487 
  def send_updateMessage(self, id, message):
488 
    self._oprot.writeMessageBegin('updateMessage', TMessageType.CALL, self._seqid)
489 
    args = updateMessage_args()
490 
    args.id = id
491 
    args.message = message
492 
    args.write(self._oprot)
493 
    self._oprot.writeMessageEnd()
494 
    self._oprot.trans.flush()
495 
 
496 
  def recv_updateMessage(self, ):
497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
498 
    if mtype == TMessageType.EXCEPTION:
499 
      x = TApplicationException()
500 
      x.read(self._iprot)
501 
      self._iprot.readMessageEnd()
502 
      raise x
503 
    result = updateMessage_result()
504 
    result.read(self._iprot)
505 
    self._iprot.readMessageEnd()
3431 rajveer 506 
    if result.se is not None:
349 ashish 507 
      raise result.se
508 
    return
509 
 
510 
  def getMessage(self, id):
511 
    """
512 
    Parameters:
513 
     - id
514 
    """
515 
    self.send_getMessage(id)
353 ashish 516 
    return self.recv_getMessage()
349 ashish 517 
 
518 
  def send_getMessage(self, id):
519 
    self._oprot.writeMessageBegin('getMessage', TMessageType.CALL, self._seqid)
520 
    args = getMessage_args()
521 
    args.id = id
522 
    args.write(self._oprot)
523 
    self._oprot.writeMessageEnd()
524 
    self._oprot.trans.flush()
525 
 
526 
  def recv_getMessage(self, ):
527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
528 
    if mtype == TMessageType.EXCEPTION:
529 
      x = TApplicationException()
530 
      x.read(self._iprot)
531 
      self._iprot.readMessageEnd()
532 
      raise x
533 
    result = getMessage_result()
534 
    result.read(self._iprot)
535 
    self._iprot.readMessageEnd()
3431 rajveer 536 
    if result.success is not None:
353 ashish 537 
      return result.success
3431 rajveer 538 
    if result.se is not None:
349 ashish 539 
      raise result.se
353 ashish 540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMessage failed: unknown result");
349 ashish 541 
 
542 
  def getSubstitutedMessage(self, id, params):
543 
    """
544 
    Parameters:
545 
     - id
546 
     - params
547 
    """
548 
    self.send_getSubstitutedMessage(id, params)
353 ashish 549 
    return self.recv_getSubstitutedMessage()
349 ashish 550 
 
551 
  def send_getSubstitutedMessage(self, id, params):
552 
    self._oprot.writeMessageBegin('getSubstitutedMessage', TMessageType.CALL, self._seqid)
553 
    args = getSubstitutedMessage_args()
554 
    args.id = id
555 
    args.params = params
556 
    args.write(self._oprot)
557 
    self._oprot.writeMessageEnd()
558 
    self._oprot.trans.flush()
559 
 
560 
  def recv_getSubstitutedMessage(self, ):
561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
562 
    if mtype == TMessageType.EXCEPTION:
563 
      x = TApplicationException()
564 
      x.read(self._iprot)
565 
      self._iprot.readMessageEnd()
566 
      raise x
567 
    result = getSubstitutedMessage_result()
568 
    result.read(self._iprot)
569 
    self._iprot.readMessageEnd()
3431 rajveer 570 
    if result.success is not None:
353 ashish 571 
      return result.success
3431 rajveer 572 
    if result.se is not None:
349 ashish 573 
      raise result.se
353 ashish 574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSubstitutedMessage failed: unknown result");
349 ashish 575 
 
494 rajveer 576 
  def addUser(self, username, password, warehouseId):
577 
    """
578 
    Parameters:
579 
     - username
580 
     - password
581 
     - warehouseId
582 
    """
583 
    self.send_addUser(username, password, warehouseId)
584 
    return self.recv_addUser()
349 ashish 585 
 
494 rajveer 586 
  def send_addUser(self, username, password, warehouseId):
587 
    self._oprot.writeMessageBegin('addUser', TMessageType.CALL, self._seqid)
588 
    args = addUser_args()
589 
    args.username = username
590 
    args.password = password
591 
    args.warehouseId = warehouseId
592 
    args.write(self._oprot)
593 
    self._oprot.writeMessageEnd()
594 
    self._oprot.trans.flush()
595 
 
596 
  def recv_addUser(self, ):
597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
598 
    if mtype == TMessageType.EXCEPTION:
599 
      x = TApplicationException()
600 
      x.read(self._iprot)
601 
      self._iprot.readMessageEnd()
602 
      raise x
603 
    result = addUser_result()
604 
    result.read(self._iprot)
605 
    self._iprot.readMessageEnd()
3431 rajveer 606 
    if result.success is not None:
494 rajveer 607 
      return result.success
3431 rajveer 608 
    if result.se is not None:
494 rajveer 609 
      raise result.se
610 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addUser failed: unknown result");
611 
 
612 
  def deleteUser(self, username):
613 
    """
614 
    Parameters:
615 
     - username
616 
    """
617 
    self.send_deleteUser(username)
618 
    return self.recv_deleteUser()
619 
 
620 
  def send_deleteUser(self, username):
621 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
622 
    args = deleteUser_args()
623 
    args.username = username
624 
    args.write(self._oprot)
625 
    self._oprot.writeMessageEnd()
626 
    self._oprot.trans.flush()
627 
 
628 
  def recv_deleteUser(self, ):
629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
630 
    if mtype == TMessageType.EXCEPTION:
631 
      x = TApplicationException()
632 
      x.read(self._iprot)
633 
      self._iprot.readMessageEnd()
634 
      raise x
635 
    result = deleteUser_result()
636 
    result.read(self._iprot)
637 
    self._iprot.readMessageEnd()
3431 rajveer 638 
    if result.success is not None:
494 rajveer 639 
      return result.success
3431 rajveer 640 
    if result.se is not None:
494 rajveer 641 
      raise result.se
642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
643 
 
2447 chandransh 644 
  def authenticateDashboardUser(self, username, password):
494 rajveer 645 
    """
2447 chandransh 646 
    Returns the dashboard user if the supplied username and password match. Raises an exception otherwise.
647 
    The loggedOn timestamp for the dashboard user is updated .
3431 rajveer 648 
 
494 rajveer 649 
    Parameters:
650 
     - username
651 
     - password
652 
    """
2447 chandransh 653 
    self.send_authenticateDashboardUser(username, password)
654 
    return self.recv_authenticateDashboardUser()
494 rajveer 655 
 
2447 chandransh 656 
  def send_authenticateDashboardUser(self, username, password):
657 
    self._oprot.writeMessageBegin('authenticateDashboardUser', TMessageType.CALL, self._seqid)
658 
    args = authenticateDashboardUser_args()
494 rajveer 659 
    args.username = username
660 
    args.password = password
661 
    args.write(self._oprot)
662 
    self._oprot.writeMessageEnd()
663 
    self._oprot.trans.flush()
664 
 
2447 chandransh 665 
  def recv_authenticateDashboardUser(self, ):
494 rajveer 666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
667 
    if mtype == TMessageType.EXCEPTION:
668 
      x = TApplicationException()
669 
      x.read(self._iprot)
670 
      self._iprot.readMessageEnd()
671 
      raise x
2447 chandransh 672 
    result = authenticateDashboardUser_result()
494 rajveer 673 
    result.read(self._iprot)
674 
    self._iprot.readMessageEnd()
3431 rajveer 675 
    if result.success is not None:
494 rajveer 676 
      return result.success
3431 rajveer 677 
    if result.se is not None:
494 rajveer 678 
      raise result.se
2447 chandransh 679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateDashboardUser failed: unknown result");
494 rajveer 680 
 
681 
  def updatePassword(self, username, oldPassword, newPassword):
682 
    """
2447 chandransh 683 
    Update the password of the dashboard user. Currently, there is no place where this method is called.
3431 rajveer 684 
 
494 rajveer 685 
    Parameters:
686 
     - username
687 
     - oldPassword
688 
     - newPassword
689 
    """
690 
    self.send_updatePassword(username, oldPassword, newPassword)
691 
    return self.recv_updatePassword()
692 
 
693 
  def send_updatePassword(self, username, oldPassword, newPassword):
694 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
695 
    args = updatePassword_args()
696 
    args.username = username
697 
    args.oldPassword = oldPassword
698 
    args.newPassword = newPassword
699 
    args.write(self._oprot)
700 
    self._oprot.writeMessageEnd()
701 
    self._oprot.trans.flush()
702 
 
703 
  def recv_updatePassword(self, ):
704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
705 
    if mtype == TMessageType.EXCEPTION:
706 
      x = TApplicationException()
707 
      x.read(self._iprot)
708 
      self._iprot.readMessageEnd()
709 
      raise x
710 
    result = updatePassword_result()
711 
    result.read(self._iprot)
712 
    self._iprot.readMessageEnd()
3431 rajveer 713 
    if result.success is not None:
494 rajveer 714 
      return result.success
3431 rajveer 715 
    if result.se is not None:
494 rajveer 716 
      raise result.se
717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
718 
 
759 chandransh 719 
  def authenticateLogisticsUser(self, username, password):
720 
    """
721 
    Returns the LogisticsUser struct associated with the given username and password if they match.
722 
    Throws an exception otherwise.
3431 rajveer 723 
 
759 chandransh 724 
    Parameters:
725 
     - username
726 
     - password
727 
    """
728 
    self.send_authenticateLogisticsUser(username, password)
729 
    return self.recv_authenticateLogisticsUser()
494 rajveer 730 
 
759 chandransh 731 
  def send_authenticateLogisticsUser(self, username, password):
732 
    self._oprot.writeMessageBegin('authenticateLogisticsUser', TMessageType.CALL, self._seqid)
733 
    args = authenticateLogisticsUser_args()
734 
    args.username = username
735 
    args.password = password
736 
    args.write(self._oprot)
737 
    self._oprot.writeMessageEnd()
738 
    self._oprot.trans.flush()
739 
 
740 
  def recv_authenticateLogisticsUser(self, ):
741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
742 
    if mtype == TMessageType.EXCEPTION:
743 
      x = TApplicationException()
744 
      x.read(self._iprot)
745 
      self._iprot.readMessageEnd()
746 
      raise x
747 
    result = authenticateLogisticsUser_result()
748 
    result.read(self._iprot)
749 
    self._iprot.readMessageEnd()
3431 rajveer 750 
    if result.success is not None:
759 chandransh 751 
      return result.success
3431 rajveer 752 
    if result.hse is not None:
759 chandransh 753 
      raise result.hse
754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateLogisticsUser failed: unknown result");
755 
 
1610 ankur.sing 756 
  def authenticateStatisticsUser(self, username, password):
757 
    """
758 
    Returns the StatisticsUser struct associated with the given username and password if they match.
759 
    Throws an exception otherwise.
3431 rajveer 760 
 
1610 ankur.sing 761 
    Parameters:
762 
     - username
763 
     - password
764 
    """
765 
    self.send_authenticateStatisticsUser(username, password)
766 
    return self.recv_authenticateStatisticsUser()
759 chandransh 767 
 
1610 ankur.sing 768 
  def send_authenticateStatisticsUser(self, username, password):
769 
    self._oprot.writeMessageBegin('authenticateStatisticsUser', TMessageType.CALL, self._seqid)
770 
    args = authenticateStatisticsUser_args()
771 
    args.username = username
772 
    args.password = password
773 
    args.write(self._oprot)
774 
    self._oprot.writeMessageEnd()
775 
    self._oprot.trans.flush()
776 
 
777 
  def recv_authenticateStatisticsUser(self, ):
778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
779 
    if mtype == TMessageType.EXCEPTION:
780 
      x = TApplicationException()
781 
      x.read(self._iprot)
782 
      self._iprot.readMessageEnd()
783 
      raise x
784 
    result = authenticateStatisticsUser_result()
785 
    result.read(self._iprot)
786 
    self._iprot.readMessageEnd()
3431 rajveer 787 
    if result.success is not None:
1610 ankur.sing 788 
      return result.success
3431 rajveer 789 
    if result.hse is not None:
1610 ankur.sing 790 
      raise result.hse
791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateStatisticsUser failed: unknown result");
792 
 
1891 ankur.sing 793 
  def authenticateReportUser(self, username, password):
794 
    """
795 
    Returns the ReportUser struct associated with the given username and password if they match.
796 
    Throws an exception otherwise.
3431 rajveer 797 
 
1891 ankur.sing 798 
    Parameters:
799 
     - username
800 
     - password
801 
    """
802 
    self.send_authenticateReportUser(username, password)
803 
    return self.recv_authenticateReportUser()
1610 ankur.sing 804 
 
1891 ankur.sing 805 
  def send_authenticateReportUser(self, username, password):
806 
    self._oprot.writeMessageBegin('authenticateReportUser', TMessageType.CALL, self._seqid)
807 
    args = authenticateReportUser_args()
808 
    args.username = username
809 
    args.password = password
810 
    args.write(self._oprot)
811 
    self._oprot.writeMessageEnd()
812 
    self._oprot.trans.flush()
813 
 
814 
  def recv_authenticateReportUser(self, ):
815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
816 
    if mtype == TMessageType.EXCEPTION:
817 
      x = TApplicationException()
818 
      x.read(self._iprot)
819 
      self._iprot.readMessageEnd()
820 
      raise x
821 
    result = authenticateReportUser_result()
822 
    result.read(self._iprot)
823 
    self._iprot.readMessageEnd()
3431 rajveer 824 
    if result.success is not None:
1891 ankur.sing 825 
      return result.success
3431 rajveer 826 
    if result.hse is not None:
1891 ankur.sing 827 
      raise result.hse
828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateReportUser failed: unknown result");
829 
 
830 
  def getReports(self, role):
831 
    """
832 
    Returns list of reports which are configured for the given role.
3431 rajveer 833 
 
1891 ankur.sing 834 
    Parameters:
835 
     - role
836 
    """
837 
    self.send_getReports(role)
838 
    return self.recv_getReports()
839 
 
840 
  def send_getReports(self, role):
841 
    self._oprot.writeMessageBegin('getReports', TMessageType.CALL, self._seqid)
842 
    args = getReports_args()
843 
    args.role = role
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_getReports(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = getReports_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
3431 rajveer 858 
    if result.success is not None:
1891 ankur.sing 859 
      return result.success
860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReports failed: unknown result");
861 
 
6788 rajveer 862 
  def authenticateCatalogUser(self, username, password):
2025 ankur.sing 863 
    """
2358 ankur.sing 864 
    Returns the CatalogDashboardUser struct associated with the given username, password and role if they match.
2025 ankur.sing 865 
    Throws an exception otherwise.
3431 rajveer 866 
 
2025 ankur.sing 867 
    Parameters:
868 
     - username
869 
     - password
870 
    """
6788 rajveer 871 
    self.send_authenticateCatalogUser(username, password)
2025 ankur.sing 872 
    return self.recv_authenticateCatalogUser()
1891 ankur.sing 873 
 
6788 rajveer 874 
  def send_authenticateCatalogUser(self, username, password):
2025 ankur.sing 875 
    self._oprot.writeMessageBegin('authenticateCatalogUser', TMessageType.CALL, self._seqid)
876 
    args = authenticateCatalogUser_args()
877 
    args.username = username
878 
    args.password = password
879 
    args.write(self._oprot)
880 
    self._oprot.writeMessageEnd()
881 
    self._oprot.trans.flush()
882 
 
883 
  def recv_authenticateCatalogUser(self, ):
884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
885 
    if mtype == TMessageType.EXCEPTION:
886 
      x = TApplicationException()
887 
      x.read(self._iprot)
888 
      self._iprot.readMessageEnd()
889 
      raise x
890 
    result = authenticateCatalogUser_result()
891 
    result.read(self._iprot)
892 
    self._iprot.readMessageEnd()
3431 rajveer 893 
    if result.success is not None:
2025 ankur.sing 894 
      return result.success
3431 rajveer 895 
    if result.hse is not None:
2025 ankur.sing 896 
      raise result.hse
897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateCatalogUser failed: unknown result");
898 
 
4544 varun.gupt 899 
  def shareEntities(self, entityIds, email):
900 
    """
901 
    Saves the list of entity Ids to be shared with an email address
2025 ankur.sing 902 
 
4544 varun.gupt 903 
    Parameters:
904 
     - entityIds
905 
     - email
906 
    """
907 
    self.send_shareEntities(entityIds, email)
908 
    self.recv_shareEntities()
909 
 
910 
  def send_shareEntities(self, entityIds, email):
911 
    self._oprot.writeMessageBegin('shareEntities', TMessageType.CALL, self._seqid)
912 
    args = shareEntities_args()
913 
    args.entityIds = entityIds
914 
    args.email = email
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_shareEntities(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = shareEntities_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
929 
    if result.hse is not None:
930 
      raise result.hse
931 
    return
932 
 
4691 mandeep.dh 933 
  def getAgents(self, ):
934 
    self.send_getAgents()
935 
    return self.recv_getAgents()
4544 varun.gupt 936 
 
4691 mandeep.dh 937 
  def send_getAgents(self, ):
938 
    self._oprot.writeMessageBegin('getAgents', TMessageType.CALL, self._seqid)
939 
    args = getAgents_args()
940 
    args.write(self._oprot)
941 
    self._oprot.writeMessageEnd()
942 
    self._oprot.trans.flush()
943 
 
944 
  def recv_getAgents(self, ):
945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
946 
    if mtype == TMessageType.EXCEPTION:
947 
      x = TApplicationException()
948 
      x.read(self._iprot)
949 
      self._iprot.readMessageEnd()
950 
      raise x
951 
    result = getAgents_result()
952 
    result.read(self._iprot)
953 
    self._iprot.readMessageEnd()
954 
    if result.success is not None:
955 
      return result.success
956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAgents failed: unknown result");
957 
 
958 
  def validateLogIn(self, emailId, password):
959 
    """
960 
    Parameters:
961 
     - emailId
962 
     - password
963 
    """
964 
    self.send_validateLogIn(emailId, password)
965 
    return self.recv_validateLogIn()
966 
 
967 
  def send_validateLogIn(self, emailId, password):
968 
    self._oprot.writeMessageBegin('validateLogIn', TMessageType.CALL, self._seqid)
969 
    args = validateLogIn_args()
970 
    args.emailId = emailId
971 
    args.password = password
972 
    args.write(self._oprot)
973 
    self._oprot.writeMessageEnd()
974 
    self._oprot.trans.flush()
975 
 
976 
  def recv_validateLogIn(self, ):
977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
978 
    if mtype == TMessageType.EXCEPTION:
979 
      x = TApplicationException()
980 
      x.read(self._iprot)
981 
      self._iprot.readMessageEnd()
982 
      raise x
983 
    result = validateLogIn_result()
984 
    result.read(self._iprot)
985 
    self._iprot.readMessageEnd()
986 
    if result.success is not None:
987 
      return result.success
988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateLogIn failed: unknown result");
989 
 
990 
  def updatePasswordForAgent(self, agentEmailId, password):
991 
    """
992 
    Parameters:
993 
     - agentEmailId
994 
     - password
995 
    """
996 
    self.send_updatePasswordForAgent(agentEmailId, password)
997 
    self.recv_updatePasswordForAgent()
998 
 
999 
  def send_updatePasswordForAgent(self, agentEmailId, password):
1000 
    self._oprot.writeMessageBegin('updatePasswordForAgent', TMessageType.CALL, self._seqid)
1001 
    args = updatePasswordForAgent_args()
1002 
    args.agentEmailId = agentEmailId
1003 
    args.password = password
1004 
    args.write(self._oprot)
1005 
    self._oprot.writeMessageEnd()
1006 
    self._oprot.trans.flush()
1007 
 
1008 
  def recv_updatePasswordForAgent(self, ):
1009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1010 
    if mtype == TMessageType.EXCEPTION:
1011 
      x = TApplicationException()
1012 
      x.read(self._iprot)
1013 
      self._iprot.readMessageEnd()
1014 
      raise x
1015 
    result = updatePasswordForAgent_result()
1016 
    result.read(self._iprot)
1017 
    self._iprot.readMessageEnd()
1018 
    return
1019 
 
1020 
  def getRoleNamesForAgent(self, agentEmailId):
1021 
    """
1022 
    Parameters:
1023 
     - agentEmailId
1024 
    """
1025 
    self.send_getRoleNamesForAgent(agentEmailId)
1026 
    return self.recv_getRoleNamesForAgent()
1027 
 
1028 
  def send_getRoleNamesForAgent(self, agentEmailId):
1029 
    self._oprot.writeMessageBegin('getRoleNamesForAgent', TMessageType.CALL, self._seqid)
1030 
    args = getRoleNamesForAgent_args()
1031 
    args.agentEmailId = agentEmailId
1032 
    args.write(self._oprot)
1033 
    self._oprot.writeMessageEnd()
1034 
    self._oprot.trans.flush()
1035 
 
1036 
  def recv_getRoleNamesForAgent(self, ):
1037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1038 
    if mtype == TMessageType.EXCEPTION:
1039 
      x = TApplicationException()
1040 
      x.read(self._iprot)
1041 
      self._iprot.readMessageEnd()
1042 
      raise x
1043 
    result = getRoleNamesForAgent_result()
1044 
    result.read(self._iprot)
1045 
    self._iprot.readMessageEnd()
1046 
    if result.success is not None:
1047 
      return result.success
1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRoleNamesForAgent failed: unknown result");
1049 
 
1050 
  def getPermissionsForRoleName(self, roleName):
1051 
    """
1052 
    Parameters:
1053 
     - roleName
1054 
    """
1055 
    self.send_getPermissionsForRoleName(roleName)
1056 
    return self.recv_getPermissionsForRoleName()
1057 
 
1058 
  def send_getPermissionsForRoleName(self, roleName):
1059 
    self._oprot.writeMessageBegin('getPermissionsForRoleName', TMessageType.CALL, self._seqid)
1060 
    args = getPermissionsForRoleName_args()
1061 
    args.roleName = roleName
1062 
    args.write(self._oprot)
1063 
    self._oprot.writeMessageEnd()
1064 
    self._oprot.trans.flush()
1065 
 
1066 
  def recv_getPermissionsForRoleName(self, ):
1067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1068 
    if mtype == TMessageType.EXCEPTION:
1069 
      x = TApplicationException()
1070 
      x.read(self._iprot)
1071 
      self._iprot.readMessageEnd()
1072 
      raise x
1073 
    result = getPermissionsForRoleName_result()
1074 
    result.read(self._iprot)
1075 
    self._iprot.readMessageEnd()
1076 
    if result.success is not None:
1077 
      return result.success
1078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPermissionsForRoleName failed: unknown result");
1079 
 
4806 varun.gupt 1080 
  def saveQuickLink(self, url, text):
1081 
    """
1082 
    Parameters:
1083 
     - url
1084 
     - text
1085 
    """
1086 
    self.send_saveQuickLink(url, text)
1087 
    self.recv_saveQuickLink()
4691 mandeep.dh 1088 
 
4806 varun.gupt 1089 
  def send_saveQuickLink(self, url, text):
1090 
    self._oprot.writeMessageBegin('saveQuickLink', TMessageType.CALL, self._seqid)
1091 
    args = saveQuickLink_args()
1092 
    args.url = url
1093 
    args.text = text
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_saveQuickLink(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = saveQuickLink_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
1108 
    if result.hse is not None:
1109 
      raise result.hse
1110 
    return
1111 
 
1112 
  def getQuickLinks(self, ):
1113 
    self.send_getQuickLinks()
1114 
    return self.recv_getQuickLinks()
1115 
 
1116 
  def send_getQuickLinks(self, ):
1117 
    self._oprot.writeMessageBegin('getQuickLinks', TMessageType.CALL, self._seqid)
1118 
    args = getQuickLinks_args()
1119 
    args.write(self._oprot)
1120 
    self._oprot.writeMessageEnd()
1121 
    self._oprot.trans.flush()
1122 
 
1123 
  def recv_getQuickLinks(self, ):
1124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1125 
    if mtype == TMessageType.EXCEPTION:
1126 
      x = TApplicationException()
1127 
      x.read(self._iprot)
1128 
      self._iprot.readMessageEnd()
1129 
      raise x
1130 
    result = getQuickLinks_result()
1131 
    result.read(self._iprot)
1132 
    self._iprot.readMessageEnd()
1133 
    if result.success is not None:
1134 
      return result.success
1135 
    if result.hse is not None:
1136 
      raise result.hse
1137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getQuickLinks failed: unknown result");
1138 
 
4996 varun.gupt 1139 
  def updateQuickLink(self, id, url, text):
1140 
    """
1141 
    Parameters:
1142 
     - id
1143 
     - url
1144 
     - text
1145 
    """
1146 
    self.send_updateQuickLink(id, url, text)
1147 
    self.recv_updateQuickLink()
4806 varun.gupt 1148 
 
4996 varun.gupt 1149 
  def send_updateQuickLink(self, id, url, text):
1150 
    self._oprot.writeMessageBegin('updateQuickLink', TMessageType.CALL, self._seqid)
1151 
    args = updateQuickLink_args()
1152 
    args.id = id
1153 
    args.url = url
1154 
    args.text = text
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_updateQuickLink(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = updateQuickLink_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.hse is not None:
1170 
      raise result.hse
1171 
    return
1172 
 
5055 varun.gupt 1173 
  def getEmailsForNotificationsSent(self, startDatetime, endDatetime):
1174 
    """
1175 
    Returns a list of emails to which product notifications have been sent in a given date range
4996 varun.gupt 1176 
 
5055 varun.gupt 1177 
    Parameters:
1178 
     - startDatetime
1179 
     - endDatetime
1180 
    """
1181 
    self.send_getEmailsForNotificationsSent(startDatetime, endDatetime)
1182 
    return self.recv_getEmailsForNotificationsSent()
1183 
 
1184 
  def send_getEmailsForNotificationsSent(self, startDatetime, endDatetime):
1185 
    self._oprot.writeMessageBegin('getEmailsForNotificationsSent', TMessageType.CALL, self._seqid)
1186 
    args = getEmailsForNotificationsSent_args()
1187 
    args.startDatetime = startDatetime
1188 
    args.endDatetime = endDatetime
1189 
    args.write(self._oprot)
1190 
    self._oprot.writeMessageEnd()
1191 
    self._oprot.trans.flush()
1192 
 
1193 
  def recv_getEmailsForNotificationsSent(self, ):
1194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1195 
    if mtype == TMessageType.EXCEPTION:
1196 
      x = TApplicationException()
1197 
      x.read(self._iprot)
1198 
      self._iprot.readMessageEnd()
1199 
      raise x
1200 
    result = getEmailsForNotificationsSent_result()
1201 
    result.read(self._iprot)
1202 
    self._iprot.readMessageEnd()
1203 
    if result.success is not None:
1204 
      return result.success
1205 
    if result.hse is not None:
1206 
      raise result.hse
1207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmailsForNotificationsSent failed: unknown result");
1208 
 
6322 amar.kumar 1209 
  def getOrderConfirmationMail(self, orderId):
1210 
    """
1211 
    Parameters:
1212 
     - orderId
1213 
    """
1214 
    self.send_getOrderConfirmationMail(orderId)
1215 
    return self.recv_getOrderConfirmationMail()
5055 varun.gupt 1216 
 
6322 amar.kumar 1217 
  def send_getOrderConfirmationMail(self, orderId):
1218 
    self._oprot.writeMessageBegin('getOrderConfirmationMail', TMessageType.CALL, self._seqid)
1219 
    args = getOrderConfirmationMail_args()
1220 
    args.orderId = orderId
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_getOrderConfirmationMail(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = getOrderConfirmationMail_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
1235 
    if result.success is not None:
1236 
      return result.success
1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderConfirmationMail failed: unknown result");
1238 
 
7221 kshitij.so 1239 
  def getOrderDeliveryMail(self, orderId):
1240 
    """
1241 
    Parameters:
1242 
     - orderId
1243 
    """
1244 
    self.send_getOrderDeliveryMail(orderId)
1245 
    return self.recv_getOrderDeliveryMail()
6322 amar.kumar 1246 
 
7221 kshitij.so 1247 
  def send_getOrderDeliveryMail(self, orderId):
1248 
    self._oprot.writeMessageBegin('getOrderDeliveryMail', TMessageType.CALL, self._seqid)
1249 
    args = getOrderDeliveryMail_args()
1250 
    args.orderId = orderId
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getOrderDeliveryMail(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getOrderDeliveryMail_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
1265 
    if result.success is not None:
1266 
      return result.success
1267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderDeliveryMail failed: unknown result");
1268 
 
1269 
 
3376 rajveer 1270 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
349 ashish 1271 
  def __init__(self, handler):
3376 rajveer 1272 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
1395 varun.gupt 1273 
    self._processMap["saveUserEmailForSending"] = Processor.process_saveUserEmailForSending
1422 varun.gupt 1274 
    self._processMap["getEmailsToBeSent"] = Processor.process_getEmailsToBeSent
1275 
    self._processMap["markEmailAsSent"] = Processor.process_markEmailAsSent
349 ashish 1276 
    self._processMap["sendMail"] = Processor.process_sendMail
1277 
    self._processMap["sendText"] = Processor.process_sendText
1278 
    self._processMap["addMessage"] = Processor.process_addMessage
1279 
    self._processMap["updateMessage"] = Processor.process_updateMessage
1280 
    self._processMap["getMessage"] = Processor.process_getMessage
1281 
    self._processMap["getSubstitutedMessage"] = Processor.process_getSubstitutedMessage
494 rajveer 1282 
    self._processMap["addUser"] = Processor.process_addUser
1283 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2447 chandransh 1284 
    self._processMap["authenticateDashboardUser"] = Processor.process_authenticateDashboardUser
494 rajveer 1285 
    self._processMap["updatePassword"] = Processor.process_updatePassword
759 chandransh 1286 
    self._processMap["authenticateLogisticsUser"] = Processor.process_authenticateLogisticsUser
1610 ankur.sing 1287 
    self._processMap["authenticateStatisticsUser"] = Processor.process_authenticateStatisticsUser
1891 ankur.sing 1288 
    self._processMap["authenticateReportUser"] = Processor.process_authenticateReportUser
1289 
    self._processMap["getReports"] = Processor.process_getReports
2025 ankur.sing 1290 
    self._processMap["authenticateCatalogUser"] = Processor.process_authenticateCatalogUser
4544 varun.gupt 1291 
    self._processMap["shareEntities"] = Processor.process_shareEntities
4691 mandeep.dh 1292 
    self._processMap["getAgents"] = Processor.process_getAgents
1293 
    self._processMap["validateLogIn"] = Processor.process_validateLogIn
1294 
    self._processMap["updatePasswordForAgent"] = Processor.process_updatePasswordForAgent
1295 
    self._processMap["getRoleNamesForAgent"] = Processor.process_getRoleNamesForAgent
1296 
    self._processMap["getPermissionsForRoleName"] = Processor.process_getPermissionsForRoleName
4806 varun.gupt 1297 
    self._processMap["saveQuickLink"] = Processor.process_saveQuickLink
1298 
    self._processMap["getQuickLinks"] = Processor.process_getQuickLinks
4996 varun.gupt 1299 
    self._processMap["updateQuickLink"] = Processor.process_updateQuickLink
5055 varun.gupt 1300 
    self._processMap["getEmailsForNotificationsSent"] = Processor.process_getEmailsForNotificationsSent
6322 amar.kumar 1301 
    self._processMap["getOrderConfirmationMail"] = Processor.process_getOrderConfirmationMail
7221 kshitij.so 1302 
    self._processMap["getOrderDeliveryMail"] = Processor.process_getOrderDeliveryMail
349 ashish 1303 
 
1304 
  def process(self, iprot, oprot):
1305 
    (name, type, seqid) = iprot.readMessageBegin()
1306 
    if name not in self._processMap:
1307 
      iprot.skip(TType.STRUCT)
1308 
      iprot.readMessageEnd()
1309 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1310 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1311 
      x.write(oprot)
1312 
      oprot.writeMessageEnd()
1313 
      oprot.trans.flush()
1314 
      return
1315 
    else:
1316 
      self._processMap[name](self, seqid, iprot, oprot)
1317 
    return True
1318 
 
1395 varun.gupt 1319 
  def process_saveUserEmailForSending(self, seqid, iprot, oprot):
1320 
    args = saveUserEmailForSending_args()
1321 
    args.read(iprot)
1322 
    iprot.readMessageEnd()
1323 
    result = saveUserEmailForSending_result()
1324 
    try:
5864 rajveer 1325 
      result.success = self._handler.saveUserEmailForSending(args.emailTo, args.emailFrom, args.subject, args.body, args.source, args.emailType, args.cc, args.bcc)
1395 varun.gupt 1326 
    except HelperServiceException, se:
1327 
      result.se = se
1328 
    oprot.writeMessageBegin("saveUserEmailForSending", TMessageType.REPLY, seqid)
1329 
    result.write(oprot)
1330 
    oprot.writeMessageEnd()
1331 
    oprot.trans.flush()
1332 
 
1422 varun.gupt 1333 
  def process_getEmailsToBeSent(self, seqid, iprot, oprot):
1334 
    args = getEmailsToBeSent_args()
1335 
    args.read(iprot)
1336 
    iprot.readMessageEnd()
1337 
    result = getEmailsToBeSent_result()
1338 
    try:
3086 rajveer 1339 
      result.success = self._handler.getEmailsToBeSent()
1422 varun.gupt 1340 
    except HelperServiceException, se:
1341 
      result.se = se
1342 
    oprot.writeMessageBegin("getEmailsToBeSent", TMessageType.REPLY, seqid)
1343 
    result.write(oprot)
1344 
    oprot.writeMessageEnd()
1345 
    oprot.trans.flush()
1346 
 
1347 
  def process_markEmailAsSent(self, seqid, iprot, oprot):
1348 
    args = markEmailAsSent_args()
1349 
    args.read(iprot)
1350 
    iprot.readMessageEnd()
1351 
    result = markEmailAsSent_result()
1352 
    try:
1353 
      self._handler.markEmailAsSent(args.emailId)
1354 
    except HelperServiceException, se:
1355 
      result.se = se
1356 
    oprot.writeMessageBegin("markEmailAsSent", TMessageType.REPLY, seqid)
1357 
    result.write(oprot)
1358 
    oprot.writeMessageEnd()
1359 
    oprot.trans.flush()
1360 
 
349 ashish 1361 
  def process_sendMail(self, seqid, iprot, oprot):
1362 
    args = sendMail_args()
1363 
    args.read(iprot)
1364 
    iprot.readMessageEnd()
1365 
    result = sendMail_result()
1366 
    try:
1367 
      self._handler.sendMail(args.mail)
1368 
    except HelperServiceException, se:
1369 
      result.se = se
1370 
    oprot.writeMessageBegin("sendMail", TMessageType.REPLY, seqid)
1371 
    result.write(oprot)
1372 
    oprot.writeMessageEnd()
1373 
    oprot.trans.flush()
1374 
 
1375 
  def process_sendText(self, seqid, iprot, oprot):
1376 
    args = sendText_args()
1377 
    args.read(iprot)
1378 
    iprot.readMessageEnd()
1379 
    result = sendText_result()
1380 
    try:
1381 
      self._handler.sendText(args.message)
1382 
    except HelperServiceException, se:
1383 
      result.se = se
1384 
    oprot.writeMessageBegin("sendText", TMessageType.REPLY, seqid)
1385 
    result.write(oprot)
1386 
    oprot.writeMessageEnd()
1387 
    oprot.trans.flush()
1388 
 
1389 
  def process_addMessage(self, seqid, iprot, oprot):
1390 
    args = addMessage_args()
1391 
    args.read(iprot)
1392 
    iprot.readMessageEnd()
1393 
    result = addMessage_result()
1394 
    try:
1395 
      self._handler.addMessage(args.message)
1396 
    except HelperServiceException, se:
1397 
      result.se = se
1398 
    oprot.writeMessageBegin("addMessage", TMessageType.REPLY, seqid)
1399 
    result.write(oprot)
1400 
    oprot.writeMessageEnd()
1401 
    oprot.trans.flush()
1402 
 
1403 
  def process_updateMessage(self, seqid, iprot, oprot):
1404 
    args = updateMessage_args()
1405 
    args.read(iprot)
1406 
    iprot.readMessageEnd()
1407 
    result = updateMessage_result()
1408 
    try:
1409 
      self._handler.updateMessage(args.id, args.message)
1410 
    except HelperServiceException, se:
1411 
      result.se = se
1412 
    oprot.writeMessageBegin("updateMessage", TMessageType.REPLY, seqid)
1413 
    result.write(oprot)
1414 
    oprot.writeMessageEnd()
1415 
    oprot.trans.flush()
1416 
 
1417 
  def process_getMessage(self, seqid, iprot, oprot):
1418 
    args = getMessage_args()
1419 
    args.read(iprot)
1420 
    iprot.readMessageEnd()
1421 
    result = getMessage_result()
1422 
    try:
353 ashish 1423 
      result.success = self._handler.getMessage(args.id)
349 ashish 1424 
    except HelperServiceException, se:
1425 
      result.se = se
1426 
    oprot.writeMessageBegin("getMessage", TMessageType.REPLY, seqid)
1427 
    result.write(oprot)
1428 
    oprot.writeMessageEnd()
1429 
    oprot.trans.flush()
1430 
 
1431 
  def process_getSubstitutedMessage(self, seqid, iprot, oprot):
1432 
    args = getSubstitutedMessage_args()
1433 
    args.read(iprot)
1434 
    iprot.readMessageEnd()
1435 
    result = getSubstitutedMessage_result()
1436 
    try:
353 ashish 1437 
      result.success = self._handler.getSubstitutedMessage(args.id, args.params)
349 ashish 1438 
    except HelperServiceException, se:
1439 
      result.se = se
1440 
    oprot.writeMessageBegin("getSubstitutedMessage", TMessageType.REPLY, seqid)
1441 
    result.write(oprot)
1442 
    oprot.writeMessageEnd()
1443 
    oprot.trans.flush()
1444 
 
494 rajveer 1445 
  def process_addUser(self, seqid, iprot, oprot):
1446 
    args = addUser_args()
1447 
    args.read(iprot)
1448 
    iprot.readMessageEnd()
1449 
    result = addUser_result()
1450 
    try:
1451 
      result.success = self._handler.addUser(args.username, args.password, args.warehouseId)
1452 
    except HelperServiceException, se:
1453 
      result.se = se
1454 
    oprot.writeMessageBegin("addUser", TMessageType.REPLY, seqid)
1455 
    result.write(oprot)
1456 
    oprot.writeMessageEnd()
1457 
    oprot.trans.flush()
349 ashish 1458 
 
494 rajveer 1459 
  def process_deleteUser(self, seqid, iprot, oprot):
1460 
    args = deleteUser_args()
1461 
    args.read(iprot)
1462 
    iprot.readMessageEnd()
1463 
    result = deleteUser_result()
1464 
    try:
1465 
      result.success = self._handler.deleteUser(args.username)
1466 
    except HelperServiceException, se:
1467 
      result.se = se
1468 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
1469 
    result.write(oprot)
1470 
    oprot.writeMessageEnd()
1471 
    oprot.trans.flush()
1472 
 
2447 chandransh 1473 
  def process_authenticateDashboardUser(self, seqid, iprot, oprot):
1474 
    args = authenticateDashboardUser_args()
494 rajveer 1475 
    args.read(iprot)
1476 
    iprot.readMessageEnd()
2447 chandransh 1477 
    result = authenticateDashboardUser_result()
494 rajveer 1478 
    try:
2447 chandransh 1479 
      result.success = self._handler.authenticateDashboardUser(args.username, args.password)
494 rajveer 1480 
    except HelperServiceException, se:
1481 
      result.se = se
2447 chandransh 1482 
    oprot.writeMessageBegin("authenticateDashboardUser", TMessageType.REPLY, seqid)
494 rajveer 1483 
    result.write(oprot)
1484 
    oprot.writeMessageEnd()
1485 
    oprot.trans.flush()
1486 
 
1487 
  def process_updatePassword(self, seqid, iprot, oprot):
1488 
    args = updatePassword_args()
1489 
    args.read(iprot)
1490 
    iprot.readMessageEnd()
1491 
    result = updatePassword_result()
1492 
    try:
1493 
      result.success = self._handler.updatePassword(args.username, args.oldPassword, args.newPassword)
1494 
    except HelperServiceException, se:
1495 
      result.se = se
1496 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
1497 
    result.write(oprot)
1498 
    oprot.writeMessageEnd()
1499 
    oprot.trans.flush()
1500 
 
759 chandransh 1501 
  def process_authenticateLogisticsUser(self, seqid, iprot, oprot):
1502 
    args = authenticateLogisticsUser_args()
1503 
    args.read(iprot)
1504 
    iprot.readMessageEnd()
1505 
    result = authenticateLogisticsUser_result()
1506 
    try:
1507 
      result.success = self._handler.authenticateLogisticsUser(args.username, args.password)
1508 
    except HelperServiceException, hse:
1509 
      result.hse = hse
1510 
    oprot.writeMessageBegin("authenticateLogisticsUser", TMessageType.REPLY, seqid)
1511 
    result.write(oprot)
1512 
    oprot.writeMessageEnd()
1513 
    oprot.trans.flush()
494 rajveer 1514 
 
1610 ankur.sing 1515 
  def process_authenticateStatisticsUser(self, seqid, iprot, oprot):
1516 
    args = authenticateStatisticsUser_args()
1517 
    args.read(iprot)
1518 
    iprot.readMessageEnd()
1519 
    result = authenticateStatisticsUser_result()
1520 
    try:
1521 
      result.success = self._handler.authenticateStatisticsUser(args.username, args.password)
1522 
    except HelperServiceException, hse:
1523 
      result.hse = hse
1524 
    oprot.writeMessageBegin("authenticateStatisticsUser", TMessageType.REPLY, seqid)
1525 
    result.write(oprot)
1526 
    oprot.writeMessageEnd()
1527 
    oprot.trans.flush()
759 chandransh 1528 
 
1891 ankur.sing 1529 
  def process_authenticateReportUser(self, seqid, iprot, oprot):
1530 
    args = authenticateReportUser_args()
1531 
    args.read(iprot)
1532 
    iprot.readMessageEnd()
1533 
    result = authenticateReportUser_result()
1534 
    try:
1535 
      result.success = self._handler.authenticateReportUser(args.username, args.password)
1536 
    except HelperServiceException, hse:
1537 
      result.hse = hse
1538 
    oprot.writeMessageBegin("authenticateReportUser", TMessageType.REPLY, seqid)
1539 
    result.write(oprot)
1540 
    oprot.writeMessageEnd()
1541 
    oprot.trans.flush()
1610 ankur.sing 1542 
 
1891 ankur.sing 1543 
  def process_getReports(self, seqid, iprot, oprot):
1544 
    args = getReports_args()
1545 
    args.read(iprot)
1546 
    iprot.readMessageEnd()
1547 
    result = getReports_result()
1548 
    result.success = self._handler.getReports(args.role)
1549 
    oprot.writeMessageBegin("getReports", TMessageType.REPLY, seqid)
1550 
    result.write(oprot)
1551 
    oprot.writeMessageEnd()
1552 
    oprot.trans.flush()
1553 
 
2025 ankur.sing 1554 
  def process_authenticateCatalogUser(self, seqid, iprot, oprot):
1555 
    args = authenticateCatalogUser_args()
1556 
    args.read(iprot)
1557 
    iprot.readMessageEnd()
1558 
    result = authenticateCatalogUser_result()
1559 
    try:
6788 rajveer 1560 
      result.success = self._handler.authenticateCatalogUser(args.username, args.password)
2025 ankur.sing 1561 
    except HelperServiceException, hse:
1562 
      result.hse = hse
1563 
    oprot.writeMessageBegin("authenticateCatalogUser", TMessageType.REPLY, seqid)
1564 
    result.write(oprot)
1565 
    oprot.writeMessageEnd()
1566 
    oprot.trans.flush()
1891 ankur.sing 1567 
 
4544 varun.gupt 1568 
  def process_shareEntities(self, seqid, iprot, oprot):
1569 
    args = shareEntities_args()
1570 
    args.read(iprot)
1571 
    iprot.readMessageEnd()
1572 
    result = shareEntities_result()
1573 
    try:
1574 
      self._handler.shareEntities(args.entityIds, args.email)
1575 
    except HelperServiceException, hse:
1576 
      result.hse = hse
1577 
    oprot.writeMessageBegin("shareEntities", TMessageType.REPLY, seqid)
1578 
    result.write(oprot)
1579 
    oprot.writeMessageEnd()
1580 
    oprot.trans.flush()
2025 ankur.sing 1581 
 
4691 mandeep.dh 1582 
  def process_getAgents(self, seqid, iprot, oprot):
1583 
    args = getAgents_args()
1584 
    args.read(iprot)
1585 
    iprot.readMessageEnd()
1586 
    result = getAgents_result()
1587 
    result.success = self._handler.getAgents()
1588 
    oprot.writeMessageBegin("getAgents", TMessageType.REPLY, seqid)
1589 
    result.write(oprot)
1590 
    oprot.writeMessageEnd()
1591 
    oprot.trans.flush()
4544 varun.gupt 1592 
 
4691 mandeep.dh 1593 
  def process_validateLogIn(self, seqid, iprot, oprot):
1594 
    args = validateLogIn_args()
1595 
    args.read(iprot)
1596 
    iprot.readMessageEnd()
1597 
    result = validateLogIn_result()
1598 
    result.success = self._handler.validateLogIn(args.emailId, args.password)
1599 
    oprot.writeMessageBegin("validateLogIn", TMessageType.REPLY, seqid)
1600 
    result.write(oprot)
1601 
    oprot.writeMessageEnd()
1602 
    oprot.trans.flush()
1603 
 
1604 
  def process_updatePasswordForAgent(self, seqid, iprot, oprot):
1605 
    args = updatePasswordForAgent_args()
1606 
    args.read(iprot)
1607 
    iprot.readMessageEnd()
1608 
    result = updatePasswordForAgent_result()
1609 
    self._handler.updatePasswordForAgent(args.agentEmailId, args.password)
1610 
    oprot.writeMessageBegin("updatePasswordForAgent", TMessageType.REPLY, seqid)
1611 
    result.write(oprot)
1612 
    oprot.writeMessageEnd()
1613 
    oprot.trans.flush()
1614 
 
1615 
  def process_getRoleNamesForAgent(self, seqid, iprot, oprot):
1616 
    args = getRoleNamesForAgent_args()
1617 
    args.read(iprot)
1618 
    iprot.readMessageEnd()
1619 
    result = getRoleNamesForAgent_result()
1620 
    result.success = self._handler.getRoleNamesForAgent(args.agentEmailId)
1621 
    oprot.writeMessageBegin("getRoleNamesForAgent", TMessageType.REPLY, seqid)
1622 
    result.write(oprot)
1623 
    oprot.writeMessageEnd()
1624 
    oprot.trans.flush()
1625 
 
1626 
  def process_getPermissionsForRoleName(self, seqid, iprot, oprot):
1627 
    args = getPermissionsForRoleName_args()
1628 
    args.read(iprot)
1629 
    iprot.readMessageEnd()
1630 
    result = getPermissionsForRoleName_result()
1631 
    result.success = self._handler.getPermissionsForRoleName(args.roleName)
1632 
    oprot.writeMessageBegin("getPermissionsForRoleName", TMessageType.REPLY, seqid)
1633 
    result.write(oprot)
1634 
    oprot.writeMessageEnd()
1635 
    oprot.trans.flush()
1636 
 
4806 varun.gupt 1637 
  def process_saveQuickLink(self, seqid, iprot, oprot):
1638 
    args = saveQuickLink_args()
1639 
    args.read(iprot)
1640 
    iprot.readMessageEnd()
1641 
    result = saveQuickLink_result()
1642 
    try:
1643 
      self._handler.saveQuickLink(args.url, args.text)
1644 
    except HelperServiceException, hse:
1645 
      result.hse = hse
1646 
    oprot.writeMessageBegin("saveQuickLink", TMessageType.REPLY, seqid)
1647 
    result.write(oprot)
1648 
    oprot.writeMessageEnd()
1649 
    oprot.trans.flush()
4691 mandeep.dh 1650 
 
4806 varun.gupt 1651 
  def process_getQuickLinks(self, seqid, iprot, oprot):
1652 
    args = getQuickLinks_args()
1653 
    args.read(iprot)
1654 
    iprot.readMessageEnd()
1655 
    result = getQuickLinks_result()
1656 
    try:
1657 
      result.success = self._handler.getQuickLinks()
1658 
    except HelperServiceException, hse:
1659 
      result.hse = hse
1660 
    oprot.writeMessageBegin("getQuickLinks", TMessageType.REPLY, seqid)
1661 
    result.write(oprot)
1662 
    oprot.writeMessageEnd()
1663 
    oprot.trans.flush()
1664 
 
4996 varun.gupt 1665 
  def process_updateQuickLink(self, seqid, iprot, oprot):
1666 
    args = updateQuickLink_args()
1667 
    args.read(iprot)
1668 
    iprot.readMessageEnd()
1669 
    result = updateQuickLink_result()
1670 
    try:
1671 
      self._handler.updateQuickLink(args.id, args.url, args.text)
1672 
    except HelperServiceException, hse:
1673 
      result.hse = hse
1674 
    oprot.writeMessageBegin("updateQuickLink", TMessageType.REPLY, seqid)
1675 
    result.write(oprot)
1676 
    oprot.writeMessageEnd()
1677 
    oprot.trans.flush()
4806 varun.gupt 1678 
 
5055 varun.gupt 1679 
  def process_getEmailsForNotificationsSent(self, seqid, iprot, oprot):
1680 
    args = getEmailsForNotificationsSent_args()
1681 
    args.read(iprot)
1682 
    iprot.readMessageEnd()
1683 
    result = getEmailsForNotificationsSent_result()
1684 
    try:
1685 
      result.success = self._handler.getEmailsForNotificationsSent(args.startDatetime, args.endDatetime)
1686 
    except HelperServiceException, hse:
1687 
      result.hse = hse
1688 
    oprot.writeMessageBegin("getEmailsForNotificationsSent", TMessageType.REPLY, seqid)
1689 
    result.write(oprot)
1690 
    oprot.writeMessageEnd()
1691 
    oprot.trans.flush()
4996 varun.gupt 1692 
 
6322 amar.kumar 1693 
  def process_getOrderConfirmationMail(self, seqid, iprot, oprot):
1694 
    args = getOrderConfirmationMail_args()
1695 
    args.read(iprot)
1696 
    iprot.readMessageEnd()
1697 
    result = getOrderConfirmationMail_result()
1698 
    result.success = self._handler.getOrderConfirmationMail(args.orderId)
1699 
    oprot.writeMessageBegin("getOrderConfirmationMail", TMessageType.REPLY, seqid)
1700 
    result.write(oprot)
1701 
    oprot.writeMessageEnd()
1702 
    oprot.trans.flush()
5055 varun.gupt 1703 
 
7221 kshitij.so 1704 
  def process_getOrderDeliveryMail(self, seqid, iprot, oprot):
1705 
    args = getOrderDeliveryMail_args()
1706 
    args.read(iprot)
1707 
    iprot.readMessageEnd()
1708 
    result = getOrderDeliveryMail_result()
1709 
    result.success = self._handler.getOrderDeliveryMail(args.orderId)
1710 
    oprot.writeMessageBegin("getOrderDeliveryMail", TMessageType.REPLY, seqid)
1711 
    result.write(oprot)
1712 
    oprot.writeMessageEnd()
1713 
    oprot.trans.flush()
6322 amar.kumar 1714 
 
7221 kshitij.so 1715 
 
349 ashish 1716 
# HELPER FUNCTIONS AND STRUCTURES
1717 
 
1395 varun.gupt 1718 
class saveUserEmailForSending_args:
1719 
  """
1720 
  Attributes:
1721 
   - emailTo
1722 
   - emailFrom
1723 
   - subject
1724 
   - body
1725 
   - source
1726 
   - emailType
5864 rajveer 1727 
   - cc
1728 
   - bcc
1395 varun.gupt 1729 
  """
1730 
 
1731 
  thrift_spec = (
1732 
    None, # 0
5864 rajveer 1733 
    (1, TType.LIST, 'emailTo', (TType.STRING,None), None, ), # 1
1395 varun.gupt 1734 
    (2, TType.STRING, 'emailFrom', None, None, ), # 2
1735 
    (3, TType.STRING, 'subject', None, None, ), # 3
1736 
    (4, TType.STRING, 'body', None, None, ), # 4
1737 
    (5, TType.STRING, 'source', None, None, ), # 5
1738 
    (6, TType.STRING, 'emailType', None, None, ), # 6
5864 rajveer 1739 
    (7, TType.LIST, 'cc', (TType.STRING,None), None, ), # 7
1740 
    (8, TType.LIST, 'bcc', (TType.STRING,None), None, ), # 8
1395 varun.gupt 1741 
  )
1742 
 
5864 rajveer 1743 
  def __init__(self, emailTo=None, emailFrom=None, subject=None, body=None, source=None, emailType=None, cc=None, bcc=None,):
1395 varun.gupt 1744 
    self.emailTo = emailTo
1745 
    self.emailFrom = emailFrom
1746 
    self.subject = subject
1747 
    self.body = body
1748 
    self.source = source
1749 
    self.emailType = emailType
5864 rajveer 1750 
    self.cc = cc
1751 
    self.bcc = bcc
1395 varun.gupt 1752 
 
1753 
  def read(self, iprot):
1754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1756 
      return
1757 
    iprot.readStructBegin()
1758 
    while True:
1759 
      (fname, ftype, fid) = iprot.readFieldBegin()
1760 
      if ftype == TType.STOP:
1761 
        break
1762 
      if fid == 1:
5864 rajveer 1763 
        if ftype == TType.LIST:
1764 
          self.emailTo = []
1765 
          (_etype38, _size35) = iprot.readListBegin()
1766 
          for _i39 in xrange(_size35):
1767 
            _elem40 = iprot.readString();
1768 
            self.emailTo.append(_elem40)
1769 
          iprot.readListEnd()
1395 varun.gupt 1770 
        else:
1771 
          iprot.skip(ftype)
1772 
      elif fid == 2:
1773 
        if ftype == TType.STRING:
1774 
          self.emailFrom = iprot.readString();
1775 
        else:
1776 
          iprot.skip(ftype)
1777 
      elif fid == 3:
1778 
        if ftype == TType.STRING:
1779 
          self.subject = iprot.readString();
1780 
        else:
1781 
          iprot.skip(ftype)
1782 
      elif fid == 4:
1783 
        if ftype == TType.STRING:
1784 
          self.body = iprot.readString();
1785 
        else:
1786 
          iprot.skip(ftype)
1787 
      elif fid == 5:
1788 
        if ftype == TType.STRING:
1789 
          self.source = iprot.readString();
1790 
        else:
1791 
          iprot.skip(ftype)
1792 
      elif fid == 6:
1793 
        if ftype == TType.STRING:
1794 
          self.emailType = iprot.readString();
1795 
        else:
1796 
          iprot.skip(ftype)
5864 rajveer 1797 
      elif fid == 7:
1798 
        if ftype == TType.LIST:
1799 
          self.cc = []
1800 
          (_etype44, _size41) = iprot.readListBegin()
1801 
          for _i45 in xrange(_size41):
1802 
            _elem46 = iprot.readString();
1803 
            self.cc.append(_elem46)
1804 
          iprot.readListEnd()
1805 
        else:
1806 
          iprot.skip(ftype)
1807 
      elif fid == 8:
1808 
        if ftype == TType.LIST:
1809 
          self.bcc = []
1810 
          (_etype50, _size47) = iprot.readListBegin()
1811 
          for _i51 in xrange(_size47):
1812 
            _elem52 = iprot.readString();
1813 
            self.bcc.append(_elem52)
1814 
          iprot.readListEnd()
1815 
        else:
1816 
          iprot.skip(ftype)
1395 varun.gupt 1817 
      else:
1818 
        iprot.skip(ftype)
1819 
      iprot.readFieldEnd()
1820 
    iprot.readStructEnd()
1821 
 
1822 
  def write(self, oprot):
1823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1825 
      return
1826 
    oprot.writeStructBegin('saveUserEmailForSending_args')
3431 rajveer 1827 
    if self.emailTo is not None:
5864 rajveer 1828 
      oprot.writeFieldBegin('emailTo', TType.LIST, 1)
1829 
      oprot.writeListBegin(TType.STRING, len(self.emailTo))
1830 
      for iter53 in self.emailTo:
1831 
        oprot.writeString(iter53)
1832 
      oprot.writeListEnd()
1395 varun.gupt 1833 
      oprot.writeFieldEnd()
3431 rajveer 1834 
    if self.emailFrom is not None:
1395 varun.gupt 1835 
      oprot.writeFieldBegin('emailFrom', TType.STRING, 2)
1836 
      oprot.writeString(self.emailFrom)
1837 
      oprot.writeFieldEnd()
3431 rajveer 1838 
    if self.subject is not None:
1395 varun.gupt 1839 
      oprot.writeFieldBegin('subject', TType.STRING, 3)
1840 
      oprot.writeString(self.subject)
1841 
      oprot.writeFieldEnd()
3431 rajveer 1842 
    if self.body is not None:
1395 varun.gupt 1843 
      oprot.writeFieldBegin('body', TType.STRING, 4)
1844 
      oprot.writeString(self.body)
1845 
      oprot.writeFieldEnd()
3431 rajveer 1846 
    if self.source is not None:
1395 varun.gupt 1847 
      oprot.writeFieldBegin('source', TType.STRING, 5)
1848 
      oprot.writeString(self.source)
1849 
      oprot.writeFieldEnd()
3431 rajveer 1850 
    if self.emailType is not None:
1395 varun.gupt 1851 
      oprot.writeFieldBegin('emailType', TType.STRING, 6)
1852 
      oprot.writeString(self.emailType)
1853 
      oprot.writeFieldEnd()
5864 rajveer 1854 
    if self.cc is not None:
1855 
      oprot.writeFieldBegin('cc', TType.LIST, 7)
1856 
      oprot.writeListBegin(TType.STRING, len(self.cc))
1857 
      for iter54 in self.cc:
1858 
        oprot.writeString(iter54)
1859 
      oprot.writeListEnd()
1860 
      oprot.writeFieldEnd()
1861 
    if self.bcc is not None:
1862 
      oprot.writeFieldBegin('bcc', TType.LIST, 8)
1863 
      oprot.writeListBegin(TType.STRING, len(self.bcc))
1864 
      for iter55 in self.bcc:
1865 
        oprot.writeString(iter55)
1866 
      oprot.writeListEnd()
1867 
      oprot.writeFieldEnd()
1395 varun.gupt 1868 
    oprot.writeFieldStop()
1869 
    oprot.writeStructEnd()
1870 
 
3431 rajveer 1871 
  def validate(self):
1872 
    return
1873 
 
1874 
 
1395 varun.gupt 1875 
  def __repr__(self):
1876 
    L = ['%s=%r' % (key, value)
1877 
      for key, value in self.__dict__.iteritems()]
1878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1879 
 
1880 
  def __eq__(self, other):
1881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1882 
 
1883 
  def __ne__(self, other):
1884 
    return not (self == other)
1885 
 
1886 
class saveUserEmailForSending_result:
1887 
  """
1888 
  Attributes:
3206 mandeep.dh 1889 
   - success
1395 varun.gupt 1890 
   - se
1891 
  """
1892 
 
1893 
  thrift_spec = (
3206 mandeep.dh 1894 
    (0, TType.I64, 'success', None, None, ), # 0
1395 varun.gupt 1895 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1896 
  )
1897 
 
3206 mandeep.dh 1898 
  def __init__(self, success=None, se=None,):
1899 
    self.success = success
1395 varun.gupt 1900 
    self.se = se
1901 
 
1902 
  def read(self, iprot):
1903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1905 
      return
1906 
    iprot.readStructBegin()
1907 
    while True:
1908 
      (fname, ftype, fid) = iprot.readFieldBegin()
1909 
      if ftype == TType.STOP:
1910 
        break
3206 mandeep.dh 1911 
      if fid == 0:
1912 
        if ftype == TType.I64:
1913 
          self.success = iprot.readI64();
1914 
        else:
1915 
          iprot.skip(ftype)
1916 
      elif fid == 1:
1395 varun.gupt 1917 
        if ftype == TType.STRUCT:
1918 
          self.se = HelperServiceException()
1919 
          self.se.read(iprot)
1920 
        else:
1921 
          iprot.skip(ftype)
1922 
      else:
1923 
        iprot.skip(ftype)
1924 
      iprot.readFieldEnd()
1925 
    iprot.readStructEnd()
1926 
 
1927 
  def write(self, oprot):
1928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1930 
      return
1931 
    oprot.writeStructBegin('saveUserEmailForSending_result')
3431 rajveer 1932 
    if self.success is not None:
3206 mandeep.dh 1933 
      oprot.writeFieldBegin('success', TType.I64, 0)
1934 
      oprot.writeI64(self.success)
1935 
      oprot.writeFieldEnd()
3431 rajveer 1936 
    if self.se is not None:
1395 varun.gupt 1937 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1938 
      self.se.write(oprot)
1939 
      oprot.writeFieldEnd()
1940 
    oprot.writeFieldStop()
1941 
    oprot.writeStructEnd()
1942 
 
3431 rajveer 1943 
  def validate(self):
1944 
    return
1945 
 
1946 
 
1395 varun.gupt 1947 
  def __repr__(self):
1948 
    L = ['%s=%r' % (key, value)
1949 
      for key, value in self.__dict__.iteritems()]
1950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1951 
 
1952 
  def __eq__(self, other):
1953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1954 
 
1955 
  def __ne__(self, other):
1956 
    return not (self == other)
1957 
 
1422 varun.gupt 1958 
class getEmailsToBeSent_args:
1959 
 
1960 
  thrift_spec = (
1961 
  )
1962 
 
1963 
  def read(self, iprot):
1964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1966 
      return
1967 
    iprot.readStructBegin()
1968 
    while True:
1969 
      (fname, ftype, fid) = iprot.readFieldBegin()
1970 
      if ftype == TType.STOP:
1971 
        break
1972 
      else:
1973 
        iprot.skip(ftype)
1974 
      iprot.readFieldEnd()
1975 
    iprot.readStructEnd()
1976 
 
1977 
  def write(self, oprot):
1978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1980 
      return
1981 
    oprot.writeStructBegin('getEmailsToBeSent_args')
1982 
    oprot.writeFieldStop()
1983 
    oprot.writeStructEnd()
1984 
 
3431 rajveer 1985 
  def validate(self):
1986 
    return
1987 
 
1988 
 
1422 varun.gupt 1989 
  def __repr__(self):
1990 
    L = ['%s=%r' % (key, value)
1991 
      for key, value in self.__dict__.iteritems()]
1992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1993 
 
1994 
  def __eq__(self, other):
1995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1996 
 
1997 
  def __ne__(self, other):
1998 
    return not (self == other)
1999 
 
2000 
class getEmailsToBeSent_result:
2001 
  """
2002 
  Attributes:
2003 
   - success
2004 
   - se
2005 
  """
2006 
 
2007 
  thrift_spec = (
2008 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserEmail, UserEmail.thrift_spec)), None, ), # 0
2009 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2010 
  )
2011 
 
2012 
  def __init__(self, success=None, se=None,):
2013 
    self.success = success
2014 
    self.se = se
2015 
 
2016 
  def read(self, iprot):
2017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2019 
      return
2020 
    iprot.readStructBegin()
2021 
    while True:
2022 
      (fname, ftype, fid) = iprot.readFieldBegin()
2023 
      if ftype == TType.STOP:
2024 
        break
2025 
      if fid == 0:
2026 
        if ftype == TType.LIST:
2027 
          self.success = []
5864 rajveer 2028 
          (_etype59, _size56) = iprot.readListBegin()
2029 
          for _i60 in xrange(_size56):
2030 
            _elem61 = UserEmail()
2031 
            _elem61.read(iprot)
2032 
            self.success.append(_elem61)
1422 varun.gupt 2033 
          iprot.readListEnd()
2034 
        else:
2035 
          iprot.skip(ftype)
2036 
      elif fid == 1:
2037 
        if ftype == TType.STRUCT:
2038 
          self.se = HelperServiceException()
2039 
          self.se.read(iprot)
2040 
        else:
2041 
          iprot.skip(ftype)
2042 
      else:
2043 
        iprot.skip(ftype)
2044 
      iprot.readFieldEnd()
2045 
    iprot.readStructEnd()
2046 
 
2047 
  def write(self, oprot):
2048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2050 
      return
2051 
    oprot.writeStructBegin('getEmailsToBeSent_result')
3431 rajveer 2052 
    if self.success is not None:
1422 varun.gupt 2053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5864 rajveer 2055 
      for iter62 in self.success:
2056 
        iter62.write(oprot)
1422 varun.gupt 2057 
      oprot.writeListEnd()
2058 
      oprot.writeFieldEnd()
3431 rajveer 2059 
    if self.se is not None:
1422 varun.gupt 2060 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2061 
      self.se.write(oprot)
2062 
      oprot.writeFieldEnd()
2063 
    oprot.writeFieldStop()
2064 
    oprot.writeStructEnd()
2065 
 
3431 rajveer 2066 
  def validate(self):
2067 
    return
2068 
 
2069 
 
1422 varun.gupt 2070 
  def __repr__(self):
2071 
    L = ['%s=%r' % (key, value)
2072 
      for key, value in self.__dict__.iteritems()]
2073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2074 
 
2075 
  def __eq__(self, other):
2076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2077 
 
2078 
  def __ne__(self, other):
2079 
    return not (self == other)
2080 
 
2081 
class markEmailAsSent_args:
2082 
  """
2083 
  Attributes:
2084 
   - emailId
2085 
  """
2086 
 
2087 
  thrift_spec = (
2088 
    None, # 0
2089 
    (1, TType.I64, 'emailId', None, None, ), # 1
2090 
  )
2091 
 
2092 
  def __init__(self, emailId=None,):
2093 
    self.emailId = emailId
2094 
 
2095 
  def read(self, iprot):
2096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2098 
      return
2099 
    iprot.readStructBegin()
2100 
    while True:
2101 
      (fname, ftype, fid) = iprot.readFieldBegin()
2102 
      if ftype == TType.STOP:
2103 
        break
2104 
      if fid == 1:
2105 
        if ftype == TType.I64:
2106 
          self.emailId = iprot.readI64();
2107 
        else:
2108 
          iprot.skip(ftype)
2109 
      else:
2110 
        iprot.skip(ftype)
2111 
      iprot.readFieldEnd()
2112 
    iprot.readStructEnd()
2113 
 
2114 
  def write(self, oprot):
2115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2117 
      return
2118 
    oprot.writeStructBegin('markEmailAsSent_args')
3431 rajveer 2119 
    if self.emailId is not None:
1422 varun.gupt 2120 
      oprot.writeFieldBegin('emailId', TType.I64, 1)
2121 
      oprot.writeI64(self.emailId)
2122 
      oprot.writeFieldEnd()
2123 
    oprot.writeFieldStop()
2124 
    oprot.writeStructEnd()
2125 
 
3431 rajveer 2126 
  def validate(self):
2127 
    return
2128 
 
2129 
 
1422 varun.gupt 2130 
  def __repr__(self):
2131 
    L = ['%s=%r' % (key, value)
2132 
      for key, value in self.__dict__.iteritems()]
2133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2134 
 
2135 
  def __eq__(self, other):
2136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2137 
 
2138 
  def __ne__(self, other):
2139 
    return not (self == other)
2140 
 
2141 
class markEmailAsSent_result:
2142 
  """
2143 
  Attributes:
2144 
   - se
2145 
  """
2146 
 
2147 
  thrift_spec = (
2148 
    None, # 0
2149 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2150 
  )
2151 
 
2152 
  def __init__(self, se=None,):
2153 
    self.se = se
2154 
 
2155 
  def read(self, iprot):
2156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2158 
      return
2159 
    iprot.readStructBegin()
2160 
    while True:
2161 
      (fname, ftype, fid) = iprot.readFieldBegin()
2162 
      if ftype == TType.STOP:
2163 
        break
2164 
      if fid == 1:
2165 
        if ftype == TType.STRUCT:
2166 
          self.se = HelperServiceException()
2167 
          self.se.read(iprot)
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('markEmailAsSent_result')
3431 rajveer 2180 
    if self.se is not None:
1422 varun.gupt 2181 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2182 
      self.se.write(oprot)
2183 
      oprot.writeFieldEnd()
2184 
    oprot.writeFieldStop()
2185 
    oprot.writeStructEnd()
2186 
 
3431 rajveer 2187 
  def validate(self):
2188 
    return
2189 
 
2190 
 
1422 varun.gupt 2191 
  def __repr__(self):
2192 
    L = ['%s=%r' % (key, value)
2193 
      for key, value in self.__dict__.iteritems()]
2194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2195 
 
2196 
  def __eq__(self, other):
2197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2198 
 
2199 
  def __ne__(self, other):
2200 
    return not (self == other)
2201 
 
349 ashish 2202 
class sendMail_args:
2203 
  """
2204 
  Attributes:
2205 
   - mail
2206 
  """
2207 
 
2208 
  thrift_spec = (
2209 
    None, # 0
2210 
    (1, TType.STRUCT, 'mail', (Mail, Mail.thrift_spec), None, ), # 1
2211 
  )
2212 
 
2213 
  def __init__(self, mail=None,):
2214 
    self.mail = mail
2215 
 
2216 
  def read(self, iprot):
2217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2219 
      return
2220 
    iprot.readStructBegin()
2221 
    while True:
2222 
      (fname, ftype, fid) = iprot.readFieldBegin()
2223 
      if ftype == TType.STOP:
2224 
        break
2225 
      if fid == 1:
2226 
        if ftype == TType.STRUCT:
2227 
          self.mail = Mail()
2228 
          self.mail.read(iprot)
2229 
        else:
2230 
          iprot.skip(ftype)
2231 
      else:
2232 
        iprot.skip(ftype)
2233 
      iprot.readFieldEnd()
2234 
    iprot.readStructEnd()
2235 
 
2236 
  def write(self, oprot):
2237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2239 
      return
2240 
    oprot.writeStructBegin('sendMail_args')
3431 rajveer 2241 
    if self.mail is not None:
349 ashish 2242 
      oprot.writeFieldBegin('mail', TType.STRUCT, 1)
2243 
      self.mail.write(oprot)
2244 
      oprot.writeFieldEnd()
2245 
    oprot.writeFieldStop()
2246 
    oprot.writeStructEnd()
2247 
 
3431 rajveer 2248 
  def validate(self):
2249 
    return
2250 
 
2251 
 
349 ashish 2252 
  def __repr__(self):
2253 
    L = ['%s=%r' % (key, value)
2254 
      for key, value in self.__dict__.iteritems()]
2255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2256 
 
2257 
  def __eq__(self, other):
2258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2259 
 
2260 
  def __ne__(self, other):
2261 
    return not (self == other)
2262 
 
2263 
class sendMail_result:
2264 
  """
2265 
  Attributes:
2266 
   - se
2267 
  """
2268 
 
2269 
  thrift_spec = (
2270 
    None, # 0
2271 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2272 
  )
2273 
 
2274 
  def __init__(self, se=None,):
2275 
    self.se = se
2276 
 
2277 
  def read(self, iprot):
2278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2280 
      return
2281 
    iprot.readStructBegin()
2282 
    while True:
2283 
      (fname, ftype, fid) = iprot.readFieldBegin()
2284 
      if ftype == TType.STOP:
2285 
        break
2286 
      if fid == 1:
2287 
        if ftype == TType.STRUCT:
2288 
          self.se = HelperServiceException()
2289 
          self.se.read(iprot)
2290 
        else:
2291 
          iprot.skip(ftype)
2292 
      else:
2293 
        iprot.skip(ftype)
2294 
      iprot.readFieldEnd()
2295 
    iprot.readStructEnd()
2296 
 
2297 
  def write(self, oprot):
2298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2300 
      return
2301 
    oprot.writeStructBegin('sendMail_result')
3431 rajveer 2302 
    if self.se is not None:
349 ashish 2303 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2304 
      self.se.write(oprot)
2305 
      oprot.writeFieldEnd()
2306 
    oprot.writeFieldStop()
2307 
    oprot.writeStructEnd()
2308 
 
3431 rajveer 2309 
  def validate(self):
2310 
    return
2311 
 
2312 
 
349 ashish 2313 
  def __repr__(self):
2314 
    L = ['%s=%r' % (key, value)
2315 
      for key, value in self.__dict__.iteritems()]
2316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2317 
 
2318 
  def __eq__(self, other):
2319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2320 
 
2321 
  def __ne__(self, other):
2322 
    return not (self == other)
2323 
 
2324 
class sendText_args:
2325 
  """
2326 
  Attributes:
2327 
   - message
2328 
  """
2329 
 
2330 
  thrift_spec = (
2331 
    None, # 0
2332 
    (1, TType.STRUCT, 'message', (TextMessage, TextMessage.thrift_spec), None, ), # 1
2333 
  )
2334 
 
2335 
  def __init__(self, message=None,):
2336 
    self.message = message
2337 
 
2338 
  def read(self, iprot):
2339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2341 
      return
2342 
    iprot.readStructBegin()
2343 
    while True:
2344 
      (fname, ftype, fid) = iprot.readFieldBegin()
2345 
      if ftype == TType.STOP:
2346 
        break
2347 
      if fid == 1:
2348 
        if ftype == TType.STRUCT:
2349 
          self.message = TextMessage()
2350 
          self.message.read(iprot)
2351 
        else:
2352 
          iprot.skip(ftype)
2353 
      else:
2354 
        iprot.skip(ftype)
2355 
      iprot.readFieldEnd()
2356 
    iprot.readStructEnd()
2357 
 
2358 
  def write(self, oprot):
2359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2361 
      return
2362 
    oprot.writeStructBegin('sendText_args')
3431 rajveer 2363 
    if self.message is not None:
349 ashish 2364 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
2365 
      self.message.write(oprot)
2366 
      oprot.writeFieldEnd()
2367 
    oprot.writeFieldStop()
2368 
    oprot.writeStructEnd()
2369 
 
3431 rajveer 2370 
  def validate(self):
2371 
    return
2372 
 
2373 
 
349 ashish 2374 
  def __repr__(self):
2375 
    L = ['%s=%r' % (key, value)
2376 
      for key, value in self.__dict__.iteritems()]
2377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2378 
 
2379 
  def __eq__(self, other):
2380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2381 
 
2382 
  def __ne__(self, other):
2383 
    return not (self == other)
2384 
 
2385 
class sendText_result:
2386 
  """
2387 
  Attributes:
2388 
   - se
2389 
  """
2390 
 
2391 
  thrift_spec = (
2392 
    None, # 0
2393 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2394 
  )
2395 
 
2396 
  def __init__(self, se=None,):
2397 
    self.se = se
2398 
 
2399 
  def read(self, iprot):
2400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2402 
      return
2403 
    iprot.readStructBegin()
2404 
    while True:
2405 
      (fname, ftype, fid) = iprot.readFieldBegin()
2406 
      if ftype == TType.STOP:
2407 
        break
2408 
      if fid == 1:
2409 
        if ftype == TType.STRUCT:
2410 
          self.se = HelperServiceException()
2411 
          self.se.read(iprot)
2412 
        else:
2413 
          iprot.skip(ftype)
2414 
      else:
2415 
        iprot.skip(ftype)
2416 
      iprot.readFieldEnd()
2417 
    iprot.readStructEnd()
2418 
 
2419 
  def write(self, oprot):
2420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2422 
      return
2423 
    oprot.writeStructBegin('sendText_result')
3431 rajveer 2424 
    if self.se is not None:
349 ashish 2425 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2426 
      self.se.write(oprot)
2427 
      oprot.writeFieldEnd()
2428 
    oprot.writeFieldStop()
2429 
    oprot.writeStructEnd()
2430 
 
3431 rajveer 2431 
  def validate(self):
2432 
    return
2433 
 
2434 
 
349 ashish 2435 
  def __repr__(self):
2436 
    L = ['%s=%r' % (key, value)
2437 
      for key, value in self.__dict__.iteritems()]
2438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2439 
 
2440 
  def __eq__(self, other):
2441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2442 
 
2443 
  def __ne__(self, other):
2444 
    return not (self == other)
2445 
 
2446 
class addMessage_args:
2447 
  """
2448 
  Attributes:
2449 
   - message
2450 
  """
2451 
 
2452 
  thrift_spec = (
2453 
    None, # 0
2454 
    (1, TType.STRUCT, 'message', (Message, Message.thrift_spec), None, ), # 1
2455 
  )
2456 
 
2457 
  def __init__(self, message=None,):
2458 
    self.message = message
2459 
 
2460 
  def read(self, iprot):
2461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2463 
      return
2464 
    iprot.readStructBegin()
2465 
    while True:
2466 
      (fname, ftype, fid) = iprot.readFieldBegin()
2467 
      if ftype == TType.STOP:
2468 
        break
2469 
      if fid == 1:
2470 
        if ftype == TType.STRUCT:
2471 
          self.message = Message()
2472 
          self.message.read(iprot)
2473 
        else:
2474 
          iprot.skip(ftype)
2475 
      else:
2476 
        iprot.skip(ftype)
2477 
      iprot.readFieldEnd()
2478 
    iprot.readStructEnd()
2479 
 
2480 
  def write(self, oprot):
2481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2483 
      return
2484 
    oprot.writeStructBegin('addMessage_args')
3431 rajveer 2485 
    if self.message is not None:
349 ashish 2486 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
2487 
      self.message.write(oprot)
2488 
      oprot.writeFieldEnd()
2489 
    oprot.writeFieldStop()
2490 
    oprot.writeStructEnd()
2491 
 
3431 rajveer 2492 
  def validate(self):
2493 
    return
2494 
 
2495 
 
349 ashish 2496 
  def __repr__(self):
2497 
    L = ['%s=%r' % (key, value)
2498 
      for key, value in self.__dict__.iteritems()]
2499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2500 
 
2501 
  def __eq__(self, other):
2502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2503 
 
2504 
  def __ne__(self, other):
2505 
    return not (self == other)
2506 
 
2507 
class addMessage_result:
2508 
  """
2509 
  Attributes:
2510 
   - se
2511 
  """
2512 
 
2513 
  thrift_spec = (
2514 
    None, # 0
2515 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2516 
  )
2517 
 
2518 
  def __init__(self, se=None,):
2519 
    self.se = se
2520 
 
2521 
  def read(self, iprot):
2522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2524 
      return
2525 
    iprot.readStructBegin()
2526 
    while True:
2527 
      (fname, ftype, fid) = iprot.readFieldBegin()
2528 
      if ftype == TType.STOP:
2529 
        break
2530 
      if fid == 1:
2531 
        if ftype == TType.STRUCT:
2532 
          self.se = HelperServiceException()
2533 
          self.se.read(iprot)
2534 
        else:
2535 
          iprot.skip(ftype)
2536 
      else:
2537 
        iprot.skip(ftype)
2538 
      iprot.readFieldEnd()
2539 
    iprot.readStructEnd()
2540 
 
2541 
  def write(self, oprot):
2542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2544 
      return
2545 
    oprot.writeStructBegin('addMessage_result')
3431 rajveer 2546 
    if self.se is not None:
349 ashish 2547 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2548 
      self.se.write(oprot)
2549 
      oprot.writeFieldEnd()
2550 
    oprot.writeFieldStop()
2551 
    oprot.writeStructEnd()
2552 
 
3431 rajveer 2553 
  def validate(self):
2554 
    return
2555 
 
2556 
 
349 ashish 2557 
  def __repr__(self):
2558 
    L = ['%s=%r' % (key, value)
2559 
      for key, value in self.__dict__.iteritems()]
2560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2561 
 
2562 
  def __eq__(self, other):
2563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2564 
 
2565 
  def __ne__(self, other):
2566 
    return not (self == other)
2567 
 
2568 
class updateMessage_args:
2569 
  """
2570 
  Attributes:
2571 
   - id
2572 
   - message
2573 
  """
2574 
 
2575 
  thrift_spec = (
2576 
    None, # 0
2577 
    (1, TType.I64, 'id', None, None, ), # 1
2578 
    (2, TType.STRING, 'message', None, None, ), # 2
2579 
  )
2580 
 
2581 
  def __init__(self, id=None, message=None,):
2582 
    self.id = id
2583 
    self.message = message
2584 
 
2585 
  def read(self, iprot):
2586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2588 
      return
2589 
    iprot.readStructBegin()
2590 
    while True:
2591 
      (fname, ftype, fid) = iprot.readFieldBegin()
2592 
      if ftype == TType.STOP:
2593 
        break
2594 
      if fid == 1:
2595 
        if ftype == TType.I64:
2596 
          self.id = iprot.readI64();
2597 
        else:
2598 
          iprot.skip(ftype)
2599 
      elif fid == 2:
2600 
        if ftype == TType.STRING:
2601 
          self.message = iprot.readString();
2602 
        else:
2603 
          iprot.skip(ftype)
2604 
      else:
2605 
        iprot.skip(ftype)
2606 
      iprot.readFieldEnd()
2607 
    iprot.readStructEnd()
2608 
 
2609 
  def write(self, oprot):
2610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2612 
      return
2613 
    oprot.writeStructBegin('updateMessage_args')
3431 rajveer 2614 
    if self.id is not None:
349 ashish 2615 
      oprot.writeFieldBegin('id', TType.I64, 1)
2616 
      oprot.writeI64(self.id)
2617 
      oprot.writeFieldEnd()
3431 rajveer 2618 
    if self.message is not None:
349 ashish 2619 
      oprot.writeFieldBegin('message', TType.STRING, 2)
2620 
      oprot.writeString(self.message)
2621 
      oprot.writeFieldEnd()
2622 
    oprot.writeFieldStop()
2623 
    oprot.writeStructEnd()
2624 
 
3431 rajveer 2625 
  def validate(self):
2626 
    return
2627 
 
2628 
 
349 ashish 2629 
  def __repr__(self):
2630 
    L = ['%s=%r' % (key, value)
2631 
      for key, value in self.__dict__.iteritems()]
2632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2633 
 
2634 
  def __eq__(self, other):
2635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2636 
 
2637 
  def __ne__(self, other):
2638 
    return not (self == other)
2639 
 
2640 
class updateMessage_result:
2641 
  """
2642 
  Attributes:
2643 
   - se
2644 
  """
2645 
 
2646 
  thrift_spec = (
2647 
    None, # 0
2648 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2649 
  )
2650 
 
2651 
  def __init__(self, se=None,):
2652 
    self.se = se
2653 
 
2654 
  def read(self, iprot):
2655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2657 
      return
2658 
    iprot.readStructBegin()
2659 
    while True:
2660 
      (fname, ftype, fid) = iprot.readFieldBegin()
2661 
      if ftype == TType.STOP:
2662 
        break
2663 
      if fid == 1:
2664 
        if ftype == TType.STRUCT:
2665 
          self.se = HelperServiceException()
2666 
          self.se.read(iprot)
2667 
        else:
2668 
          iprot.skip(ftype)
2669 
      else:
2670 
        iprot.skip(ftype)
2671 
      iprot.readFieldEnd()
2672 
    iprot.readStructEnd()
2673 
 
2674 
  def write(self, oprot):
2675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2677 
      return
2678 
    oprot.writeStructBegin('updateMessage_result')
3431 rajveer 2679 
    if self.se is not None:
349 ashish 2680 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2681 
      self.se.write(oprot)
2682 
      oprot.writeFieldEnd()
2683 
    oprot.writeFieldStop()
2684 
    oprot.writeStructEnd()
2685 
 
3431 rajveer 2686 
  def validate(self):
2687 
    return
2688 
 
2689 
 
349 ashish 2690 
  def __repr__(self):
2691 
    L = ['%s=%r' % (key, value)
2692 
      for key, value in self.__dict__.iteritems()]
2693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2694 
 
2695 
  def __eq__(self, other):
2696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2697 
 
2698 
  def __ne__(self, other):
2699 
    return not (self == other)
2700 
 
2701 
class getMessage_args:
2702 
  """
2703 
  Attributes:
2704 
   - id
2705 
  """
2706 
 
2707 
  thrift_spec = (
2708 
    None, # 0
2709 
    (1, TType.I64, 'id', None, None, ), # 1
2710 
  )
2711 
 
2712 
  def __init__(self, id=None,):
2713 
    self.id = id
2714 
 
2715 
  def read(self, iprot):
2716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2718 
      return
2719 
    iprot.readStructBegin()
2720 
    while True:
2721 
      (fname, ftype, fid) = iprot.readFieldBegin()
2722 
      if ftype == TType.STOP:
2723 
        break
2724 
      if fid == 1:
2725 
        if ftype == TType.I64:
2726 
          self.id = iprot.readI64();
2727 
        else:
2728 
          iprot.skip(ftype)
2729 
      else:
2730 
        iprot.skip(ftype)
2731 
      iprot.readFieldEnd()
2732 
    iprot.readStructEnd()
2733 
 
2734 
  def write(self, oprot):
2735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2737 
      return
2738 
    oprot.writeStructBegin('getMessage_args')
3431 rajveer 2739 
    if self.id is not None:
349 ashish 2740 
      oprot.writeFieldBegin('id', TType.I64, 1)
2741 
      oprot.writeI64(self.id)
2742 
      oprot.writeFieldEnd()
2743 
    oprot.writeFieldStop()
2744 
    oprot.writeStructEnd()
2745 
 
3431 rajveer 2746 
  def validate(self):
2747 
    return
2748 
 
2749 
 
349 ashish 2750 
  def __repr__(self):
2751 
    L = ['%s=%r' % (key, value)
2752 
      for key, value in self.__dict__.iteritems()]
2753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2754 
 
2755 
  def __eq__(self, other):
2756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2757 
 
2758 
  def __ne__(self, other):
2759 
    return not (self == other)
2760 
 
2761 
class getMessage_result:
2762 
  """
2763 
  Attributes:
353 ashish 2764 
   - success
349 ashish 2765 
   - se
2766 
  """
2767 
 
2768 
  thrift_spec = (
353 ashish 2769 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 2770 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2771 
  )
2772 
 
353 ashish 2773 
  def __init__(self, success=None, se=None,):
2774 
    self.success = success
349 ashish 2775 
    self.se = se
2776 
 
2777 
  def read(self, iprot):
2778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2780 
      return
2781 
    iprot.readStructBegin()
2782 
    while True:
2783 
      (fname, ftype, fid) = iprot.readFieldBegin()
2784 
      if ftype == TType.STOP:
2785 
        break
353 ashish 2786 
      if fid == 0:
349 ashish 2787 
        if ftype == TType.STRUCT:
353 ashish 2788 
          self.success = Message()
2789 
          self.success.read(iprot)
2790 
        else:
2791 
          iprot.skip(ftype)
2792 
      elif fid == 1:
2793 
        if ftype == TType.STRUCT:
349 ashish 2794 
          self.se = HelperServiceException()
2795 
          self.se.read(iprot)
2796 
        else:
2797 
          iprot.skip(ftype)
2798 
      else:
2799 
        iprot.skip(ftype)
2800 
      iprot.readFieldEnd()
2801 
    iprot.readStructEnd()
2802 
 
2803 
  def write(self, oprot):
2804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2806 
      return
2807 
    oprot.writeStructBegin('getMessage_result')
3431 rajveer 2808 
    if self.success is not None:
353 ashish 2809 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2810 
      self.success.write(oprot)
2811 
      oprot.writeFieldEnd()
3431 rajveer 2812 
    if self.se is not None:
349 ashish 2813 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2814 
      self.se.write(oprot)
2815 
      oprot.writeFieldEnd()
2816 
    oprot.writeFieldStop()
2817 
    oprot.writeStructEnd()
2818 
 
3431 rajveer 2819 
  def validate(self):
2820 
    return
2821 
 
2822 
 
349 ashish 2823 
  def __repr__(self):
2824 
    L = ['%s=%r' % (key, value)
2825 
      for key, value in self.__dict__.iteritems()]
2826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2827 
 
2828 
  def __eq__(self, other):
2829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2830 
 
2831 
  def __ne__(self, other):
2832 
    return not (self == other)
2833 
 
2834 
class getSubstitutedMessage_args:
2835 
  """
2836 
  Attributes:
2837 
   - id
2838 
   - params
2839 
  """
2840 
 
2841 
  thrift_spec = (
2842 
    None, # 0
2843 
    (1, TType.I64, 'id', None, None, ), # 1
2844 
    (2, TType.MAP, 'params', (TType.STRING,None,TType.STRING,None), None, ), # 2
2845 
  )
2846 
 
2847 
  def __init__(self, id=None, params=None,):
2848 
    self.id = id
2849 
    self.params = params
2850 
 
2851 
  def read(self, iprot):
2852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2854 
      return
2855 
    iprot.readStructBegin()
2856 
    while True:
2857 
      (fname, ftype, fid) = iprot.readFieldBegin()
2858 
      if ftype == TType.STOP:
2859 
        break
2860 
      if fid == 1:
2861 
        if ftype == TType.I64:
2862 
          self.id = iprot.readI64();
2863 
        else:
2864 
          iprot.skip(ftype)
2865 
      elif fid == 2:
2866 
        if ftype == TType.MAP:
2867 
          self.params = {}
5864 rajveer 2868 
          (_ktype64, _vtype65, _size63 ) = iprot.readMapBegin()
2869 
          for _i67 in xrange(_size63):
2870 
            _key68 = iprot.readString();
2871 
            _val69 = iprot.readString();
2872 
            self.params[_key68] = _val69
349 ashish 2873 
          iprot.readMapEnd()
2874 
        else:
2875 
          iprot.skip(ftype)
2876 
      else:
2877 
        iprot.skip(ftype)
2878 
      iprot.readFieldEnd()
2879 
    iprot.readStructEnd()
2880 
 
2881 
  def write(self, oprot):
2882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2884 
      return
2885 
    oprot.writeStructBegin('getSubstitutedMessage_args')
3431 rajveer 2886 
    if self.id is not None:
349 ashish 2887 
      oprot.writeFieldBegin('id', TType.I64, 1)
2888 
      oprot.writeI64(self.id)
2889 
      oprot.writeFieldEnd()
3431 rajveer 2890 
    if self.params is not None:
349 ashish 2891 
      oprot.writeFieldBegin('params', TType.MAP, 2)
2892 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.params))
5864 rajveer 2893 
      for kiter70,viter71 in self.params.items():
2894 
        oprot.writeString(kiter70)
2895 
        oprot.writeString(viter71)
349 ashish 2896 
      oprot.writeMapEnd()
2897 
      oprot.writeFieldEnd()
2898 
    oprot.writeFieldStop()
2899 
    oprot.writeStructEnd()
2900 
 
3431 rajveer 2901 
  def validate(self):
2902 
    return
2903 
 
2904 
 
349 ashish 2905 
  def __repr__(self):
2906 
    L = ['%s=%r' % (key, value)
2907 
      for key, value in self.__dict__.iteritems()]
2908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2909 
 
2910 
  def __eq__(self, other):
2911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2912 
 
2913 
  def __ne__(self, other):
2914 
    return not (self == other)
2915 
 
2916 
class getSubstitutedMessage_result:
2917 
  """
2918 
  Attributes:
353 ashish 2919 
   - success
349 ashish 2920 
   - se
2921 
  """
2922 
 
2923 
  thrift_spec = (
353 ashish 2924 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 2925 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
2926 
  )
2927 
 
353 ashish 2928 
  def __init__(self, success=None, se=None,):
2929 
    self.success = success
349 ashish 2930 
    self.se = se
2931 
 
2932 
  def read(self, iprot):
2933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2935 
      return
2936 
    iprot.readStructBegin()
2937 
    while True:
2938 
      (fname, ftype, fid) = iprot.readFieldBegin()
2939 
      if ftype == TType.STOP:
2940 
        break
353 ashish 2941 
      if fid == 0:
349 ashish 2942 
        if ftype == TType.STRUCT:
353 ashish 2943 
          self.success = Message()
2944 
          self.success.read(iprot)
2945 
        else:
2946 
          iprot.skip(ftype)
2947 
      elif fid == 1:
2948 
        if ftype == TType.STRUCT:
349 ashish 2949 
          self.se = HelperServiceException()
2950 
          self.se.read(iprot)
2951 
        else:
2952 
          iprot.skip(ftype)
2953 
      else:
2954 
        iprot.skip(ftype)
2955 
      iprot.readFieldEnd()
2956 
    iprot.readStructEnd()
2957 
 
2958 
  def write(self, oprot):
2959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2961 
      return
2962 
    oprot.writeStructBegin('getSubstitutedMessage_result')
3431 rajveer 2963 
    if self.success is not None:
353 ashish 2964 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2965 
      self.success.write(oprot)
2966 
      oprot.writeFieldEnd()
3431 rajveer 2967 
    if self.se is not None:
349 ashish 2968 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2969 
      self.se.write(oprot)
2970 
      oprot.writeFieldEnd()
2971 
    oprot.writeFieldStop()
2972 
    oprot.writeStructEnd()
2973 
 
3431 rajveer 2974 
  def validate(self):
2975 
    return
2976 
 
2977 
 
349 ashish 2978 
  def __repr__(self):
2979 
    L = ['%s=%r' % (key, value)
2980 
      for key, value in self.__dict__.iteritems()]
2981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2982 
 
2983 
  def __eq__(self, other):
2984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2985 
 
2986 
  def __ne__(self, other):
2987 
    return not (self == other)
2988 
 
494 rajveer 2989 
class addUser_args:
2990 
  """
2991 
  Attributes:
2992 
   - username
2993 
   - password
2994 
   - warehouseId
2995 
  """
349 ashish 2996 
 
494 rajveer 2997 
  thrift_spec = (
2998 
    None, # 0
2999 
    (1, TType.STRING, 'username', None, None, ), # 1
3000 
    (2, TType.STRING, 'password', None, None, ), # 2
3001 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
3002 
  )
3003 
 
3004 
  def __init__(self, username=None, password=None, warehouseId=None,):
3005 
    self.username = username
3006 
    self.password = password
3007 
    self.warehouseId = warehouseId
3008 
 
3009 
  def read(self, iprot):
3010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3012 
      return
3013 
    iprot.readStructBegin()
3014 
    while True:
3015 
      (fname, ftype, fid) = iprot.readFieldBegin()
3016 
      if ftype == TType.STOP:
3017 
        break
3018 
      if fid == 1:
3019 
        if ftype == TType.STRING:
3020 
          self.username = iprot.readString();
3021 
        else:
3022 
          iprot.skip(ftype)
3023 
      elif fid == 2:
3024 
        if ftype == TType.STRING:
3025 
          self.password = iprot.readString();
3026 
        else:
3027 
          iprot.skip(ftype)
3028 
      elif fid == 3:
3029 
        if ftype == TType.I64:
3030 
          self.warehouseId = iprot.readI64();
3031 
        else:
3032 
          iprot.skip(ftype)
3033 
      else:
3034 
        iprot.skip(ftype)
3035 
      iprot.readFieldEnd()
3036 
    iprot.readStructEnd()
3037 
 
3038 
  def write(self, oprot):
3039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3041 
      return
3042 
    oprot.writeStructBegin('addUser_args')
3431 rajveer 3043 
    if self.username is not None:
494 rajveer 3044 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3045 
      oprot.writeString(self.username)
3046 
      oprot.writeFieldEnd()
3431 rajveer 3047 
    if self.password is not None:
494 rajveer 3048 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3049 
      oprot.writeString(self.password)
3050 
      oprot.writeFieldEnd()
3431 rajveer 3051 
    if self.warehouseId is not None:
494 rajveer 3052 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
3053 
      oprot.writeI64(self.warehouseId)
3054 
      oprot.writeFieldEnd()
3055 
    oprot.writeFieldStop()
3056 
    oprot.writeStructEnd()
3057 
 
3431 rajveer 3058 
  def validate(self):
3059 
    return
3060 
 
3061 
 
494 rajveer 3062 
  def __repr__(self):
3063 
    L = ['%s=%r' % (key, value)
3064 
      for key, value in self.__dict__.iteritems()]
3065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3066 
 
3067 
  def __eq__(self, other):
3068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3069 
 
3070 
  def __ne__(self, other):
3071 
    return not (self == other)
3072 
 
3073 
class addUser_result:
3074 
  """
3075 
  Attributes:
3076 
   - success
3077 
   - se
3078 
  """
3079 
 
3080 
  thrift_spec = (
3081 
    (0, TType.BOOL, 'success', None, None, ), # 0
3082 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3083 
  )
3084 
 
3085 
  def __init__(self, success=None, se=None,):
3086 
    self.success = success
3087 
    self.se = se
3088 
 
3089 
  def read(self, iprot):
3090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3092 
      return
3093 
    iprot.readStructBegin()
3094 
    while True:
3095 
      (fname, ftype, fid) = iprot.readFieldBegin()
3096 
      if ftype == TType.STOP:
3097 
        break
3098 
      if fid == 0:
3099 
        if ftype == TType.BOOL:
3100 
          self.success = iprot.readBool();
3101 
        else:
3102 
          iprot.skip(ftype)
3103 
      elif fid == 1:
3104 
        if ftype == TType.STRUCT:
3105 
          self.se = HelperServiceException()
3106 
          self.se.read(iprot)
3107 
        else:
3108 
          iprot.skip(ftype)
3109 
      else:
3110 
        iprot.skip(ftype)
3111 
      iprot.readFieldEnd()
3112 
    iprot.readStructEnd()
3113 
 
3114 
  def write(self, oprot):
3115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3117 
      return
3118 
    oprot.writeStructBegin('addUser_result')
3431 rajveer 3119 
    if self.success is not None:
494 rajveer 3120 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3121 
      oprot.writeBool(self.success)
3122 
      oprot.writeFieldEnd()
3431 rajveer 3123 
    if self.se is not None:
494 rajveer 3124 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
3125 
      self.se.write(oprot)
3126 
      oprot.writeFieldEnd()
3127 
    oprot.writeFieldStop()
3128 
    oprot.writeStructEnd()
3129 
 
3431 rajveer 3130 
  def validate(self):
3131 
    return
3132 
 
3133 
 
494 rajveer 3134 
  def __repr__(self):
3135 
    L = ['%s=%r' % (key, value)
3136 
      for key, value in self.__dict__.iteritems()]
3137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3138 
 
3139 
  def __eq__(self, other):
3140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3141 
 
3142 
  def __ne__(self, other):
3143 
    return not (self == other)
3144 
 
3145 
class deleteUser_args:
3146 
  """
3147 
  Attributes:
3148 
   - username
3149 
  """
3150 
 
3151 
  thrift_spec = (
3152 
    None, # 0
3153 
    (1, TType.STRING, 'username', None, None, ), # 1
3154 
  )
3155 
 
3156 
  def __init__(self, username=None,):
3157 
    self.username = username
3158 
 
3159 
  def read(self, iprot):
3160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3162 
      return
3163 
    iprot.readStructBegin()
3164 
    while True:
3165 
      (fname, ftype, fid) = iprot.readFieldBegin()
3166 
      if ftype == TType.STOP:
3167 
        break
3168 
      if fid == 1:
3169 
        if ftype == TType.STRING:
3170 
          self.username = iprot.readString();
3171 
        else:
3172 
          iprot.skip(ftype)
3173 
      else:
3174 
        iprot.skip(ftype)
3175 
      iprot.readFieldEnd()
3176 
    iprot.readStructEnd()
3177 
 
3178 
  def write(self, oprot):
3179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3181 
      return
3182 
    oprot.writeStructBegin('deleteUser_args')
3431 rajveer 3183 
    if self.username is not None:
494 rajveer 3184 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3185 
      oprot.writeString(self.username)
3186 
      oprot.writeFieldEnd()
3187 
    oprot.writeFieldStop()
3188 
    oprot.writeStructEnd()
3189 
 
3431 rajveer 3190 
  def validate(self):
3191 
    return
3192 
 
3193 
 
494 rajveer 3194 
  def __repr__(self):
3195 
    L = ['%s=%r' % (key, value)
3196 
      for key, value in self.__dict__.iteritems()]
3197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3198 
 
3199 
  def __eq__(self, other):
3200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3201 
 
3202 
  def __ne__(self, other):
3203 
    return not (self == other)
3204 
 
3205 
class deleteUser_result:
3206 
  """
3207 
  Attributes:
3208 
   - success
3209 
   - se
3210 
  """
3211 
 
3212 
  thrift_spec = (
3213 
    (0, TType.BOOL, 'success', None, None, ), # 0
3214 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3215 
  )
3216 
 
3217 
  def __init__(self, success=None, se=None,):
3218 
    self.success = success
3219 
    self.se = se
3220 
 
3221 
  def read(self, iprot):
3222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3224 
      return
3225 
    iprot.readStructBegin()
3226 
    while True:
3227 
      (fname, ftype, fid) = iprot.readFieldBegin()
3228 
      if ftype == TType.STOP:
3229 
        break
3230 
      if fid == 0:
3231 
        if ftype == TType.BOOL:
3232 
          self.success = iprot.readBool();
3233 
        else:
3234 
          iprot.skip(ftype)
3235 
      elif fid == 1:
3236 
        if ftype == TType.STRUCT:
3237 
          self.se = HelperServiceException()
3238 
          self.se.read(iprot)
3239 
        else:
3240 
          iprot.skip(ftype)
3241 
      else:
3242 
        iprot.skip(ftype)
3243 
      iprot.readFieldEnd()
3244 
    iprot.readStructEnd()
3245 
 
3246 
  def write(self, oprot):
3247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3249 
      return
3250 
    oprot.writeStructBegin('deleteUser_result')
3431 rajveer 3251 
    if self.success is not None:
494 rajveer 3252 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3253 
      oprot.writeBool(self.success)
3254 
      oprot.writeFieldEnd()
3431 rajveer 3255 
    if self.se is not None:
494 rajveer 3256 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
3257 
      self.se.write(oprot)
3258 
      oprot.writeFieldEnd()
3259 
    oprot.writeFieldStop()
3260 
    oprot.writeStructEnd()
3261 
 
3431 rajveer 3262 
  def validate(self):
3263 
    return
3264 
 
3265 
 
494 rajveer 3266 
  def __repr__(self):
3267 
    L = ['%s=%r' % (key, value)
3268 
      for key, value in self.__dict__.iteritems()]
3269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3270 
 
3271 
  def __eq__(self, other):
3272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3273 
 
3274 
  def __ne__(self, other):
3275 
    return not (self == other)
3276 
 
2447 chandransh 3277 
class authenticateDashboardUser_args:
494 rajveer 3278 
  """
3279 
  Attributes:
3280 
   - username
3281 
   - password
3282 
  """
3283 
 
3284 
  thrift_spec = (
3285 
    None, # 0
3286 
    (1, TType.STRING, 'username', None, None, ), # 1
3287 
    (2, TType.STRING, 'password', None, None, ), # 2
3288 
  )
3289 
 
3290 
  def __init__(self, username=None, password=None,):
3291 
    self.username = username
3292 
    self.password = password
3293 
 
3294 
  def read(self, iprot):
3295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3297 
      return
3298 
    iprot.readStructBegin()
3299 
    while True:
3300 
      (fname, ftype, fid) = iprot.readFieldBegin()
3301 
      if ftype == TType.STOP:
3302 
        break
3303 
      if fid == 1:
3304 
        if ftype == TType.STRING:
3305 
          self.username = iprot.readString();
3306 
        else:
3307 
          iprot.skip(ftype)
3308 
      elif fid == 2:
3309 
        if ftype == TType.STRING:
3310 
          self.password = iprot.readString();
3311 
        else:
3312 
          iprot.skip(ftype)
3313 
      else:
3314 
        iprot.skip(ftype)
3315 
      iprot.readFieldEnd()
3316 
    iprot.readStructEnd()
3317 
 
3318 
  def write(self, oprot):
3319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3321 
      return
2447 chandransh 3322 
    oprot.writeStructBegin('authenticateDashboardUser_args')
3431 rajveer 3323 
    if self.username is not None:
494 rajveer 3324 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3325 
      oprot.writeString(self.username)
3326 
      oprot.writeFieldEnd()
3431 rajveer 3327 
    if self.password is not None:
494 rajveer 3328 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3329 
      oprot.writeString(self.password)
3330 
      oprot.writeFieldEnd()
3331 
    oprot.writeFieldStop()
3332 
    oprot.writeStructEnd()
3333 
 
3431 rajveer 3334 
  def validate(self):
3335 
    return
3336 
 
3337 
 
494 rajveer 3338 
  def __repr__(self):
3339 
    L = ['%s=%r' % (key, value)
3340 
      for key, value in self.__dict__.iteritems()]
3341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3342 
 
3343 
  def __eq__(self, other):
3344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3345 
 
3346 
  def __ne__(self, other):
3347 
    return not (self == other)
3348 
 
2447 chandransh 3349 
class authenticateDashboardUser_result:
494 rajveer 3350 
  """
3351 
  Attributes:
3352 
   - success
3353 
   - se
3354 
  """
3355 
 
3356 
  thrift_spec = (
2447 chandransh 3357 
    (0, TType.STRUCT, 'success', (DashboardUser, DashboardUser.thrift_spec), None, ), # 0
494 rajveer 3358 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3359 
  )
3360 
 
3361 
  def __init__(self, success=None, se=None,):
3362 
    self.success = success
3363 
    self.se = se
3364 
 
3365 
  def read(self, iprot):
3366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3368 
      return
3369 
    iprot.readStructBegin()
3370 
    while True:
3371 
      (fname, ftype, fid) = iprot.readFieldBegin()
3372 
      if ftype == TType.STOP:
3373 
        break
3374 
      if fid == 0:
2447 chandransh 3375 
        if ftype == TType.STRUCT:
3376 
          self.success = DashboardUser()
3377 
          self.success.read(iprot)
494 rajveer 3378 
        else:
3379 
          iprot.skip(ftype)
3380 
      elif fid == 1:
3381 
        if ftype == TType.STRUCT:
3382 
          self.se = HelperServiceException()
3383 
          self.se.read(iprot)
3384 
        else:
3385 
          iprot.skip(ftype)
3386 
      else:
3387 
        iprot.skip(ftype)
3388 
      iprot.readFieldEnd()
3389 
    iprot.readStructEnd()
3390 
 
3391 
  def write(self, oprot):
3392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3394 
      return
2447 chandransh 3395 
    oprot.writeStructBegin('authenticateDashboardUser_result')
3431 rajveer 3396 
    if self.success is not None:
2447 chandransh 3397 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3398 
      self.success.write(oprot)
494 rajveer 3399 
      oprot.writeFieldEnd()
3431 rajveer 3400 
    if self.se is not None:
494 rajveer 3401 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
3402 
      self.se.write(oprot)
3403 
      oprot.writeFieldEnd()
3404 
    oprot.writeFieldStop()
3405 
    oprot.writeStructEnd()
3406 
 
3431 rajveer 3407 
  def validate(self):
3408 
    return
3409 
 
3410 
 
494 rajveer 3411 
  def __repr__(self):
3412 
    L = ['%s=%r' % (key, value)
3413 
      for key, value in self.__dict__.iteritems()]
3414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3415 
 
3416 
  def __eq__(self, other):
3417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3418 
 
3419 
  def __ne__(self, other):
3420 
    return not (self == other)
3421 
 
3422 
class updatePassword_args:
3423 
  """
3424 
  Attributes:
3425 
   - username
3426 
   - oldPassword
3427 
   - newPassword
3428 
  """
3429 
 
3430 
  thrift_spec = (
3431 
    None, # 0
3432 
    (1, TType.STRING, 'username', None, None, ), # 1
3433 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
3434 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
3435 
  )
3436 
 
3437 
  def __init__(self, username=None, oldPassword=None, newPassword=None,):
3438 
    self.username = username
3439 
    self.oldPassword = oldPassword
3440 
    self.newPassword = newPassword
3441 
 
3442 
  def read(self, iprot):
3443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3445 
      return
3446 
    iprot.readStructBegin()
3447 
    while True:
3448 
      (fname, ftype, fid) = iprot.readFieldBegin()
3449 
      if ftype == TType.STOP:
3450 
        break
3451 
      if fid == 1:
3452 
        if ftype == TType.STRING:
3453 
          self.username = iprot.readString();
3454 
        else:
3455 
          iprot.skip(ftype)
3456 
      elif fid == 2:
3457 
        if ftype == TType.STRING:
3458 
          self.oldPassword = iprot.readString();
3459 
        else:
3460 
          iprot.skip(ftype)
3461 
      elif fid == 3:
3462 
        if ftype == TType.STRING:
3463 
          self.newPassword = iprot.readString();
3464 
        else:
3465 
          iprot.skip(ftype)
3466 
      else:
3467 
        iprot.skip(ftype)
3468 
      iprot.readFieldEnd()
3469 
    iprot.readStructEnd()
3470 
 
3471 
  def write(self, oprot):
3472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3474 
      return
3475 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 3476 
    if self.username is not None:
494 rajveer 3477 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3478 
      oprot.writeString(self.username)
3479 
      oprot.writeFieldEnd()
3431 rajveer 3480 
    if self.oldPassword is not None:
494 rajveer 3481 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
3482 
      oprot.writeString(self.oldPassword)
3483 
      oprot.writeFieldEnd()
3431 rajveer 3484 
    if self.newPassword is not None:
494 rajveer 3485 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
3486 
      oprot.writeString(self.newPassword)
3487 
      oprot.writeFieldEnd()
3488 
    oprot.writeFieldStop()
3489 
    oprot.writeStructEnd()
3490 
 
3431 rajveer 3491 
  def validate(self):
3492 
    return
3493 
 
3494 
 
494 rajveer 3495 
  def __repr__(self):
3496 
    L = ['%s=%r' % (key, value)
3497 
      for key, value in self.__dict__.iteritems()]
3498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3499 
 
3500 
  def __eq__(self, other):
3501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3502 
 
3503 
  def __ne__(self, other):
3504 
    return not (self == other)
3505 
 
3506 
class updatePassword_result:
3507 
  """
3508 
  Attributes:
3509 
   - success
3510 
   - se
3511 
  """
3512 
 
3513 
  thrift_spec = (
3514 
    (0, TType.BOOL, 'success', None, None, ), # 0
3515 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3516 
  )
3517 
 
3518 
  def __init__(self, success=None, se=None,):
3519 
    self.success = success
3520 
    self.se = se
3521 
 
3522 
  def read(self, iprot):
3523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3525 
      return
3526 
    iprot.readStructBegin()
3527 
    while True:
3528 
      (fname, ftype, fid) = iprot.readFieldBegin()
3529 
      if ftype == TType.STOP:
3530 
        break
3531 
      if fid == 0:
3532 
        if ftype == TType.BOOL:
3533 
          self.success = iprot.readBool();
3534 
        else:
3535 
          iprot.skip(ftype)
3536 
      elif fid == 1:
3537 
        if ftype == TType.STRUCT:
3538 
          self.se = HelperServiceException()
3539 
          self.se.read(iprot)
3540 
        else:
3541 
          iprot.skip(ftype)
3542 
      else:
3543 
        iprot.skip(ftype)
3544 
      iprot.readFieldEnd()
3545 
    iprot.readStructEnd()
3546 
 
3547 
  def write(self, oprot):
3548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3550 
      return
3551 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 3552 
    if self.success is not None:
494 rajveer 3553 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3554 
      oprot.writeBool(self.success)
3555 
      oprot.writeFieldEnd()
3431 rajveer 3556 
    if self.se is not None:
494 rajveer 3557 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
3558 
      self.se.write(oprot)
3559 
      oprot.writeFieldEnd()
3560 
    oprot.writeFieldStop()
3561 
    oprot.writeStructEnd()
3562 
 
3431 rajveer 3563 
  def validate(self):
3564 
    return
3565 
 
3566 
 
494 rajveer 3567 
  def __repr__(self):
3568 
    L = ['%s=%r' % (key, value)
3569 
      for key, value in self.__dict__.iteritems()]
3570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3571 
 
3572 
  def __eq__(self, other):
3573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3574 
 
3575 
  def __ne__(self, other):
3576 
    return not (self == other)
3577 
 
759 chandransh 3578 
class authenticateLogisticsUser_args:
3579 
  """
3580 
  Attributes:
3581 
   - username
3582 
   - password
3583 
  """
494 rajveer 3584 
 
759 chandransh 3585 
  thrift_spec = (
3586 
    None, # 0
3587 
    (1, TType.STRING, 'username', None, None, ), # 1
3588 
    (2, TType.STRING, 'password', None, None, ), # 2
3589 
  )
3590 
 
3591 
  def __init__(self, username=None, password=None,):
3592 
    self.username = username
3593 
    self.password = password
3594 
 
3595 
  def read(self, iprot):
3596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3598 
      return
3599 
    iprot.readStructBegin()
3600 
    while True:
3601 
      (fname, ftype, fid) = iprot.readFieldBegin()
3602 
      if ftype == TType.STOP:
3603 
        break
3604 
      if fid == 1:
3605 
        if ftype == TType.STRING:
3606 
          self.username = iprot.readString();
3607 
        else:
3608 
          iprot.skip(ftype)
3609 
      elif fid == 2:
3610 
        if ftype == TType.STRING:
3611 
          self.password = iprot.readString();
3612 
        else:
3613 
          iprot.skip(ftype)
3614 
      else:
3615 
        iprot.skip(ftype)
3616 
      iprot.readFieldEnd()
3617 
    iprot.readStructEnd()
3618 
 
3619 
  def write(self, oprot):
3620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3622 
      return
3623 
    oprot.writeStructBegin('authenticateLogisticsUser_args')
3431 rajveer 3624 
    if self.username is not None:
759 chandransh 3625 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3626 
      oprot.writeString(self.username)
3627 
      oprot.writeFieldEnd()
3431 rajveer 3628 
    if self.password is not None:
759 chandransh 3629 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3630 
      oprot.writeString(self.password)
3631 
      oprot.writeFieldEnd()
3632 
    oprot.writeFieldStop()
3633 
    oprot.writeStructEnd()
3634 
 
3431 rajveer 3635 
  def validate(self):
3636 
    return
3637 
 
3638 
 
759 chandransh 3639 
  def __repr__(self):
3640 
    L = ['%s=%r' % (key, value)
3641 
      for key, value in self.__dict__.iteritems()]
3642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3643 
 
3644 
  def __eq__(self, other):
3645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3646 
 
3647 
  def __ne__(self, other):
3648 
    return not (self == other)
3649 
 
3650 
class authenticateLogisticsUser_result:
3651 
  """
3652 
  Attributes:
3653 
   - success
3654 
   - hse
3655 
  """
3656 
 
3657 
  thrift_spec = (
3658 
    (0, TType.STRUCT, 'success', (LogisticsUser, LogisticsUser.thrift_spec), None, ), # 0
3659 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3660 
  )
3661 
 
3662 
  def __init__(self, success=None, hse=None,):
3663 
    self.success = success
3664 
    self.hse = hse
3665 
 
3666 
  def read(self, iprot):
3667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3669 
      return
3670 
    iprot.readStructBegin()
3671 
    while True:
3672 
      (fname, ftype, fid) = iprot.readFieldBegin()
3673 
      if ftype == TType.STOP:
3674 
        break
3675 
      if fid == 0:
3676 
        if ftype == TType.STRUCT:
3677 
          self.success = LogisticsUser()
3678 
          self.success.read(iprot)
3679 
        else:
3680 
          iprot.skip(ftype)
3681 
      elif fid == 1:
3682 
        if ftype == TType.STRUCT:
3683 
          self.hse = HelperServiceException()
3684 
          self.hse.read(iprot)
3685 
        else:
3686 
          iprot.skip(ftype)
3687 
      else:
3688 
        iprot.skip(ftype)
3689 
      iprot.readFieldEnd()
3690 
    iprot.readStructEnd()
3691 
 
3692 
  def write(self, oprot):
3693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3695 
      return
3696 
    oprot.writeStructBegin('authenticateLogisticsUser_result')
3431 rajveer 3697 
    if self.success is not None:
759 chandransh 3698 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3699 
      self.success.write(oprot)
3700 
      oprot.writeFieldEnd()
3431 rajveer 3701 
    if self.hse is not None:
759 chandransh 3702 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3703 
      self.hse.write(oprot)
3704 
      oprot.writeFieldEnd()
3705 
    oprot.writeFieldStop()
3706 
    oprot.writeStructEnd()
3707 
 
3431 rajveer 3708 
  def validate(self):
3709 
    return
3710 
 
3711 
 
759 chandransh 3712 
  def __repr__(self):
3713 
    L = ['%s=%r' % (key, value)
3714 
      for key, value in self.__dict__.iteritems()]
3715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3716 
 
3717 
  def __eq__(self, other):
3718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3719 
 
3720 
  def __ne__(self, other):
3721 
    return not (self == other)
3722 
 
1610 ankur.sing 3723 
class authenticateStatisticsUser_args:
3724 
  """
3725 
  Attributes:
3726 
   - username
3727 
   - password
3728 
  """
759 chandransh 3729 
 
1610 ankur.sing 3730 
  thrift_spec = (
3731 
    None, # 0
3732 
    (1, TType.STRING, 'username', None, None, ), # 1
3733 
    (2, TType.STRING, 'password', None, None, ), # 2
3734 
  )
3735 
 
3736 
  def __init__(self, username=None, password=None,):
3737 
    self.username = username
3738 
    self.password = password
3739 
 
3740 
  def read(self, iprot):
3741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3743 
      return
3744 
    iprot.readStructBegin()
3745 
    while True:
3746 
      (fname, ftype, fid) = iprot.readFieldBegin()
3747 
      if ftype == TType.STOP:
3748 
        break
3749 
      if fid == 1:
3750 
        if ftype == TType.STRING:
3751 
          self.username = iprot.readString();
3752 
        else:
3753 
          iprot.skip(ftype)
3754 
      elif fid == 2:
3755 
        if ftype == TType.STRING:
3756 
          self.password = iprot.readString();
3757 
        else:
3758 
          iprot.skip(ftype)
3759 
      else:
3760 
        iprot.skip(ftype)
3761 
      iprot.readFieldEnd()
3762 
    iprot.readStructEnd()
3763 
 
3764 
  def write(self, oprot):
3765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3767 
      return
3768 
    oprot.writeStructBegin('authenticateStatisticsUser_args')
3431 rajveer 3769 
    if self.username is not None:
1610 ankur.sing 3770 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3771 
      oprot.writeString(self.username)
3772 
      oprot.writeFieldEnd()
3431 rajveer 3773 
    if self.password is not None:
1610 ankur.sing 3774 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3775 
      oprot.writeString(self.password)
3776 
      oprot.writeFieldEnd()
3777 
    oprot.writeFieldStop()
3778 
    oprot.writeStructEnd()
3779 
 
3431 rajveer 3780 
  def validate(self):
3781 
    return
3782 
 
3783 
 
1610 ankur.sing 3784 
  def __repr__(self):
3785 
    L = ['%s=%r' % (key, value)
3786 
      for key, value in self.__dict__.iteritems()]
3787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3788 
 
3789 
  def __eq__(self, other):
3790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3791 
 
3792 
  def __ne__(self, other):
3793 
    return not (self == other)
3794 
 
3795 
class authenticateStatisticsUser_result:
3796 
  """
3797 
  Attributes:
3798 
   - success
3799 
   - hse
3800 
  """
3801 
 
3802 
  thrift_spec = (
3803 
    (0, TType.STRUCT, 'success', (StatisticsUser, StatisticsUser.thrift_spec), None, ), # 0
3804 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3805 
  )
3806 
 
3807 
  def __init__(self, success=None, hse=None,):
3808 
    self.success = success
3809 
    self.hse = hse
3810 
 
3811 
  def read(self, iprot):
3812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3814 
      return
3815 
    iprot.readStructBegin()
3816 
    while True:
3817 
      (fname, ftype, fid) = iprot.readFieldBegin()
3818 
      if ftype == TType.STOP:
3819 
        break
3820 
      if fid == 0:
3821 
        if ftype == TType.STRUCT:
3822 
          self.success = StatisticsUser()
3823 
          self.success.read(iprot)
3824 
        else:
3825 
          iprot.skip(ftype)
3826 
      elif fid == 1:
3827 
        if ftype == TType.STRUCT:
3828 
          self.hse = HelperServiceException()
3829 
          self.hse.read(iprot)
3830 
        else:
3831 
          iprot.skip(ftype)
3832 
      else:
3833 
        iprot.skip(ftype)
3834 
      iprot.readFieldEnd()
3835 
    iprot.readStructEnd()
3836 
 
3837 
  def write(self, oprot):
3838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3840 
      return
3841 
    oprot.writeStructBegin('authenticateStatisticsUser_result')
3431 rajveer 3842 
    if self.success is not None:
1610 ankur.sing 3843 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3844 
      self.success.write(oprot)
3845 
      oprot.writeFieldEnd()
3431 rajveer 3846 
    if self.hse is not None:
1610 ankur.sing 3847 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3848 
      self.hse.write(oprot)
3849 
      oprot.writeFieldEnd()
3850 
    oprot.writeFieldStop()
3851 
    oprot.writeStructEnd()
3852 
 
3431 rajveer 3853 
  def validate(self):
3854 
    return
3855 
 
3856 
 
1610 ankur.sing 3857 
  def __repr__(self):
3858 
    L = ['%s=%r' % (key, value)
3859 
      for key, value in self.__dict__.iteritems()]
3860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3861 
 
3862 
  def __eq__(self, other):
3863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3864 
 
3865 
  def __ne__(self, other):
3866 
    return not (self == other)
3867 
 
1891 ankur.sing 3868 
class authenticateReportUser_args:
3869 
  """
3870 
  Attributes:
3871 
   - username
3872 
   - password
3873 
  """
1610 ankur.sing 3874 
 
1891 ankur.sing 3875 
  thrift_spec = (
3876 
    None, # 0
3877 
    (1, TType.STRING, 'username', None, None, ), # 1
3878 
    (2, TType.STRING, 'password', None, None, ), # 2
3879 
  )
3880 
 
3881 
  def __init__(self, username=None, password=None,):
3882 
    self.username = username
3883 
    self.password = password
3884 
 
3885 
  def read(self, iprot):
3886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3888 
      return
3889 
    iprot.readStructBegin()
3890 
    while True:
3891 
      (fname, ftype, fid) = iprot.readFieldBegin()
3892 
      if ftype == TType.STOP:
3893 
        break
3894 
      if fid == 1:
3895 
        if ftype == TType.STRING:
3896 
          self.username = iprot.readString();
3897 
        else:
3898 
          iprot.skip(ftype)
3899 
      elif fid == 2:
3900 
        if ftype == TType.STRING:
3901 
          self.password = iprot.readString();
3902 
        else:
3903 
          iprot.skip(ftype)
3904 
      else:
3905 
        iprot.skip(ftype)
3906 
      iprot.readFieldEnd()
3907 
    iprot.readStructEnd()
3908 
 
3909 
  def write(self, oprot):
3910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3912 
      return
3913 
    oprot.writeStructBegin('authenticateReportUser_args')
3431 rajveer 3914 
    if self.username is not None:
1891 ankur.sing 3915 
      oprot.writeFieldBegin('username', TType.STRING, 1)
3916 
      oprot.writeString(self.username)
3917 
      oprot.writeFieldEnd()
3431 rajveer 3918 
    if self.password is not None:
1891 ankur.sing 3919 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3920 
      oprot.writeString(self.password)
3921 
      oprot.writeFieldEnd()
3922 
    oprot.writeFieldStop()
3923 
    oprot.writeStructEnd()
3924 
 
3431 rajveer 3925 
  def validate(self):
3926 
    return
3927 
 
3928 
 
1891 ankur.sing 3929 
  def __repr__(self):
3930 
    L = ['%s=%r' % (key, value)
3931 
      for key, value in self.__dict__.iteritems()]
3932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3933 
 
3934 
  def __eq__(self, other):
3935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3936 
 
3937 
  def __ne__(self, other):
3938 
    return not (self == other)
3939 
 
3940 
class authenticateReportUser_result:
3941 
  """
3942 
  Attributes:
3943 
   - success
3944 
   - hse
3945 
  """
3946 
 
3947 
  thrift_spec = (
3948 
    (0, TType.STRUCT, 'success', (ReportUser, ReportUser.thrift_spec), None, ), # 0
3949 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
3950 
  )
3951 
 
3952 
  def __init__(self, success=None, hse=None,):
3953 
    self.success = success
3954 
    self.hse = hse
3955 
 
3956 
  def read(self, iprot):
3957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3959 
      return
3960 
    iprot.readStructBegin()
3961 
    while True:
3962 
      (fname, ftype, fid) = iprot.readFieldBegin()
3963 
      if ftype == TType.STOP:
3964 
        break
3965 
      if fid == 0:
3966 
        if ftype == TType.STRUCT:
3967 
          self.success = ReportUser()
3968 
          self.success.read(iprot)
3969 
        else:
3970 
          iprot.skip(ftype)
3971 
      elif fid == 1:
3972 
        if ftype == TType.STRUCT:
3973 
          self.hse = HelperServiceException()
3974 
          self.hse.read(iprot)
3975 
        else:
3976 
          iprot.skip(ftype)
3977 
      else:
3978 
        iprot.skip(ftype)
3979 
      iprot.readFieldEnd()
3980 
    iprot.readStructEnd()
3981 
 
3982 
  def write(self, oprot):
3983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3985 
      return
3986 
    oprot.writeStructBegin('authenticateReportUser_result')
3431 rajveer 3987 
    if self.success is not None:
1891 ankur.sing 3988 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3989 
      self.success.write(oprot)
3990 
      oprot.writeFieldEnd()
3431 rajveer 3991 
    if self.hse is not None:
1891 ankur.sing 3992 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
3993 
      self.hse.write(oprot)
3994 
      oprot.writeFieldEnd()
3995 
    oprot.writeFieldStop()
3996 
    oprot.writeStructEnd()
3997 
 
3431 rajveer 3998 
  def validate(self):
3999 
    return
4000 
 
4001 
 
1891 ankur.sing 4002 
  def __repr__(self):
4003 
    L = ['%s=%r' % (key, value)
4004 
      for key, value in self.__dict__.iteritems()]
4005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4006 
 
4007 
  def __eq__(self, other):
4008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4009 
 
4010 
  def __ne__(self, other):
4011 
    return not (self == other)
4012 
 
4013 
class getReports_args:
4014 
  """
4015 
  Attributes:
4016 
   - role
4017 
  """
4018 
 
4019 
  thrift_spec = (
4020 
    None, # 0
4021 
    (1, TType.I64, 'role', None, None, ), # 1
4022 
  )
4023 
 
4024 
  def __init__(self, role=None,):
4025 
    self.role = role
4026 
 
4027 
  def read(self, iprot):
4028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4030 
      return
4031 
    iprot.readStructBegin()
4032 
    while True:
4033 
      (fname, ftype, fid) = iprot.readFieldBegin()
4034 
      if ftype == TType.STOP:
4035 
        break
4036 
      if fid == 1:
4037 
        if ftype == TType.I64:
4038 
          self.role = iprot.readI64();
4039 
        else:
4040 
          iprot.skip(ftype)
4041 
      else:
4042 
        iprot.skip(ftype)
4043 
      iprot.readFieldEnd()
4044 
    iprot.readStructEnd()
4045 
 
4046 
  def write(self, oprot):
4047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4049 
      return
4050 
    oprot.writeStructBegin('getReports_args')
3431 rajveer 4051 
    if self.role is not None:
1891 ankur.sing 4052 
      oprot.writeFieldBegin('role', TType.I64, 1)
4053 
      oprot.writeI64(self.role)
4054 
      oprot.writeFieldEnd()
4055 
    oprot.writeFieldStop()
4056 
    oprot.writeStructEnd()
4057 
 
3431 rajveer 4058 
  def validate(self):
4059 
    return
4060 
 
4061 
 
1891 ankur.sing 4062 
  def __repr__(self):
4063 
    L = ['%s=%r' % (key, value)
4064 
      for key, value in self.__dict__.iteritems()]
4065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4066 
 
4067 
  def __eq__(self, other):
4068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4069 
 
4070 
  def __ne__(self, other):
4071 
    return not (self == other)
4072 
 
4073 
class getReports_result:
4074 
  """
4075 
  Attributes:
4076 
   - success
4077 
  """
4078 
 
4079 
  thrift_spec = (
4080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Report, Report.thrift_spec)), None, ), # 0
4081 
  )
4082 
 
4083 
  def __init__(self, success=None,):
4084 
    self.success = success
4085 
 
4086 
  def read(self, iprot):
4087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4089 
      return
4090 
    iprot.readStructBegin()
4091 
    while True:
4092 
      (fname, ftype, fid) = iprot.readFieldBegin()
4093 
      if ftype == TType.STOP:
4094 
        break
4095 
      if fid == 0:
4096 
        if ftype == TType.LIST:
4097 
          self.success = []
5864 rajveer 4098 
          (_etype75, _size72) = iprot.readListBegin()
4099 
          for _i76 in xrange(_size72):
4100 
            _elem77 = Report()
4101 
            _elem77.read(iprot)
4102 
            self.success.append(_elem77)
1891 ankur.sing 4103 
          iprot.readListEnd()
4104 
        else:
4105 
          iprot.skip(ftype)
4106 
      else:
4107 
        iprot.skip(ftype)
4108 
      iprot.readFieldEnd()
4109 
    iprot.readStructEnd()
4110 
 
4111 
  def write(self, oprot):
4112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4114 
      return
4115 
    oprot.writeStructBegin('getReports_result')
3431 rajveer 4116 
    if self.success is not None:
1891 ankur.sing 4117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5864 rajveer 4119 
      for iter78 in self.success:
4120 
        iter78.write(oprot)
1891 ankur.sing 4121 
      oprot.writeListEnd()
4122 
      oprot.writeFieldEnd()
4123 
    oprot.writeFieldStop()
4124 
    oprot.writeStructEnd()
4125 
 
3431 rajveer 4126 
  def validate(self):
4127 
    return
4128 
 
4129 
 
1891 ankur.sing 4130 
  def __repr__(self):
4131 
    L = ['%s=%r' % (key, value)
4132 
      for key, value in self.__dict__.iteritems()]
4133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4134 
 
4135 
  def __eq__(self, other):
4136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4137 
 
4138 
  def __ne__(self, other):
4139 
    return not (self == other)
4140 
 
2025 ankur.sing 4141 
class authenticateCatalogUser_args:
4142 
  """
4143 
  Attributes:
4144 
   - username
4145 
   - password
4146 
  """
1891 ankur.sing 4147 
 
2025 ankur.sing 4148 
  thrift_spec = (
4149 
    None, # 0
4150 
    (1, TType.STRING, 'username', None, None, ), # 1
4151 
    (2, TType.STRING, 'password', None, None, ), # 2
4152 
  )
4153 
 
6788 rajveer 4154 
  def __init__(self, username=None, password=None,):
2025 ankur.sing 4155 
    self.username = username
4156 
    self.password = password
4157 
 
4158 
  def read(self, iprot):
4159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4161 
      return
4162 
    iprot.readStructBegin()
4163 
    while True:
4164 
      (fname, ftype, fid) = iprot.readFieldBegin()
4165 
      if ftype == TType.STOP:
4166 
        break
4167 
      if fid == 1:
4168 
        if ftype == TType.STRING:
4169 
          self.username = iprot.readString();
4170 
        else:
4171 
          iprot.skip(ftype)
4172 
      elif fid == 2:
4173 
        if ftype == TType.STRING:
4174 
          self.password = iprot.readString();
4175 
        else:
4176 
          iprot.skip(ftype)
4177 
      else:
4178 
        iprot.skip(ftype)
4179 
      iprot.readFieldEnd()
4180 
    iprot.readStructEnd()
4181 
 
4182 
  def write(self, oprot):
4183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4185 
      return
4186 
    oprot.writeStructBegin('authenticateCatalogUser_args')
3431 rajveer 4187 
    if self.username is not None:
2025 ankur.sing 4188 
      oprot.writeFieldBegin('username', TType.STRING, 1)
4189 
      oprot.writeString(self.username)
4190 
      oprot.writeFieldEnd()
3431 rajveer 4191 
    if self.password is not None:
2025 ankur.sing 4192 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4193 
      oprot.writeString(self.password)
4194 
      oprot.writeFieldEnd()
4195 
    oprot.writeFieldStop()
4196 
    oprot.writeStructEnd()
4197 
 
3431 rajveer 4198 
  def validate(self):
4199 
    return
4200 
 
4201 
 
2025 ankur.sing 4202 
  def __repr__(self):
4203 
    L = ['%s=%r' % (key, value)
4204 
      for key, value in self.__dict__.iteritems()]
4205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4206 
 
4207 
  def __eq__(self, other):
4208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4209 
 
4210 
  def __ne__(self, other):
4211 
    return not (self == other)
4212 
 
4213 
class authenticateCatalogUser_result:
4214 
  """
4215 
  Attributes:
4216 
   - success
4217 
   - hse
4218 
  """
4219 
 
4220 
  thrift_spec = (
4221 
    (0, TType.STRUCT, 'success', (CatalogDashboardUser, CatalogDashboardUser.thrift_spec), None, ), # 0
4222 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
4223 
  )
4224 
 
4225 
  def __init__(self, success=None, hse=None,):
4226 
    self.success = success
4227 
    self.hse = hse
4228 
 
4229 
  def read(self, iprot):
4230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4232 
      return
4233 
    iprot.readStructBegin()
4234 
    while True:
4235 
      (fname, ftype, fid) = iprot.readFieldBegin()
4236 
      if ftype == TType.STOP:
4237 
        break
4238 
      if fid == 0:
4239 
        if ftype == TType.STRUCT:
4240 
          self.success = CatalogDashboardUser()
4241 
          self.success.read(iprot)
4242 
        else:
4243 
          iprot.skip(ftype)
4244 
      elif fid == 1:
4245 
        if ftype == TType.STRUCT:
4246 
          self.hse = HelperServiceException()
4247 
          self.hse.read(iprot)
4248 
        else:
4249 
          iprot.skip(ftype)
4250 
      else:
4251 
        iprot.skip(ftype)
4252 
      iprot.readFieldEnd()
4253 
    iprot.readStructEnd()
4254 
 
4255 
  def write(self, oprot):
4256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4258 
      return
4259 
    oprot.writeStructBegin('authenticateCatalogUser_result')
3431 rajveer 4260 
    if self.success is not None:
2025 ankur.sing 4261 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4262 
      self.success.write(oprot)
4263 
      oprot.writeFieldEnd()
3431 rajveer 4264 
    if self.hse is not None:
2025 ankur.sing 4265 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
4266 
      self.hse.write(oprot)
4267 
      oprot.writeFieldEnd()
4268 
    oprot.writeFieldStop()
4269 
    oprot.writeStructEnd()
4270 
 
3431 rajveer 4271 
  def validate(self):
4272 
    return
4273 
 
4274 
 
2025 ankur.sing 4275 
  def __repr__(self):
4276 
    L = ['%s=%r' % (key, value)
4277 
      for key, value in self.__dict__.iteritems()]
4278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4279 
 
4280 
  def __eq__(self, other):
4281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4282 
 
4283 
  def __ne__(self, other):
4284 
    return not (self == other)
4544 varun.gupt 4285 
 
4286 
class shareEntities_args:
4287 
  """
4288 
  Attributes:
4289 
   - entityIds
4290 
   - email
4291 
  """
4292 
 
4293 
  thrift_spec = (
4294 
    None, # 0
4295 
    (1, TType.LIST, 'entityIds', (TType.I64,None), None, ), # 1
4296 
    (2, TType.STRING, 'email', None, None, ), # 2
4297 
  )
4298 
 
4299 
  def __init__(self, entityIds=None, email=None,):
4300 
    self.entityIds = entityIds
4301 
    self.email = email
4302 
 
4303 
  def read(self, iprot):
4304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4306 
      return
4307 
    iprot.readStructBegin()
4308 
    while True:
4309 
      (fname, ftype, fid) = iprot.readFieldBegin()
4310 
      if ftype == TType.STOP:
4311 
        break
4312 
      if fid == 1:
4313 
        if ftype == TType.LIST:
4314 
          self.entityIds = []
5864 rajveer 4315 
          (_etype82, _size79) = iprot.readListBegin()
4316 
          for _i83 in xrange(_size79):
4317 
            _elem84 = iprot.readI64();
4318 
            self.entityIds.append(_elem84)
4544 varun.gupt 4319 
          iprot.readListEnd()
4320 
        else:
4321 
          iprot.skip(ftype)
4322 
      elif fid == 2:
4323 
        if ftype == TType.STRING:
4324 
          self.email = iprot.readString();
4325 
        else:
4326 
          iprot.skip(ftype)
4327 
      else:
4328 
        iprot.skip(ftype)
4329 
      iprot.readFieldEnd()
4330 
    iprot.readStructEnd()
4331 
 
4332 
  def write(self, oprot):
4333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4335 
      return
4336 
    oprot.writeStructBegin('shareEntities_args')
4337 
    if self.entityIds is not None:
4338 
      oprot.writeFieldBegin('entityIds', TType.LIST, 1)
4339 
      oprot.writeListBegin(TType.I64, len(self.entityIds))
5864 rajveer 4340 
      for iter85 in self.entityIds:
4341 
        oprot.writeI64(iter85)
4544 varun.gupt 4342 
      oprot.writeListEnd()
4343 
      oprot.writeFieldEnd()
4344 
    if self.email is not None:
4345 
      oprot.writeFieldBegin('email', TType.STRING, 2)
4346 
      oprot.writeString(self.email)
4347 
      oprot.writeFieldEnd()
4348 
    oprot.writeFieldStop()
4349 
    oprot.writeStructEnd()
4350 
 
4351 
  def validate(self):
4352 
    return
4353 
 
4354 
 
4355 
  def __repr__(self):
4356 
    L = ['%s=%r' % (key, value)
4357 
      for key, value in self.__dict__.iteritems()]
4358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4359 
 
4360 
  def __eq__(self, other):
4361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4362 
 
4363 
  def __ne__(self, other):
4364 
    return not (self == other)
4365 
 
4366 
class shareEntities_result:
4367 
  """
4368 
  Attributes:
4369 
   - hse
4370 
  """
4371 
 
4372 
  thrift_spec = (
4373 
    None, # 0
4374 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
4375 
  )
4376 
 
4377 
  def __init__(self, hse=None,):
4378 
    self.hse = hse
4379 
 
4380 
  def read(self, iprot):
4381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4383 
      return
4384 
    iprot.readStructBegin()
4385 
    while True:
4386 
      (fname, ftype, fid) = iprot.readFieldBegin()
4387 
      if ftype == TType.STOP:
4388 
        break
4389 
      if fid == 1:
4390 
        if ftype == TType.STRUCT:
4391 
          self.hse = HelperServiceException()
4392 
          self.hse.read(iprot)
4393 
        else:
4394 
          iprot.skip(ftype)
4395 
      else:
4396 
        iprot.skip(ftype)
4397 
      iprot.readFieldEnd()
4398 
    iprot.readStructEnd()
4399 
 
4400 
  def write(self, oprot):
4401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4403 
      return
4404 
    oprot.writeStructBegin('shareEntities_result')
4405 
    if self.hse is not None:
4406 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
4407 
      self.hse.write(oprot)
4408 
      oprot.writeFieldEnd()
4409 
    oprot.writeFieldStop()
4410 
    oprot.writeStructEnd()
4411 
 
4412 
  def validate(self):
4413 
    return
4414 
 
4415 
 
4416 
  def __repr__(self):
4417 
    L = ['%s=%r' % (key, value)
4418 
      for key, value in self.__dict__.iteritems()]
4419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4420 
 
4421 
  def __eq__(self, other):
4422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4423 
 
4424 
  def __ne__(self, other):
4425 
    return not (self == other)
4691 mandeep.dh 4426 
 
4427 
class getAgents_args:
4428 
 
4429 
  thrift_spec = (
4430 
  )
4431 
 
4432 
  def read(self, iprot):
4433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4435 
      return
4436 
    iprot.readStructBegin()
4437 
    while True:
4438 
      (fname, ftype, fid) = iprot.readFieldBegin()
4439 
      if ftype == TType.STOP:
4440 
        break
4441 
      else:
4442 
        iprot.skip(ftype)
4443 
      iprot.readFieldEnd()
4444 
    iprot.readStructEnd()
4445 
 
4446 
  def write(self, oprot):
4447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4449 
      return
4450 
    oprot.writeStructBegin('getAgents_args')
4451 
    oprot.writeFieldStop()
4452 
    oprot.writeStructEnd()
4453 
 
4454 
  def validate(self):
4455 
    return
4456 
 
4457 
 
4458 
  def __repr__(self):
4459 
    L = ['%s=%r' % (key, value)
4460 
      for key, value in self.__dict__.iteritems()]
4461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4462 
 
4463 
  def __eq__(self, other):
4464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4465 
 
4466 
  def __ne__(self, other):
4467 
    return not (self == other)
4468 
 
4469 
class getAgents_result:
4470 
  """
4471 
  Attributes:
4472 
   - success
4473 
  """
4474 
 
4475 
  thrift_spec = (
4476 
    (0, TType.LIST, 'success', (TType.STRUCT,(Agent, Agent.thrift_spec)), None, ), # 0
4477 
  )
4478 
 
4479 
  def __init__(self, success=None,):
4480 
    self.success = success
4481 
 
4482 
  def read(self, iprot):
4483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4485 
      return
4486 
    iprot.readStructBegin()
4487 
    while True:
4488 
      (fname, ftype, fid) = iprot.readFieldBegin()
4489 
      if ftype == TType.STOP:
4490 
        break
4491 
      if fid == 0:
4492 
        if ftype == TType.LIST:
4493 
          self.success = []
5864 rajveer 4494 
          (_etype89, _size86) = iprot.readListBegin()
4495 
          for _i90 in xrange(_size86):
4496 
            _elem91 = Agent()
4497 
            _elem91.read(iprot)
4498 
            self.success.append(_elem91)
4691 mandeep.dh 4499 
          iprot.readListEnd()
4500 
        else:
4501 
          iprot.skip(ftype)
4502 
      else:
4503 
        iprot.skip(ftype)
4504 
      iprot.readFieldEnd()
4505 
    iprot.readStructEnd()
4506 
 
4507 
  def write(self, oprot):
4508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4510 
      return
4511 
    oprot.writeStructBegin('getAgents_result')
4512 
    if self.success is not None:
4513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5864 rajveer 4515 
      for iter92 in self.success:
4516 
        iter92.write(oprot)
4691 mandeep.dh 4517 
      oprot.writeListEnd()
4518 
      oprot.writeFieldEnd()
4519 
    oprot.writeFieldStop()
4520 
    oprot.writeStructEnd()
4521 
 
4522 
  def validate(self):
4523 
    return
4524 
 
4525 
 
4526 
  def __repr__(self):
4527 
    L = ['%s=%r' % (key, value)
4528 
      for key, value in self.__dict__.iteritems()]
4529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4530 
 
4531 
  def __eq__(self, other):
4532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4533 
 
4534 
  def __ne__(self, other):
4535 
    return not (self == other)
4536 
 
4537 
class validateLogIn_args:
4538 
  """
4539 
  Attributes:
4540 
   - emailId
4541 
   - password
4542 
  """
4543 
 
4544 
  thrift_spec = (
4545 
    None, # 0
4546 
    (1, TType.STRING, 'emailId', None, None, ), # 1
4547 
    (2, TType.STRING, 'password', None, None, ), # 2
4548 
  )
4549 
 
4550 
  def __init__(self, emailId=None, password=None,):
4551 
    self.emailId = emailId
4552 
    self.password = password
4553 
 
4554 
  def read(self, iprot):
4555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4557 
      return
4558 
    iprot.readStructBegin()
4559 
    while True:
4560 
      (fname, ftype, fid) = iprot.readFieldBegin()
4561 
      if ftype == TType.STOP:
4562 
        break
4563 
      if fid == 1:
4564 
        if ftype == TType.STRING:
4565 
          self.emailId = iprot.readString();
4566 
        else:
4567 
          iprot.skip(ftype)
4568 
      elif fid == 2:
4569 
        if ftype == TType.STRING:
4570 
          self.password = iprot.readString();
4571 
        else:
4572 
          iprot.skip(ftype)
4573 
      else:
4574 
        iprot.skip(ftype)
4575 
      iprot.readFieldEnd()
4576 
    iprot.readStructEnd()
4577 
 
4578 
  def write(self, oprot):
4579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4581 
      return
4582 
    oprot.writeStructBegin('validateLogIn_args')
4583 
    if self.emailId is not None:
4584 
      oprot.writeFieldBegin('emailId', TType.STRING, 1)
4585 
      oprot.writeString(self.emailId)
4586 
      oprot.writeFieldEnd()
4587 
    if self.password is not None:
4588 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4589 
      oprot.writeString(self.password)
4590 
      oprot.writeFieldEnd()
4591 
    oprot.writeFieldStop()
4592 
    oprot.writeStructEnd()
4593 
 
4594 
  def validate(self):
4595 
    return
4596 
 
4597 
 
4598 
  def __repr__(self):
4599 
    L = ['%s=%r' % (key, value)
4600 
      for key, value in self.__dict__.iteritems()]
4601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4602 
 
4603 
  def __eq__(self, other):
4604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4605 
 
4606 
  def __ne__(self, other):
4607 
    return not (self == other)
4608 
 
4609 
class validateLogIn_result:
4610 
  """
4611 
  Attributes:
4612 
   - success
4613 
  """
4614 
 
4615 
  thrift_spec = (
4616 
    (0, TType.BOOL, 'success', None, None, ), # 0
4617 
  )
4618 
 
4619 
  def __init__(self, success=None,):
4620 
    self.success = success
4621 
 
4622 
  def read(self, iprot):
4623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4625 
      return
4626 
    iprot.readStructBegin()
4627 
    while True:
4628 
      (fname, ftype, fid) = iprot.readFieldBegin()
4629 
      if ftype == TType.STOP:
4630 
        break
4631 
      if fid == 0:
4632 
        if ftype == TType.BOOL:
4633 
          self.success = iprot.readBool();
4634 
        else:
4635 
          iprot.skip(ftype)
4636 
      else:
4637 
        iprot.skip(ftype)
4638 
      iprot.readFieldEnd()
4639 
    iprot.readStructEnd()
4640 
 
4641 
  def write(self, oprot):
4642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4644 
      return
4645 
    oprot.writeStructBegin('validateLogIn_result')
4646 
    if self.success is not None:
4647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4648 
      oprot.writeBool(self.success)
4649 
      oprot.writeFieldEnd()
4650 
    oprot.writeFieldStop()
4651 
    oprot.writeStructEnd()
4652 
 
4653 
  def validate(self):
4654 
    return
4655 
 
4656 
 
4657 
  def __repr__(self):
4658 
    L = ['%s=%r' % (key, value)
4659 
      for key, value in self.__dict__.iteritems()]
4660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4661 
 
4662 
  def __eq__(self, other):
4663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4664 
 
4665 
  def __ne__(self, other):
4666 
    return not (self == other)
4667 
 
4668 
class updatePasswordForAgent_args:
4669 
  """
4670 
  Attributes:
4671 
   - agentEmailId
4672 
   - password
4673 
  """
4674 
 
4675 
  thrift_spec = (
4676 
    None, # 0
4677 
    (1, TType.STRING, 'agentEmailId', None, None, ), # 1
4678 
    (2, TType.STRING, 'password', None, None, ), # 2
4679 
  )
4680 
 
4681 
  def __init__(self, agentEmailId=None, password=None,):
4682 
    self.agentEmailId = agentEmailId
4683 
    self.password = password
4684 
 
4685 
  def read(self, iprot):
4686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4688 
      return
4689 
    iprot.readStructBegin()
4690 
    while True:
4691 
      (fname, ftype, fid) = iprot.readFieldBegin()
4692 
      if ftype == TType.STOP:
4693 
        break
4694 
      if fid == 1:
4695 
        if ftype == TType.STRING:
4696 
          self.agentEmailId = iprot.readString();
4697 
        else:
4698 
          iprot.skip(ftype)
4699 
      elif fid == 2:
4700 
        if ftype == TType.STRING:
4701 
          self.password = iprot.readString();
4702 
        else:
4703 
          iprot.skip(ftype)
4704 
      else:
4705 
        iprot.skip(ftype)
4706 
      iprot.readFieldEnd()
4707 
    iprot.readStructEnd()
4708 
 
4709 
  def write(self, oprot):
4710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4712 
      return
4713 
    oprot.writeStructBegin('updatePasswordForAgent_args')
4714 
    if self.agentEmailId is not None:
4715 
      oprot.writeFieldBegin('agentEmailId', TType.STRING, 1)
4716 
      oprot.writeString(self.agentEmailId)
4717 
      oprot.writeFieldEnd()
4718 
    if self.password is not None:
4719 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4720 
      oprot.writeString(self.password)
4721 
      oprot.writeFieldEnd()
4722 
    oprot.writeFieldStop()
4723 
    oprot.writeStructEnd()
4724 
 
4725 
  def validate(self):
4726 
    return
4727 
 
4728 
 
4729 
  def __repr__(self):
4730 
    L = ['%s=%r' % (key, value)
4731 
      for key, value in self.__dict__.iteritems()]
4732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4733 
 
4734 
  def __eq__(self, other):
4735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4736 
 
4737 
  def __ne__(self, other):
4738 
    return not (self == other)
4739 
 
4740 
class updatePasswordForAgent_result:
4741 
 
4742 
  thrift_spec = (
4743 
  )
4744 
 
4745 
  def read(self, iprot):
4746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4748 
      return
4749 
    iprot.readStructBegin()
4750 
    while True:
4751 
      (fname, ftype, fid) = iprot.readFieldBegin()
4752 
      if ftype == TType.STOP:
4753 
        break
4754 
      else:
4755 
        iprot.skip(ftype)
4756 
      iprot.readFieldEnd()
4757 
    iprot.readStructEnd()
4758 
 
4759 
  def write(self, oprot):
4760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4762 
      return
4763 
    oprot.writeStructBegin('updatePasswordForAgent_result')
4764 
    oprot.writeFieldStop()
4765 
    oprot.writeStructEnd()
4766 
 
4767 
  def validate(self):
4768 
    return
4769 
 
4770 
 
4771 
  def __repr__(self):
4772 
    L = ['%s=%r' % (key, value)
4773 
      for key, value in self.__dict__.iteritems()]
4774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4775 
 
4776 
  def __eq__(self, other):
4777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4778 
 
4779 
  def __ne__(self, other):
4780 
    return not (self == other)
4781 
 
4782 
class getRoleNamesForAgent_args:
4783 
  """
4784 
  Attributes:
4785 
   - agentEmailId
4786 
  """
4787 
 
4788 
  thrift_spec = (
4789 
    None, # 0
4790 
    (1, TType.STRING, 'agentEmailId', None, None, ), # 1
4791 
  )
4792 
 
4793 
  def __init__(self, agentEmailId=None,):
4794 
    self.agentEmailId = agentEmailId
4795 
 
4796 
  def read(self, iprot):
4797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4799 
      return
4800 
    iprot.readStructBegin()
4801 
    while True:
4802 
      (fname, ftype, fid) = iprot.readFieldBegin()
4803 
      if ftype == TType.STOP:
4804 
        break
4805 
      if fid == 1:
4806 
        if ftype == TType.STRING:
4807 
          self.agentEmailId = iprot.readString();
4808 
        else:
4809 
          iprot.skip(ftype)
4810 
      else:
4811 
        iprot.skip(ftype)
4812 
      iprot.readFieldEnd()
4813 
    iprot.readStructEnd()
4814 
 
4815 
  def write(self, oprot):
4816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4818 
      return
4819 
    oprot.writeStructBegin('getRoleNamesForAgent_args')
4820 
    if self.agentEmailId is not None:
4821 
      oprot.writeFieldBegin('agentEmailId', TType.STRING, 1)
4822 
      oprot.writeString(self.agentEmailId)
4823 
      oprot.writeFieldEnd()
4824 
    oprot.writeFieldStop()
4825 
    oprot.writeStructEnd()
4826 
 
4827 
  def validate(self):
4828 
    return
4829 
 
4830 
 
4831 
  def __repr__(self):
4832 
    L = ['%s=%r' % (key, value)
4833 
      for key, value in self.__dict__.iteritems()]
4834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4835 
 
4836 
  def __eq__(self, other):
4837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4838 
 
4839 
  def __ne__(self, other):
4840 
    return not (self == other)
4841 
 
4842 
class getRoleNamesForAgent_result:
4843 
  """
4844 
  Attributes:
4845 
   - success
4846 
  """
4847 
 
4848 
  thrift_spec = (
4849 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
4850 
  )
4851 
 
4852 
  def __init__(self, success=None,):
4853 
    self.success = success
4854 
 
4855 
  def read(self, iprot):
4856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4858 
      return
4859 
    iprot.readStructBegin()
4860 
    while True:
4861 
      (fname, ftype, fid) = iprot.readFieldBegin()
4862 
      if ftype == TType.STOP:
4863 
        break
4864 
      if fid == 0:
4865 
        if ftype == TType.LIST:
4866 
          self.success = []
5864 rajveer 4867 
          (_etype96, _size93) = iprot.readListBegin()
4868 
          for _i97 in xrange(_size93):
4869 
            _elem98 = iprot.readString();
4870 
            self.success.append(_elem98)
4691 mandeep.dh 4871 
          iprot.readListEnd()
4872 
        else:
4873 
          iprot.skip(ftype)
4874 
      else:
4875 
        iprot.skip(ftype)
4876 
      iprot.readFieldEnd()
4877 
    iprot.readStructEnd()
4878 
 
4879 
  def write(self, oprot):
4880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4882 
      return
4883 
    oprot.writeStructBegin('getRoleNamesForAgent_result')
4884 
    if self.success is not None:
4885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4886 
      oprot.writeListBegin(TType.STRING, len(self.success))
5864 rajveer 4887 
      for iter99 in self.success:
4888 
        oprot.writeString(iter99)
4691 mandeep.dh 4889 
      oprot.writeListEnd()
4890 
      oprot.writeFieldEnd()
4891 
    oprot.writeFieldStop()
4892 
    oprot.writeStructEnd()
4893 
 
4894 
  def validate(self):
4895 
    return
4896 
 
4897 
 
4898 
  def __repr__(self):
4899 
    L = ['%s=%r' % (key, value)
4900 
      for key, value in self.__dict__.iteritems()]
4901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4902 
 
4903 
  def __eq__(self, other):
4904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4905 
 
4906 
  def __ne__(self, other):
4907 
    return not (self == other)
4908 
 
4909 
class getPermissionsForRoleName_args:
4910 
  """
4911 
  Attributes:
4912 
   - roleName
4913 
  """
4914 
 
4915 
  thrift_spec = (
4916 
    None, # 0
4917 
    (1, TType.STRING, 'roleName', None, None, ), # 1
4918 
  )
4919 
 
4920 
  def __init__(self, roleName=None,):
4921 
    self.roleName = roleName
4922 
 
4923 
  def read(self, iprot):
4924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4926 
      return
4927 
    iprot.readStructBegin()
4928 
    while True:
4929 
      (fname, ftype, fid) = iprot.readFieldBegin()
4930 
      if ftype == TType.STOP:
4931 
        break
4932 
      if fid == 1:
4933 
        if ftype == TType.STRING:
4934 
          self.roleName = iprot.readString();
4935 
        else:
4936 
          iprot.skip(ftype)
4937 
      else:
4938 
        iprot.skip(ftype)
4939 
      iprot.readFieldEnd()
4940 
    iprot.readStructEnd()
4941 
 
4942 
  def write(self, oprot):
4943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4945 
      return
4946 
    oprot.writeStructBegin('getPermissionsForRoleName_args')
4947 
    if self.roleName is not None:
4948 
      oprot.writeFieldBegin('roleName', TType.STRING, 1)
4949 
      oprot.writeString(self.roleName)
4950 
      oprot.writeFieldEnd()
4951 
    oprot.writeFieldStop()
4952 
    oprot.writeStructEnd()
4953 
 
4954 
  def validate(self):
4955 
    return
4956 
 
4957 
 
4958 
  def __repr__(self):
4959 
    L = ['%s=%r' % (key, value)
4960 
      for key, value in self.__dict__.iteritems()]
4961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4962 
 
4963 
  def __eq__(self, other):
4964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4965 
 
4966 
  def __ne__(self, other):
4967 
    return not (self == other)
4968 
 
4969 
class getPermissionsForRoleName_result:
4970 
  """
4971 
  Attributes:
4972 
   - success
4973 
  """
4974 
 
4975 
  thrift_spec = (
4976 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
4977 
  )
4978 
 
4979 
  def __init__(self, success=None,):
4980 
    self.success = success
4981 
 
4982 
  def read(self, iprot):
4983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4985 
      return
4986 
    iprot.readStructBegin()
4987 
    while True:
4988 
      (fname, ftype, fid) = iprot.readFieldBegin()
4989 
      if ftype == TType.STOP:
4990 
        break
4991 
      if fid == 0:
4992 
        if ftype == TType.LIST:
4993 
          self.success = []
5864 rajveer 4994 
          (_etype103, _size100) = iprot.readListBegin()
4995 
          for _i104 in xrange(_size100):
4996 
            _elem105 = iprot.readString();
4997 
            self.success.append(_elem105)
4691 mandeep.dh 4998 
          iprot.readListEnd()
4999 
        else:
5000 
          iprot.skip(ftype)
5001 
      else:
5002 
        iprot.skip(ftype)
5003 
      iprot.readFieldEnd()
5004 
    iprot.readStructEnd()
5005 
 
5006 
  def write(self, oprot):
5007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5009 
      return
5010 
    oprot.writeStructBegin('getPermissionsForRoleName_result')
5011 
    if self.success is not None:
5012 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5013 
      oprot.writeListBegin(TType.STRING, len(self.success))
5864 rajveer 5014 
      for iter106 in self.success:
5015 
        oprot.writeString(iter106)
4691 mandeep.dh 5016 
      oprot.writeListEnd()
5017 
      oprot.writeFieldEnd()
5018 
    oprot.writeFieldStop()
5019 
    oprot.writeStructEnd()
5020 
 
5021 
  def validate(self):
5022 
    return
5023 
 
5024 
 
5025 
  def __repr__(self):
5026 
    L = ['%s=%r' % (key, value)
5027 
      for key, value in self.__dict__.iteritems()]
5028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5029 
 
5030 
  def __eq__(self, other):
5031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5032 
 
5033 
  def __ne__(self, other):
5034 
    return not (self == other)
4806 varun.gupt 5035 
 
5036 
class saveQuickLink_args:
5037 
  """
5038 
  Attributes:
5039 
   - url
5040 
   - text
5041 
  """
5042 
 
5043 
  thrift_spec = (
5044 
    None, # 0
5045 
    (1, TType.STRING, 'url', None, None, ), # 1
5046 
    (2, TType.STRING, 'text', None, None, ), # 2
5047 
  )
5048 
 
5049 
  def __init__(self, url=None, text=None,):
5050 
    self.url = url
5051 
    self.text = text
5052 
 
5053 
  def read(self, iprot):
5054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5056 
      return
5057 
    iprot.readStructBegin()
5058 
    while True:
5059 
      (fname, ftype, fid) = iprot.readFieldBegin()
5060 
      if ftype == TType.STOP:
5061 
        break
5062 
      if fid == 1:
5063 
        if ftype == TType.STRING:
5064 
          self.url = iprot.readString();
5065 
        else:
5066 
          iprot.skip(ftype)
5067 
      elif fid == 2:
5068 
        if ftype == TType.STRING:
5069 
          self.text = iprot.readString();
5070 
        else:
5071 
          iprot.skip(ftype)
5072 
      else:
5073 
        iprot.skip(ftype)
5074 
      iprot.readFieldEnd()
5075 
    iprot.readStructEnd()
5076 
 
5077 
  def write(self, oprot):
5078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5080 
      return
5081 
    oprot.writeStructBegin('saveQuickLink_args')
5082 
    if self.url is not None:
5083 
      oprot.writeFieldBegin('url', TType.STRING, 1)
5084 
      oprot.writeString(self.url)
5085 
      oprot.writeFieldEnd()
5086 
    if self.text is not None:
5087 
      oprot.writeFieldBegin('text', TType.STRING, 2)
5088 
      oprot.writeString(self.text)
5089 
      oprot.writeFieldEnd()
5090 
    oprot.writeFieldStop()
5091 
    oprot.writeStructEnd()
5092 
 
5093 
  def validate(self):
5094 
    return
5095 
 
5096 
 
5097 
  def __repr__(self):
5098 
    L = ['%s=%r' % (key, value)
5099 
      for key, value in self.__dict__.iteritems()]
5100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5101 
 
5102 
  def __eq__(self, other):
5103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5104 
 
5105 
  def __ne__(self, other):
5106 
    return not (self == other)
5107 
 
5108 
class saveQuickLink_result:
5109 
  """
5110 
  Attributes:
5111 
   - hse
5112 
  """
5113 
 
5114 
  thrift_spec = (
5115 
    None, # 0
5116 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
5117 
  )
5118 
 
5119 
  def __init__(self, hse=None,):
5120 
    self.hse = hse
5121 
 
5122 
  def read(self, iprot):
5123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5125 
      return
5126 
    iprot.readStructBegin()
5127 
    while True:
5128 
      (fname, ftype, fid) = iprot.readFieldBegin()
5129 
      if ftype == TType.STOP:
5130 
        break
5131 
      if fid == 1:
5132 
        if ftype == TType.STRUCT:
5133 
          self.hse = HelperServiceException()
5134 
          self.hse.read(iprot)
5135 
        else:
5136 
          iprot.skip(ftype)
5137 
      else:
5138 
        iprot.skip(ftype)
5139 
      iprot.readFieldEnd()
5140 
    iprot.readStructEnd()
5141 
 
5142 
  def write(self, oprot):
5143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5145 
      return
5146 
    oprot.writeStructBegin('saveQuickLink_result')
5147 
    if self.hse is not None:
5148 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
5149 
      self.hse.write(oprot)
5150 
      oprot.writeFieldEnd()
5151 
    oprot.writeFieldStop()
5152 
    oprot.writeStructEnd()
5153 
 
5154 
  def validate(self):
5155 
    return
5156 
 
5157 
 
5158 
  def __repr__(self):
5159 
    L = ['%s=%r' % (key, value)
5160 
      for key, value in self.__dict__.iteritems()]
5161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5162 
 
5163 
  def __eq__(self, other):
5164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5165 
 
5166 
  def __ne__(self, other):
5167 
    return not (self == other)
5168 
 
5169 
class getQuickLinks_args:
5170 
 
5171 
  thrift_spec = (
5172 
  )
5173 
 
5174 
  def read(self, iprot):
5175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5177 
      return
5178 
    iprot.readStructBegin()
5179 
    while True:
5180 
      (fname, ftype, fid) = iprot.readFieldBegin()
5181 
      if ftype == TType.STOP:
5182 
        break
5183 
      else:
5184 
        iprot.skip(ftype)
5185 
      iprot.readFieldEnd()
5186 
    iprot.readStructEnd()
5187 
 
5188 
  def write(self, oprot):
5189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5191 
      return
5192 
    oprot.writeStructBegin('getQuickLinks_args')
5193 
    oprot.writeFieldStop()
5194 
    oprot.writeStructEnd()
5195 
 
5196 
  def validate(self):
5197 
    return
5198 
 
5199 
 
5200 
  def __repr__(self):
5201 
    L = ['%s=%r' % (key, value)
5202 
      for key, value in self.__dict__.iteritems()]
5203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5204 
 
5205 
  def __eq__(self, other):
5206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5207 
 
5208 
  def __ne__(self, other):
5209 
    return not (self == other)
5210 
 
5211 
class getQuickLinks_result:
5212 
  """
5213 
  Attributes:
5214 
   - success
5215 
   - hse
5216 
  """
5217 
 
5218 
  thrift_spec = (
5219 
    (0, TType.LIST, 'success', (TType.STRUCT,(QuickLink, QuickLink.thrift_spec)), None, ), # 0
5220 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
5221 
  )
5222 
 
5223 
  def __init__(self, success=None, hse=None,):
5224 
    self.success = success
5225 
    self.hse = hse
5226 
 
5227 
  def read(self, iprot):
5228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5230 
      return
5231 
    iprot.readStructBegin()
5232 
    while True:
5233 
      (fname, ftype, fid) = iprot.readFieldBegin()
5234 
      if ftype == TType.STOP:
5235 
        break
5236 
      if fid == 0:
5237 
        if ftype == TType.LIST:
5238 
          self.success = []
5864 rajveer 5239 
          (_etype110, _size107) = iprot.readListBegin()
5240 
          for _i111 in xrange(_size107):
5241 
            _elem112 = QuickLink()
5242 
            _elem112.read(iprot)
5243 
            self.success.append(_elem112)
4806 varun.gupt 5244 
          iprot.readListEnd()
5245 
        else:
5246 
          iprot.skip(ftype)
5247 
      elif fid == 1:
5248 
        if ftype == TType.STRUCT:
5249 
          self.hse = HelperServiceException()
5250 
          self.hse.read(iprot)
5251 
        else:
5252 
          iprot.skip(ftype)
5253 
      else:
5254 
        iprot.skip(ftype)
5255 
      iprot.readFieldEnd()
5256 
    iprot.readStructEnd()
5257 
 
5258 
  def write(self, oprot):
5259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5261 
      return
5262 
    oprot.writeStructBegin('getQuickLinks_result')
5263 
    if self.success is not None:
5264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5864 rajveer 5266 
      for iter113 in self.success:
5267 
        iter113.write(oprot)
4806 varun.gupt 5268 
      oprot.writeListEnd()
5269 
      oprot.writeFieldEnd()
5270 
    if self.hse is not None:
5271 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
5272 
      self.hse.write(oprot)
5273 
      oprot.writeFieldEnd()
5274 
    oprot.writeFieldStop()
5275 
    oprot.writeStructEnd()
5276 
 
5277 
  def validate(self):
5278 
    return
5279 
 
5280 
 
5281 
  def __repr__(self):
5282 
    L = ['%s=%r' % (key, value)
5283 
      for key, value in self.__dict__.iteritems()]
5284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5285 
 
5286 
  def __eq__(self, other):
5287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5288 
 
5289 
  def __ne__(self, other):
5290 
    return not (self == other)
4996 varun.gupt 5291 
 
5292 
class updateQuickLink_args:
5293 
  """
5294 
  Attributes:
5295 
   - id
5296 
   - url
5297 
   - text
5298 
  """
5299 
 
5300 
  thrift_spec = (
5301 
    None, # 0
5302 
    (1, TType.I64, 'id', None, None, ), # 1
5303 
    (2, TType.STRING, 'url', None, None, ), # 2
5304 
    (3, TType.STRING, 'text', None, None, ), # 3
5305 
  )
5306 
 
5307 
  def __init__(self, id=None, url=None, text=None,):
5308 
    self.id = id
5309 
    self.url = url
5310 
    self.text = text
5311 
 
5312 
  def read(self, iprot):
5313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5315 
      return
5316 
    iprot.readStructBegin()
5317 
    while True:
5318 
      (fname, ftype, fid) = iprot.readFieldBegin()
5319 
      if ftype == TType.STOP:
5320 
        break
5321 
      if fid == 1:
5322 
        if ftype == TType.I64:
5323 
          self.id = iprot.readI64();
5324 
        else:
5325 
          iprot.skip(ftype)
5326 
      elif fid == 2:
5327 
        if ftype == TType.STRING:
5328 
          self.url = iprot.readString();
5329 
        else:
5330 
          iprot.skip(ftype)
5331 
      elif fid == 3:
5332 
        if ftype == TType.STRING:
5333 
          self.text = iprot.readString();
5334 
        else:
5335 
          iprot.skip(ftype)
5336 
      else:
5337 
        iprot.skip(ftype)
5338 
      iprot.readFieldEnd()
5339 
    iprot.readStructEnd()
5340 
 
5341 
  def write(self, oprot):
5342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5344 
      return
5345 
    oprot.writeStructBegin('updateQuickLink_args')
5346 
    if self.id is not None:
5347 
      oprot.writeFieldBegin('id', TType.I64, 1)
5348 
      oprot.writeI64(self.id)
5349 
      oprot.writeFieldEnd()
5350 
    if self.url is not None:
5351 
      oprot.writeFieldBegin('url', TType.STRING, 2)
5352 
      oprot.writeString(self.url)
5353 
      oprot.writeFieldEnd()
5354 
    if self.text is not None:
5355 
      oprot.writeFieldBegin('text', TType.STRING, 3)
5356 
      oprot.writeString(self.text)
5357 
      oprot.writeFieldEnd()
5358 
    oprot.writeFieldStop()
5359 
    oprot.writeStructEnd()
5360 
 
5361 
  def validate(self):
5362 
    return
5363 
 
5364 
 
5365 
  def __repr__(self):
5366 
    L = ['%s=%r' % (key, value)
5367 
      for key, value in self.__dict__.iteritems()]
5368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5369 
 
5370 
  def __eq__(self, other):
5371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5372 
 
5373 
  def __ne__(self, other):
5374 
    return not (self == other)
5375 
 
5376 
class updateQuickLink_result:
5377 
  """
5378 
  Attributes:
5379 
   - hse
5380 
  """
5381 
 
5382 
  thrift_spec = (
5383 
    None, # 0
5384 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
5385 
  )
5386 
 
5387 
  def __init__(self, hse=None,):
5388 
    self.hse = hse
5389 
 
5390 
  def read(self, iprot):
5391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5393 
      return
5394 
    iprot.readStructBegin()
5395 
    while True:
5396 
      (fname, ftype, fid) = iprot.readFieldBegin()
5397 
      if ftype == TType.STOP:
5398 
        break
5399 
      if fid == 1:
5400 
        if ftype == TType.STRUCT:
5401 
          self.hse = HelperServiceException()
5402 
          self.hse.read(iprot)
5403 
        else:
5404 
          iprot.skip(ftype)
5405 
      else:
5406 
        iprot.skip(ftype)
5407 
      iprot.readFieldEnd()
5408 
    iprot.readStructEnd()
5409 
 
5410 
  def write(self, oprot):
5411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5413 
      return
5414 
    oprot.writeStructBegin('updateQuickLink_result')
5415 
    if self.hse is not None:
5416 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
5417 
      self.hse.write(oprot)
5418 
      oprot.writeFieldEnd()
5419 
    oprot.writeFieldStop()
5420 
    oprot.writeStructEnd()
5421 
 
5422 
  def validate(self):
5423 
    return
5424 
 
5425 
 
5426 
  def __repr__(self):
5427 
    L = ['%s=%r' % (key, value)
5428 
      for key, value in self.__dict__.iteritems()]
5429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5430 
 
5431 
  def __eq__(self, other):
5432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5433 
 
5434 
  def __ne__(self, other):
5435 
    return not (self == other)
5055 varun.gupt 5436 
 
5437 
class getEmailsForNotificationsSent_args:
5438 
  """
5439 
  Attributes:
5440 
   - startDatetime
5441 
   - endDatetime
5442 
  """
5443 
 
5444 
  thrift_spec = (
5445 
    None, # 0
5446 
    (1, TType.I64, 'startDatetime', None, None, ), # 1
5447 
    (2, TType.I64, 'endDatetime', None, None, ), # 2
5448 
  )
5449 
 
5450 
  def __init__(self, startDatetime=None, endDatetime=None,):
5451 
    self.startDatetime = startDatetime
5452 
    self.endDatetime = endDatetime
5453 
 
5454 
  def read(self, iprot):
5455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5457 
      return
5458 
    iprot.readStructBegin()
5459 
    while True:
5460 
      (fname, ftype, fid) = iprot.readFieldBegin()
5461 
      if ftype == TType.STOP:
5462 
        break
5463 
      if fid == 1:
5464 
        if ftype == TType.I64:
5465 
          self.startDatetime = iprot.readI64();
5466 
        else:
5467 
          iprot.skip(ftype)
5468 
      elif fid == 2:
5469 
        if ftype == TType.I64:
5470 
          self.endDatetime = iprot.readI64();
5471 
        else:
5472 
          iprot.skip(ftype)
5473 
      else:
5474 
        iprot.skip(ftype)
5475 
      iprot.readFieldEnd()
5476 
    iprot.readStructEnd()
5477 
 
5478 
  def write(self, oprot):
5479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5481 
      return
5482 
    oprot.writeStructBegin('getEmailsForNotificationsSent_args')
5483 
    if self.startDatetime is not None:
5484 
      oprot.writeFieldBegin('startDatetime', TType.I64, 1)
5485 
      oprot.writeI64(self.startDatetime)
5486 
      oprot.writeFieldEnd()
5487 
    if self.endDatetime is not None:
5488 
      oprot.writeFieldBegin('endDatetime', TType.I64, 2)
5489 
      oprot.writeI64(self.endDatetime)
5490 
      oprot.writeFieldEnd()
5491 
    oprot.writeFieldStop()
5492 
    oprot.writeStructEnd()
5493 
 
5494 
  def validate(self):
5495 
    return
5496 
 
5497 
 
5498 
  def __repr__(self):
5499 
    L = ['%s=%r' % (key, value)
5500 
      for key, value in self.__dict__.iteritems()]
5501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5502 
 
5503 
  def __eq__(self, other):
5504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5505 
 
5506 
  def __ne__(self, other):
5507 
    return not (self == other)
5508 
 
5509 
class getEmailsForNotificationsSent_result:
5510 
  """
5511 
  Attributes:
5512 
   - success
5513 
   - hse
5514 
  """
5515 
 
5516 
  thrift_spec = (
5517 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
5518 
    (1, TType.STRUCT, 'hse', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
5519 
  )
5520 
 
5521 
  def __init__(self, success=None, hse=None,):
5522 
    self.success = success
5523 
    self.hse = hse
5524 
 
5525 
  def read(self, iprot):
5526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5528 
      return
5529 
    iprot.readStructBegin()
5530 
    while True:
5531 
      (fname, ftype, fid) = iprot.readFieldBegin()
5532 
      if ftype == TType.STOP:
5533 
        break
5534 
      if fid == 0:
5535 
        if ftype == TType.LIST:
5536 
          self.success = []
5864 rajveer 5537 
          (_etype117, _size114) = iprot.readListBegin()
5538 
          for _i118 in xrange(_size114):
5539 
            _elem119 = iprot.readString();
5540 
            self.success.append(_elem119)
5055 varun.gupt 5541 
          iprot.readListEnd()
5542 
        else:
5543 
          iprot.skip(ftype)
5544 
      elif fid == 1:
5545 
        if ftype == TType.STRUCT:
5546 
          self.hse = HelperServiceException()
5547 
          self.hse.read(iprot)
5548 
        else:
5549 
          iprot.skip(ftype)
5550 
      else:
5551 
        iprot.skip(ftype)
5552 
      iprot.readFieldEnd()
5553 
    iprot.readStructEnd()
5554 
 
5555 
  def write(self, oprot):
5556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5558 
      return
5559 
    oprot.writeStructBegin('getEmailsForNotificationsSent_result')
5560 
    if self.success is not None:
5561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5562 
      oprot.writeListBegin(TType.STRING, len(self.success))
5864 rajveer 5563 
      for iter120 in self.success:
5564 
        oprot.writeString(iter120)
5055 varun.gupt 5565 
      oprot.writeListEnd()
5566 
      oprot.writeFieldEnd()
5567 
    if self.hse is not None:
5568 
      oprot.writeFieldBegin('hse', TType.STRUCT, 1)
5569 
      self.hse.write(oprot)
5570 
      oprot.writeFieldEnd()
5571 
    oprot.writeFieldStop()
5572 
    oprot.writeStructEnd()
5573 
 
5574 
  def validate(self):
5575 
    return
5576 
 
5577 
 
5578 
  def __repr__(self):
5579 
    L = ['%s=%r' % (key, value)
5580 
      for key, value in self.__dict__.iteritems()]
5581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5582 
 
5583 
  def __eq__(self, other):
5584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5585 
 
5586 
  def __ne__(self, other):
5587 
    return not (self == other)
6322 amar.kumar 5588 
 
5589 
class getOrderConfirmationMail_args:
5590 
  """
5591 
  Attributes:
5592 
   - orderId
5593 
  """
5594 
 
5595 
  thrift_spec = (
5596 
    None, # 0
5597 
    (1, TType.I64, 'orderId', None, None, ), # 1
5598 
  )
5599 
 
5600 
  def __init__(self, orderId=None,):
5601 
    self.orderId = orderId
5602 
 
5603 
  def read(self, iprot):
5604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5606 
      return
5607 
    iprot.readStructBegin()
5608 
    while True:
5609 
      (fname, ftype, fid) = iprot.readFieldBegin()
5610 
      if ftype == TType.STOP:
5611 
        break
5612 
      if fid == 1:
5613 
        if ftype == TType.I64:
5614 
          self.orderId = iprot.readI64();
5615 
        else:
5616 
          iprot.skip(ftype)
5617 
      else:
5618 
        iprot.skip(ftype)
5619 
      iprot.readFieldEnd()
5620 
    iprot.readStructEnd()
5621 
 
5622 
  def write(self, oprot):
5623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5625 
      return
5626 
    oprot.writeStructBegin('getOrderConfirmationMail_args')
5627 
    if self.orderId is not None:
5628 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5629 
      oprot.writeI64(self.orderId)
5630 
      oprot.writeFieldEnd()
5631 
    oprot.writeFieldStop()
5632 
    oprot.writeStructEnd()
5633 
 
5634 
  def validate(self):
5635 
    return
5636 
 
5637 
 
5638 
  def __repr__(self):
5639 
    L = ['%s=%r' % (key, value)
5640 
      for key, value in self.__dict__.iteritems()]
5641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5642 
 
5643 
  def __eq__(self, other):
5644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5645 
 
5646 
  def __ne__(self, other):
5647 
    return not (self == other)
5648 
 
5649 
class getOrderConfirmationMail_result:
5650 
  """
5651 
  Attributes:
5652 
   - success
5653 
  """
5654 
 
5655 
  thrift_spec = (
5656 
    (0, TType.STRING, 'success', None, None, ), # 0
5657 
  )
5658 
 
5659 
  def __init__(self, success=None,):
5660 
    self.success = success
5661 
 
5662 
  def read(self, iprot):
5663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5665 
      return
5666 
    iprot.readStructBegin()
5667 
    while True:
5668 
      (fname, ftype, fid) = iprot.readFieldBegin()
5669 
      if ftype == TType.STOP:
5670 
        break
5671 
      if fid == 0:
5672 
        if ftype == TType.STRING:
5673 
          self.success = iprot.readString();
5674 
        else:
5675 
          iprot.skip(ftype)
5676 
      else:
5677 
        iprot.skip(ftype)
5678 
      iprot.readFieldEnd()
5679 
    iprot.readStructEnd()
5680 
 
5681 
  def write(self, oprot):
5682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5684 
      return
5685 
    oprot.writeStructBegin('getOrderConfirmationMail_result')
5686 
    if self.success is not None:
5687 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5688 
      oprot.writeString(self.success)
5689 
      oprot.writeFieldEnd()
5690 
    oprot.writeFieldStop()
5691 
    oprot.writeStructEnd()
5692 
 
5693 
  def validate(self):
5694 
    return
5695 
 
5696 
 
5697 
  def __repr__(self):
5698 
    L = ['%s=%r' % (key, value)
5699 
      for key, value in self.__dict__.iteritems()]
5700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5701 
 
5702 
  def __eq__(self, other):
5703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5704 
 
5705 
  def __ne__(self, other):
5706 
    return not (self == other)
7221 kshitij.so 5707 
 
5708 
class getOrderDeliveryMail_args:
5709 
  """
5710 
  Attributes:
5711 
   - orderId
5712 
  """
5713 
 
5714 
  thrift_spec = (
5715 
    None, # 0
5716 
    (1, TType.I64, 'orderId', None, None, ), # 1
5717 
  )
5718 
 
5719 
  def __init__(self, orderId=None,):
5720 
    self.orderId = orderId
5721 
 
5722 
  def read(self, iprot):
5723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5725 
      return
5726 
    iprot.readStructBegin()
5727 
    while True:
5728 
      (fname, ftype, fid) = iprot.readFieldBegin()
5729 
      if ftype == TType.STOP:
5730 
        break
5731 
      if fid == 1:
5732 
        if ftype == TType.I64:
5733 
          self.orderId = iprot.readI64();
5734 
        else:
5735 
          iprot.skip(ftype)
5736 
      else:
5737 
        iprot.skip(ftype)
5738 
      iprot.readFieldEnd()
5739 
    iprot.readStructEnd()
5740 
 
5741 
  def write(self, oprot):
5742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5744 
      return
5745 
    oprot.writeStructBegin('getOrderDeliveryMail_args')
5746 
    if self.orderId is not None:
5747 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5748 
      oprot.writeI64(self.orderId)
5749 
      oprot.writeFieldEnd()
5750 
    oprot.writeFieldStop()
5751 
    oprot.writeStructEnd()
5752 
 
5753 
  def validate(self):
5754 
    return
5755 
 
5756 
 
5757 
  def __repr__(self):
5758 
    L = ['%s=%r' % (key, value)
5759 
      for key, value in self.__dict__.iteritems()]
5760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5761 
 
5762 
  def __eq__(self, other):
5763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5764 
 
5765 
  def __ne__(self, other):
5766 
    return not (self == other)
5767 
 
5768 
class getOrderDeliveryMail_result:
5769 
  """
5770 
  Attributes:
5771 
   - success
5772 
  """
5773 
 
5774 
  thrift_spec = (
5775 
    (0, TType.STRING, 'success', None, None, ), # 0
5776 
  )
5777 
 
5778 
  def __init__(self, success=None,):
5779 
    self.success = success
5780 
 
5781 
  def read(self, iprot):
5782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5784 
      return
5785 
    iprot.readStructBegin()
5786 
    while True:
5787 
      (fname, ftype, fid) = iprot.readFieldBegin()
5788 
      if ftype == TType.STOP:
5789 
        break
5790 
      if fid == 0:
5791 
        if ftype == TType.STRING:
5792 
          self.success = iprot.readString();
5793 
        else:
5794 
          iprot.skip(ftype)
5795 
      else:
5796 
        iprot.skip(ftype)
5797 
      iprot.readFieldEnd()
5798 
    iprot.readStructEnd()
5799 
 
5800 
  def write(self, oprot):
5801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5803 
      return
5804 
    oprot.writeStructBegin('getOrderDeliveryMail_result')
5805 
    if self.success is not None:
5806 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5807 
      oprot.writeString(self.success)
5808 
      oprot.writeFieldEnd()
5809 
    oprot.writeFieldStop()
5810 
    oprot.writeStructEnd()
5811 
 
5812 
  def validate(self):
5813 
    return
5814 
 
5815 
 
5816 
  def __repr__(self):
5817 
    L = ['%s=%r' % (key, value)
5818 
      for key, value in self.__dict__.iteritems()]
5819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5820 
 
5821 
  def __eq__(self, other):
5822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5823 
 
5824 
  def __ne__(self, other):
5825 
    return not (self == other)