Subversion Repositories SmartDukaan

Rev

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