Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
765 rajveer 19 
  def closeSession(self, ):
20 
    """
21 
    For closing the open session in sqlalchemy
22 
    """
23 
    pass
24 
 
94 ashish 25 
  def createTransaction(self, transaction):
26 
    """
27 
    Parameters:
28 
     - transaction
29 
    """
30 
    pass
31 
 
32 
  def getTransaction(self, id):
33 
    """
34 
    Parameters:
35 
     - id
36 
    """
37 
    pass
38 
 
39 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
40 
    """
41 
    Parameters:
42 
     - customerId
43 
     - from_date
44 
     - to_date
45 
     - status
46 
    """
47 
    pass
48 
 
132 ashish 49 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
50 
    """
51 
    Parameters:
52 
     - shoppingCartId
53 
    """
54 
    pass
55 
 
94 ashish 56 
  def getTransactionStatus(self, transactionId):
57 
    """
58 
    Parameters:
59 
     - transactionId
60 
    """
61 
    pass
62 
 
63 
  def changeTransactionStatus(self, transactionId, status, description):
64 
    """
65 
    Parameters:
66 
     - transactionId
67 
     - status
68 
     - description
69 
    """
70 
    pass
71 
 
483 rajveer 72 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 73 
    """
74 
    Parameters:
483 rajveer 75 
     - status
76 
     - from_date
77 
     - to_date
78 
     - warehouse_id
94 ashish 79 
    """
80 
    pass
81 
 
999 varun.gupt 82 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
83 
    """
1132 chandransh 84 
    Returns orders within a range of their billing dates
85 
 
999 varun.gupt 86 
    Parameters:
87 
     - status
88 
     - start_billing_date
89 
     - end_billing_date
90 
     - warehouse_id
91 
    """
92 
    pass
93 
 
483 rajveer 94 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 95 
    """
96 
    Parameters:
483 rajveer 97 
     - orderId
98 
     - status
99 
     - description
94 ashish 100 
    """
101 
    pass
102 
 
1149 chandransh 103 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 104 
    """
1149 chandransh 105 
    Add billing details such as the bill number and the biller to the Order.
106 
 
494 rajveer 107 
    Parameters:
108 
     - orderId
109 
     - invoice_number
110 
     - billed_by
111 
    """
112 
    pass
113 
 
1149 chandransh 114 
  def addJacketNumber(self, orderId, jacketNumber):
115 
    """
116 
    Adds jacket number to the order. Return false if it doesn't find the order with the given ID.
117 
 
118 
    Parameters:
119 
     - orderId
120 
     - jacketNumber
121 
    """
122 
    pass
123 
 
921 rajveer 124 
  def acceptOrder(self, orderId):
125 
    """
126 
    Parameters:
127 
     - orderId
128 
    """
129 
    pass
130 
 
131 
  def billOrder(self, orderId):
132 
    """
133 
    Parameters:
134 
     - orderId
135 
    """
136 
    pass
137 
 
483 rajveer 138 
  def getOrdersForTransaction(self, transactionId):
94 ashish 139 
    """
140 
    Parameters:
141 
     - transactionId
142 
    """
143 
    pass
144 
 
483 rajveer 145 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 146 
    """
147 
    Parameters:
483 rajveer 148 
     - customerId
149 
     - from_date
150 
     - to_date
151 
     - status
94 ashish 152 
    """
153 
    pass
154 
 
483 rajveer 155 
  def createOrder(self, order):
94 ashish 156 
    """
157 
    Parameters:
483 rajveer 158 
     - order
94 ashish 159 
    """
160 
    pass
161 
 
483 rajveer 162 
  def getOrder(self, id):
94 ashish 163 
    """
164 
    Parameters:
483 rajveer 165 
     - id
94 ashish 166 
    """
167 
    pass
168 
 
483 rajveer 169 
  def getLineItemsForOrder(self, orderId):
94 ashish 170 
    """
171 
    Parameters:
483 rajveer 172 
     - orderId
94 ashish 173 
    """
174 
    pass
175 
 
759 chandransh 176 
  def markOrdersAsManifested(self, warehouseId, providerId):
177 
    """
178 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
179 
 
180 
    Parameters:
181 
     - warehouseId
182 
     - providerId
183 
    """
184 
    pass
185 
 
1113 chandransh 186 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
187 
    """
188 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
189 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
190 
    Raises an exception if we encounter report for an AWB number that we did not ship.
191 
 
192 
    Parameters:
193 
     - providerId
194 
     - pickupDetails
195 
    """
196 
    pass
197 
 
1132 chandransh 198 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
199 
    """
200 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
201 
    the name of the receiver.
202 
    Raises an exception if we encounter report for an AWB number that we did not ship.
203 
 
204 
    Parameters:
205 
     - providerId
206 
     - deliveredOrders
207 
    """
208 
    pass
209 
 
1135 chandransh 210 
  def markOrdersAsFailed(self, providerId, returnedOrders):
211 
    """
212 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
213 
    Raises an exception if we encounter report for an AWB number that we did not ship.
214 
 
215 
    Parameters:
216 
     - providerId
217 
     - returnedOrders
218 
    """
219 
    pass
220 
 
483 rajveer 221 
  def getAlerts(self, orderId, valid):
94 ashish 222 
    """
223 
    Parameters:
483 rajveer 224 
     - orderId
304 ashish 225 
     - valid
226 
    """
227 
    pass
94 ashish 228 
 
483 rajveer 229 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 230 
    """
231 
    Parameters:
483 rajveer 232 
     - orderId
304 ashish 233 
     - unset
234 
     - type
235 
     - comment
236 
    """
237 
    pass
238 
 
239 
 
94 ashish 240 
class Client(Iface):
241 
  def __init__(self, iprot, oprot=None):
242 
    self._iprot = self._oprot = iprot
243 
    if oprot != None:
244 
      self._oprot = oprot
245 
    self._seqid = 0
246 
 
765 rajveer 247 
  def closeSession(self, ):
248 
    """
249 
    For closing the open session in sqlalchemy
250 
    """
251 
    self.send_closeSession()
252 
    self.recv_closeSession()
253 
 
254 
  def send_closeSession(self, ):
255 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
256 
    args = closeSession_args()
257 
    args.write(self._oprot)
258 
    self._oprot.writeMessageEnd()
259 
    self._oprot.trans.flush()
260 
 
261 
  def recv_closeSession(self, ):
262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
263 
    if mtype == TMessageType.EXCEPTION:
264 
      x = TApplicationException()
265 
      x.read(self._iprot)
266 
      self._iprot.readMessageEnd()
267 
      raise x
268 
    result = closeSession_result()
269 
    result.read(self._iprot)
270 
    self._iprot.readMessageEnd()
271 
    return
272 
 
94 ashish 273 
  def createTransaction(self, transaction):
274 
    """
275 
    Parameters:
276 
     - transaction
277 
    """
278 
    self.send_createTransaction(transaction)
132 ashish 279 
    return self.recv_createTransaction()
94 ashish 280 
 
281 
  def send_createTransaction(self, transaction):
282 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
283 
    args = createTransaction_args()
284 
    args.transaction = transaction
285 
    args.write(self._oprot)
286 
    self._oprot.writeMessageEnd()
287 
    self._oprot.trans.flush()
288 
 
289 
  def recv_createTransaction(self, ):
290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
291 
    if mtype == TMessageType.EXCEPTION:
292 
      x = TApplicationException()
293 
      x.read(self._iprot)
294 
      self._iprot.readMessageEnd()
295 
      raise x
296 
    result = createTransaction_result()
297 
    result.read(self._iprot)
298 
    self._iprot.readMessageEnd()
132 ashish 299 
    if result.success != None:
300 
      return result.success
94 ashish 301 
    if result.ex != None:
302 
      raise result.ex
132 ashish 303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 304 
 
305 
  def getTransaction(self, id):
306 
    """
307 
    Parameters:
308 
     - id
309 
    """
310 
    self.send_getTransaction(id)
311 
    return self.recv_getTransaction()
312 
 
313 
  def send_getTransaction(self, id):
314 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
315 
    args = getTransaction_args()
316 
    args.id = id
317 
    args.write(self._oprot)
318 
    self._oprot.writeMessageEnd()
319 
    self._oprot.trans.flush()
320 
 
321 
  def recv_getTransaction(self, ):
322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
323 
    if mtype == TMessageType.EXCEPTION:
324 
      x = TApplicationException()
325 
      x.read(self._iprot)
326 
      self._iprot.readMessageEnd()
327 
      raise x
328 
    result = getTransaction_result()
329 
    result.read(self._iprot)
330 
    self._iprot.readMessageEnd()
331 
    if result.success != None:
332 
      return result.success
333 
    if result.ex != None:
334 
      raise result.ex
335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
336 
 
337 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
338 
    """
339 
    Parameters:
340 
     - customerId
341 
     - from_date
342 
     - to_date
343 
     - status
344 
    """
345 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
346 
    return self.recv_getTransactionsForCustomer()
347 
 
348 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
349 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
350 
    args = getTransactionsForCustomer_args()
351 
    args.customerId = customerId
352 
    args.from_date = from_date
353 
    args.to_date = to_date
354 
    args.status = status
355 
    args.write(self._oprot)
356 
    self._oprot.writeMessageEnd()
357 
    self._oprot.trans.flush()
358 
 
359 
  def recv_getTransactionsForCustomer(self, ):
360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
361 
    if mtype == TMessageType.EXCEPTION:
362 
      x = TApplicationException()
363 
      x.read(self._iprot)
364 
      self._iprot.readMessageEnd()
365 
      raise x
366 
    result = getTransactionsForCustomer_result()
367 
    result.read(self._iprot)
368 
    self._iprot.readMessageEnd()
369 
    if result.success != None:
370 
      return result.success
371 
    if result.ex != None:
372 
      raise result.ex
373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
374 
 
132 ashish 375 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
376 
    """
377 
    Parameters:
378 
     - shoppingCartId
379 
    """
380 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
381 
    return self.recv_getTransactionsForShoppingCartId()
382 
 
383 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
384 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
385 
    args = getTransactionsForShoppingCartId_args()
386 
    args.shoppingCartId = shoppingCartId
387 
    args.write(self._oprot)
388 
    self._oprot.writeMessageEnd()
389 
    self._oprot.trans.flush()
390 
 
391 
  def recv_getTransactionsForShoppingCartId(self, ):
392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
393 
    if mtype == TMessageType.EXCEPTION:
394 
      x = TApplicationException()
395 
      x.read(self._iprot)
396 
      self._iprot.readMessageEnd()
397 
      raise x
398 
    result = getTransactionsForShoppingCartId_result()
399 
    result.read(self._iprot)
400 
    self._iprot.readMessageEnd()
401 
    if result.success != None:
402 
      return result.success
403 
    if result.ex != None:
404 
      raise result.ex
405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
406 
 
94 ashish 407 
  def getTransactionStatus(self, transactionId):
408 
    """
409 
    Parameters:
410 
     - transactionId
411 
    """
412 
    self.send_getTransactionStatus(transactionId)
413 
    return self.recv_getTransactionStatus()
414 
 
415 
  def send_getTransactionStatus(self, transactionId):
416 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
417 
    args = getTransactionStatus_args()
418 
    args.transactionId = transactionId
419 
    args.write(self._oprot)
420 
    self._oprot.writeMessageEnd()
421 
    self._oprot.trans.flush()
422 
 
423 
  def recv_getTransactionStatus(self, ):
424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
425 
    if mtype == TMessageType.EXCEPTION:
426 
      x = TApplicationException()
427 
      x.read(self._iprot)
428 
      self._iprot.readMessageEnd()
429 
      raise x
430 
    result = getTransactionStatus_result()
431 
    result.read(self._iprot)
432 
    self._iprot.readMessageEnd()
433 
    if result.success != None:
434 
      return result.success
435 
    if result.ex != None:
436 
      raise result.ex
437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
438 
 
439 
  def changeTransactionStatus(self, transactionId, status, description):
440 
    """
441 
    Parameters:
442 
     - transactionId
443 
     - status
444 
     - description
445 
    """
446 
    self.send_changeTransactionStatus(transactionId, status, description)
447 
    return self.recv_changeTransactionStatus()
448 
 
449 
  def send_changeTransactionStatus(self, transactionId, status, description):
450 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
451 
    args = changeTransactionStatus_args()
452 
    args.transactionId = transactionId
453 
    args.status = status
454 
    args.description = description
455 
    args.write(self._oprot)
456 
    self._oprot.writeMessageEnd()
457 
    self._oprot.trans.flush()
458 
 
459 
  def recv_changeTransactionStatus(self, ):
460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
461 
    if mtype == TMessageType.EXCEPTION:
462 
      x = TApplicationException()
463 
      x.read(self._iprot)
464 
      self._iprot.readMessageEnd()
465 
      raise x
466 
    result = changeTransactionStatus_result()
467 
    result.read(self._iprot)
468 
    self._iprot.readMessageEnd()
469 
    if result.success != None:
470 
      return result.success
471 
    if result.ex != None:
472 
      raise result.ex
473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
474 
 
483 rajveer 475 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 476 
    """
477 
    Parameters:
483 rajveer 478 
     - status
479 
     - from_date
480 
     - to_date
481 
     - warehouse_id
94 ashish 482 
    """
483 rajveer 483 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
484 
    return self.recv_getAllOrders()
94 ashish 485 
 
483 rajveer 486 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
487 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
488 
    args = getAllOrders_args()
489 
    args.status = status
490 
    args.from_date = from_date
491 
    args.to_date = to_date
492 
    args.warehouse_id = warehouse_id
94 ashish 493 
    args.write(self._oprot)
494 
    self._oprot.writeMessageEnd()
495 
    self._oprot.trans.flush()
496 
 
483 rajveer 497 
  def recv_getAllOrders(self, ):
94 ashish 498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
499 
    if mtype == TMessageType.EXCEPTION:
500 
      x = TApplicationException()
501 
      x.read(self._iprot)
502 
      self._iprot.readMessageEnd()
503 
      raise x
483 rajveer 504 
    result = getAllOrders_result()
94 ashish 505 
    result.read(self._iprot)
506 
    self._iprot.readMessageEnd()
507 
    if result.success != None:
508 
      return result.success
509 
    if result.ex != None:
510 
      raise result.ex
483 rajveer 511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 512 
 
999 varun.gupt 513 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
514 
    """
1132 chandransh 515 
    Returns orders within a range of their billing dates
516 
 
999 varun.gupt 517 
    Parameters:
518 
     - status
519 
     - start_billing_date
520 
     - end_billing_date
521 
     - warehouse_id
522 
    """
523 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
524 
    return self.recv_getOrdersByBillingDate()
525 
 
526 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
527 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
528 
    args = getOrdersByBillingDate_args()
529 
    args.status = status
530 
    args.start_billing_date = start_billing_date
531 
    args.end_billing_date = end_billing_date
532 
    args.warehouse_id = warehouse_id
533 
    args.write(self._oprot)
534 
    self._oprot.writeMessageEnd()
535 
    self._oprot.trans.flush()
536 
 
537 
  def recv_getOrdersByBillingDate(self, ):
538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
539 
    if mtype == TMessageType.EXCEPTION:
540 
      x = TApplicationException()
541 
      x.read(self._iprot)
542 
      self._iprot.readMessageEnd()
543 
      raise x
544 
    result = getOrdersByBillingDate_result()
545 
    result.read(self._iprot)
546 
    self._iprot.readMessageEnd()
547 
    if result.success != None:
548 
      return result.success
549 
    if result.ex != None:
550 
      raise result.ex
551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
552 
 
483 rajveer 553 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 554 
    """
555 
    Parameters:
483 rajveer 556 
     - orderId
557 
     - status
558 
     - description
94 ashish 559 
    """
483 rajveer 560 
    self.send_changeOrderStatus(orderId, status, description)
561 
    return self.recv_changeOrderStatus()
94 ashish 562 
 
483 rajveer 563 
  def send_changeOrderStatus(self, orderId, status, description):
564 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
565 
    args = changeOrderStatus_args()
566 
    args.orderId = orderId
567 
    args.status = status
568 
    args.description = description
94 ashish 569 
    args.write(self._oprot)
570 
    self._oprot.writeMessageEnd()
571 
    self._oprot.trans.flush()
572 
 
483 rajveer 573 
  def recv_changeOrderStatus(self, ):
94 ashish 574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
575 
    if mtype == TMessageType.EXCEPTION:
576 
      x = TApplicationException()
577 
      x.read(self._iprot)
578 
      self._iprot.readMessageEnd()
579 
      raise x
483 rajveer 580 
    result = changeOrderStatus_result()
94 ashish 581 
    result.read(self._iprot)
582 
    self._iprot.readMessageEnd()
583 
    if result.success != None:
584 
      return result.success
585 
    if result.ex != None:
586 
      raise result.ex
483 rajveer 587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 588 
 
1149 chandransh 589 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 590 
    """
1149 chandransh 591 
    Add billing details such as the bill number and the biller to the Order.
592 
 
494 rajveer 593 
    Parameters:
594 
     - orderId
595 
     - invoice_number
596 
     - billed_by
597 
    """
1149 chandransh 598 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
494 rajveer 599 
    return self.recv_addBillingDetails()
600 
 
1149 chandransh 601 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 602 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
603 
    args = addBillingDetails_args()
604 
    args.orderId = orderId
605 
    args.invoice_number = invoice_number
606 
    args.billed_by = billed_by
607 
    args.write(self._oprot)
608 
    self._oprot.writeMessageEnd()
609 
    self._oprot.trans.flush()
610 
 
611 
  def recv_addBillingDetails(self, ):
612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
613 
    if mtype == TMessageType.EXCEPTION:
614 
      x = TApplicationException()
615 
      x.read(self._iprot)
616 
      self._iprot.readMessageEnd()
617 
      raise x
618 
    result = addBillingDetails_result()
619 
    result.read(self._iprot)
620 
    self._iprot.readMessageEnd()
621 
    if result.success != None:
622 
      return result.success
623 
    if result.ex != None:
624 
      raise result.ex
625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
626 
 
1149 chandransh 627 
  def addJacketNumber(self, orderId, jacketNumber):
628 
    """
629 
    Adds jacket number to the order. Return false if it doesn't find the order with the given ID.
630 
 
631 
    Parameters:
632 
     - orderId
633 
     - jacketNumber
634 
    """
635 
    self.send_addJacketNumber(orderId, jacketNumber)
636 
    return self.recv_addJacketNumber()
637 
 
638 
  def send_addJacketNumber(self, orderId, jacketNumber):
639 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
640 
    args = addJacketNumber_args()
641 
    args.orderId = orderId
642 
    args.jacketNumber = jacketNumber
643 
    args.write(self._oprot)
644 
    self._oprot.writeMessageEnd()
645 
    self._oprot.trans.flush()
646 
 
647 
  def recv_addJacketNumber(self, ):
648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
649 
    if mtype == TMessageType.EXCEPTION:
650 
      x = TApplicationException()
651 
      x.read(self._iprot)
652 
      self._iprot.readMessageEnd()
653 
      raise x
654 
    result = addJacketNumber_result()
655 
    result.read(self._iprot)
656 
    self._iprot.readMessageEnd()
657 
    if result.success != None:
658 
      return result.success
659 
    if result.ex != None:
660 
      raise result.ex
661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
662 
 
921 rajveer 663 
  def acceptOrder(self, orderId):
664 
    """
665 
    Parameters:
666 
     - orderId
667 
    """
668 
    self.send_acceptOrder(orderId)
669 
    return self.recv_acceptOrder()
670 
 
671 
  def send_acceptOrder(self, orderId):
672 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
673 
    args = acceptOrder_args()
674 
    args.orderId = orderId
675 
    args.write(self._oprot)
676 
    self._oprot.writeMessageEnd()
677 
    self._oprot.trans.flush()
678 
 
679 
  def recv_acceptOrder(self, ):
680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
681 
    if mtype == TMessageType.EXCEPTION:
682 
      x = TApplicationException()
683 
      x.read(self._iprot)
684 
      self._iprot.readMessageEnd()
685 
      raise x
686 
    result = acceptOrder_result()
687 
    result.read(self._iprot)
688 
    self._iprot.readMessageEnd()
689 
    if result.success != None:
690 
      return result.success
691 
    if result.ex != None:
692 
      raise result.ex
693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
694 
 
695 
  def billOrder(self, orderId):
696 
    """
697 
    Parameters:
698 
     - orderId
699 
    """
700 
    self.send_billOrder(orderId)
701 
    return self.recv_billOrder()
702 
 
703 
  def send_billOrder(self, orderId):
704 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
705 
    args = billOrder_args()
706 
    args.orderId = orderId
707 
    args.write(self._oprot)
708 
    self._oprot.writeMessageEnd()
709 
    self._oprot.trans.flush()
710 
 
711 
  def recv_billOrder(self, ):
712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
713 
    if mtype == TMessageType.EXCEPTION:
714 
      x = TApplicationException()
715 
      x.read(self._iprot)
716 
      self._iprot.readMessageEnd()
717 
      raise x
718 
    result = billOrder_result()
719 
    result.read(self._iprot)
720 
    self._iprot.readMessageEnd()
721 
    if result.success != None:
722 
      return result.success
723 
    if result.ex != None:
724 
      raise result.ex
725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
726 
 
483 rajveer 727 
  def getOrdersForTransaction(self, transactionId):
94 ashish 728 
    """
729 
    Parameters:
730 
     - transactionId
731 
    """
483 rajveer 732 
    self.send_getOrdersForTransaction(transactionId)
733 
    return self.recv_getOrdersForTransaction()
94 ashish 734 
 
483 rajveer 735 
  def send_getOrdersForTransaction(self, transactionId):
736 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
737 
    args = getOrdersForTransaction_args()
94 ashish 738 
    args.transactionId = transactionId
739 
    args.write(self._oprot)
740 
    self._oprot.writeMessageEnd()
741 
    self._oprot.trans.flush()
742 
 
483 rajveer 743 
  def recv_getOrdersForTransaction(self, ):
94 ashish 744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
745 
    if mtype == TMessageType.EXCEPTION:
746 
      x = TApplicationException()
747 
      x.read(self._iprot)
748 
      self._iprot.readMessageEnd()
749 
      raise x
483 rajveer 750 
    result = getOrdersForTransaction_result()
94 ashish 751 
    result.read(self._iprot)
752 
    self._iprot.readMessageEnd()
753 
    if result.success != None:
754 
      return result.success
755 
    if result.ex != None:
756 
      raise result.ex
483 rajveer 757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 758 
 
483 rajveer 759 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 760 
    """
761 
    Parameters:
483 rajveer 762 
     - customerId
763 
     - from_date
764 
     - to_date
765 
     - status
94 ashish 766 
    """
483 rajveer 767 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, status)
768 
    return self.recv_getOrdersForCustomer()
94 ashish 769 
 
483 rajveer 770 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, status):
771 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
772 
    args = getOrdersForCustomer_args()
773 
    args.customerId = customerId
774 
    args.from_date = from_date
775 
    args.to_date = to_date
776 
    args.status = status
94 ashish 777 
    args.write(self._oprot)
778 
    self._oprot.writeMessageEnd()
779 
    self._oprot.trans.flush()
780 
 
483 rajveer 781 
  def recv_getOrdersForCustomer(self, ):
94 ashish 782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
783 
    if mtype == TMessageType.EXCEPTION:
784 
      x = TApplicationException()
785 
      x.read(self._iprot)
786 
      self._iprot.readMessageEnd()
787 
      raise x
483 rajveer 788 
    result = getOrdersForCustomer_result()
94 ashish 789 
    result.read(self._iprot)
790 
    self._iprot.readMessageEnd()
791 
    if result.success != None:
792 
      return result.success
793 
    if result.ex != None:
794 
      raise result.ex
483 rajveer 795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 796 
 
483 rajveer 797 
  def createOrder(self, order):
94 ashish 798 
    """
799 
    Parameters:
483 rajveer 800 
     - order
94 ashish 801 
    """
483 rajveer 802 
    self.send_createOrder(order)
803 
    return self.recv_createOrder()
94 ashish 804 
 
483 rajveer 805 
  def send_createOrder(self, order):
806 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
807 
    args = createOrder_args()
808 
    args.order = order
94 ashish 809 
    args.write(self._oprot)
810 
    self._oprot.writeMessageEnd()
811 
    self._oprot.trans.flush()
812 
 
483 rajveer 813 
  def recv_createOrder(self, ):
94 ashish 814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
815 
    if mtype == TMessageType.EXCEPTION:
816 
      x = TApplicationException()
817 
      x.read(self._iprot)
818 
      self._iprot.readMessageEnd()
819 
      raise x
483 rajveer 820 
    result = createOrder_result()
94 ashish 821 
    result.read(self._iprot)
822 
    self._iprot.readMessageEnd()
823 
    if result.success != None:
824 
      return result.success
825 
    if result.ex != None:
826 
      raise result.ex
483 rajveer 827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 828 
 
483 rajveer 829 
  def getOrder(self, id):
94 ashish 830 
    """
831 
    Parameters:
483 rajveer 832 
     - id
94 ashish 833 
    """
483 rajveer 834 
    self.send_getOrder(id)
835 
    return self.recv_getOrder()
94 ashish 836 
 
483 rajveer 837 
  def send_getOrder(self, id):
838 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
839 
    args = getOrder_args()
840 
    args.id = id
94 ashish 841 
    args.write(self._oprot)
842 
    self._oprot.writeMessageEnd()
843 
    self._oprot.trans.flush()
844 
 
483 rajveer 845 
  def recv_getOrder(self, ):
94 ashish 846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
847 
    if mtype == TMessageType.EXCEPTION:
848 
      x = TApplicationException()
849 
      x.read(self._iprot)
850 
      self._iprot.readMessageEnd()
851 
      raise x
483 rajveer 852 
    result = getOrder_result()
94 ashish 853 
    result.read(self._iprot)
854 
    self._iprot.readMessageEnd()
855 
    if result.success != None:
856 
      return result.success
857 
    if result.ex != None:
858 
      raise result.ex
483 rajveer 859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 860 
 
483 rajveer 861 
  def getLineItemsForOrder(self, orderId):
94 ashish 862 
    """
863 
    Parameters:
483 rajveer 864 
     - orderId
94 ashish 865 
    """
483 rajveer 866 
    self.send_getLineItemsForOrder(orderId)
867 
    return self.recv_getLineItemsForOrder()
94 ashish 868 
 
483 rajveer 869 
  def send_getLineItemsForOrder(self, orderId):
870 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
871 
    args = getLineItemsForOrder_args()
872 
    args.orderId = orderId
94 ashish 873 
    args.write(self._oprot)
874 
    self._oprot.writeMessageEnd()
875 
    self._oprot.trans.flush()
876 
 
483 rajveer 877 
  def recv_getLineItemsForOrder(self, ):
94 ashish 878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
879 
    if mtype == TMessageType.EXCEPTION:
880 
      x = TApplicationException()
881 
      x.read(self._iprot)
882 
      self._iprot.readMessageEnd()
883 
      raise x
483 rajveer 884 
    result = getLineItemsForOrder_result()
94 ashish 885 
    result.read(self._iprot)
886 
    self._iprot.readMessageEnd()
887 
    if result.success != None:
888 
      return result.success
889 
    if result.ex != None:
890 
      raise result.ex
483 rajveer 891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 892 
 
759 chandransh 893 
  def markOrdersAsManifested(self, warehouseId, providerId):
894 
    """
895 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
896 
 
897 
    Parameters:
898 
     - warehouseId
899 
     - providerId
900 
    """
901 
    self.send_markOrdersAsManifested(warehouseId, providerId)
902 
    return self.recv_markOrdersAsManifested()
903 
 
904 
  def send_markOrdersAsManifested(self, warehouseId, providerId):
905 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
906 
    args = markOrdersAsManifested_args()
907 
    args.warehouseId = warehouseId
908 
    args.providerId = providerId
909 
    args.write(self._oprot)
910 
    self._oprot.writeMessageEnd()
911 
    self._oprot.trans.flush()
912 
 
913 
  def recv_markOrdersAsManifested(self, ):
914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
915 
    if mtype == TMessageType.EXCEPTION:
916 
      x = TApplicationException()
917 
      x.read(self._iprot)
918 
      self._iprot.readMessageEnd()
919 
      raise x
920 
    result = markOrdersAsManifested_result()
921 
    result.read(self._iprot)
922 
    self._iprot.readMessageEnd()
923 
    if result.success != None:
924 
      return result.success
925 
    if result.ex != None:
926 
      raise result.ex
927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
928 
 
1113 chandransh 929 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
930 
    """
931 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
932 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
933 
    Raises an exception if we encounter report for an AWB number that we did not ship.
934 
 
935 
    Parameters:
936 
     - providerId
937 
     - pickupDetails
938 
    """
939 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
940 
    return self.recv_markOrdersAsPickedUp()
941 
 
942 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
943 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
944 
    args = markOrdersAsPickedUp_args()
945 
    args.providerId = providerId
946 
    args.pickupDetails = pickupDetails
947 
    args.write(self._oprot)
948 
    self._oprot.writeMessageEnd()
949 
    self._oprot.trans.flush()
950 
 
951 
  def recv_markOrdersAsPickedUp(self, ):
952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
953 
    if mtype == TMessageType.EXCEPTION:
954 
      x = TApplicationException()
955 
      x.read(self._iprot)
956 
      self._iprot.readMessageEnd()
957 
      raise x
958 
    result = markOrdersAsPickedUp_result()
959 
    result.read(self._iprot)
960 
    self._iprot.readMessageEnd()
961 
    if result.success != None:
962 
      return result.success
963 
    if result.ex != None:
964 
      raise result.ex
965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
966 
 
1132 chandransh 967 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
968 
    """
969 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
970 
    the name of the receiver.
971 
    Raises an exception if we encounter report for an AWB number that we did not ship.
972 
 
973 
    Parameters:
974 
     - providerId
975 
     - deliveredOrders
976 
    """
977 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
978 
    self.recv_markOrdersAsDelivered()
979 
 
980 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
981 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
982 
    args = markOrdersAsDelivered_args()
983 
    args.providerId = providerId
984 
    args.deliveredOrders = deliveredOrders
985 
    args.write(self._oprot)
986 
    self._oprot.writeMessageEnd()
987 
    self._oprot.trans.flush()
988 
 
989 
  def recv_markOrdersAsDelivered(self, ):
990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
991 
    if mtype == TMessageType.EXCEPTION:
992 
      x = TApplicationException()
993 
      x.read(self._iprot)
994 
      self._iprot.readMessageEnd()
995 
      raise x
996 
    result = markOrdersAsDelivered_result()
997 
    result.read(self._iprot)
998 
    self._iprot.readMessageEnd()
999 
    if result.ex != None:
1000 
      raise result.ex
1001 
    return
1002 
 
1135 chandransh 1003 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1004 
    """
1005 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1006 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1007 
 
1008 
    Parameters:
1009 
     - providerId
1010 
     - returnedOrders
1011 
    """
1012 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1013 
    self.recv_markOrdersAsFailed()
1014 
 
1015 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1016 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1017 
    args = markOrdersAsFailed_args()
1018 
    args.providerId = providerId
1019 
    args.returnedOrders = returnedOrders
1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
1024 
  def recv_markOrdersAsFailed(self, ):
1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
1031 
    result = markOrdersAsFailed_result()
1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
1034 
    if result.ex != None:
1035 
      raise result.ex
1036 
    return
1037 
 
483 rajveer 1038 
  def getAlerts(self, orderId, valid):
94 ashish 1039 
    """
1040 
    Parameters:
483 rajveer 1041 
     - orderId
304 ashish 1042 
     - valid
1043 
    """
483 rajveer 1044 
    self.send_getAlerts(orderId, valid)
304 ashish 1045 
    return self.recv_getAlerts()
94 ashish 1046 
 
483 rajveer 1047 
  def send_getAlerts(self, orderId, valid):
304 ashish 1048 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1049 
    args = getAlerts_args()
483 rajveer 1050 
    args.orderId = orderId
304 ashish 1051 
    args.valid = valid
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_getAlerts(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = getAlerts_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
1066 
    if result.success != None:
1067 
      return result.success
1068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1069 
 
483 rajveer 1070 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 1071 
    """
1072 
    Parameters:
483 rajveer 1073 
     - orderId
304 ashish 1074 
     - unset
1075 
     - type
1076 
     - comment
1077 
    """
483 rajveer 1078 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 1079 
    self.recv_setAlert()
1080 
 
483 rajveer 1081 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 1082 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1083 
    args = setAlert_args()
483 rajveer 1084 
    args.orderId = orderId
304 ashish 1085 
    args.unset = unset
1086 
    args.type = type
1087 
    args.comment = comment
1088 
    args.write(self._oprot)
1089 
    self._oprot.writeMessageEnd()
1090 
    self._oprot.trans.flush()
1091 
 
1092 
  def recv_setAlert(self, ):
1093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1094 
    if mtype == TMessageType.EXCEPTION:
1095 
      x = TApplicationException()
1096 
      x.read(self._iprot)
1097 
      self._iprot.readMessageEnd()
1098 
      raise x
1099 
    result = setAlert_result()
1100 
    result.read(self._iprot)
1101 
    self._iprot.readMessageEnd()
1102 
    return
1103 
 
1104 
 
94 ashish 1105 
class Processor(Iface, TProcessor):
1106 
  def __init__(self, handler):
1107 
    self._handler = handler
1108 
    self._processMap = {}
765 rajveer 1109 
    self._processMap["closeSession"] = Processor.process_closeSession
94 ashish 1110 
    self._processMap["createTransaction"] = Processor.process_createTransaction
1111 
    self._processMap["getTransaction"] = Processor.process_getTransaction
1112 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 1113 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 1114 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
1115 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
483 rajveer 1116 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 1117 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
483 rajveer 1118 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 1119 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
1149 chandransh 1120 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
921 rajveer 1121 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
1122 
    self._processMap["billOrder"] = Processor.process_billOrder
483 rajveer 1123 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
1124 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
1125 
    self._processMap["createOrder"] = Processor.process_createOrder
1126 
    self._processMap["getOrder"] = Processor.process_getOrder
1127 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
759 chandransh 1128 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 1129 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 1130 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 1131 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
304 ashish 1132 
    self._processMap["getAlerts"] = Processor.process_getAlerts
1133 
    self._processMap["setAlert"] = Processor.process_setAlert
94 ashish 1134 
 
1135 
  def process(self, iprot, oprot):
1136 
    (name, type, seqid) = iprot.readMessageBegin()
1137 
    if name not in self._processMap:
1138 
      iprot.skip(TType.STRUCT)
1139 
      iprot.readMessageEnd()
1140 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1141 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1142 
      x.write(oprot)
1143 
      oprot.writeMessageEnd()
1144 
      oprot.trans.flush()
1145 
      return
1146 
    else:
1147 
      self._processMap[name](self, seqid, iprot, oprot)
1148 
    return True
1149 
 
765 rajveer 1150 
  def process_closeSession(self, seqid, iprot, oprot):
1151 
    args = closeSession_args()
1152 
    args.read(iprot)
1153 
    iprot.readMessageEnd()
1154 
    result = closeSession_result()
1155 
    self._handler.closeSession()
1156 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
1157 
    result.write(oprot)
1158 
    oprot.writeMessageEnd()
1159 
    oprot.trans.flush()
1160 
 
94 ashish 1161 
  def process_createTransaction(self, seqid, iprot, oprot):
1162 
    args = createTransaction_args()
1163 
    args.read(iprot)
1164 
    iprot.readMessageEnd()
1165 
    result = createTransaction_result()
1166 
    try:
132 ashish 1167 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 1168 
    except TransactionServiceException, ex:
1169 
      result.ex = ex
1170 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
1171 
    result.write(oprot)
1172 
    oprot.writeMessageEnd()
1173 
    oprot.trans.flush()
1174 
 
1175 
  def process_getTransaction(self, seqid, iprot, oprot):
1176 
    args = getTransaction_args()
1177 
    args.read(iprot)
1178 
    iprot.readMessageEnd()
1179 
    result = getTransaction_result()
1180 
    try:
1181 
      result.success = self._handler.getTransaction(args.id)
1182 
    except TransactionServiceException, ex:
1183 
      result.ex = ex
1184 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
1185 
    result.write(oprot)
1186 
    oprot.writeMessageEnd()
1187 
    oprot.trans.flush()
1188 
 
1189 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
1190 
    args = getTransactionsForCustomer_args()
1191 
    args.read(iprot)
1192 
    iprot.readMessageEnd()
1193 
    result = getTransactionsForCustomer_result()
1194 
    try:
1195 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
1196 
    except TransactionServiceException, ex:
1197 
      result.ex = ex
1198 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
1199 
    result.write(oprot)
1200 
    oprot.writeMessageEnd()
1201 
    oprot.trans.flush()
1202 
 
132 ashish 1203 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
1204 
    args = getTransactionsForShoppingCartId_args()
1205 
    args.read(iprot)
1206 
    iprot.readMessageEnd()
1207 
    result = getTransactionsForShoppingCartId_result()
1208 
    try:
1209 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
1210 
    except TransactionServiceException, ex:
1211 
      result.ex = ex
1212 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
1213 
    result.write(oprot)
1214 
    oprot.writeMessageEnd()
1215 
    oprot.trans.flush()
1216 
 
94 ashish 1217 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
1218 
    args = getTransactionStatus_args()
1219 
    args.read(iprot)
1220 
    iprot.readMessageEnd()
1221 
    result = getTransactionStatus_result()
1222 
    try:
1223 
      result.success = self._handler.getTransactionStatus(args.transactionId)
1224 
    except TransactionServiceException, ex:
1225 
      result.ex = ex
1226 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
1227 
    result.write(oprot)
1228 
    oprot.writeMessageEnd()
1229 
    oprot.trans.flush()
1230 
 
1231 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
1232 
    args = changeTransactionStatus_args()
1233 
    args.read(iprot)
1234 
    iprot.readMessageEnd()
1235 
    result = changeTransactionStatus_result()
1236 
    try:
1237 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
1238 
    except TransactionServiceException, ex:
1239 
      result.ex = ex
1240 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
1241 
    result.write(oprot)
1242 
    oprot.writeMessageEnd()
1243 
    oprot.trans.flush()
1244 
 
483 rajveer 1245 
  def process_getAllOrders(self, seqid, iprot, oprot):
1246 
    args = getAllOrders_args()
94 ashish 1247 
    args.read(iprot)
1248 
    iprot.readMessageEnd()
483 rajveer 1249 
    result = getAllOrders_result()
94 ashish 1250 
    try:
483 rajveer 1251 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 1252 
    except TransactionServiceException, ex:
1253 
      result.ex = ex
483 rajveer 1254 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 1255 
    result.write(oprot)
1256 
    oprot.writeMessageEnd()
1257 
    oprot.trans.flush()
1258 
 
999 varun.gupt 1259 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
1260 
    args = getOrdersByBillingDate_args()
1261 
    args.read(iprot)
1262 
    iprot.readMessageEnd()
1263 
    result = getOrdersByBillingDate_result()
1264 
    try:
1265 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
1266 
    except TransactionServiceException, ex:
1267 
      result.ex = ex
1268 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
1269 
    result.write(oprot)
1270 
    oprot.writeMessageEnd()
1271 
    oprot.trans.flush()
1272 
 
483 rajveer 1273 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
1274 
    args = changeOrderStatus_args()
94 ashish 1275 
    args.read(iprot)
1276 
    iprot.readMessageEnd()
483 rajveer 1277 
    result = changeOrderStatus_result()
94 ashish 1278 
    try:
483 rajveer 1279 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 1280 
    except TransactionServiceException, ex:
1281 
      result.ex = ex
483 rajveer 1282 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 1283 
    result.write(oprot)
1284 
    oprot.writeMessageEnd()
1285 
    oprot.trans.flush()
1286 
 
494 rajveer 1287 
  def process_addBillingDetails(self, seqid, iprot, oprot):
1288 
    args = addBillingDetails_args()
1289 
    args.read(iprot)
1290 
    iprot.readMessageEnd()
1291 
    result = addBillingDetails_result()
1292 
    try:
1149 chandransh 1293 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
494 rajveer 1294 
    except TransactionServiceException, ex:
1295 
      result.ex = ex
1296 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1297 
    result.write(oprot)
1298 
    oprot.writeMessageEnd()
1299 
    oprot.trans.flush()
1300 
 
1149 chandransh 1301 
  def process_addJacketNumber(self, seqid, iprot, oprot):
1302 
    args = addJacketNumber_args()
1303 
    args.read(iprot)
1304 
    iprot.readMessageEnd()
1305 
    result = addJacketNumber_result()
1306 
    try:
1307 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber)
1308 
    except TransactionServiceException, ex:
1309 
      result.ex = ex
1310 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
1311 
    result.write(oprot)
1312 
    oprot.writeMessageEnd()
1313 
    oprot.trans.flush()
1314 
 
921 rajveer 1315 
  def process_acceptOrder(self, seqid, iprot, oprot):
1316 
    args = acceptOrder_args()
1317 
    args.read(iprot)
1318 
    iprot.readMessageEnd()
1319 
    result = acceptOrder_result()
1320 
    try:
1321 
      result.success = self._handler.acceptOrder(args.orderId)
1322 
    except TransactionServiceException, ex:
1323 
      result.ex = ex
1324 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1325 
    result.write(oprot)
1326 
    oprot.writeMessageEnd()
1327 
    oprot.trans.flush()
1328 
 
1329 
  def process_billOrder(self, seqid, iprot, oprot):
1330 
    args = billOrder_args()
1331 
    args.read(iprot)
1332 
    iprot.readMessageEnd()
1333 
    result = billOrder_result()
1334 
    try:
1335 
      result.success = self._handler.billOrder(args.orderId)
1336 
    except TransactionServiceException, ex:
1337 
      result.ex = ex
1338 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
1339 
    result.write(oprot)
1340 
    oprot.writeMessageEnd()
1341 
    oprot.trans.flush()
1342 
 
483 rajveer 1343 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
1344 
    args = getOrdersForTransaction_args()
94 ashish 1345 
    args.read(iprot)
1346 
    iprot.readMessageEnd()
483 rajveer 1347 
    result = getOrdersForTransaction_result()
94 ashish 1348 
    try:
483 rajveer 1349 
      result.success = self._handler.getOrdersForTransaction(args.transactionId)
94 ashish 1350 
    except TransactionServiceException, ex:
1351 
      result.ex = ex
483 rajveer 1352 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 1353 
    result.write(oprot)
1354 
    oprot.writeMessageEnd()
1355 
    oprot.trans.flush()
1356 
 
483 rajveer 1357 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
1358 
    args = getOrdersForCustomer_args()
94 ashish 1359 
    args.read(iprot)
1360 
    iprot.readMessageEnd()
483 rajveer 1361 
    result = getOrdersForCustomer_result()
94 ashish 1362 
    try:
483 rajveer 1363 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status)
94 ashish 1364 
    except TransactionServiceException, ex:
1365 
      result.ex = ex
483 rajveer 1366 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 1367 
    result.write(oprot)
1368 
    oprot.writeMessageEnd()
1369 
    oprot.trans.flush()
1370 
 
483 rajveer 1371 
  def process_createOrder(self, seqid, iprot, oprot):
1372 
    args = createOrder_args()
94 ashish 1373 
    args.read(iprot)
1374 
    iprot.readMessageEnd()
483 rajveer 1375 
    result = createOrder_result()
94 ashish 1376 
    try:
483 rajveer 1377 
      result.success = self._handler.createOrder(args.order)
94 ashish 1378 
    except TransactionServiceException, ex:
1379 
      result.ex = ex
483 rajveer 1380 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 1381 
    result.write(oprot)
1382 
    oprot.writeMessageEnd()
1383 
    oprot.trans.flush()
1384 
 
483 rajveer 1385 
  def process_getOrder(self, seqid, iprot, oprot):
1386 
    args = getOrder_args()
94 ashish 1387 
    args.read(iprot)
1388 
    iprot.readMessageEnd()
483 rajveer 1389 
    result = getOrder_result()
94 ashish 1390 
    try:
483 rajveer 1391 
      result.success = self._handler.getOrder(args.id)
94 ashish 1392 
    except TransactionServiceException, ex:
1393 
      result.ex = ex
483 rajveer 1394 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 1395 
    result.write(oprot)
1396 
    oprot.writeMessageEnd()
1397 
    oprot.trans.flush()
1398 
 
483 rajveer 1399 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
1400 
    args = getLineItemsForOrder_args()
94 ashish 1401 
    args.read(iprot)
1402 
    iprot.readMessageEnd()
483 rajveer 1403 
    result = getLineItemsForOrder_result()
94 ashish 1404 
    try:
483 rajveer 1405 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 1406 
    except TransactionServiceException, ex:
1407 
      result.ex = ex
483 rajveer 1408 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 1409 
    result.write(oprot)
1410 
    oprot.writeMessageEnd()
1411 
    oprot.trans.flush()
1412 
 
759 chandransh 1413 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
1414 
    args = markOrdersAsManifested_args()
1415 
    args.read(iprot)
1416 
    iprot.readMessageEnd()
1417 
    result = markOrdersAsManifested_result()
1418 
    try:
1419 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
1420 
    except TransactionServiceException, ex:
1421 
      result.ex = ex
1422 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1423 
    result.write(oprot)
1424 
    oprot.writeMessageEnd()
1425 
    oprot.trans.flush()
1426 
 
1113 chandransh 1427 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
1428 
    args = markOrdersAsPickedUp_args()
1429 
    args.read(iprot)
1430 
    iprot.readMessageEnd()
1431 
    result = markOrdersAsPickedUp_result()
1432 
    try:
1433 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
1434 
    except TransactionServiceException, ex:
1435 
      result.ex = ex
1436 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
1437 
    result.write(oprot)
1438 
    oprot.writeMessageEnd()
1439 
    oprot.trans.flush()
1440 
 
1132 chandransh 1441 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
1442 
    args = markOrdersAsDelivered_args()
1443 
    args.read(iprot)
1444 
    iprot.readMessageEnd()
1445 
    result = markOrdersAsDelivered_result()
1446 
    try:
1447 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
1448 
    except TransactionServiceException, ex:
1449 
      result.ex = ex
1450 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
1451 
    result.write(oprot)
1452 
    oprot.writeMessageEnd()
1453 
    oprot.trans.flush()
1454 
 
1135 chandransh 1455 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
1456 
    args = markOrdersAsFailed_args()
1457 
    args.read(iprot)
1458 
    iprot.readMessageEnd()
1459 
    result = markOrdersAsFailed_result()
1460 
    try:
1461 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
1462 
    except TransactionServiceException, ex:
1463 
      result.ex = ex
1464 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1465 
    result.write(oprot)
1466 
    oprot.writeMessageEnd()
1467 
    oprot.trans.flush()
1468 
 
304 ashish 1469 
  def process_getAlerts(self, seqid, iprot, oprot):
1470 
    args = getAlerts_args()
1471 
    args.read(iprot)
1472 
    iprot.readMessageEnd()
1473 
    result = getAlerts_result()
483 rajveer 1474 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 1475 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
1476 
    result.write(oprot)
1477 
    oprot.writeMessageEnd()
1478 
    oprot.trans.flush()
94 ashish 1479 
 
304 ashish 1480 
  def process_setAlert(self, seqid, iprot, oprot):
1481 
    args = setAlert_args()
1482 
    args.read(iprot)
1483 
    iprot.readMessageEnd()
1484 
    result = setAlert_result()
483 rajveer 1485 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 1486 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
1487 
    result.write(oprot)
1488 
    oprot.writeMessageEnd()
1489 
    oprot.trans.flush()
1490 
 
1491 
 
94 ashish 1492 
# HELPER FUNCTIONS AND STRUCTURES
1493 
 
765 rajveer 1494 
class closeSession_args:
1495 
 
1496 
  thrift_spec = (
1497 
  )
1498 
 
1499 
  def read(self, iprot):
1500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1502 
      return
1503 
    iprot.readStructBegin()
1504 
    while True:
1505 
      (fname, ftype, fid) = iprot.readFieldBegin()
1506 
      if ftype == TType.STOP:
1507 
        break
1508 
      else:
1509 
        iprot.skip(ftype)
1510 
      iprot.readFieldEnd()
1511 
    iprot.readStructEnd()
1512 
 
1513 
  def write(self, oprot):
1514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1516 
      return
1517 
    oprot.writeStructBegin('closeSession_args')
1518 
    oprot.writeFieldStop()
1519 
    oprot.writeStructEnd()
1520 
 
1521 
  def __repr__(self):
1522 
    L = ['%s=%r' % (key, value)
1523 
      for key, value in self.__dict__.iteritems()]
1524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1525 
 
1526 
  def __eq__(self, other):
1527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1528 
 
1529 
  def __ne__(self, other):
1530 
    return not (self == other)
1531 
 
1532 
class closeSession_result:
1533 
 
1534 
  thrift_spec = (
1535 
  )
1536 
 
1537 
  def read(self, iprot):
1538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1540 
      return
1541 
    iprot.readStructBegin()
1542 
    while True:
1543 
      (fname, ftype, fid) = iprot.readFieldBegin()
1544 
      if ftype == TType.STOP:
1545 
        break
1546 
      else:
1547 
        iprot.skip(ftype)
1548 
      iprot.readFieldEnd()
1549 
    iprot.readStructEnd()
1550 
 
1551 
  def write(self, oprot):
1552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1554 
      return
1555 
    oprot.writeStructBegin('closeSession_result')
1556 
    oprot.writeFieldStop()
1557 
    oprot.writeStructEnd()
1558 
 
1559 
  def __repr__(self):
1560 
    L = ['%s=%r' % (key, value)
1561 
      for key, value in self.__dict__.iteritems()]
1562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1563 
 
1564 
  def __eq__(self, other):
1565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1566 
 
1567 
  def __ne__(self, other):
1568 
    return not (self == other)
1569 
 
94 ashish 1570 
class createTransaction_args:
1571 
  """
1572 
  Attributes:
1573 
   - transaction
1574 
  """
1575 
 
1576 
  thrift_spec = (
1577 
    None, # 0
1578 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
1579 
  )
1580 
 
1581 
  def __init__(self, transaction=None,):
1582 
    self.transaction = transaction
1583 
 
1584 
  def read(self, iprot):
1585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1587 
      return
1588 
    iprot.readStructBegin()
1589 
    while True:
1590 
      (fname, ftype, fid) = iprot.readFieldBegin()
1591 
      if ftype == TType.STOP:
1592 
        break
1593 
      if fid == 1:
1594 
        if ftype == TType.STRUCT:
1595 
          self.transaction = Transaction()
1596 
          self.transaction.read(iprot)
1597 
        else:
1598 
          iprot.skip(ftype)
1599 
      else:
1600 
        iprot.skip(ftype)
1601 
      iprot.readFieldEnd()
1602 
    iprot.readStructEnd()
1603 
 
1604 
  def write(self, oprot):
1605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1607 
      return
1608 
    oprot.writeStructBegin('createTransaction_args')
1609 
    if self.transaction != None:
1610 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
1611 
      self.transaction.write(oprot)
1612 
      oprot.writeFieldEnd()
1613 
    oprot.writeFieldStop()
1614 
    oprot.writeStructEnd()
1615 
 
1616 
  def __repr__(self):
1617 
    L = ['%s=%r' % (key, value)
1618 
      for key, value in self.__dict__.iteritems()]
1619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1620 
 
1621 
  def __eq__(self, other):
1622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1623 
 
1624 
  def __ne__(self, other):
1625 
    return not (self == other)
1626 
 
1627 
class createTransaction_result:
1628 
  """
1629 
  Attributes:
132 ashish 1630 
   - success
94 ashish 1631 
   - ex
1632 
  """
1633 
 
1634 
  thrift_spec = (
132 ashish 1635 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 1636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1637 
  )
1638 
 
132 ashish 1639 
  def __init__(self, success=None, ex=None,):
1640 
    self.success = success
94 ashish 1641 
    self.ex = ex
1642 
 
1643 
  def read(self, iprot):
1644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1646 
      return
1647 
    iprot.readStructBegin()
1648 
    while True:
1649 
      (fname, ftype, fid) = iprot.readFieldBegin()
1650 
      if ftype == TType.STOP:
1651 
        break
132 ashish 1652 
      if fid == 0:
1653 
        if ftype == TType.I64:
1654 
          self.success = iprot.readI64();
1655 
        else:
1656 
          iprot.skip(ftype)
1657 
      elif fid == 1:
94 ashish 1658 
        if ftype == TType.STRUCT:
1659 
          self.ex = TransactionServiceException()
1660 
          self.ex.read(iprot)
1661 
        else:
1662 
          iprot.skip(ftype)
1663 
      else:
1664 
        iprot.skip(ftype)
1665 
      iprot.readFieldEnd()
1666 
    iprot.readStructEnd()
1667 
 
1668 
  def write(self, oprot):
1669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1671 
      return
1672 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 1673 
    if self.success != None:
1674 
      oprot.writeFieldBegin('success', TType.I64, 0)
1675 
      oprot.writeI64(self.success)
1676 
      oprot.writeFieldEnd()
94 ashish 1677 
    if self.ex != None:
1678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1679 
      self.ex.write(oprot)
1680 
      oprot.writeFieldEnd()
1681 
    oprot.writeFieldStop()
1682 
    oprot.writeStructEnd()
1683 
 
1684 
  def __repr__(self):
1685 
    L = ['%s=%r' % (key, value)
1686 
      for key, value in self.__dict__.iteritems()]
1687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1688 
 
1689 
  def __eq__(self, other):
1690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1691 
 
1692 
  def __ne__(self, other):
1693 
    return not (self == other)
1694 
 
1695 
class getTransaction_args:
1696 
  """
1697 
  Attributes:
1698 
   - id
1699 
  """
1700 
 
1701 
  thrift_spec = (
1702 
    None, # 0
1703 
    (1, TType.I64, 'id', None, None, ), # 1
1704 
  )
1705 
 
1706 
  def __init__(self, id=None,):
1707 
    self.id = id
1708 
 
1709 
  def read(self, iprot):
1710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1712 
      return
1713 
    iprot.readStructBegin()
1714 
    while True:
1715 
      (fname, ftype, fid) = iprot.readFieldBegin()
1716 
      if ftype == TType.STOP:
1717 
        break
1718 
      if fid == 1:
1719 
        if ftype == TType.I64:
1720 
          self.id = iprot.readI64();
1721 
        else:
1722 
          iprot.skip(ftype)
1723 
      else:
1724 
        iprot.skip(ftype)
1725 
      iprot.readFieldEnd()
1726 
    iprot.readStructEnd()
1727 
 
1728 
  def write(self, oprot):
1729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1731 
      return
1732 
    oprot.writeStructBegin('getTransaction_args')
1733 
    if self.id != None:
1734 
      oprot.writeFieldBegin('id', TType.I64, 1)
1735 
      oprot.writeI64(self.id)
1736 
      oprot.writeFieldEnd()
1737 
    oprot.writeFieldStop()
1738 
    oprot.writeStructEnd()
1739 
 
1740 
  def __repr__(self):
1741 
    L = ['%s=%r' % (key, value)
1742 
      for key, value in self.__dict__.iteritems()]
1743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1744 
 
1745 
  def __eq__(self, other):
1746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1747 
 
1748 
  def __ne__(self, other):
1749 
    return not (self == other)
1750 
 
1751 
class getTransaction_result:
1752 
  """
1753 
  Attributes:
1754 
   - success
1755 
   - ex
1756 
  """
1757 
 
1758 
  thrift_spec = (
1759 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
1760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1761 
  )
1762 
 
1763 
  def __init__(self, success=None, ex=None,):
1764 
    self.success = success
1765 
    self.ex = ex
1766 
 
1767 
  def read(self, iprot):
1768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1770 
      return
1771 
    iprot.readStructBegin()
1772 
    while True:
1773 
      (fname, ftype, fid) = iprot.readFieldBegin()
1774 
      if ftype == TType.STOP:
1775 
        break
1776 
      if fid == 0:
1777 
        if ftype == TType.STRUCT:
1778 
          self.success = Transaction()
1779 
          self.success.read(iprot)
1780 
        else:
1781 
          iprot.skip(ftype)
1782 
      elif fid == 1:
1783 
        if ftype == TType.STRUCT:
1784 
          self.ex = TransactionServiceException()
1785 
          self.ex.read(iprot)
1786 
        else:
1787 
          iprot.skip(ftype)
1788 
      else:
1789 
        iprot.skip(ftype)
1790 
      iprot.readFieldEnd()
1791 
    iprot.readStructEnd()
1792 
 
1793 
  def write(self, oprot):
1794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1796 
      return
1797 
    oprot.writeStructBegin('getTransaction_result')
1798 
    if self.success != None:
1799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1800 
      self.success.write(oprot)
1801 
      oprot.writeFieldEnd()
1802 
    if self.ex != None:
1803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1804 
      self.ex.write(oprot)
1805 
      oprot.writeFieldEnd()
1806 
    oprot.writeFieldStop()
1807 
    oprot.writeStructEnd()
1808 
 
1809 
  def __repr__(self):
1810 
    L = ['%s=%r' % (key, value)
1811 
      for key, value in self.__dict__.iteritems()]
1812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1813 
 
1814 
  def __eq__(self, other):
1815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1816 
 
1817 
  def __ne__(self, other):
1818 
    return not (self == other)
1819 
 
1820 
class getTransactionsForCustomer_args:
1821 
  """
1822 
  Attributes:
1823 
   - customerId
1824 
   - from_date
1825 
   - to_date
1826 
   - status
1827 
  """
1828 
 
1829 
  thrift_spec = (
1830 
    None, # 0
1831 
    (1, TType.I64, 'customerId', None, None, ), # 1
1832 
    (2, TType.I64, 'from_date', None, None, ), # 2
1833 
    (3, TType.I64, 'to_date', None, None, ), # 3
1834 
    (4, TType.I32, 'status', None, None, ), # 4
1835 
  )
1836 
 
1837 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
1838 
    self.customerId = customerId
1839 
    self.from_date = from_date
1840 
    self.to_date = to_date
1841 
    self.status = status
1842 
 
1843 
  def read(self, iprot):
1844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1846 
      return
1847 
    iprot.readStructBegin()
1848 
    while True:
1849 
      (fname, ftype, fid) = iprot.readFieldBegin()
1850 
      if ftype == TType.STOP:
1851 
        break
1852 
      if fid == 1:
1853 
        if ftype == TType.I64:
1854 
          self.customerId = iprot.readI64();
1855 
        else:
1856 
          iprot.skip(ftype)
1857 
      elif fid == 2:
1858 
        if ftype == TType.I64:
1859 
          self.from_date = iprot.readI64();
1860 
        else:
1861 
          iprot.skip(ftype)
1862 
      elif fid == 3:
1863 
        if ftype == TType.I64:
1864 
          self.to_date = iprot.readI64();
1865 
        else:
1866 
          iprot.skip(ftype)
1867 
      elif fid == 4:
1868 
        if ftype == TType.I32:
1869 
          self.status = iprot.readI32();
1870 
        else:
1871 
          iprot.skip(ftype)
1872 
      else:
1873 
        iprot.skip(ftype)
1874 
      iprot.readFieldEnd()
1875 
    iprot.readStructEnd()
1876 
 
1877 
  def write(self, oprot):
1878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1880 
      return
1881 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
1882 
    if self.customerId != None:
1883 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
1884 
      oprot.writeI64(self.customerId)
1885 
      oprot.writeFieldEnd()
1886 
    if self.from_date != None:
1887 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
1888 
      oprot.writeI64(self.from_date)
1889 
      oprot.writeFieldEnd()
1890 
    if self.to_date != None:
1891 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
1892 
      oprot.writeI64(self.to_date)
1893 
      oprot.writeFieldEnd()
1894 
    if self.status != None:
1895 
      oprot.writeFieldBegin('status', TType.I32, 4)
1896 
      oprot.writeI32(self.status)
1897 
      oprot.writeFieldEnd()
1898 
    oprot.writeFieldStop()
1899 
    oprot.writeStructEnd()
1900 
 
1901 
  def __repr__(self):
1902 
    L = ['%s=%r' % (key, value)
1903 
      for key, value in self.__dict__.iteritems()]
1904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1905 
 
1906 
  def __eq__(self, other):
1907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1908 
 
1909 
  def __ne__(self, other):
1910 
    return not (self == other)
1911 
 
1912 
class getTransactionsForCustomer_result:
1913 
  """
1914 
  Attributes:
1915 
   - success
1916 
   - ex
1917 
  """
1918 
 
1919 
  thrift_spec = (
1920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
1921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1922 
  )
1923 
 
1924 
  def __init__(self, success=None, ex=None,):
1925 
    self.success = success
1926 
    self.ex = ex
1927 
 
1928 
  def read(self, iprot):
1929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1931 
      return
1932 
    iprot.readStructBegin()
1933 
    while True:
1934 
      (fname, ftype, fid) = iprot.readFieldBegin()
1935 
      if ftype == TType.STOP:
1936 
        break
1937 
      if fid == 0:
1938 
        if ftype == TType.LIST:
1939 
          self.success = []
685 chandransh 1940 
          (_etype17, _size14) = iprot.readListBegin()
1941 
          for _i18 in xrange(_size14):
1942 
            _elem19 = Transaction()
1943 
            _elem19.read(iprot)
1944 
            self.success.append(_elem19)
94 ashish 1945 
          iprot.readListEnd()
1946 
        else:
1947 
          iprot.skip(ftype)
1948 
      elif fid == 1:
1949 
        if ftype == TType.STRUCT:
1950 
          self.ex = TransactionServiceException()
1951 
          self.ex.read(iprot)
1952 
        else:
1953 
          iprot.skip(ftype)
1954 
      else:
1955 
        iprot.skip(ftype)
1956 
      iprot.readFieldEnd()
1957 
    iprot.readStructEnd()
1958 
 
1959 
  def write(self, oprot):
1960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1962 
      return
1963 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
1964 
    if self.success != None:
1965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
1966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 1967 
      for iter20 in self.success:
1968 
        iter20.write(oprot)
94 ashish 1969 
      oprot.writeListEnd()
1970 
      oprot.writeFieldEnd()
1971 
    if self.ex != None:
1972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1973 
      self.ex.write(oprot)
1974 
      oprot.writeFieldEnd()
1975 
    oprot.writeFieldStop()
1976 
    oprot.writeStructEnd()
1977 
 
1978 
  def __repr__(self):
1979 
    L = ['%s=%r' % (key, value)
1980 
      for key, value in self.__dict__.iteritems()]
1981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1982 
 
1983 
  def __eq__(self, other):
1984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1985 
 
1986 
  def __ne__(self, other):
1987 
    return not (self == other)
1988 
 
132 ashish 1989 
class getTransactionsForShoppingCartId_args:
1990 
  """
1991 
  Attributes:
1992 
   - shoppingCartId
1993 
  """
1994 
 
1995 
  thrift_spec = (
1996 
    None, # 0
1997 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
1998 
  )
1999 
 
2000 
  def __init__(self, shoppingCartId=None,):
2001 
    self.shoppingCartId = shoppingCartId
2002 
 
2003 
  def read(self, iprot):
2004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2006 
      return
2007 
    iprot.readStructBegin()
2008 
    while True:
2009 
      (fname, ftype, fid) = iprot.readFieldBegin()
2010 
      if ftype == TType.STOP:
2011 
        break
2012 
      if fid == 1:
2013 
        if ftype == TType.I64:
2014 
          self.shoppingCartId = iprot.readI64();
2015 
        else:
2016 
          iprot.skip(ftype)
2017 
      else:
2018 
        iprot.skip(ftype)
2019 
      iprot.readFieldEnd()
2020 
    iprot.readStructEnd()
2021 
 
2022 
  def write(self, oprot):
2023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2025 
      return
2026 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
2027 
    if self.shoppingCartId != None:
2028 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
2029 
      oprot.writeI64(self.shoppingCartId)
2030 
      oprot.writeFieldEnd()
2031 
    oprot.writeFieldStop()
2032 
    oprot.writeStructEnd()
2033 
 
2034 
  def __repr__(self):
2035 
    L = ['%s=%r' % (key, value)
2036 
      for key, value in self.__dict__.iteritems()]
2037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2038 
 
2039 
  def __eq__(self, other):
2040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2041 
 
2042 
  def __ne__(self, other):
2043 
    return not (self == other)
2044 
 
2045 
class getTransactionsForShoppingCartId_result:
2046 
  """
2047 
  Attributes:
2048 
   - success
2049 
   - ex
2050 
  """
2051 
 
2052 
  thrift_spec = (
2053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
2054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2055 
  )
2056 
 
2057 
  def __init__(self, success=None, ex=None,):
2058 
    self.success = success
2059 
    self.ex = ex
2060 
 
2061 
  def read(self, iprot):
2062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2064 
      return
2065 
    iprot.readStructBegin()
2066 
    while True:
2067 
      (fname, ftype, fid) = iprot.readFieldBegin()
2068 
      if ftype == TType.STOP:
2069 
        break
2070 
      if fid == 0:
2071 
        if ftype == TType.LIST:
2072 
          self.success = []
685 chandransh 2073 
          (_etype24, _size21) = iprot.readListBegin()
2074 
          for _i25 in xrange(_size21):
2075 
            _elem26 = Transaction()
2076 
            _elem26.read(iprot)
2077 
            self.success.append(_elem26)
132 ashish 2078 
          iprot.readListEnd()
2079 
        else:
2080 
          iprot.skip(ftype)
2081 
      elif fid == 1:
2082 
        if ftype == TType.STRUCT:
2083 
          self.ex = TransactionServiceException()
2084 
          self.ex.read(iprot)
2085 
        else:
2086 
          iprot.skip(ftype)
2087 
      else:
2088 
        iprot.skip(ftype)
2089 
      iprot.readFieldEnd()
2090 
    iprot.readStructEnd()
2091 
 
2092 
  def write(self, oprot):
2093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2095 
      return
2096 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
2097 
    if self.success != None:
2098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 2100 
      for iter27 in self.success:
2101 
        iter27.write(oprot)
132 ashish 2102 
      oprot.writeListEnd()
2103 
      oprot.writeFieldEnd()
2104 
    if self.ex != None:
2105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2106 
      self.ex.write(oprot)
2107 
      oprot.writeFieldEnd()
2108 
    oprot.writeFieldStop()
2109 
    oprot.writeStructEnd()
2110 
 
2111 
  def __repr__(self):
2112 
    L = ['%s=%r' % (key, value)
2113 
      for key, value in self.__dict__.iteritems()]
2114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2115 
 
2116 
  def __eq__(self, other):
2117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2118 
 
2119 
  def __ne__(self, other):
2120 
    return not (self == other)
2121 
 
94 ashish 2122 
class getTransactionStatus_args:
2123 
  """
2124 
  Attributes:
2125 
   - transactionId
2126 
  """
2127 
 
2128 
  thrift_spec = (
2129 
    None, # 0
2130 
    (1, TType.I64, 'transactionId', None, None, ), # 1
2131 
  )
2132 
 
2133 
  def __init__(self, transactionId=None,):
2134 
    self.transactionId = transactionId
2135 
 
2136 
  def read(self, iprot):
2137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2139 
      return
2140 
    iprot.readStructBegin()
2141 
    while True:
2142 
      (fname, ftype, fid) = iprot.readFieldBegin()
2143 
      if ftype == TType.STOP:
2144 
        break
2145 
      if fid == 1:
2146 
        if ftype == TType.I64:
2147 
          self.transactionId = iprot.readI64();
2148 
        else:
2149 
          iprot.skip(ftype)
2150 
      else:
2151 
        iprot.skip(ftype)
2152 
      iprot.readFieldEnd()
2153 
    iprot.readStructEnd()
2154 
 
2155 
  def write(self, oprot):
2156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2158 
      return
2159 
    oprot.writeStructBegin('getTransactionStatus_args')
2160 
    if self.transactionId != None:
2161 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
2162 
      oprot.writeI64(self.transactionId)
2163 
      oprot.writeFieldEnd()
2164 
    oprot.writeFieldStop()
2165 
    oprot.writeStructEnd()
2166 
 
2167 
  def __repr__(self):
2168 
    L = ['%s=%r' % (key, value)
2169 
      for key, value in self.__dict__.iteritems()]
2170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2171 
 
2172 
  def __eq__(self, other):
2173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2174 
 
2175 
  def __ne__(self, other):
2176 
    return not (self == other)
2177 
 
2178 
class getTransactionStatus_result:
2179 
  """
2180 
  Attributes:
2181 
   - success
2182 
   - ex
2183 
  """
2184 
 
2185 
  thrift_spec = (
2186 
    (0, TType.I32, 'success', None, None, ), # 0
2187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2188 
  )
2189 
 
2190 
  def __init__(self, success=None, ex=None,):
2191 
    self.success = success
2192 
    self.ex = ex
2193 
 
2194 
  def read(self, iprot):
2195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2197 
      return
2198 
    iprot.readStructBegin()
2199 
    while True:
2200 
      (fname, ftype, fid) = iprot.readFieldBegin()
2201 
      if ftype == TType.STOP:
2202 
        break
2203 
      if fid == 0:
2204 
        if ftype == TType.I32:
2205 
          self.success = iprot.readI32();
2206 
        else:
2207 
          iprot.skip(ftype)
2208 
      elif fid == 1:
2209 
        if ftype == TType.STRUCT:
2210 
          self.ex = TransactionServiceException()
2211 
          self.ex.read(iprot)
2212 
        else:
2213 
          iprot.skip(ftype)
2214 
      else:
2215 
        iprot.skip(ftype)
2216 
      iprot.readFieldEnd()
2217 
    iprot.readStructEnd()
2218 
 
2219 
  def write(self, oprot):
2220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2222 
      return
2223 
    oprot.writeStructBegin('getTransactionStatus_result')
2224 
    if self.success != None:
2225 
      oprot.writeFieldBegin('success', TType.I32, 0)
2226 
      oprot.writeI32(self.success)
2227 
      oprot.writeFieldEnd()
2228 
    if self.ex != None:
2229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2230 
      self.ex.write(oprot)
2231 
      oprot.writeFieldEnd()
2232 
    oprot.writeFieldStop()
2233 
    oprot.writeStructEnd()
2234 
 
2235 
  def __repr__(self):
2236 
    L = ['%s=%r' % (key, value)
2237 
      for key, value in self.__dict__.iteritems()]
2238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2239 
 
2240 
  def __eq__(self, other):
2241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2242 
 
2243 
  def __ne__(self, other):
2244 
    return not (self == other)
2245 
 
2246 
class changeTransactionStatus_args:
2247 
  """
2248 
  Attributes:
2249 
   - transactionId
2250 
   - status
2251 
   - description
2252 
  """
2253 
 
2254 
  thrift_spec = (
2255 
    None, # 0
2256 
    (1, TType.I64, 'transactionId', None, None, ), # 1
2257 
    (2, TType.I32, 'status', None, None, ), # 2
2258 
    (3, TType.STRING, 'description', None, None, ), # 3
2259 
  )
2260 
 
2261 
  def __init__(self, transactionId=None, status=None, description=None,):
2262 
    self.transactionId = transactionId
2263 
    self.status = status
2264 
    self.description = description
2265 
 
2266 
  def read(self, iprot):
2267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2269 
      return
2270 
    iprot.readStructBegin()
2271 
    while True:
2272 
      (fname, ftype, fid) = iprot.readFieldBegin()
2273 
      if ftype == TType.STOP:
2274 
        break
2275 
      if fid == 1:
2276 
        if ftype == TType.I64:
2277 
          self.transactionId = iprot.readI64();
2278 
        else:
2279 
          iprot.skip(ftype)
2280 
      elif fid == 2:
2281 
        if ftype == TType.I32:
2282 
          self.status = iprot.readI32();
2283 
        else:
2284 
          iprot.skip(ftype)
2285 
      elif fid == 3:
2286 
        if ftype == TType.STRING:
2287 
          self.description = iprot.readString();
2288 
        else:
2289 
          iprot.skip(ftype)
2290 
      else:
2291 
        iprot.skip(ftype)
2292 
      iprot.readFieldEnd()
2293 
    iprot.readStructEnd()
2294 
 
2295 
  def write(self, oprot):
2296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2298 
      return
2299 
    oprot.writeStructBegin('changeTransactionStatus_args')
2300 
    if self.transactionId != None:
2301 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
2302 
      oprot.writeI64(self.transactionId)
2303 
      oprot.writeFieldEnd()
2304 
    if self.status != None:
2305 
      oprot.writeFieldBegin('status', TType.I32, 2)
2306 
      oprot.writeI32(self.status)
2307 
      oprot.writeFieldEnd()
2308 
    if self.description != None:
2309 
      oprot.writeFieldBegin('description', TType.STRING, 3)
2310 
      oprot.writeString(self.description)
2311 
      oprot.writeFieldEnd()
2312 
    oprot.writeFieldStop()
2313 
    oprot.writeStructEnd()
2314 
 
2315 
  def __repr__(self):
2316 
    L = ['%s=%r' % (key, value)
2317 
      for key, value in self.__dict__.iteritems()]
2318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2319 
 
2320 
  def __eq__(self, other):
2321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2322 
 
2323 
  def __ne__(self, other):
2324 
    return not (self == other)
2325 
 
2326 
class changeTransactionStatus_result:
2327 
  """
2328 
  Attributes:
2329 
   - success
2330 
   - ex
2331 
  """
2332 
 
2333 
  thrift_spec = (
2334 
    (0, TType.BOOL, 'success', None, None, ), # 0
2335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2336 
  )
2337 
 
2338 
  def __init__(self, success=None, ex=None,):
2339 
    self.success = success
2340 
    self.ex = ex
2341 
 
2342 
  def read(self, iprot):
2343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2345 
      return
2346 
    iprot.readStructBegin()
2347 
    while True:
2348 
      (fname, ftype, fid) = iprot.readFieldBegin()
2349 
      if ftype == TType.STOP:
2350 
        break
2351 
      if fid == 0:
2352 
        if ftype == TType.BOOL:
2353 
          self.success = iprot.readBool();
2354 
        else:
2355 
          iprot.skip(ftype)
2356 
      elif fid == 1:
2357 
        if ftype == TType.STRUCT:
2358 
          self.ex = TransactionServiceException()
2359 
          self.ex.read(iprot)
2360 
        else:
2361 
          iprot.skip(ftype)
2362 
      else:
2363 
        iprot.skip(ftype)
2364 
      iprot.readFieldEnd()
2365 
    iprot.readStructEnd()
2366 
 
2367 
  def write(self, oprot):
2368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2370 
      return
2371 
    oprot.writeStructBegin('changeTransactionStatus_result')
2372 
    if self.success != None:
2373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2374 
      oprot.writeBool(self.success)
2375 
      oprot.writeFieldEnd()
2376 
    if self.ex != None:
2377 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2378 
      self.ex.write(oprot)
2379 
      oprot.writeFieldEnd()
2380 
    oprot.writeFieldStop()
2381 
    oprot.writeStructEnd()
2382 
 
2383 
  def __repr__(self):
2384 
    L = ['%s=%r' % (key, value)
2385 
      for key, value in self.__dict__.iteritems()]
2386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2387 
 
2388 
  def __eq__(self, other):
2389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2390 
 
2391 
  def __ne__(self, other):
2392 
    return not (self == other)
2393 
 
483 rajveer 2394 
class getAllOrders_args:
94 ashish 2395 
  """
2396 
  Attributes:
483 rajveer 2397 
   - status
2398 
   - from_date
2399 
   - to_date
2400 
   - warehouse_id
94 ashish 2401 
  """
2402 
 
2403 
  thrift_spec = (
2404 
    None, # 0
483 rajveer 2405 
    (1, TType.I32, 'status', None, None, ), # 1
2406 
    (2, TType.I64, 'from_date', None, None, ), # 2
2407 
    (3, TType.I64, 'to_date', None, None, ), # 3
2408 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 2409 
  )
2410 
 
483 rajveer 2411 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
2412 
    self.status = status
2413 
    self.from_date = from_date
2414 
    self.to_date = to_date
2415 
    self.warehouse_id = warehouse_id
94 ashish 2416 
 
2417 
  def read(self, iprot):
2418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2420 
      return
2421 
    iprot.readStructBegin()
2422 
    while True:
2423 
      (fname, ftype, fid) = iprot.readFieldBegin()
2424 
      if ftype == TType.STOP:
2425 
        break
2426 
      if fid == 1:
483 rajveer 2427 
        if ftype == TType.I32:
2428 
          self.status = iprot.readI32();
94 ashish 2429 
        else:
2430 
          iprot.skip(ftype)
483 rajveer 2431 
      elif fid == 2:
2432 
        if ftype == TType.I64:
2433 
          self.from_date = iprot.readI64();
94 ashish 2434 
        else:
2435 
          iprot.skip(ftype)
483 rajveer 2436 
      elif fid == 3:
2437 
        if ftype == TType.I64:
2438 
          self.to_date = iprot.readI64();
94 ashish 2439 
        else:
2440 
          iprot.skip(ftype)
483 rajveer 2441 
      elif fid == 4:
94 ashish 2442 
        if ftype == TType.I64:
483 rajveer 2443 
          self.warehouse_id = iprot.readI64();
94 ashish 2444 
        else:
2445 
          iprot.skip(ftype)
2446 
      else:
2447 
        iprot.skip(ftype)
2448 
      iprot.readFieldEnd()
2449 
    iprot.readStructEnd()
2450 
 
2451 
  def write(self, oprot):
2452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2454 
      return
483 rajveer 2455 
    oprot.writeStructBegin('getAllOrders_args')
2456 
    if self.status != None:
2457 
      oprot.writeFieldBegin('status', TType.I32, 1)
2458 
      oprot.writeI32(self.status)
94 ashish 2459 
      oprot.writeFieldEnd()
483 rajveer 2460 
    if self.from_date != None:
2461 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
2462 
      oprot.writeI64(self.from_date)
94 ashish 2463 
      oprot.writeFieldEnd()
483 rajveer 2464 
    if self.to_date != None:
2465 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
2466 
      oprot.writeI64(self.to_date)
94 ashish 2467 
      oprot.writeFieldEnd()
483 rajveer 2468 
    if self.warehouse_id != None:
2469 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
2470 
      oprot.writeI64(self.warehouse_id)
94 ashish 2471 
      oprot.writeFieldEnd()
2472 
    oprot.writeFieldStop()
2473 
    oprot.writeStructEnd()
2474 
 
2475 
  def __repr__(self):
2476 
    L = ['%s=%r' % (key, value)
2477 
      for key, value in self.__dict__.iteritems()]
2478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2479 
 
2480 
  def __eq__(self, other):
2481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2482 
 
2483 
  def __ne__(self, other):
2484 
    return not (self == other)
2485 
 
483 rajveer 2486 
class getAllOrders_result:
94 ashish 2487 
  """
2488 
  Attributes:
2489 
   - success
2490 
   - ex
2491 
  """
2492 
 
2493 
  thrift_spec = (
483 rajveer 2494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 2495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2496 
  )
2497 
 
2498 
  def __init__(self, success=None, ex=None,):
2499 
    self.success = success
2500 
    self.ex = ex
2501 
 
2502 
  def read(self, iprot):
2503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2505 
      return
2506 
    iprot.readStructBegin()
2507 
    while True:
2508 
      (fname, ftype, fid) = iprot.readFieldBegin()
2509 
      if ftype == TType.STOP:
2510 
        break
2511 
      if fid == 0:
483 rajveer 2512 
        if ftype == TType.LIST:
2513 
          self.success = []
685 chandransh 2514 
          (_etype31, _size28) = iprot.readListBegin()
2515 
          for _i32 in xrange(_size28):
2516 
            _elem33 = Order()
2517 
            _elem33.read(iprot)
2518 
            self.success.append(_elem33)
483 rajveer 2519 
          iprot.readListEnd()
94 ashish 2520 
        else:
2521 
          iprot.skip(ftype)
2522 
      elif fid == 1:
2523 
        if ftype == TType.STRUCT:
2524 
          self.ex = TransactionServiceException()
2525 
          self.ex.read(iprot)
2526 
        else:
2527 
          iprot.skip(ftype)
2528 
      else:
2529 
        iprot.skip(ftype)
2530 
      iprot.readFieldEnd()
2531 
    iprot.readStructEnd()
2532 
 
2533 
  def write(self, oprot):
2534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2536 
      return
483 rajveer 2537 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 2538 
    if self.success != None:
483 rajveer 2539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2540 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 2541 
      for iter34 in self.success:
2542 
        iter34.write(oprot)
483 rajveer 2543 
      oprot.writeListEnd()
94 ashish 2544 
      oprot.writeFieldEnd()
2545 
    if self.ex != None:
2546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2547 
      self.ex.write(oprot)
2548 
      oprot.writeFieldEnd()
2549 
    oprot.writeFieldStop()
2550 
    oprot.writeStructEnd()
2551 
 
2552 
  def __repr__(self):
2553 
    L = ['%s=%r' % (key, value)
2554 
      for key, value in self.__dict__.iteritems()]
2555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2556 
 
2557 
  def __eq__(self, other):
2558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2559 
 
2560 
  def __ne__(self, other):
2561 
    return not (self == other)
2562 
 
999 varun.gupt 2563 
class getOrdersByBillingDate_args:
2564 
  """
2565 
  Attributes:
2566 
   - status
2567 
   - start_billing_date
2568 
   - end_billing_date
2569 
   - warehouse_id
2570 
  """
2571 
 
2572 
  thrift_spec = (
2573 
    None, # 0
2574 
    (1, TType.I32, 'status', None, None, ), # 1
2575 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
2576 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
2577 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
2578 
  )
2579 
 
2580 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
2581 
    self.status = status
2582 
    self.start_billing_date = start_billing_date
2583 
    self.end_billing_date = end_billing_date
2584 
    self.warehouse_id = warehouse_id
2585 
 
2586 
  def read(self, iprot):
2587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2589 
      return
2590 
    iprot.readStructBegin()
2591 
    while True:
2592 
      (fname, ftype, fid) = iprot.readFieldBegin()
2593 
      if ftype == TType.STOP:
2594 
        break
2595 
      if fid == 1:
2596 
        if ftype == TType.I32:
2597 
          self.status = iprot.readI32();
2598 
        else:
2599 
          iprot.skip(ftype)
2600 
      elif fid == 2:
2601 
        if ftype == TType.I64:
2602 
          self.start_billing_date = iprot.readI64();
2603 
        else:
2604 
          iprot.skip(ftype)
2605 
      elif fid == 3:
2606 
        if ftype == TType.I64:
2607 
          self.end_billing_date = iprot.readI64();
2608 
        else:
2609 
          iprot.skip(ftype)
2610 
      elif fid == 4:
2611 
        if ftype == TType.I64:
2612 
          self.warehouse_id = iprot.readI64();
2613 
        else:
2614 
          iprot.skip(ftype)
2615 
      else:
2616 
        iprot.skip(ftype)
2617 
      iprot.readFieldEnd()
2618 
    iprot.readStructEnd()
2619 
 
2620 
  def write(self, oprot):
2621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2623 
      return
2624 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
2625 
    if self.status != None:
2626 
      oprot.writeFieldBegin('status', TType.I32, 1)
2627 
      oprot.writeI32(self.status)
2628 
      oprot.writeFieldEnd()
2629 
    if self.start_billing_date != None:
2630 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
2631 
      oprot.writeI64(self.start_billing_date)
2632 
      oprot.writeFieldEnd()
2633 
    if self.end_billing_date != None:
2634 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
2635 
      oprot.writeI64(self.end_billing_date)
2636 
      oprot.writeFieldEnd()
2637 
    if self.warehouse_id != None:
2638 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
2639 
      oprot.writeI64(self.warehouse_id)
2640 
      oprot.writeFieldEnd()
2641 
    oprot.writeFieldStop()
2642 
    oprot.writeStructEnd()
2643 
 
2644 
  def __repr__(self):
2645 
    L = ['%s=%r' % (key, value)
2646 
      for key, value in self.__dict__.iteritems()]
2647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2648 
 
2649 
  def __eq__(self, other):
2650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2651 
 
2652 
  def __ne__(self, other):
2653 
    return not (self == other)
2654 
 
2655 
class getOrdersByBillingDate_result:
2656 
  """
2657 
  Attributes:
2658 
   - success
2659 
   - ex
2660 
  """
2661 
 
2662 
  thrift_spec = (
2663 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
2664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2665 
  )
2666 
 
2667 
  def __init__(self, success=None, ex=None,):
2668 
    self.success = success
2669 
    self.ex = ex
2670 
 
2671 
  def read(self, iprot):
2672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2674 
      return
2675 
    iprot.readStructBegin()
2676 
    while True:
2677 
      (fname, ftype, fid) = iprot.readFieldBegin()
2678 
      if ftype == TType.STOP:
2679 
        break
2680 
      if fid == 0:
2681 
        if ftype == TType.LIST:
2682 
          self.success = []
2683 
          (_etype38, _size35) = iprot.readListBegin()
2684 
          for _i39 in xrange(_size35):
2685 
            _elem40 = Order()
2686 
            _elem40.read(iprot)
2687 
            self.success.append(_elem40)
2688 
          iprot.readListEnd()
2689 
        else:
2690 
          iprot.skip(ftype)
2691 
      elif fid == 1:
2692 
        if ftype == TType.STRUCT:
2693 
          self.ex = TransactionServiceException()
2694 
          self.ex.read(iprot)
2695 
        else:
2696 
          iprot.skip(ftype)
2697 
      else:
2698 
        iprot.skip(ftype)
2699 
      iprot.readFieldEnd()
2700 
    iprot.readStructEnd()
2701 
 
2702 
  def write(self, oprot):
2703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2705 
      return
2706 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
2707 
    if self.success != None:
2708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2709 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2710 
      for iter41 in self.success:
2711 
        iter41.write(oprot)
2712 
      oprot.writeListEnd()
2713 
      oprot.writeFieldEnd()
2714 
    if self.ex != None:
2715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2716 
      self.ex.write(oprot)
2717 
      oprot.writeFieldEnd()
2718 
    oprot.writeFieldStop()
2719 
    oprot.writeStructEnd()
2720 
 
2721 
  def __repr__(self):
2722 
    L = ['%s=%r' % (key, value)
2723 
      for key, value in self.__dict__.iteritems()]
2724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2725 
 
2726 
  def __eq__(self, other):
2727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2728 
 
2729 
  def __ne__(self, other):
2730 
    return not (self == other)
2731 
 
483 rajveer 2732 
class changeOrderStatus_args:
94 ashish 2733 
  """
2734 
  Attributes:
483 rajveer 2735 
   - orderId
2736 
   - status
2737 
   - description
94 ashish 2738 
  """
2739 
 
2740 
  thrift_spec = (
2741 
    None, # 0
483 rajveer 2742 
    (1, TType.I64, 'orderId', None, None, ), # 1
2743 
    (2, TType.I32, 'status', None, None, ), # 2
2744 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 2745 
  )
2746 
 
483 rajveer 2747 
  def __init__(self, orderId=None, status=None, description=None,):
2748 
    self.orderId = orderId
2749 
    self.status = status
2750 
    self.description = description
94 ashish 2751 
 
2752 
  def read(self, iprot):
2753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2755 
      return
2756 
    iprot.readStructBegin()
2757 
    while True:
2758 
      (fname, ftype, fid) = iprot.readFieldBegin()
2759 
      if ftype == TType.STOP:
2760 
        break
2761 
      if fid == 1:
2762 
        if ftype == TType.I64:
483 rajveer 2763 
          self.orderId = iprot.readI64();
94 ashish 2764 
        else:
2765 
          iprot.skip(ftype)
2766 
      elif fid == 2:
483 rajveer 2767 
        if ftype == TType.I32:
2768 
          self.status = iprot.readI32();
94 ashish 2769 
        else:
2770 
          iprot.skip(ftype)
483 rajveer 2771 
      elif fid == 3:
2772 
        if ftype == TType.STRING:
2773 
          self.description = iprot.readString();
2774 
        else:
2775 
          iprot.skip(ftype)
94 ashish 2776 
      else:
2777 
        iprot.skip(ftype)
2778 
      iprot.readFieldEnd()
2779 
    iprot.readStructEnd()
2780 
 
2781 
  def write(self, oprot):
2782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2784 
      return
483 rajveer 2785 
    oprot.writeStructBegin('changeOrderStatus_args')
2786 
    if self.orderId != None:
2787 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2788 
      oprot.writeI64(self.orderId)
94 ashish 2789 
      oprot.writeFieldEnd()
483 rajveer 2790 
    if self.status != None:
2791 
      oprot.writeFieldBegin('status', TType.I32, 2)
2792 
      oprot.writeI32(self.status)
94 ashish 2793 
      oprot.writeFieldEnd()
483 rajveer 2794 
    if self.description != None:
2795 
      oprot.writeFieldBegin('description', TType.STRING, 3)
2796 
      oprot.writeString(self.description)
2797 
      oprot.writeFieldEnd()
94 ashish 2798 
    oprot.writeFieldStop()
2799 
    oprot.writeStructEnd()
2800 
 
2801 
  def __repr__(self):
2802 
    L = ['%s=%r' % (key, value)
2803 
      for key, value in self.__dict__.iteritems()]
2804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2805 
 
2806 
  def __eq__(self, other):
2807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2808 
 
2809 
  def __ne__(self, other):
2810 
    return not (self == other)
2811 
 
483 rajveer 2812 
class changeOrderStatus_result:
94 ashish 2813 
  """
2814 
  Attributes:
2815 
   - success
2816 
   - ex
2817 
  """
2818 
 
2819 
  thrift_spec = (
2820 
    (0, TType.BOOL, 'success', None, None, ), # 0
2821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2822 
  )
2823 
 
2824 
  def __init__(self, success=None, ex=None,):
2825 
    self.success = success
2826 
    self.ex = ex
2827 
 
2828 
  def read(self, iprot):
2829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2831 
      return
2832 
    iprot.readStructBegin()
2833 
    while True:
2834 
      (fname, ftype, fid) = iprot.readFieldBegin()
2835 
      if ftype == TType.STOP:
2836 
        break
2837 
      if fid == 0:
2838 
        if ftype == TType.BOOL:
2839 
          self.success = iprot.readBool();
2840 
        else:
2841 
          iprot.skip(ftype)
2842 
      elif fid == 1:
2843 
        if ftype == TType.STRUCT:
2844 
          self.ex = TransactionServiceException()
2845 
          self.ex.read(iprot)
2846 
        else:
2847 
          iprot.skip(ftype)
2848 
      else:
2849 
        iprot.skip(ftype)
2850 
      iprot.readFieldEnd()
2851 
    iprot.readStructEnd()
2852 
 
2853 
  def write(self, oprot):
2854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2856 
      return
483 rajveer 2857 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 2858 
    if self.success != None:
2859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2860 
      oprot.writeBool(self.success)
2861 
      oprot.writeFieldEnd()
2862 
    if self.ex != None:
2863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2864 
      self.ex.write(oprot)
2865 
      oprot.writeFieldEnd()
2866 
    oprot.writeFieldStop()
2867 
    oprot.writeStructEnd()
2868 
 
2869 
  def __repr__(self):
2870 
    L = ['%s=%r' % (key, value)
2871 
      for key, value in self.__dict__.iteritems()]
2872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2873 
 
2874 
  def __eq__(self, other):
2875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2876 
 
2877 
  def __ne__(self, other):
2878 
    return not (self == other)
2879 
 
494 rajveer 2880 
class addBillingDetails_args:
2881 
  """
2882 
  Attributes:
2883 
   - orderId
2884 
   - invoice_number
2885 
   - billed_by
2886 
  """
2887 
 
2888 
  thrift_spec = (
2889 
    None, # 0
2890 
    (1, TType.I64, 'orderId', None, None, ), # 1
2891 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
1149 chandransh 2892 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
494 rajveer 2893 
  )
2894 
 
1149 chandransh 2895 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
494 rajveer 2896 
    self.orderId = orderId
2897 
    self.invoice_number = invoice_number
2898 
    self.billed_by = billed_by
2899 
 
2900 
  def read(self, iprot):
2901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2903 
      return
2904 
    iprot.readStructBegin()
2905 
    while True:
2906 
      (fname, ftype, fid) = iprot.readFieldBegin()
2907 
      if ftype == TType.STOP:
2908 
        break
2909 
      if fid == 1:
2910 
        if ftype == TType.I64:
2911 
          self.orderId = iprot.readI64();
2912 
        else:
2913 
          iprot.skip(ftype)
2914 
      elif fid == 2:
2915 
        if ftype == TType.STRING:
2916 
          self.invoice_number = iprot.readString();
2917 
        else:
2918 
          iprot.skip(ftype)
2919 
      elif fid == 3:
2920 
        if ftype == TType.STRING:
2921 
          self.billed_by = iprot.readString();
2922 
        else:
2923 
          iprot.skip(ftype)
2924 
      else:
2925 
        iprot.skip(ftype)
2926 
      iprot.readFieldEnd()
2927 
    iprot.readStructEnd()
2928 
 
2929 
  def write(self, oprot):
2930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2932 
      return
2933 
    oprot.writeStructBegin('addBillingDetails_args')
2934 
    if self.orderId != None:
2935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2936 
      oprot.writeI64(self.orderId)
2937 
      oprot.writeFieldEnd()
2938 
    if self.invoice_number != None:
2939 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
2940 
      oprot.writeString(self.invoice_number)
2941 
      oprot.writeFieldEnd()
2942 
    if self.billed_by != None:
1149 chandransh 2943 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
494 rajveer 2944 
      oprot.writeString(self.billed_by)
2945 
      oprot.writeFieldEnd()
2946 
    oprot.writeFieldStop()
2947 
    oprot.writeStructEnd()
2948 
 
2949 
  def __repr__(self):
2950 
    L = ['%s=%r' % (key, value)
2951 
      for key, value in self.__dict__.iteritems()]
2952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2953 
 
2954 
  def __eq__(self, other):
2955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2956 
 
2957 
  def __ne__(self, other):
2958 
    return not (self == other)
2959 
 
2960 
class addBillingDetails_result:
2961 
  """
2962 
  Attributes:
2963 
   - success
2964 
   - ex
2965 
  """
2966 
 
2967 
  thrift_spec = (
2968 
    (0, TType.BOOL, 'success', None, None, ), # 0
2969 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2970 
  )
2971 
 
2972 
  def __init__(self, success=None, ex=None,):
2973 
    self.success = success
2974 
    self.ex = ex
2975 
 
2976 
  def read(self, iprot):
2977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2979 
      return
2980 
    iprot.readStructBegin()
2981 
    while True:
2982 
      (fname, ftype, fid) = iprot.readFieldBegin()
2983 
      if ftype == TType.STOP:
2984 
        break
2985 
      if fid == 0:
2986 
        if ftype == TType.BOOL:
2987 
          self.success = iprot.readBool();
2988 
        else:
2989 
          iprot.skip(ftype)
2990 
      elif fid == 1:
2991 
        if ftype == TType.STRUCT:
2992 
          self.ex = TransactionServiceException()
2993 
          self.ex.read(iprot)
2994 
        else:
2995 
          iprot.skip(ftype)
2996 
      else:
2997 
        iprot.skip(ftype)
2998 
      iprot.readFieldEnd()
2999 
    iprot.readStructEnd()
3000 
 
3001 
  def write(self, oprot):
3002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3004 
      return
3005 
    oprot.writeStructBegin('addBillingDetails_result')
3006 
    if self.success != None:
3007 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3008 
      oprot.writeBool(self.success)
3009 
      oprot.writeFieldEnd()
3010 
    if self.ex != None:
3011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3012 
      self.ex.write(oprot)
3013 
      oprot.writeFieldEnd()
3014 
    oprot.writeFieldStop()
3015 
    oprot.writeStructEnd()
3016 
 
3017 
  def __repr__(self):
3018 
    L = ['%s=%r' % (key, value)
3019 
      for key, value in self.__dict__.iteritems()]
3020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3021 
 
3022 
  def __eq__(self, other):
3023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3024 
 
3025 
  def __ne__(self, other):
3026 
    return not (self == other)
3027 
 
1149 chandransh 3028 
class addJacketNumber_args:
3029 
  """
3030 
  Attributes:
3031 
   - orderId
3032 
   - jacketNumber
3033 
  """
3034 
 
3035 
  thrift_spec = (
3036 
    None, # 0
3037 
    (1, TType.I64, 'orderId', None, None, ), # 1
3038 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
3039 
  )
3040 
 
3041 
  def __init__(self, orderId=None, jacketNumber=None,):
3042 
    self.orderId = orderId
3043 
    self.jacketNumber = jacketNumber
3044 
 
3045 
  def read(self, iprot):
3046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3048 
      return
3049 
    iprot.readStructBegin()
3050 
    while True:
3051 
      (fname, ftype, fid) = iprot.readFieldBegin()
3052 
      if ftype == TType.STOP:
3053 
        break
3054 
      if fid == 1:
3055 
        if ftype == TType.I64:
3056 
          self.orderId = iprot.readI64();
3057 
        else:
3058 
          iprot.skip(ftype)
3059 
      elif fid == 2:
3060 
        if ftype == TType.I64:
3061 
          self.jacketNumber = iprot.readI64();
3062 
        else:
3063 
          iprot.skip(ftype)
3064 
      else:
3065 
        iprot.skip(ftype)
3066 
      iprot.readFieldEnd()
3067 
    iprot.readStructEnd()
3068 
 
3069 
  def write(self, oprot):
3070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3072 
      return
3073 
    oprot.writeStructBegin('addJacketNumber_args')
3074 
    if self.orderId != None:
3075 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3076 
      oprot.writeI64(self.orderId)
3077 
      oprot.writeFieldEnd()
3078 
    if self.jacketNumber != None:
3079 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
3080 
      oprot.writeI64(self.jacketNumber)
3081 
      oprot.writeFieldEnd()
3082 
    oprot.writeFieldStop()
3083 
    oprot.writeStructEnd()
3084 
 
3085 
  def __repr__(self):
3086 
    L = ['%s=%r' % (key, value)
3087 
      for key, value in self.__dict__.iteritems()]
3088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3089 
 
3090 
  def __eq__(self, other):
3091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3092 
 
3093 
  def __ne__(self, other):
3094 
    return not (self == other)
3095 
 
3096 
class addJacketNumber_result:
3097 
  """
3098 
  Attributes:
3099 
   - success
3100 
   - ex
3101 
  """
3102 
 
3103 
  thrift_spec = (
3104 
    (0, TType.BOOL, 'success', None, None, ), # 0
3105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3106 
  )
3107 
 
3108 
  def __init__(self, success=None, ex=None,):
3109 
    self.success = success
3110 
    self.ex = ex
3111 
 
3112 
  def read(self, iprot):
3113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3115 
      return
3116 
    iprot.readStructBegin()
3117 
    while True:
3118 
      (fname, ftype, fid) = iprot.readFieldBegin()
3119 
      if ftype == TType.STOP:
3120 
        break
3121 
      if fid == 0:
3122 
        if ftype == TType.BOOL:
3123 
          self.success = iprot.readBool();
3124 
        else:
3125 
          iprot.skip(ftype)
3126 
      elif fid == 1:
3127 
        if ftype == TType.STRUCT:
3128 
          self.ex = TransactionServiceException()
3129 
          self.ex.read(iprot)
3130 
        else:
3131 
          iprot.skip(ftype)
3132 
      else:
3133 
        iprot.skip(ftype)
3134 
      iprot.readFieldEnd()
3135 
    iprot.readStructEnd()
3136 
 
3137 
  def write(self, oprot):
3138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3140 
      return
3141 
    oprot.writeStructBegin('addJacketNumber_result')
3142 
    if self.success != None:
3143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3144 
      oprot.writeBool(self.success)
3145 
      oprot.writeFieldEnd()
3146 
    if self.ex != None:
3147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3148 
      self.ex.write(oprot)
3149 
      oprot.writeFieldEnd()
3150 
    oprot.writeFieldStop()
3151 
    oprot.writeStructEnd()
3152 
 
3153 
  def __repr__(self):
3154 
    L = ['%s=%r' % (key, value)
3155 
      for key, value in self.__dict__.iteritems()]
3156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3157 
 
3158 
  def __eq__(self, other):
3159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3160 
 
3161 
  def __ne__(self, other):
3162 
    return not (self == other)
3163 
 
921 rajveer 3164 
class acceptOrder_args:
3165 
  """
3166 
  Attributes:
3167 
   - orderId
3168 
  """
3169 
 
3170 
  thrift_spec = (
3171 
    None, # 0
3172 
    (1, TType.I64, 'orderId', None, None, ), # 1
3173 
  )
3174 
 
3175 
  def __init__(self, orderId=None,):
3176 
    self.orderId = orderId
3177 
 
3178 
  def read(self, iprot):
3179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3181 
      return
3182 
    iprot.readStructBegin()
3183 
    while True:
3184 
      (fname, ftype, fid) = iprot.readFieldBegin()
3185 
      if ftype == TType.STOP:
3186 
        break
3187 
      if fid == 1:
3188 
        if ftype == TType.I64:
3189 
          self.orderId = iprot.readI64();
3190 
        else:
3191 
          iprot.skip(ftype)
3192 
      else:
3193 
        iprot.skip(ftype)
3194 
      iprot.readFieldEnd()
3195 
    iprot.readStructEnd()
3196 
 
3197 
  def write(self, oprot):
3198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3200 
      return
3201 
    oprot.writeStructBegin('acceptOrder_args')
3202 
    if self.orderId != None:
3203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3204 
      oprot.writeI64(self.orderId)
3205 
      oprot.writeFieldEnd()
3206 
    oprot.writeFieldStop()
3207 
    oprot.writeStructEnd()
3208 
 
3209 
  def __repr__(self):
3210 
    L = ['%s=%r' % (key, value)
3211 
      for key, value in self.__dict__.iteritems()]
3212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3213 
 
3214 
  def __eq__(self, other):
3215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3216 
 
3217 
  def __ne__(self, other):
3218 
    return not (self == other)
3219 
 
3220 
class acceptOrder_result:
3221 
  """
3222 
  Attributes:
3223 
   - success
3224 
   - ex
3225 
  """
3226 
 
3227 
  thrift_spec = (
3228 
    (0, TType.BOOL, 'success', None, None, ), # 0
3229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3230 
  )
3231 
 
3232 
  def __init__(self, success=None, ex=None,):
3233 
    self.success = success
3234 
    self.ex = ex
3235 
 
3236 
  def read(self, iprot):
3237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3239 
      return
3240 
    iprot.readStructBegin()
3241 
    while True:
3242 
      (fname, ftype, fid) = iprot.readFieldBegin()
3243 
      if ftype == TType.STOP:
3244 
        break
3245 
      if fid == 0:
3246 
        if ftype == TType.BOOL:
3247 
          self.success = iprot.readBool();
3248 
        else:
3249 
          iprot.skip(ftype)
3250 
      elif fid == 1:
3251 
        if ftype == TType.STRUCT:
3252 
          self.ex = TransactionServiceException()
3253 
          self.ex.read(iprot)
3254 
        else:
3255 
          iprot.skip(ftype)
3256 
      else:
3257 
        iprot.skip(ftype)
3258 
      iprot.readFieldEnd()
3259 
    iprot.readStructEnd()
3260 
 
3261 
  def write(self, oprot):
3262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3264 
      return
3265 
    oprot.writeStructBegin('acceptOrder_result')
3266 
    if self.success != None:
3267 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3268 
      oprot.writeBool(self.success)
3269 
      oprot.writeFieldEnd()
3270 
    if self.ex != None:
3271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3272 
      self.ex.write(oprot)
3273 
      oprot.writeFieldEnd()
3274 
    oprot.writeFieldStop()
3275 
    oprot.writeStructEnd()
3276 
 
3277 
  def __repr__(self):
3278 
    L = ['%s=%r' % (key, value)
3279 
      for key, value in self.__dict__.iteritems()]
3280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3281 
 
3282 
  def __eq__(self, other):
3283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3284 
 
3285 
  def __ne__(self, other):
3286 
    return not (self == other)
3287 
 
3288 
class billOrder_args:
3289 
  """
3290 
  Attributes:
3291 
   - orderId
3292 
  """
3293 
 
3294 
  thrift_spec = (
3295 
    None, # 0
3296 
    (1, TType.I64, 'orderId', None, None, ), # 1
3297 
  )
3298 
 
3299 
  def __init__(self, orderId=None,):
3300 
    self.orderId = orderId
3301 
 
3302 
  def read(self, iprot):
3303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3305 
      return
3306 
    iprot.readStructBegin()
3307 
    while True:
3308 
      (fname, ftype, fid) = iprot.readFieldBegin()
3309 
      if ftype == TType.STOP:
3310 
        break
3311 
      if fid == 1:
3312 
        if ftype == TType.I64:
3313 
          self.orderId = iprot.readI64();
3314 
        else:
3315 
          iprot.skip(ftype)
3316 
      else:
3317 
        iprot.skip(ftype)
3318 
      iprot.readFieldEnd()
3319 
    iprot.readStructEnd()
3320 
 
3321 
  def write(self, oprot):
3322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3324 
      return
3325 
    oprot.writeStructBegin('billOrder_args')
3326 
    if self.orderId != None:
3327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3328 
      oprot.writeI64(self.orderId)
3329 
      oprot.writeFieldEnd()
3330 
    oprot.writeFieldStop()
3331 
    oprot.writeStructEnd()
3332 
 
3333 
  def __repr__(self):
3334 
    L = ['%s=%r' % (key, value)
3335 
      for key, value in self.__dict__.iteritems()]
3336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3337 
 
3338 
  def __eq__(self, other):
3339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3340 
 
3341 
  def __ne__(self, other):
3342 
    return not (self == other)
3343 
 
3344 
class billOrder_result:
3345 
  """
3346 
  Attributes:
3347 
   - success
3348 
   - ex
3349 
  """
3350 
 
3351 
  thrift_spec = (
3352 
    (0, TType.BOOL, 'success', None, None, ), # 0
3353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3354 
  )
3355 
 
3356 
  def __init__(self, success=None, ex=None,):
3357 
    self.success = success
3358 
    self.ex = ex
3359 
 
3360 
  def read(self, iprot):
3361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3363 
      return
3364 
    iprot.readStructBegin()
3365 
    while True:
3366 
      (fname, ftype, fid) = iprot.readFieldBegin()
3367 
      if ftype == TType.STOP:
3368 
        break
3369 
      if fid == 0:
3370 
        if ftype == TType.BOOL:
3371 
          self.success = iprot.readBool();
3372 
        else:
3373 
          iprot.skip(ftype)
3374 
      elif fid == 1:
3375 
        if ftype == TType.STRUCT:
3376 
          self.ex = TransactionServiceException()
3377 
          self.ex.read(iprot)
3378 
        else:
3379 
          iprot.skip(ftype)
3380 
      else:
3381 
        iprot.skip(ftype)
3382 
      iprot.readFieldEnd()
3383 
    iprot.readStructEnd()
3384 
 
3385 
  def write(self, oprot):
3386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3388 
      return
3389 
    oprot.writeStructBegin('billOrder_result')
3390 
    if self.success != None:
3391 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3392 
      oprot.writeBool(self.success)
3393 
      oprot.writeFieldEnd()
3394 
    if self.ex != None:
3395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3396 
      self.ex.write(oprot)
3397 
      oprot.writeFieldEnd()
3398 
    oprot.writeFieldStop()
3399 
    oprot.writeStructEnd()
3400 
 
3401 
  def __repr__(self):
3402 
    L = ['%s=%r' % (key, value)
3403 
      for key, value in self.__dict__.iteritems()]
3404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3405 
 
3406 
  def __eq__(self, other):
3407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3408 
 
3409 
  def __ne__(self, other):
3410 
    return not (self == other)
3411 
 
483 rajveer 3412 
class getOrdersForTransaction_args:
94 ashish 3413 
  """
3414 
  Attributes:
3415 
   - transactionId
3416 
  """
3417 
 
3418 
  thrift_spec = (
3419 
    None, # 0
3420 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3421 
  )
3422 
 
483 rajveer 3423 
  def __init__(self, transactionId=None,):
94 ashish 3424 
    self.transactionId = transactionId
3425 
 
3426 
  def read(self, iprot):
3427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3429 
      return
3430 
    iprot.readStructBegin()
3431 
    while True:
3432 
      (fname, ftype, fid) = iprot.readFieldBegin()
3433 
      if ftype == TType.STOP:
3434 
        break
3435 
      if fid == 1:
3436 
        if ftype == TType.I64:
3437 
          self.transactionId = iprot.readI64();
3438 
        else:
3439 
          iprot.skip(ftype)
3440 
      else:
3441 
        iprot.skip(ftype)
3442 
      iprot.readFieldEnd()
3443 
    iprot.readStructEnd()
3444 
 
3445 
  def write(self, oprot):
3446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3448 
      return
483 rajveer 3449 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 3450 
    if self.transactionId != None:
3451 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3452 
      oprot.writeI64(self.transactionId)
3453 
      oprot.writeFieldEnd()
3454 
    oprot.writeFieldStop()
3455 
    oprot.writeStructEnd()
3456 
 
3457 
  def __repr__(self):
3458 
    L = ['%s=%r' % (key, value)
3459 
      for key, value in self.__dict__.iteritems()]
3460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3461 
 
3462 
  def __eq__(self, other):
3463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3464 
 
3465 
  def __ne__(self, other):
3466 
    return not (self == other)
3467 
 
483 rajveer 3468 
class getOrdersForTransaction_result:
94 ashish 3469 
  """
3470 
  Attributes:
3471 
   - success
3472 
   - ex
3473 
  """
3474 
 
3475 
  thrift_spec = (
483 rajveer 3476 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 3477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3478 
  )
3479 
 
3480 
  def __init__(self, success=None, ex=None,):
3481 
    self.success = success
3482 
    self.ex = ex
3483 
 
3484 
  def read(self, iprot):
3485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3487 
      return
3488 
    iprot.readStructBegin()
3489 
    while True:
3490 
      (fname, ftype, fid) = iprot.readFieldBegin()
3491 
      if ftype == TType.STOP:
3492 
        break
3493 
      if fid == 0:
483 rajveer 3494 
        if ftype == TType.LIST:
3495 
          self.success = []
999 varun.gupt 3496 
          (_etype45, _size42) = iprot.readListBegin()
3497 
          for _i46 in xrange(_size42):
3498 
            _elem47 = Order()
3499 
            _elem47.read(iprot)
3500 
            self.success.append(_elem47)
483 rajveer 3501 
          iprot.readListEnd()
94 ashish 3502 
        else:
3503 
          iprot.skip(ftype)
3504 
      elif fid == 1:
3505 
        if ftype == TType.STRUCT:
3506 
          self.ex = TransactionServiceException()
3507 
          self.ex.read(iprot)
3508 
        else:
3509 
          iprot.skip(ftype)
3510 
      else:
3511 
        iprot.skip(ftype)
3512 
      iprot.readFieldEnd()
3513 
    iprot.readStructEnd()
3514 
 
3515 
  def write(self, oprot):
3516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3518 
      return
483 rajveer 3519 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 3520 
    if self.success != None:
483 rajveer 3521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
999 varun.gupt 3523 
      for iter48 in self.success:
3524 
        iter48.write(oprot)
483 rajveer 3525 
      oprot.writeListEnd()
94 ashish 3526 
      oprot.writeFieldEnd()
3527 
    if self.ex != None:
3528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3529 
      self.ex.write(oprot)
3530 
      oprot.writeFieldEnd()
3531 
    oprot.writeFieldStop()
3532 
    oprot.writeStructEnd()
3533 
 
3534 
  def __repr__(self):
3535 
    L = ['%s=%r' % (key, value)
3536 
      for key, value in self.__dict__.iteritems()]
3537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3538 
 
3539 
  def __eq__(self, other):
3540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3541 
 
3542 
  def __ne__(self, other):
3543 
    return not (self == other)
3544 
 
483 rajveer 3545 
class getOrdersForCustomer_args:
94 ashish 3546 
  """
3547 
  Attributes:
483 rajveer 3548 
   - customerId
3549 
   - from_date
3550 
   - to_date
3551 
   - status
94 ashish 3552 
  """
3553 
 
3554 
  thrift_spec = (
3555 
    None, # 0
483 rajveer 3556 
    (1, TType.I64, 'customerId', None, None, ), # 1
3557 
    (2, TType.I64, 'from_date', None, None, ), # 2
3558 
    (3, TType.I64, 'to_date', None, None, ), # 3
3559 
    (4, TType.I32, 'status', None, None, ), # 4
94 ashish 3560 
  )
3561 
 
483 rajveer 3562 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
3563 
    self.customerId = customerId
3564 
    self.from_date = from_date
3565 
    self.to_date = to_date
3566 
    self.status = status
94 ashish 3567 
 
3568 
  def read(self, iprot):
3569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3571 
      return
3572 
    iprot.readStructBegin()
3573 
    while True:
3574 
      (fname, ftype, fid) = iprot.readFieldBegin()
3575 
      if ftype == TType.STOP:
3576 
        break
3577 
      if fid == 1:
3578 
        if ftype == TType.I64:
483 rajveer 3579 
          self.customerId = iprot.readI64();
94 ashish 3580 
        else:
3581 
          iprot.skip(ftype)
3582 
      elif fid == 2:
3583 
        if ftype == TType.I64:
483 rajveer 3584 
          self.from_date = iprot.readI64();
94 ashish 3585 
        else:
3586 
          iprot.skip(ftype)
3587 
      elif fid == 3:
3588 
        if ftype == TType.I64:
483 rajveer 3589 
          self.to_date = iprot.readI64();
94 ashish 3590 
        else:
3591 
          iprot.skip(ftype)
483 rajveer 3592 
      elif fid == 4:
3593 
        if ftype == TType.I32:
3594 
          self.status = iprot.readI32();
3595 
        else:
3596 
          iprot.skip(ftype)
94 ashish 3597 
      else:
3598 
        iprot.skip(ftype)
3599 
      iprot.readFieldEnd()
3600 
    iprot.readStructEnd()
3601 
 
3602 
  def write(self, oprot):
3603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3605 
      return
483 rajveer 3606 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3607 
    if self.customerId != None:
3608 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
3609 
      oprot.writeI64(self.customerId)
94 ashish 3610 
      oprot.writeFieldEnd()
483 rajveer 3611 
    if self.from_date != None:
3612 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3613 
      oprot.writeI64(self.from_date)
94 ashish 3614 
      oprot.writeFieldEnd()
483 rajveer 3615 
    if self.to_date != None:
3616 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3617 
      oprot.writeI64(self.to_date)
94 ashish 3618 
      oprot.writeFieldEnd()
483 rajveer 3619 
    if self.status != None:
3620 
      oprot.writeFieldBegin('status', TType.I32, 4)
3621 
      oprot.writeI32(self.status)
3622 
      oprot.writeFieldEnd()
94 ashish 3623 
    oprot.writeFieldStop()
3624 
    oprot.writeStructEnd()
3625 
 
3626 
  def __repr__(self):
3627 
    L = ['%s=%r' % (key, value)
3628 
      for key, value in self.__dict__.iteritems()]
3629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3630 
 
3631 
  def __eq__(self, other):
3632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3633 
 
3634 
  def __ne__(self, other):
3635 
    return not (self == other)
3636 
 
483 rajveer 3637 
class getOrdersForCustomer_result:
94 ashish 3638 
  """
3639 
  Attributes:
3640 
   - success
3641 
   - ex
3642 
  """
3643 
 
3644 
  thrift_spec = (
483 rajveer 3645 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 3646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3647 
  )
3648 
 
3649 
  def __init__(self, success=None, ex=None,):
3650 
    self.success = success
3651 
    self.ex = ex
3652 
 
3653 
  def read(self, iprot):
3654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3656 
      return
3657 
    iprot.readStructBegin()
3658 
    while True:
3659 
      (fname, ftype, fid) = iprot.readFieldBegin()
3660 
      if ftype == TType.STOP:
3661 
        break
3662 
      if fid == 0:
483 rajveer 3663 
        if ftype == TType.LIST:
3664 
          self.success = []
999 varun.gupt 3665 
          (_etype52, _size49) = iprot.readListBegin()
3666 
          for _i53 in xrange(_size49):
3667 
            _elem54 = Order()
3668 
            _elem54.read(iprot)
3669 
            self.success.append(_elem54)
483 rajveer 3670 
          iprot.readListEnd()
94 ashish 3671 
        else:
3672 
          iprot.skip(ftype)
3673 
      elif fid == 1:
3674 
        if ftype == TType.STRUCT:
3675 
          self.ex = TransactionServiceException()
3676 
          self.ex.read(iprot)
3677 
        else:
3678 
          iprot.skip(ftype)
3679 
      else:
3680 
        iprot.skip(ftype)
3681 
      iprot.readFieldEnd()
3682 
    iprot.readStructEnd()
3683 
 
3684 
  def write(self, oprot):
3685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3687 
      return
483 rajveer 3688 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 3689 
    if self.success != None:
483 rajveer 3690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
999 varun.gupt 3692 
      for iter55 in self.success:
3693 
        iter55.write(oprot)
483 rajveer 3694 
      oprot.writeListEnd()
94 ashish 3695 
      oprot.writeFieldEnd()
3696 
    if self.ex != None:
3697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3698 
      self.ex.write(oprot)
3699 
      oprot.writeFieldEnd()
3700 
    oprot.writeFieldStop()
3701 
    oprot.writeStructEnd()
3702 
 
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 
 
483 rajveer 3714 
class createOrder_args:
94 ashish 3715 
  """
3716 
  Attributes:
483 rajveer 3717 
   - order
94 ashish 3718 
  """
3719 
 
3720 
  thrift_spec = (
3721 
    None, # 0
483 rajveer 3722 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 3723 
  )
3724 
 
483 rajveer 3725 
  def __init__(self, order=None,):
3726 
    self.order = order
94 ashish 3727 
 
3728 
  def read(self, iprot):
3729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3731 
      return
3732 
    iprot.readStructBegin()
3733 
    while True:
3734 
      (fname, ftype, fid) = iprot.readFieldBegin()
3735 
      if ftype == TType.STOP:
3736 
        break
3737 
      if fid == 1:
483 rajveer 3738 
        if ftype == TType.STRUCT:
3739 
          self.order = Order()
3740 
          self.order.read(iprot)
94 ashish 3741 
        else:
3742 
          iprot.skip(ftype)
3743 
      else:
3744 
        iprot.skip(ftype)
3745 
      iprot.readFieldEnd()
3746 
    iprot.readStructEnd()
3747 
 
3748 
  def write(self, oprot):
3749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3751 
      return
483 rajveer 3752 
    oprot.writeStructBegin('createOrder_args')
3753 
    if self.order != None:
3754 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
3755 
      self.order.write(oprot)
94 ashish 3756 
      oprot.writeFieldEnd()
3757 
    oprot.writeFieldStop()
3758 
    oprot.writeStructEnd()
3759 
 
3760 
  def __repr__(self):
3761 
    L = ['%s=%r' % (key, value)
3762 
      for key, value in self.__dict__.iteritems()]
3763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3764 
 
3765 
  def __eq__(self, other):
3766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3767 
 
3768 
  def __ne__(self, other):
3769 
    return not (self == other)
3770 
 
483 rajveer 3771 
class createOrder_result:
94 ashish 3772 
  """
3773 
  Attributes:
3774 
   - success
3775 
   - ex
3776 
  """
3777 
 
3778 
  thrift_spec = (
483 rajveer 3779 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 3780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3781 
  )
3782 
 
3783 
  def __init__(self, success=None, ex=None,):
3784 
    self.success = success
3785 
    self.ex = ex
3786 
 
3787 
  def read(self, iprot):
3788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3790 
      return
3791 
    iprot.readStructBegin()
3792 
    while True:
3793 
      (fname, ftype, fid) = iprot.readFieldBegin()
3794 
      if ftype == TType.STOP:
3795 
        break
3796 
      if fid == 0:
483 rajveer 3797 
        if ftype == TType.I64:
3798 
          self.success = iprot.readI64();
94 ashish 3799 
        else:
3800 
          iprot.skip(ftype)
3801 
      elif fid == 1:
3802 
        if ftype == TType.STRUCT:
3803 
          self.ex = TransactionServiceException()
3804 
          self.ex.read(iprot)
3805 
        else:
3806 
          iprot.skip(ftype)
3807 
      else:
3808 
        iprot.skip(ftype)
3809 
      iprot.readFieldEnd()
3810 
    iprot.readStructEnd()
3811 
 
3812 
  def write(self, oprot):
3813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3815 
      return
483 rajveer 3816 
    oprot.writeStructBegin('createOrder_result')
94 ashish 3817 
    if self.success != None:
483 rajveer 3818 
      oprot.writeFieldBegin('success', TType.I64, 0)
3819 
      oprot.writeI64(self.success)
94 ashish 3820 
      oprot.writeFieldEnd()
3821 
    if self.ex != None:
3822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3823 
      self.ex.write(oprot)
3824 
      oprot.writeFieldEnd()
3825 
    oprot.writeFieldStop()
3826 
    oprot.writeStructEnd()
3827 
 
3828 
  def __repr__(self):
3829 
    L = ['%s=%r' % (key, value)
3830 
      for key, value in self.__dict__.iteritems()]
3831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3832 
 
3833 
  def __eq__(self, other):
3834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3835 
 
3836 
  def __ne__(self, other):
3837 
    return not (self == other)
3838 
 
483 rajveer 3839 
class getOrder_args:
94 ashish 3840 
  """
3841 
  Attributes:
483 rajveer 3842 
   - id
94 ashish 3843 
  """
3844 
 
3845 
  thrift_spec = (
3846 
    None, # 0
483 rajveer 3847 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 3848 
  )
3849 
 
483 rajveer 3850 
  def __init__(self, id=None,):
3851 
    self.id = id
94 ashish 3852 
 
3853 
  def read(self, iprot):
3854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3856 
      return
3857 
    iprot.readStructBegin()
3858 
    while True:
3859 
      (fname, ftype, fid) = iprot.readFieldBegin()
3860 
      if ftype == TType.STOP:
3861 
        break
3862 
      if fid == 1:
3863 
        if ftype == TType.I64:
483 rajveer 3864 
          self.id = iprot.readI64();
94 ashish 3865 
        else:
3866 
          iprot.skip(ftype)
3867 
      else:
3868 
        iprot.skip(ftype)
3869 
      iprot.readFieldEnd()
3870 
    iprot.readStructEnd()
3871 
 
3872 
  def write(self, oprot):
3873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3875 
      return
483 rajveer 3876 
    oprot.writeStructBegin('getOrder_args')
3877 
    if self.id != None:
3878 
      oprot.writeFieldBegin('id', TType.I64, 1)
3879 
      oprot.writeI64(self.id)
94 ashish 3880 
      oprot.writeFieldEnd()
3881 
    oprot.writeFieldStop()
3882 
    oprot.writeStructEnd()
3883 
 
3884 
  def __repr__(self):
3885 
    L = ['%s=%r' % (key, value)
3886 
      for key, value in self.__dict__.iteritems()]
3887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3888 
 
3889 
  def __eq__(self, other):
3890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3891 
 
3892 
  def __ne__(self, other):
3893 
    return not (self == other)
3894 
 
483 rajveer 3895 
class getOrder_result:
94 ashish 3896 
  """
3897 
  Attributes:
3898 
   - success
3899 
   - ex
3900 
  """
3901 
 
3902 
  thrift_spec = (
483 rajveer 3903 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 3904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3905 
  )
3906 
 
3907 
  def __init__(self, success=None, ex=None,):
3908 
    self.success = success
3909 
    self.ex = ex
3910 
 
3911 
  def read(self, iprot):
3912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3914 
      return
3915 
    iprot.readStructBegin()
3916 
    while True:
3917 
      (fname, ftype, fid) = iprot.readFieldBegin()
3918 
      if ftype == TType.STOP:
3919 
        break
3920 
      if fid == 0:
483 rajveer 3921 
        if ftype == TType.STRUCT:
3922 
          self.success = Order()
3923 
          self.success.read(iprot)
94 ashish 3924 
        else:
3925 
          iprot.skip(ftype)
3926 
      elif fid == 1:
3927 
        if ftype == TType.STRUCT:
3928 
          self.ex = TransactionServiceException()
3929 
          self.ex.read(iprot)
3930 
        else:
3931 
          iprot.skip(ftype)
3932 
      else:
3933 
        iprot.skip(ftype)
3934 
      iprot.readFieldEnd()
3935 
    iprot.readStructEnd()
3936 
 
3937 
  def write(self, oprot):
3938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3940 
      return
483 rajveer 3941 
    oprot.writeStructBegin('getOrder_result')
94 ashish 3942 
    if self.success != None:
483 rajveer 3943 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3944 
      self.success.write(oprot)
94 ashish 3945 
      oprot.writeFieldEnd()
3946 
    if self.ex != None:
3947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3948 
      self.ex.write(oprot)
3949 
      oprot.writeFieldEnd()
3950 
    oprot.writeFieldStop()
3951 
    oprot.writeStructEnd()
3952 
 
3953 
  def __repr__(self):
3954 
    L = ['%s=%r' % (key, value)
3955 
      for key, value in self.__dict__.iteritems()]
3956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3957 
 
3958 
  def __eq__(self, other):
3959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3960 
 
3961 
  def __ne__(self, other):
3962 
    return not (self == other)
3963 
 
483 rajveer 3964 
class getLineItemsForOrder_args:
94 ashish 3965 
  """
3966 
  Attributes:
483 rajveer 3967 
   - orderId
94 ashish 3968 
  """
3969 
 
3970 
  thrift_spec = (
3971 
    None, # 0
483 rajveer 3972 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 3973 
  )
3974 
 
483 rajveer 3975 
  def __init__(self, orderId=None,):
3976 
    self.orderId = orderId
94 ashish 3977 
 
3978 
  def read(self, iprot):
3979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3981 
      return
3982 
    iprot.readStructBegin()
3983 
    while True:
3984 
      (fname, ftype, fid) = iprot.readFieldBegin()
3985 
      if ftype == TType.STOP:
3986 
        break
3987 
      if fid == 1:
3988 
        if ftype == TType.I64:
483 rajveer 3989 
          self.orderId = iprot.readI64();
94 ashish 3990 
        else:
3991 
          iprot.skip(ftype)
3992 
      else:
3993 
        iprot.skip(ftype)
3994 
      iprot.readFieldEnd()
3995 
    iprot.readStructEnd()
3996 
 
3997 
  def write(self, oprot):
3998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4000 
      return
483 rajveer 4001 
    oprot.writeStructBegin('getLineItemsForOrder_args')
4002 
    if self.orderId != None:
4003 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4004 
      oprot.writeI64(self.orderId)
94 ashish 4005 
      oprot.writeFieldEnd()
4006 
    oprot.writeFieldStop()
4007 
    oprot.writeStructEnd()
4008 
 
4009 
  def __repr__(self):
4010 
    L = ['%s=%r' % (key, value)
4011 
      for key, value in self.__dict__.iteritems()]
4012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4013 
 
4014 
  def __eq__(self, other):
4015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4016 
 
4017 
  def __ne__(self, other):
4018 
    return not (self == other)
4019 
 
483 rajveer 4020 
class getLineItemsForOrder_result:
94 ashish 4021 
  """
4022 
  Attributes:
4023 
   - success
4024 
   - ex
4025 
  """
4026 
 
4027 
  thrift_spec = (
483 rajveer 4028 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 4029 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4030 
  )
4031 
 
4032 
  def __init__(self, success=None, ex=None,):
4033 
    self.success = success
4034 
    self.ex = ex
4035 
 
4036 
  def read(self, iprot):
4037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4039 
      return
4040 
    iprot.readStructBegin()
4041 
    while True:
4042 
      (fname, ftype, fid) = iprot.readFieldBegin()
4043 
      if ftype == TType.STOP:
4044 
        break
4045 
      if fid == 0:
483 rajveer 4046 
        if ftype == TType.LIST:
4047 
          self.success = []
999 varun.gupt 4048 
          (_etype59, _size56) = iprot.readListBegin()
4049 
          for _i60 in xrange(_size56):
4050 
            _elem61 = LineItem()
4051 
            _elem61.read(iprot)
4052 
            self.success.append(_elem61)
483 rajveer 4053 
          iprot.readListEnd()
94 ashish 4054 
        else:
4055 
          iprot.skip(ftype)
4056 
      elif fid == 1:
4057 
        if ftype == TType.STRUCT:
4058 
          self.ex = TransactionServiceException()
4059 
          self.ex.read(iprot)
4060 
        else:
4061 
          iprot.skip(ftype)
4062 
      else:
4063 
        iprot.skip(ftype)
4064 
      iprot.readFieldEnd()
4065 
    iprot.readStructEnd()
4066 
 
4067 
  def write(self, oprot):
4068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4070 
      return
483 rajveer 4071 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 4072 
    if self.success != None:
483 rajveer 4073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
999 varun.gupt 4075 
      for iter62 in self.success:
4076 
        iter62.write(oprot)
483 rajveer 4077 
      oprot.writeListEnd()
94 ashish 4078 
      oprot.writeFieldEnd()
4079 
    if self.ex != None:
4080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4081 
      self.ex.write(oprot)
4082 
      oprot.writeFieldEnd()
4083 
    oprot.writeFieldStop()
4084 
    oprot.writeStructEnd()
4085 
 
4086 
  def __repr__(self):
4087 
    L = ['%s=%r' % (key, value)
4088 
      for key, value in self.__dict__.iteritems()]
4089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4090 
 
4091 
  def __eq__(self, other):
4092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4093 
 
4094 
  def __ne__(self, other):
4095 
    return not (self == other)
4096 
 
759 chandransh 4097 
class markOrdersAsManifested_args:
4098 
  """
4099 
  Attributes:
4100 
   - warehouseId
4101 
   - providerId
4102 
  """
4103 
 
4104 
  thrift_spec = (
4105 
    None, # 0
4106 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
4107 
    (2, TType.I64, 'providerId', None, None, ), # 2
4108 
  )
4109 
 
4110 
  def __init__(self, warehouseId=None, providerId=None,):
4111 
    self.warehouseId = warehouseId
4112 
    self.providerId = providerId
4113 
 
4114 
  def read(self, iprot):
4115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4117 
      return
4118 
    iprot.readStructBegin()
4119 
    while True:
4120 
      (fname, ftype, fid) = iprot.readFieldBegin()
4121 
      if ftype == TType.STOP:
4122 
        break
4123 
      if fid == 1:
4124 
        if ftype == TType.I64:
4125 
          self.warehouseId = iprot.readI64();
4126 
        else:
4127 
          iprot.skip(ftype)
4128 
      elif fid == 2:
4129 
        if ftype == TType.I64:
4130 
          self.providerId = iprot.readI64();
4131 
        else:
4132 
          iprot.skip(ftype)
4133 
      else:
4134 
        iprot.skip(ftype)
4135 
      iprot.readFieldEnd()
4136 
    iprot.readStructEnd()
4137 
 
4138 
  def write(self, oprot):
4139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4141 
      return
4142 
    oprot.writeStructBegin('markOrdersAsManifested_args')
4143 
    if self.warehouseId != None:
4144 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
4145 
      oprot.writeI64(self.warehouseId)
4146 
      oprot.writeFieldEnd()
4147 
    if self.providerId != None:
4148 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
4149 
      oprot.writeI64(self.providerId)
4150 
      oprot.writeFieldEnd()
4151 
    oprot.writeFieldStop()
4152 
    oprot.writeStructEnd()
4153 
 
4154 
  def __repr__(self):
4155 
    L = ['%s=%r' % (key, value)
4156 
      for key, value in self.__dict__.iteritems()]
4157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4158 
 
4159 
  def __eq__(self, other):
4160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4161 
 
4162 
  def __ne__(self, other):
4163 
    return not (self == other)
4164 
 
4165 
class markOrdersAsManifested_result:
4166 
  """
4167 
  Attributes:
4168 
   - success
4169 
   - ex
4170 
  """
4171 
 
4172 
  thrift_spec = (
4173 
    (0, TType.BOOL, 'success', None, None, ), # 0
4174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4175 
  )
4176 
 
4177 
  def __init__(self, success=None, ex=None,):
4178 
    self.success = success
4179 
    self.ex = ex
4180 
 
4181 
  def read(self, iprot):
4182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4184 
      return
4185 
    iprot.readStructBegin()
4186 
    while True:
4187 
      (fname, ftype, fid) = iprot.readFieldBegin()
4188 
      if ftype == TType.STOP:
4189 
        break
4190 
      if fid == 0:
4191 
        if ftype == TType.BOOL:
4192 
          self.success = iprot.readBool();
4193 
        else:
4194 
          iprot.skip(ftype)
4195 
      elif fid == 1:
4196 
        if ftype == TType.STRUCT:
4197 
          self.ex = TransactionServiceException()
4198 
          self.ex.read(iprot)
4199 
        else:
4200 
          iprot.skip(ftype)
4201 
      else:
4202 
        iprot.skip(ftype)
4203 
      iprot.readFieldEnd()
4204 
    iprot.readStructEnd()
4205 
 
4206 
  def write(self, oprot):
4207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4209 
      return
4210 
    oprot.writeStructBegin('markOrdersAsManifested_result')
4211 
    if self.success != None:
4212 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4213 
      oprot.writeBool(self.success)
4214 
      oprot.writeFieldEnd()
4215 
    if self.ex != None:
4216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4217 
      self.ex.write(oprot)
4218 
      oprot.writeFieldEnd()
4219 
    oprot.writeFieldStop()
4220 
    oprot.writeStructEnd()
4221 
 
4222 
  def __repr__(self):
4223 
    L = ['%s=%r' % (key, value)
4224 
      for key, value in self.__dict__.iteritems()]
4225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4226 
 
4227 
  def __eq__(self, other):
4228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4229 
 
4230 
  def __ne__(self, other):
4231 
    return not (self == other)
4232 
 
1113 chandransh 4233 
class markOrdersAsPickedUp_args:
4234 
  """
4235 
  Attributes:
4236 
   - providerId
4237 
   - pickupDetails
4238 
  """
4239 
 
4240 
  thrift_spec = (
4241 
    None, # 0
4242 
    (1, TType.I64, 'providerId', None, None, ), # 1
4243 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.I64,None), None, ), # 2
4244 
  )
4245 
 
4246 
  def __init__(self, providerId=None, pickupDetails=None,):
4247 
    self.providerId = providerId
4248 
    self.pickupDetails = pickupDetails
4249 
 
4250 
  def read(self, iprot):
4251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4253 
      return
4254 
    iprot.readStructBegin()
4255 
    while True:
4256 
      (fname, ftype, fid) = iprot.readFieldBegin()
4257 
      if ftype == TType.STOP:
4258 
        break
4259 
      if fid == 1:
4260 
        if ftype == TType.I64:
4261 
          self.providerId = iprot.readI64();
4262 
        else:
4263 
          iprot.skip(ftype)
4264 
      elif fid == 2:
4265 
        if ftype == TType.MAP:
4266 
          self.pickupDetails = {}
4267 
          (_ktype64, _vtype65, _size63 ) = iprot.readMapBegin()
4268 
          for _i67 in xrange(_size63):
4269 
            _key68 = iprot.readString();
4270 
            _val69 = iprot.readI64();
4271 
            self.pickupDetails[_key68] = _val69
4272 
          iprot.readMapEnd()
4273 
        else:
4274 
          iprot.skip(ftype)
4275 
      else:
4276 
        iprot.skip(ftype)
4277 
      iprot.readFieldEnd()
4278 
    iprot.readStructEnd()
4279 
 
4280 
  def write(self, oprot):
4281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4283 
      return
4284 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4285 
    if self.providerId != None:
4286 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4287 
      oprot.writeI64(self.providerId)
4288 
      oprot.writeFieldEnd()
4289 
    if self.pickupDetails != None:
4290 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
4291 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.pickupDetails))
4292 
      for kiter70,viter71 in self.pickupDetails.items():
4293 
        oprot.writeString(kiter70)
4294 
        oprot.writeI64(viter71)
4295 
      oprot.writeMapEnd()
4296 
      oprot.writeFieldEnd()
4297 
    oprot.writeFieldStop()
4298 
    oprot.writeStructEnd()
4299 
 
4300 
  def __repr__(self):
4301 
    L = ['%s=%r' % (key, value)
4302 
      for key, value in self.__dict__.iteritems()]
4303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4304 
 
4305 
  def __eq__(self, other):
4306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4307 
 
4308 
  def __ne__(self, other):
4309 
    return not (self == other)
4310 
 
4311 
class markOrdersAsPickedUp_result:
4312 
  """
4313 
  Attributes:
4314 
   - success
4315 
   - ex
4316 
  """
4317 
 
4318 
  thrift_spec = (
4319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
4320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4321 
  )
4322 
 
4323 
  def __init__(self, success=None, ex=None,):
4324 
    self.success = success
4325 
    self.ex = ex
4326 
 
4327 
  def read(self, iprot):
4328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4330 
      return
4331 
    iprot.readStructBegin()
4332 
    while True:
4333 
      (fname, ftype, fid) = iprot.readFieldBegin()
4334 
      if ftype == TType.STOP:
4335 
        break
4336 
      if fid == 0:
4337 
        if ftype == TType.LIST:
4338 
          self.success = []
4339 
          (_etype75, _size72) = iprot.readListBegin()
4340 
          for _i76 in xrange(_size72):
4341 
            _elem77 = Order()
4342 
            _elem77.read(iprot)
4343 
            self.success.append(_elem77)
4344 
          iprot.readListEnd()
4345 
        else:
4346 
          iprot.skip(ftype)
4347 
      elif fid == 1:
4348 
        if ftype == TType.STRUCT:
4349 
          self.ex = TransactionServiceException()
4350 
          self.ex.read(iprot)
4351 
        else:
4352 
          iprot.skip(ftype)
4353 
      else:
4354 
        iprot.skip(ftype)
4355 
      iprot.readFieldEnd()
4356 
    iprot.readStructEnd()
4357 
 
4358 
  def write(self, oprot):
4359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4361 
      return
4362 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4363 
    if self.success != None:
4364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4366 
      for iter78 in self.success:
4367 
        iter78.write(oprot)
4368 
      oprot.writeListEnd()
4369 
      oprot.writeFieldEnd()
4370 
    if self.ex != None:
4371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4372 
      self.ex.write(oprot)
4373 
      oprot.writeFieldEnd()
4374 
    oprot.writeFieldStop()
4375 
    oprot.writeStructEnd()
4376 
 
4377 
  def __repr__(self):
4378 
    L = ['%s=%r' % (key, value)
4379 
      for key, value in self.__dict__.iteritems()]
4380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4381 
 
4382 
  def __eq__(self, other):
4383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4384 
 
4385 
  def __ne__(self, other):
4386 
    return not (self == other)
4387 
 
1132 chandransh 4388 
class markOrdersAsDelivered_args:
4389 
  """
4390 
  Attributes:
4391 
   - providerId
4392 
   - deliveredOrders
4393 
  """
4394 
 
4395 
  thrift_spec = (
4396 
    None, # 0
4397 
    (1, TType.I64, 'providerId', None, None, ), # 1
4398 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
4399 
  )
4400 
 
4401 
  def __init__(self, providerId=None, deliveredOrders=None,):
4402 
    self.providerId = providerId
4403 
    self.deliveredOrders = deliveredOrders
4404 
 
4405 
  def read(self, iprot):
4406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4408 
      return
4409 
    iprot.readStructBegin()
4410 
    while True:
4411 
      (fname, ftype, fid) = iprot.readFieldBegin()
4412 
      if ftype == TType.STOP:
4413 
        break
4414 
      if fid == 1:
4415 
        if ftype == TType.I64:
4416 
          self.providerId = iprot.readI64();
4417 
        else:
4418 
          iprot.skip(ftype)
4419 
      elif fid == 2:
4420 
        if ftype == TType.MAP:
4421 
          self.deliveredOrders = {}
4422 
          (_ktype80, _vtype81, _size79 ) = iprot.readMapBegin()
4423 
          for _i83 in xrange(_size79):
4424 
            _key84 = iprot.readString();
4425 
            _val85 = iprot.readString();
4426 
            self.deliveredOrders[_key84] = _val85
4427 
          iprot.readMapEnd()
4428 
        else:
4429 
          iprot.skip(ftype)
4430 
      else:
4431 
        iprot.skip(ftype)
4432 
      iprot.readFieldEnd()
4433 
    iprot.readStructEnd()
4434 
 
4435 
  def write(self, oprot):
4436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4438 
      return
4439 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
4440 
    if self.providerId != None:
4441 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4442 
      oprot.writeI64(self.providerId)
4443 
      oprot.writeFieldEnd()
4444 
    if self.deliveredOrders != None:
4445 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
4446 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4447 
      for kiter86,viter87 in self.deliveredOrders.items():
4448 
        oprot.writeString(kiter86)
4449 
        oprot.writeString(viter87)
4450 
      oprot.writeMapEnd()
4451 
      oprot.writeFieldEnd()
4452 
    oprot.writeFieldStop()
4453 
    oprot.writeStructEnd()
4454 
 
4455 
  def __repr__(self):
4456 
    L = ['%s=%r' % (key, value)
4457 
      for key, value in self.__dict__.iteritems()]
4458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4459 
 
4460 
  def __eq__(self, other):
4461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4462 
 
4463 
  def __ne__(self, other):
4464 
    return not (self == other)
4465 
 
4466 
class markOrdersAsDelivered_result:
4467 
  """
4468 
  Attributes:
4469 
   - ex
4470 
  """
4471 
 
4472 
  thrift_spec = (
4473 
    None, # 0
4474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4475 
  )
4476 
 
4477 
  def __init__(self, ex=None,):
4478 
    self.ex = ex
4479 
 
4480 
  def read(self, iprot):
4481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4483 
      return
4484 
    iprot.readStructBegin()
4485 
    while True:
4486 
      (fname, ftype, fid) = iprot.readFieldBegin()
4487 
      if ftype == TType.STOP:
4488 
        break
4489 
      if fid == 1:
4490 
        if ftype == TType.STRUCT:
4491 
          self.ex = TransactionServiceException()
4492 
          self.ex.read(iprot)
4493 
        else:
4494 
          iprot.skip(ftype)
4495 
      else:
4496 
        iprot.skip(ftype)
4497 
      iprot.readFieldEnd()
4498 
    iprot.readStructEnd()
4499 
 
4500 
  def write(self, oprot):
4501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4503 
      return
4504 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
4505 
    if self.ex != None:
4506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4507 
      self.ex.write(oprot)
4508 
      oprot.writeFieldEnd()
4509 
    oprot.writeFieldStop()
4510 
    oprot.writeStructEnd()
4511 
 
4512 
  def __repr__(self):
4513 
    L = ['%s=%r' % (key, value)
4514 
      for key, value in self.__dict__.iteritems()]
4515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4516 
 
4517 
  def __eq__(self, other):
4518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4519 
 
4520 
  def __ne__(self, other):
4521 
    return not (self == other)
4522 
 
1135 chandransh 4523 
class markOrdersAsFailed_args:
4524 
  """
4525 
  Attributes:
4526 
   - providerId
4527 
   - returnedOrders
4528 
  """
4529 
 
4530 
  thrift_spec = (
4531 
    None, # 0
4532 
    (1, TType.I64, 'providerId', None, None, ), # 1
4533 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
4534 
  )
4535 
 
4536 
  def __init__(self, providerId=None, returnedOrders=None,):
4537 
    self.providerId = providerId
4538 
    self.returnedOrders = returnedOrders
4539 
 
4540 
  def read(self, iprot):
4541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4543 
      return
4544 
    iprot.readStructBegin()
4545 
    while True:
4546 
      (fname, ftype, fid) = iprot.readFieldBegin()
4547 
      if ftype == TType.STOP:
4548 
        break
4549 
      if fid == 1:
4550 
        if ftype == TType.I64:
4551 
          self.providerId = iprot.readI64();
4552 
        else:
4553 
          iprot.skip(ftype)
4554 
      elif fid == 2:
4555 
        if ftype == TType.MAP:
4556 
          self.returnedOrders = {}
4557 
          (_ktype89, _vtype90, _size88 ) = iprot.readMapBegin()
4558 
          for _i92 in xrange(_size88):
4559 
            _key93 = iprot.readString();
4560 
            _val94 = iprot.readString();
4561 
            self.returnedOrders[_key93] = _val94
4562 
          iprot.readMapEnd()
4563 
        else:
4564 
          iprot.skip(ftype)
4565 
      else:
4566 
        iprot.skip(ftype)
4567 
      iprot.readFieldEnd()
4568 
    iprot.readStructEnd()
4569 
 
4570 
  def write(self, oprot):
4571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4573 
      return
4574 
    oprot.writeStructBegin('markOrdersAsFailed_args')
4575 
    if self.providerId != None:
4576 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4577 
      oprot.writeI64(self.providerId)
4578 
      oprot.writeFieldEnd()
4579 
    if self.returnedOrders != None:
4580 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
4581 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4582 
      for kiter95,viter96 in self.returnedOrders.items():
4583 
        oprot.writeString(kiter95)
4584 
        oprot.writeString(viter96)
4585 
      oprot.writeMapEnd()
4586 
      oprot.writeFieldEnd()
4587 
    oprot.writeFieldStop()
4588 
    oprot.writeStructEnd()
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 markOrdersAsFailed_result:
4602 
  """
4603 
  Attributes:
4604 
   - ex
4605 
  """
4606 
 
4607 
  thrift_spec = (
4608 
    None, # 0
4609 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4610 
  )
4611 
 
4612 
  def __init__(self, ex=None,):
4613 
    self.ex = ex
4614 
 
4615 
  def read(self, iprot):
4616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4618 
      return
4619 
    iprot.readStructBegin()
4620 
    while True:
4621 
      (fname, ftype, fid) = iprot.readFieldBegin()
4622 
      if ftype == TType.STOP:
4623 
        break
4624 
      if fid == 1:
4625 
        if ftype == TType.STRUCT:
4626 
          self.ex = TransactionServiceException()
4627 
          self.ex.read(iprot)
4628 
        else:
4629 
          iprot.skip(ftype)
4630 
      else:
4631 
        iprot.skip(ftype)
4632 
      iprot.readFieldEnd()
4633 
    iprot.readStructEnd()
4634 
 
4635 
  def write(self, oprot):
4636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4638 
      return
4639 
    oprot.writeStructBegin('markOrdersAsFailed_result')
4640 
    if self.ex != None:
4641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4642 
      self.ex.write(oprot)
4643 
      oprot.writeFieldEnd()
4644 
    oprot.writeFieldStop()
4645 
    oprot.writeStructEnd()
4646 
 
4647 
  def __repr__(self):
4648 
    L = ['%s=%r' % (key, value)
4649 
      for key, value in self.__dict__.iteritems()]
4650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4651 
 
4652 
  def __eq__(self, other):
4653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4654 
 
4655 
  def __ne__(self, other):
4656 
    return not (self == other)
4657 
 
304 ashish 4658 
class getAlerts_args:
4659 
  """
4660 
  Attributes:
483 rajveer 4661 
   - orderId
304 ashish 4662 
   - valid
4663 
  """
94 ashish 4664 
 
304 ashish 4665 
  thrift_spec = (
4666 
    None, # 0
483 rajveer 4667 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 4668 
    (2, TType.BOOL, 'valid', None, None, ), # 2
4669 
  )
4670 
 
483 rajveer 4671 
  def __init__(self, orderId=None, valid=None,):
4672 
    self.orderId = orderId
304 ashish 4673 
    self.valid = valid
4674 
 
4675 
  def read(self, iprot):
4676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4678 
      return
4679 
    iprot.readStructBegin()
4680 
    while True:
4681 
      (fname, ftype, fid) = iprot.readFieldBegin()
4682 
      if ftype == TType.STOP:
4683 
        break
4684 
      if fid == 1:
4685 
        if ftype == TType.I64:
483 rajveer 4686 
          self.orderId = iprot.readI64();
304 ashish 4687 
        else:
4688 
          iprot.skip(ftype)
4689 
      elif fid == 2:
4690 
        if ftype == TType.BOOL:
4691 
          self.valid = iprot.readBool();
4692 
        else:
4693 
          iprot.skip(ftype)
4694 
      else:
4695 
        iprot.skip(ftype)
4696 
      iprot.readFieldEnd()
4697 
    iprot.readStructEnd()
4698 
 
4699 
  def write(self, oprot):
4700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4702 
      return
4703 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 4704 
    if self.orderId != None:
4705 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4706 
      oprot.writeI64(self.orderId)
304 ashish 4707 
      oprot.writeFieldEnd()
4708 
    if self.valid != None:
4709 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
4710 
      oprot.writeBool(self.valid)
4711 
      oprot.writeFieldEnd()
4712 
    oprot.writeFieldStop()
4713 
    oprot.writeStructEnd()
4714 
 
4715 
  def __repr__(self):
4716 
    L = ['%s=%r' % (key, value)
4717 
      for key, value in self.__dict__.iteritems()]
4718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4719 
 
4720 
  def __eq__(self, other):
4721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4722 
 
4723 
  def __ne__(self, other):
4724 
    return not (self == other)
4725 
 
4726 
class getAlerts_result:
4727 
  """
4728 
  Attributes:
4729 
   - success
4730 
  """
4731 
 
4732 
  thrift_spec = (
4733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
4734 
  )
4735 
 
4736 
  def __init__(self, success=None,):
4737 
    self.success = success
4738 
 
4739 
  def read(self, iprot):
4740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4742 
      return
4743 
    iprot.readStructBegin()
4744 
    while True:
4745 
      (fname, ftype, fid) = iprot.readFieldBegin()
4746 
      if ftype == TType.STOP:
4747 
        break
4748 
      if fid == 0:
4749 
        if ftype == TType.LIST:
4750 
          self.success = []
1135 chandransh 4751 
          (_etype100, _size97) = iprot.readListBegin()
4752 
          for _i101 in xrange(_size97):
4753 
            _elem102 = Alert()
4754 
            _elem102.read(iprot)
4755 
            self.success.append(_elem102)
304 ashish 4756 
          iprot.readListEnd()
4757 
        else:
4758 
          iprot.skip(ftype)
4759 
      else:
4760 
        iprot.skip(ftype)
4761 
      iprot.readFieldEnd()
4762 
    iprot.readStructEnd()
4763 
 
4764 
  def write(self, oprot):
4765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4767 
      return
4768 
    oprot.writeStructBegin('getAlerts_result')
4769 
    if self.success != None:
4770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1135 chandransh 4772 
      for iter103 in self.success:
4773 
        iter103.write(oprot)
304 ashish 4774 
      oprot.writeListEnd()
4775 
      oprot.writeFieldEnd()
4776 
    oprot.writeFieldStop()
4777 
    oprot.writeStructEnd()
4778 
 
4779 
  def __repr__(self):
4780 
    L = ['%s=%r' % (key, value)
4781 
      for key, value in self.__dict__.iteritems()]
4782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4783 
 
4784 
  def __eq__(self, other):
4785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4786 
 
4787 
  def __ne__(self, other):
4788 
    return not (self == other)
4789 
 
4790 
class setAlert_args:
4791 
  """
4792 
  Attributes:
483 rajveer 4793 
   - orderId
304 ashish 4794 
   - unset
4795 
   - type
4796 
   - comment
4797 
  """
4798 
 
4799 
  thrift_spec = (
4800 
    None, # 0
483 rajveer 4801 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 4802 
    (2, TType.BOOL, 'unset', None, None, ), # 2
4803 
    (3, TType.I64, 'type', None, None, ), # 3
4804 
    (4, TType.STRING, 'comment', None, None, ), # 4
4805 
  )
4806 
 
483 rajveer 4807 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
4808 
    self.orderId = orderId
304 ashish 4809 
    self.unset = unset
4810 
    self.type = type
4811 
    self.comment = comment
4812 
 
4813 
  def read(self, iprot):
4814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4816 
      return
4817 
    iprot.readStructBegin()
4818 
    while True:
4819 
      (fname, ftype, fid) = iprot.readFieldBegin()
4820 
      if ftype == TType.STOP:
4821 
        break
4822 
      if fid == 1:
4823 
        if ftype == TType.I64:
483 rajveer 4824 
          self.orderId = iprot.readI64();
304 ashish 4825 
        else:
4826 
          iprot.skip(ftype)
4827 
      elif fid == 2:
4828 
        if ftype == TType.BOOL:
4829 
          self.unset = iprot.readBool();
4830 
        else:
4831 
          iprot.skip(ftype)
4832 
      elif fid == 3:
4833 
        if ftype == TType.I64:
4834 
          self.type = iprot.readI64();
4835 
        else:
4836 
          iprot.skip(ftype)
4837 
      elif fid == 4:
4838 
        if ftype == TType.STRING:
4839 
          self.comment = iprot.readString();
4840 
        else:
4841 
          iprot.skip(ftype)
4842 
      else:
4843 
        iprot.skip(ftype)
4844 
      iprot.readFieldEnd()
4845 
    iprot.readStructEnd()
4846 
 
4847 
  def write(self, oprot):
4848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4850 
      return
4851 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 4852 
    if self.orderId != None:
4853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4854 
      oprot.writeI64(self.orderId)
304 ashish 4855 
      oprot.writeFieldEnd()
4856 
    if self.unset != None:
4857 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
4858 
      oprot.writeBool(self.unset)
4859 
      oprot.writeFieldEnd()
4860 
    if self.type != None:
4861 
      oprot.writeFieldBegin('type', TType.I64, 3)
4862 
      oprot.writeI64(self.type)
4863 
      oprot.writeFieldEnd()
4864 
    if self.comment != None:
4865 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
4866 
      oprot.writeString(self.comment)
4867 
      oprot.writeFieldEnd()
4868 
    oprot.writeFieldStop()
4869 
    oprot.writeStructEnd()
4870 
 
4871 
  def __repr__(self):
4872 
    L = ['%s=%r' % (key, value)
4873 
      for key, value in self.__dict__.iteritems()]
4874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4875 
 
4876 
  def __eq__(self, other):
4877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4878 
 
4879 
  def __ne__(self, other):
4880 
    return not (self == other)
4881 
 
4882 
class setAlert_result:
4883 
 
4884 
  thrift_spec = (
4885 
  )
4886 
 
4887 
  def read(self, iprot):
4888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4890 
      return
4891 
    iprot.readStructBegin()
4892 
    while True:
4893 
      (fname, ftype, fid) = iprot.readFieldBegin()
4894 
      if ftype == TType.STOP:
4895 
        break
4896 
      else:
4897 
        iprot.skip(ftype)
4898 
      iprot.readFieldEnd()
4899 
    iprot.readStructEnd()
4900 
 
4901 
  def write(self, oprot):
4902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4904 
      return
4905 
    oprot.writeStructBegin('setAlert_result')
4906 
    oprot.writeFieldStop()
4907 
    oprot.writeStructEnd()
4908 
 
4909 
  def __repr__(self):
4910 
    L = ['%s=%r' % (key, value)
4911 
      for key, value in self.__dict__.iteritems()]
4912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4913 
 
4914 
  def __eq__(self, other):
4915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4916 
 
4917 
  def __ne__(self, other):
4918 
    return not (self == other)
4919 
 
4920