Subversion Repositories SmartDukaan

Rev

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