Subversion Repositories SmartDukaan

Rev

Rev 2536 | Rev 2599 | 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 
 
1398 varun.gupt 72 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 73 
    """
74 
    Parameters:
75 
     - transactionId
76 
    """
77 
    pass
78 
 
483 rajveer 79 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 80 
    """
81 
    Parameters:
483 rajveer 82 
     - status
83 
     - from_date
84 
     - to_date
85 
     - warehouse_id
94 ashish 86 
    """
87 
    pass
88 
 
999 varun.gupt 89 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
90 
    """
1132 chandransh 91 
    Returns orders within a range of their billing dates
92 
 
999 varun.gupt 93 
    Parameters:
94 
     - status
95 
     - start_billing_date
96 
     - end_billing_date
97 
     - warehouse_id
98 
    """
99 
    pass
100 
 
1382 varun.gupt 101 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
102 
    """
103 
    Returns order ids for orders which can be returned
104 
 
105 
    Parameters:
106 
     - customer_id
107 
     - limit
108 
    """
109 
    pass
110 
 
111 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
112 
    """
113 
    Returns order ids for orders which can be cancelled
114 
 
115 
    Parameters:
116 
     - customer_id
117 
     - limit
118 
    """
119 
    pass
120 
 
483 rajveer 121 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 122 
    """
123 
    Parameters:
483 rajveer 124 
     - orderId
125 
     - status
126 
     - description
94 ashish 127 
    """
128 
    pass
129 
 
1149 chandransh 130 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 131 
    """
1149 chandransh 132 
    Add billing details such as the bill number and the biller to the Order.
133 
 
494 rajveer 134 
    Parameters:
135 
     - orderId
136 
     - invoice_number
137 
     - billed_by
138 
    """
139 
    pass
140 
 
1149 chandransh 141 
  def addJacketNumber(self, orderId, jacketNumber):
142 
    """
2446 chandransh 143 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
144 
    Also marks the order as billed and sets the billing timestamp.
145 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 146 
 
147 
    Parameters:
148 
     - orderId
149 
     - jacketNumber
150 
    """
151 
    pass
152 
 
921 rajveer 153 
  def acceptOrder(self, orderId):
154 
    """
155 
    Parameters:
156 
     - orderId
157 
    """
158 
    pass
159 
 
160 
  def billOrder(self, orderId):
161 
    """
162 
    Parameters:
163 
     - orderId
164 
    """
165 
    pass
166 
 
1528 ankur.sing 167 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 168 
    """
1528 ankur.sing 169 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
170 
    only user who owns the transaction can view its order details.
171 
 
94 ashish 172 
    Parameters:
173 
     - transactionId
1528 ankur.sing 174 
     - customerId
94 ashish 175 
    """
176 
    pass
177 
 
483 rajveer 178 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 179 
    """
180 
    Parameters:
483 rajveer 181 
     - customerId
182 
     - from_date
183 
     - to_date
184 
     - status
94 ashish 185 
    """
186 
    pass
187 
 
483 rajveer 188 
  def createOrder(self, order):
94 ashish 189 
    """
190 
    Parameters:
483 rajveer 191 
     - order
94 ashish 192 
    """
193 
    pass
194 
 
483 rajveer 195 
  def getOrder(self, id):
94 ashish 196 
    """
197 
    Parameters:
483 rajveer 198 
     - id
94 ashish 199 
    """
200 
    pass
201 
 
483 rajveer 202 
  def getLineItemsForOrder(self, orderId):
94 ashish 203 
    """
204 
    Parameters:
483 rajveer 205 
     - orderId
94 ashish 206 
    """
207 
    pass
208 
 
1528 ankur.sing 209 
  def getOrderForCustomer(self, orderId, customerId):
210 
    """
211 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
212 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
213 
 
214 
    Parameters:
215 
     - orderId
216 
     - customerId
217 
    """
218 
    pass
219 
 
1220 chandransh 220 
  def batchOrders(self, warehouseId):
221 
    """
222 
    Create a batch of all the pending orders for the given warehouse.
223 
    The returned list is orderd by created_timestamp.
224 
    If there are no pending orders, an empty list is returned.
225 
 
226 
    Parameters:
227 
     - warehouseId
228 
    """
229 
    pass
230 
 
1208 chandransh 231 
  def markOrderAsOutOfStock(self, orderId):
232 
    """
233 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
234 
 
235 
    Parameters:
236 
     - orderId
237 
    """
238 
    pass
239 
 
759 chandransh 240 
  def markOrdersAsManifested(self, warehouseId, providerId):
241 
    """
242 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
243 
 
244 
    Parameters:
245 
     - warehouseId
246 
     - providerId
247 
    """
248 
    pass
249 
 
1113 chandransh 250 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
251 
    """
252 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
253 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
254 
    Raises an exception if we encounter report for an AWB number that we did not ship.
255 
 
256 
    Parameters:
257 
     - providerId
258 
     - pickupDetails
259 
    """
260 
    pass
261 
 
1132 chandransh 262 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
263 
    """
264 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
265 
    the name of the receiver.
266 
    Raises an exception if we encounter report for an AWB number that we did not ship.
267 
 
268 
    Parameters:
269 
     - providerId
270 
     - deliveredOrders
271 
    """
272 
    pass
273 
 
1135 chandransh 274 
  def markOrdersAsFailed(self, providerId, returnedOrders):
275 
    """
276 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
277 
    Raises an exception if we encounter report for an AWB number that we did not ship.
278 
 
279 
    Parameters:
280 
     - providerId
281 
     - returnedOrders
282 
    """
283 
    pass
284 
 
1246 chandransh 285 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
286 
    """
287 
    Update the status description of orders whose AWB numbers are keys of the Map.
288 
 
289 
    Parameters:
290 
     - providerId
291 
     - undeliveredOrders
292 
    """
293 
    pass
294 
 
1408 ankur.sing 295 
  def getUndeliveredOrders(self, providerId, warehouseId):
296 
    """
297 
    Returns the list of orders whose delivery time has passed but have not been
298 
    delivered yet for the given provider and warehouse. To get a complete list of
299 
    undelivered orders, pass them as -1.
300 
    Returns an empty list if no such orders exist.
301 
 
302 
    Parameters:
303 
     - providerId
304 
     - warehouseId
305 
    """
306 
    pass
307 
 
483 rajveer 308 
  def getAlerts(self, orderId, valid):
94 ashish 309 
    """
310 
    Parameters:
483 rajveer 311 
     - orderId
304 ashish 312 
     - valid
313 
    """
314 
    pass
94 ashish 315 
 
483 rajveer 316 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 317 
    """
318 
    Parameters:
483 rajveer 319 
     - orderId
304 ashish 320 
     - unset
321 
     - type
322 
     - comment
323 
    """
324 
    pass
325 
 
1596 ankur.sing 326 
  def getValidOrderCount(self, ):
327 
    """
328 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
329 
    """
330 
    pass
304 ashish 331 
 
1627 ankur.sing 332 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
333 
    """
334 
    Returns the number of distinct customers who have done successful transactions
335 
    """
336 
    pass
1596 ankur.sing 337 
 
1731 ankur.sing 338 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 339 
    """
1731 ankur.sing 340 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
341 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 342 
    """
343 
    pass
344 
 
1886 ankur.sing 345 
  def getValidOrders(self, limit):
346 
    """
347 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
348 
    If limit is passed as 0, then all valid Orders are returned.
349 
 
350 
    Parameters:
351 
     - limit
352 
    """
353 
    pass
1627 ankur.sing 354 
 
2536 chandransh 355 
  def toggleDOAFlag(self, orderId):
356 
    """
357 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
358 
    Returns the final flag status.
359 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
360 
 
361 
    Parameters:
362 
     - orderId
363 
    """
364 
    pass
1886 ankur.sing 365 
 
2536 chandransh 366 
  def requestPickupNumber(self, orderId):
367 
    """
368 
    Sends out an email to the account manager of the original courier provider used to ship the order.
369 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
370 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
371 
    For any other status, it returns false.
372 
    Throws an exception if the order with the given id couldn't be found.
373 
 
374 
    Parameters:
375 
     - orderId
376 
    """
377 
    pass
378 
 
379 
  def authorizePickup(self, orderId, pickupNumber):
380 
    """
381 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
382 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
383 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
384 
    	3. Returns true
2591 chandransh 385 
    If the order is in any other status, it returns false.
2536 chandransh 386 
    Throws an exception if the order with the given id couldn't be found.
387 
 
388 
    Parameters:
389 
     - orderId
390 
     - pickupNumber
391 
    """
392 
    pass
393 
 
2591 chandransh 394 
  def acceptDoa(self, orderId):
395 
    """
396 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RETURNED and returns true.
397 
    If the order is in any other state, it returns false.
398 
    Throws an exception if the order with the given id couldn't be found.
399 
 
400 
    Parameters:
401 
     - orderId
402 
    """
403 
    pass
2536 chandransh 404 
 
2591 chandransh 405 
  def validateDoa(self, orderId, isValid):
406 
    """
407 
    Used to validate the DOA certificate for an order in the DOA_RETURNED state. If the certificate is valid,
408 
    the order state is changed to DOA_PENDING and the warehouse executive gets to print a return receiving letter.
409 
    If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
410 
    If the order is in any other state, it returns false.
411 
    Throws an exception if the order with the given id couldn't be found.
412 
 
413 
    Parameters:
414 
     - orderId
415 
     - isValid
416 
    """
417 
    pass
418 
 
419 
 
94 ashish 420 
class Client(Iface):
421 
  def __init__(self, iprot, oprot=None):
422 
    self._iprot = self._oprot = iprot
423 
    if oprot != None:
424 
      self._oprot = oprot
425 
    self._seqid = 0
426 
 
765 rajveer 427 
  def closeSession(self, ):
428 
    """
429 
    For closing the open session in sqlalchemy
430 
    """
431 
    self.send_closeSession()
432 
    self.recv_closeSession()
433 
 
434 
  def send_closeSession(self, ):
435 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
436 
    args = closeSession_args()
437 
    args.write(self._oprot)
438 
    self._oprot.writeMessageEnd()
439 
    self._oprot.trans.flush()
440 
 
441 
  def recv_closeSession(self, ):
442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
443 
    if mtype == TMessageType.EXCEPTION:
444 
      x = TApplicationException()
445 
      x.read(self._iprot)
446 
      self._iprot.readMessageEnd()
447 
      raise x
448 
    result = closeSession_result()
449 
    result.read(self._iprot)
450 
    self._iprot.readMessageEnd()
451 
    return
452 
 
94 ashish 453 
  def createTransaction(self, transaction):
454 
    """
455 
    Parameters:
456 
     - transaction
457 
    """
458 
    self.send_createTransaction(transaction)
132 ashish 459 
    return self.recv_createTransaction()
94 ashish 460 
 
461 
  def send_createTransaction(self, transaction):
462 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
463 
    args = createTransaction_args()
464 
    args.transaction = transaction
465 
    args.write(self._oprot)
466 
    self._oprot.writeMessageEnd()
467 
    self._oprot.trans.flush()
468 
 
469 
  def recv_createTransaction(self, ):
470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
471 
    if mtype == TMessageType.EXCEPTION:
472 
      x = TApplicationException()
473 
      x.read(self._iprot)
474 
      self._iprot.readMessageEnd()
475 
      raise x
476 
    result = createTransaction_result()
477 
    result.read(self._iprot)
478 
    self._iprot.readMessageEnd()
132 ashish 479 
    if result.success != None:
480 
      return result.success
94 ashish 481 
    if result.ex != None:
482 
      raise result.ex
132 ashish 483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 484 
 
485 
  def getTransaction(self, id):
486 
    """
487 
    Parameters:
488 
     - id
489 
    """
490 
    self.send_getTransaction(id)
491 
    return self.recv_getTransaction()
492 
 
493 
  def send_getTransaction(self, id):
494 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
495 
    args = getTransaction_args()
496 
    args.id = id
497 
    args.write(self._oprot)
498 
    self._oprot.writeMessageEnd()
499 
    self._oprot.trans.flush()
500 
 
501 
  def recv_getTransaction(self, ):
502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
503 
    if mtype == TMessageType.EXCEPTION:
504 
      x = TApplicationException()
505 
      x.read(self._iprot)
506 
      self._iprot.readMessageEnd()
507 
      raise x
508 
    result = getTransaction_result()
509 
    result.read(self._iprot)
510 
    self._iprot.readMessageEnd()
511 
    if result.success != None:
512 
      return result.success
513 
    if result.ex != None:
514 
      raise result.ex
515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
516 
 
517 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
518 
    """
519 
    Parameters:
520 
     - customerId
521 
     - from_date
522 
     - to_date
523 
     - status
524 
    """
525 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
526 
    return self.recv_getTransactionsForCustomer()
527 
 
528 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
529 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
530 
    args = getTransactionsForCustomer_args()
531 
    args.customerId = customerId
532 
    args.from_date = from_date
533 
    args.to_date = to_date
534 
    args.status = status
535 
    args.write(self._oprot)
536 
    self._oprot.writeMessageEnd()
537 
    self._oprot.trans.flush()
538 
 
539 
  def recv_getTransactionsForCustomer(self, ):
540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
541 
    if mtype == TMessageType.EXCEPTION:
542 
      x = TApplicationException()
543 
      x.read(self._iprot)
544 
      self._iprot.readMessageEnd()
545 
      raise x
546 
    result = getTransactionsForCustomer_result()
547 
    result.read(self._iprot)
548 
    self._iprot.readMessageEnd()
549 
    if result.success != None:
550 
      return result.success
551 
    if result.ex != None:
552 
      raise result.ex
553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
554 
 
132 ashish 555 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
556 
    """
557 
    Parameters:
558 
     - shoppingCartId
559 
    """
560 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
561 
    return self.recv_getTransactionsForShoppingCartId()
562 
 
563 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
564 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
565 
    args = getTransactionsForShoppingCartId_args()
566 
    args.shoppingCartId = shoppingCartId
567 
    args.write(self._oprot)
568 
    self._oprot.writeMessageEnd()
569 
    self._oprot.trans.flush()
570 
 
571 
  def recv_getTransactionsForShoppingCartId(self, ):
572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
573 
    if mtype == TMessageType.EXCEPTION:
574 
      x = TApplicationException()
575 
      x.read(self._iprot)
576 
      self._iprot.readMessageEnd()
577 
      raise x
578 
    result = getTransactionsForShoppingCartId_result()
579 
    result.read(self._iprot)
580 
    self._iprot.readMessageEnd()
581 
    if result.success != None:
582 
      return result.success
583 
    if result.ex != None:
584 
      raise result.ex
585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
586 
 
94 ashish 587 
  def getTransactionStatus(self, transactionId):
588 
    """
589 
    Parameters:
590 
     - transactionId
591 
    """
592 
    self.send_getTransactionStatus(transactionId)
593 
    return self.recv_getTransactionStatus()
594 
 
595 
  def send_getTransactionStatus(self, transactionId):
596 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
597 
    args = getTransactionStatus_args()
598 
    args.transactionId = transactionId
599 
    args.write(self._oprot)
600 
    self._oprot.writeMessageEnd()
601 
    self._oprot.trans.flush()
602 
 
603 
  def recv_getTransactionStatus(self, ):
604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
605 
    if mtype == TMessageType.EXCEPTION:
606 
      x = TApplicationException()
607 
      x.read(self._iprot)
608 
      self._iprot.readMessageEnd()
609 
      raise x
610 
    result = getTransactionStatus_result()
611 
    result.read(self._iprot)
612 
    self._iprot.readMessageEnd()
613 
    if result.success != None:
614 
      return result.success
615 
    if result.ex != None:
616 
      raise result.ex
617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
618 
 
619 
  def changeTransactionStatus(self, transactionId, status, description):
620 
    """
621 
    Parameters:
622 
     - transactionId
623 
     - status
624 
     - description
625 
    """
626 
    self.send_changeTransactionStatus(transactionId, status, description)
627 
    return self.recv_changeTransactionStatus()
628 
 
629 
  def send_changeTransactionStatus(self, transactionId, status, description):
630 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
631 
    args = changeTransactionStatus_args()
632 
    args.transactionId = transactionId
633 
    args.status = status
634 
    args.description = description
635 
    args.write(self._oprot)
636 
    self._oprot.writeMessageEnd()
637 
    self._oprot.trans.flush()
638 
 
639 
  def recv_changeTransactionStatus(self, ):
640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
641 
    if mtype == TMessageType.EXCEPTION:
642 
      x = TApplicationException()
643 
      x.read(self._iprot)
644 
      self._iprot.readMessageEnd()
645 
      raise x
646 
    result = changeTransactionStatus_result()
647 
    result.read(self._iprot)
648 
    self._iprot.readMessageEnd()
649 
    if result.success != None:
650 
      return result.success
651 
    if result.ex != None:
652 
      raise result.ex
653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
654 
 
1398 varun.gupt 655 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 656 
    """
657 
    Parameters:
658 
     - transactionId
659 
    """
1398 varun.gupt 660 
    self.send_enqueueTransactionInfoEmail(transactionId)
661 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 662 
 
1398 varun.gupt 663 
  def send_enqueueTransactionInfoEmail(self, transactionId):
664 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
665 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 666 
    args.transactionId = transactionId
667 
    args.write(self._oprot)
668 
    self._oprot.writeMessageEnd()
669 
    self._oprot.trans.flush()
670 
 
1398 varun.gupt 671 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
673 
    if mtype == TMessageType.EXCEPTION:
674 
      x = TApplicationException()
675 
      x.read(self._iprot)
676 
      self._iprot.readMessageEnd()
677 
      raise x
1398 varun.gupt 678 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 679 
    result.read(self._iprot)
680 
    self._iprot.readMessageEnd()
681 
    if result.success != None:
682 
      return result.success
683 
    if result.ex != None:
684 
      raise result.ex
1398 varun.gupt 685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 686 
 
483 rajveer 687 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 688 
    """
689 
    Parameters:
483 rajveer 690 
     - status
691 
     - from_date
692 
     - to_date
693 
     - warehouse_id
94 ashish 694 
    """
483 rajveer 695 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
696 
    return self.recv_getAllOrders()
94 ashish 697 
 
483 rajveer 698 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
699 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
700 
    args = getAllOrders_args()
701 
    args.status = status
702 
    args.from_date = from_date
703 
    args.to_date = to_date
704 
    args.warehouse_id = warehouse_id
94 ashish 705 
    args.write(self._oprot)
706 
    self._oprot.writeMessageEnd()
707 
    self._oprot.trans.flush()
708 
 
483 rajveer 709 
  def recv_getAllOrders(self, ):
94 ashish 710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
711 
    if mtype == TMessageType.EXCEPTION:
712 
      x = TApplicationException()
713 
      x.read(self._iprot)
714 
      self._iprot.readMessageEnd()
715 
      raise x
483 rajveer 716 
    result = getAllOrders_result()
94 ashish 717 
    result.read(self._iprot)
718 
    self._iprot.readMessageEnd()
719 
    if result.success != None:
720 
      return result.success
721 
    if result.ex != None:
722 
      raise result.ex
483 rajveer 723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 724 
 
999 varun.gupt 725 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
726 
    """
1132 chandransh 727 
    Returns orders within a range of their billing dates
728 
 
999 varun.gupt 729 
    Parameters:
730 
     - status
731 
     - start_billing_date
732 
     - end_billing_date
733 
     - warehouse_id
734 
    """
735 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
736 
    return self.recv_getOrdersByBillingDate()
737 
 
738 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
739 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
740 
    args = getOrdersByBillingDate_args()
741 
    args.status = status
742 
    args.start_billing_date = start_billing_date
743 
    args.end_billing_date = end_billing_date
744 
    args.warehouse_id = warehouse_id
745 
    args.write(self._oprot)
746 
    self._oprot.writeMessageEnd()
747 
    self._oprot.trans.flush()
748 
 
749 
  def recv_getOrdersByBillingDate(self, ):
750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
751 
    if mtype == TMessageType.EXCEPTION:
752 
      x = TApplicationException()
753 
      x.read(self._iprot)
754 
      self._iprot.readMessageEnd()
755 
      raise x
756 
    result = getOrdersByBillingDate_result()
757 
    result.read(self._iprot)
758 
    self._iprot.readMessageEnd()
759 
    if result.success != None:
760 
      return result.success
761 
    if result.ex != None:
762 
      raise result.ex
763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
764 
 
1382 varun.gupt 765 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
766 
    """
767 
    Returns order ids for orders which can be returned
768 
 
769 
    Parameters:
770 
     - customer_id
771 
     - limit
772 
    """
773 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
774 
    return self.recv_getReturnableOrdersForCustomer()
775 
 
776 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
777 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
778 
    args = getReturnableOrdersForCustomer_args()
779 
    args.customer_id = customer_id
780 
    args.limit = limit
781 
    args.write(self._oprot)
782 
    self._oprot.writeMessageEnd()
783 
    self._oprot.trans.flush()
784 
 
785 
  def recv_getReturnableOrdersForCustomer(self, ):
786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
787 
    if mtype == TMessageType.EXCEPTION:
788 
      x = TApplicationException()
789 
      x.read(self._iprot)
790 
      self._iprot.readMessageEnd()
791 
      raise x
792 
    result = getReturnableOrdersForCustomer_result()
793 
    result.read(self._iprot)
794 
    self._iprot.readMessageEnd()
795 
    if result.success != None:
796 
      return result.success
797 
    if result.ex != None:
798 
      raise result.ex
799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
800 
 
801 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
802 
    """
803 
    Returns order ids for orders which can be cancelled
804 
 
805 
    Parameters:
806 
     - customer_id
807 
     - limit
808 
    """
809 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
810 
    return self.recv_getCancellableOrdersForCustomer()
811 
 
812 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
813 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
814 
    args = getCancellableOrdersForCustomer_args()
815 
    args.customer_id = customer_id
816 
    args.limit = limit
817 
    args.write(self._oprot)
818 
    self._oprot.writeMessageEnd()
819 
    self._oprot.trans.flush()
820 
 
821 
  def recv_getCancellableOrdersForCustomer(self, ):
822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
823 
    if mtype == TMessageType.EXCEPTION:
824 
      x = TApplicationException()
825 
      x.read(self._iprot)
826 
      self._iprot.readMessageEnd()
827 
      raise x
828 
    result = getCancellableOrdersForCustomer_result()
829 
    result.read(self._iprot)
830 
    self._iprot.readMessageEnd()
831 
    if result.success != None:
832 
      return result.success
833 
    if result.ex != None:
834 
      raise result.ex
835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
836 
 
483 rajveer 837 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 838 
    """
839 
    Parameters:
483 rajveer 840 
     - orderId
841 
     - status
842 
     - description
94 ashish 843 
    """
483 rajveer 844 
    self.send_changeOrderStatus(orderId, status, description)
845 
    return self.recv_changeOrderStatus()
94 ashish 846 
 
483 rajveer 847 
  def send_changeOrderStatus(self, orderId, status, description):
848 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
849 
    args = changeOrderStatus_args()
850 
    args.orderId = orderId
851 
    args.status = status
852 
    args.description = description
94 ashish 853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
483 rajveer 857 
  def recv_changeOrderStatus(self, ):
94 ashish 858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
483 rajveer 864 
    result = changeOrderStatus_result()
94 ashish 865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
867 
    if result.success != None:
868 
      return result.success
869 
    if result.ex != None:
870 
      raise result.ex
483 rajveer 871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 872 
 
1149 chandransh 873 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 874 
    """
1149 chandransh 875 
    Add billing details such as the bill number and the biller to the Order.
876 
 
494 rajveer 877 
    Parameters:
878 
     - orderId
879 
     - invoice_number
880 
     - billed_by
881 
    """
1149 chandransh 882 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
494 rajveer 883 
    return self.recv_addBillingDetails()
884 
 
1149 chandransh 885 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 886 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
887 
    args = addBillingDetails_args()
888 
    args.orderId = orderId
889 
    args.invoice_number = invoice_number
890 
    args.billed_by = billed_by
891 
    args.write(self._oprot)
892 
    self._oprot.writeMessageEnd()
893 
    self._oprot.trans.flush()
894 
 
895 
  def recv_addBillingDetails(self, ):
896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
897 
    if mtype == TMessageType.EXCEPTION:
898 
      x = TApplicationException()
899 
      x.read(self._iprot)
900 
      self._iprot.readMessageEnd()
901 
      raise x
902 
    result = addBillingDetails_result()
903 
    result.read(self._iprot)
904 
    self._iprot.readMessageEnd()
905 
    if result.success != None:
906 
      return result.success
907 
    if result.ex != None:
908 
      raise result.ex
909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
910 
 
1149 chandransh 911 
  def addJacketNumber(self, orderId, jacketNumber):
912 
    """
2446 chandransh 913 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
914 
    Also marks the order as billed and sets the billing timestamp.
915 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 916 
 
917 
    Parameters:
918 
     - orderId
919 
     - jacketNumber
920 
    """
921 
    self.send_addJacketNumber(orderId, jacketNumber)
922 
    return self.recv_addJacketNumber()
923 
 
924 
  def send_addJacketNumber(self, orderId, jacketNumber):
925 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
926 
    args = addJacketNumber_args()
927 
    args.orderId = orderId
928 
    args.jacketNumber = jacketNumber
929 
    args.write(self._oprot)
930 
    self._oprot.writeMessageEnd()
931 
    self._oprot.trans.flush()
932 
 
933 
  def recv_addJacketNumber(self, ):
934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
935 
    if mtype == TMessageType.EXCEPTION:
936 
      x = TApplicationException()
937 
      x.read(self._iprot)
938 
      self._iprot.readMessageEnd()
939 
      raise x
940 
    result = addJacketNumber_result()
941 
    result.read(self._iprot)
942 
    self._iprot.readMessageEnd()
943 
    if result.success != None:
944 
      return result.success
945 
    if result.ex != None:
946 
      raise result.ex
947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
948 
 
921 rajveer 949 
  def acceptOrder(self, orderId):
950 
    """
951 
    Parameters:
952 
     - orderId
953 
    """
954 
    self.send_acceptOrder(orderId)
955 
    return self.recv_acceptOrder()
956 
 
957 
  def send_acceptOrder(self, orderId):
958 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
959 
    args = acceptOrder_args()
960 
    args.orderId = orderId
961 
    args.write(self._oprot)
962 
    self._oprot.writeMessageEnd()
963 
    self._oprot.trans.flush()
964 
 
965 
  def recv_acceptOrder(self, ):
966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
967 
    if mtype == TMessageType.EXCEPTION:
968 
      x = TApplicationException()
969 
      x.read(self._iprot)
970 
      self._iprot.readMessageEnd()
971 
      raise x
972 
    result = acceptOrder_result()
973 
    result.read(self._iprot)
974 
    self._iprot.readMessageEnd()
975 
    if result.success != None:
976 
      return result.success
977 
    if result.ex != None:
978 
      raise result.ex
979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
980 
 
981 
  def billOrder(self, orderId):
982 
    """
983 
    Parameters:
984 
     - orderId
985 
    """
986 
    self.send_billOrder(orderId)
987 
    return self.recv_billOrder()
988 
 
989 
  def send_billOrder(self, orderId):
990 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
991 
    args = billOrder_args()
992 
    args.orderId = orderId
993 
    args.write(self._oprot)
994 
    self._oprot.writeMessageEnd()
995 
    self._oprot.trans.flush()
996 
 
997 
  def recv_billOrder(self, ):
998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
999 
    if mtype == TMessageType.EXCEPTION:
1000 
      x = TApplicationException()
1001 
      x.read(self._iprot)
1002 
      self._iprot.readMessageEnd()
1003 
      raise x
1004 
    result = billOrder_result()
1005 
    result.read(self._iprot)
1006 
    self._iprot.readMessageEnd()
1007 
    if result.success != None:
1008 
      return result.success
1009 
    if result.ex != None:
1010 
      raise result.ex
1011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1012 
 
1528 ankur.sing 1013 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1014 
    """
1528 ankur.sing 1015 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1016 
    only user who owns the transaction can view its order details.
1017 
 
94 ashish 1018 
    Parameters:
1019 
     - transactionId
1528 ankur.sing 1020 
     - customerId
94 ashish 1021 
    """
1528 ankur.sing 1022 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1023 
    return self.recv_getOrdersForTransaction()
94 ashish 1024 
 
1528 ankur.sing 1025 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1026 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1027 
    args = getOrdersForTransaction_args()
94 ashish 1028 
    args.transactionId = transactionId
1528 ankur.sing 1029 
    args.customerId = customerId
94 ashish 1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
483 rajveer 1034 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
483 rajveer 1041 
    result = getOrdersForTransaction_result()
94 ashish 1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
1044 
    if result.success != None:
1045 
      return result.success
1046 
    if result.ex != None:
1047 
      raise result.ex
483 rajveer 1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1049 
 
483 rajveer 1050 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 1051 
    """
1052 
    Parameters:
483 rajveer 1053 
     - customerId
1054 
     - from_date
1055 
     - to_date
1056 
     - status
94 ashish 1057 
    """
483 rajveer 1058 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, status)
1059 
    return self.recv_getOrdersForCustomer()
94 ashish 1060 
 
483 rajveer 1061 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, status):
1062 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1063 
    args = getOrdersForCustomer_args()
1064 
    args.customerId = customerId
1065 
    args.from_date = from_date
1066 
    args.to_date = to_date
1067 
    args.status = status
94 ashish 1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
483 rajveer 1072 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
483 rajveer 1079 
    result = getOrdersForCustomer_result()
94 ashish 1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
1082 
    if result.success != None:
1083 
      return result.success
1084 
    if result.ex != None:
1085 
      raise result.ex
483 rajveer 1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1087 
 
483 rajveer 1088 
  def createOrder(self, order):
94 ashish 1089 
    """
1090 
    Parameters:
483 rajveer 1091 
     - order
94 ashish 1092 
    """
483 rajveer 1093 
    self.send_createOrder(order)
1094 
    return self.recv_createOrder()
94 ashish 1095 
 
483 rajveer 1096 
  def send_createOrder(self, order):
1097 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1098 
    args = createOrder_args()
1099 
    args.order = order
94 ashish 1100 
    args.write(self._oprot)
1101 
    self._oprot.writeMessageEnd()
1102 
    self._oprot.trans.flush()
1103 
 
483 rajveer 1104 
  def recv_createOrder(self, ):
94 ashish 1105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1106 
    if mtype == TMessageType.EXCEPTION:
1107 
      x = TApplicationException()
1108 
      x.read(self._iprot)
1109 
      self._iprot.readMessageEnd()
1110 
      raise x
483 rajveer 1111 
    result = createOrder_result()
94 ashish 1112 
    result.read(self._iprot)
1113 
    self._iprot.readMessageEnd()
1114 
    if result.success != None:
1115 
      return result.success
1116 
    if result.ex != None:
1117 
      raise result.ex
483 rajveer 1118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1119 
 
483 rajveer 1120 
  def getOrder(self, id):
94 ashish 1121 
    """
1122 
    Parameters:
483 rajveer 1123 
     - id
94 ashish 1124 
    """
483 rajveer 1125 
    self.send_getOrder(id)
1126 
    return self.recv_getOrder()
94 ashish 1127 
 
483 rajveer 1128 
  def send_getOrder(self, id):
1129 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1130 
    args = getOrder_args()
1131 
    args.id = id
94 ashish 1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
483 rajveer 1136 
  def recv_getOrder(self, ):
94 ashish 1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
483 rajveer 1143 
    result = getOrder_result()
94 ashish 1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
1146 
    if result.success != None:
1147 
      return result.success
1148 
    if result.ex != None:
1149 
      raise result.ex
483 rajveer 1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1151 
 
483 rajveer 1152 
  def getLineItemsForOrder(self, orderId):
94 ashish 1153 
    """
1154 
    Parameters:
483 rajveer 1155 
     - orderId
94 ashish 1156 
    """
483 rajveer 1157 
    self.send_getLineItemsForOrder(orderId)
1158 
    return self.recv_getLineItemsForOrder()
94 ashish 1159 
 
483 rajveer 1160 
  def send_getLineItemsForOrder(self, orderId):
1161 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1162 
    args = getLineItemsForOrder_args()
1163 
    args.orderId = orderId
94 ashish 1164 
    args.write(self._oprot)
1165 
    self._oprot.writeMessageEnd()
1166 
    self._oprot.trans.flush()
1167 
 
483 rajveer 1168 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1170 
    if mtype == TMessageType.EXCEPTION:
1171 
      x = TApplicationException()
1172 
      x.read(self._iprot)
1173 
      self._iprot.readMessageEnd()
1174 
      raise x
483 rajveer 1175 
    result = getLineItemsForOrder_result()
94 ashish 1176 
    result.read(self._iprot)
1177 
    self._iprot.readMessageEnd()
1178 
    if result.success != None:
1179 
      return result.success
1180 
    if result.ex != None:
1181 
      raise result.ex
483 rajveer 1182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1183 
 
1528 ankur.sing 1184 
  def getOrderForCustomer(self, orderId, customerId):
1185 
    """
1186 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1187 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
1188 
 
1189 
    Parameters:
1190 
     - orderId
1191 
     - customerId
1192 
    """
1193 
    self.send_getOrderForCustomer(orderId, customerId)
1194 
    return self.recv_getOrderForCustomer()
1195 
 
1196 
  def send_getOrderForCustomer(self, orderId, customerId):
1197 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1198 
    args = getOrderForCustomer_args()
1199 
    args.orderId = orderId
1200 
    args.customerId = customerId
1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_getOrderForCustomer(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = getOrderForCustomer_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
1215 
    if result.success != None:
1216 
      return result.success
1217 
    if result.ex != None:
1218 
      raise result.ex
1219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1220 
 
1220 chandransh 1221 
  def batchOrders(self, warehouseId):
1222 
    """
1223 
    Create a batch of all the pending orders for the given warehouse.
1224 
    The returned list is orderd by created_timestamp.
1225 
    If there are no pending orders, an empty list is returned.
1226 
 
1227 
    Parameters:
1228 
     - warehouseId
1229 
    """
1230 
    self.send_batchOrders(warehouseId)
1231 
    return self.recv_batchOrders()
1232 
 
1233 
  def send_batchOrders(self, warehouseId):
1234 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1235 
    args = batchOrders_args()
1236 
    args.warehouseId = warehouseId
1237 
    args.write(self._oprot)
1238 
    self._oprot.writeMessageEnd()
1239 
    self._oprot.trans.flush()
1240 
 
1241 
  def recv_batchOrders(self, ):
1242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1243 
    if mtype == TMessageType.EXCEPTION:
1244 
      x = TApplicationException()
1245 
      x.read(self._iprot)
1246 
      self._iprot.readMessageEnd()
1247 
      raise x
1248 
    result = batchOrders_result()
1249 
    result.read(self._iprot)
1250 
    self._iprot.readMessageEnd()
1251 
    if result.success != None:
1252 
      return result.success
1253 
    if result.ex != None:
1254 
      raise result.ex
1255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1256 
 
1208 chandransh 1257 
  def markOrderAsOutOfStock(self, orderId):
1258 
    """
1259 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
1260 
 
1261 
    Parameters:
1262 
     - orderId
1263 
    """
1264 
    self.send_markOrderAsOutOfStock(orderId)
1265 
    return self.recv_markOrderAsOutOfStock()
1266 
 
1267 
  def send_markOrderAsOutOfStock(self, orderId):
1268 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1269 
    args = markOrderAsOutOfStock_args()
1270 
    args.orderId = orderId
1271 
    args.write(self._oprot)
1272 
    self._oprot.writeMessageEnd()
1273 
    self._oprot.trans.flush()
1274 
 
1275 
  def recv_markOrderAsOutOfStock(self, ):
1276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1277 
    if mtype == TMessageType.EXCEPTION:
1278 
      x = TApplicationException()
1279 
      x.read(self._iprot)
1280 
      self._iprot.readMessageEnd()
1281 
      raise x
1282 
    result = markOrderAsOutOfStock_result()
1283 
    result.read(self._iprot)
1284 
    self._iprot.readMessageEnd()
1285 
    if result.success != None:
1286 
      return result.success
1287 
    if result.ex != None:
1288 
      raise result.ex
1289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1290 
 
759 chandransh 1291 
  def markOrdersAsManifested(self, warehouseId, providerId):
1292 
    """
1293 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
1294 
 
1295 
    Parameters:
1296 
     - warehouseId
1297 
     - providerId
1298 
    """
1299 
    self.send_markOrdersAsManifested(warehouseId, providerId)
1300 
    return self.recv_markOrdersAsManifested()
1301 
 
1302 
  def send_markOrdersAsManifested(self, warehouseId, providerId):
1303 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1304 
    args = markOrdersAsManifested_args()
1305 
    args.warehouseId = warehouseId
1306 
    args.providerId = providerId
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_markOrdersAsManifested(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = markOrdersAsManifested_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
1321 
    if result.success != None:
1322 
      return result.success
1323 
    if result.ex != None:
1324 
      raise result.ex
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1326 
 
1113 chandransh 1327 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
1328 
    """
1329 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1330 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1331 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1332 
 
1333 
    Parameters:
1334 
     - providerId
1335 
     - pickupDetails
1336 
    """
1337 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1338 
    return self.recv_markOrdersAsPickedUp()
1339 
 
1340 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1341 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1342 
    args = markOrdersAsPickedUp_args()
1343 
    args.providerId = providerId
1344 
    args.pickupDetails = pickupDetails
1345 
    args.write(self._oprot)
1346 
    self._oprot.writeMessageEnd()
1347 
    self._oprot.trans.flush()
1348 
 
1349 
  def recv_markOrdersAsPickedUp(self, ):
1350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1351 
    if mtype == TMessageType.EXCEPTION:
1352 
      x = TApplicationException()
1353 
      x.read(self._iprot)
1354 
      self._iprot.readMessageEnd()
1355 
      raise x
1356 
    result = markOrdersAsPickedUp_result()
1357 
    result.read(self._iprot)
1358 
    self._iprot.readMessageEnd()
1359 
    if result.success != None:
1360 
      return result.success
1361 
    if result.ex != None:
1362 
      raise result.ex
1363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
1364 
 
1132 chandransh 1365 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
1366 
    """
1367 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1368 
    the name of the receiver.
1369 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1370 
 
1371 
    Parameters:
1372 
     - providerId
1373 
     - deliveredOrders
1374 
    """
1375 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1376 
    self.recv_markOrdersAsDelivered()
1377 
 
1378 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1379 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1380 
    args = markOrdersAsDelivered_args()
1381 
    args.providerId = providerId
1382 
    args.deliveredOrders = deliveredOrders
1383 
    args.write(self._oprot)
1384 
    self._oprot.writeMessageEnd()
1385 
    self._oprot.trans.flush()
1386 
 
1387 
  def recv_markOrdersAsDelivered(self, ):
1388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1389 
    if mtype == TMessageType.EXCEPTION:
1390 
      x = TApplicationException()
1391 
      x.read(self._iprot)
1392 
      self._iprot.readMessageEnd()
1393 
      raise x
1394 
    result = markOrdersAsDelivered_result()
1395 
    result.read(self._iprot)
1396 
    self._iprot.readMessageEnd()
1397 
    if result.ex != None:
1398 
      raise result.ex
1399 
    return
1400 
 
1135 chandransh 1401 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1402 
    """
1403 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1404 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1405 
 
1406 
    Parameters:
1407 
     - providerId
1408 
     - returnedOrders
1409 
    """
1410 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1411 
    self.recv_markOrdersAsFailed()
1412 
 
1413 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1414 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1415 
    args = markOrdersAsFailed_args()
1416 
    args.providerId = providerId
1417 
    args.returnedOrders = returnedOrders
1418 
    args.write(self._oprot)
1419 
    self._oprot.writeMessageEnd()
1420 
    self._oprot.trans.flush()
1421 
 
1422 
  def recv_markOrdersAsFailed(self, ):
1423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1424 
    if mtype == TMessageType.EXCEPTION:
1425 
      x = TApplicationException()
1426 
      x.read(self._iprot)
1427 
      self._iprot.readMessageEnd()
1428 
      raise x
1429 
    result = markOrdersAsFailed_result()
1430 
    result.read(self._iprot)
1431 
    self._iprot.readMessageEnd()
1432 
    if result.ex != None:
1433 
      raise result.ex
1434 
    return
1435 
 
1246 chandransh 1436 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1437 
    """
1438 
    Update the status description of orders whose AWB numbers are keys of the Map.
1439 
 
1440 
    Parameters:
1441 
     - providerId
1442 
     - undeliveredOrders
1443 
    """
1444 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
1445 
    self.recv_updateNonDeliveryReason()
1446 
 
1447 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
1448 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
1449 
    args = updateNonDeliveryReason_args()
1450 
    args.providerId = providerId
1451 
    args.undeliveredOrders = undeliveredOrders
1452 
    args.write(self._oprot)
1453 
    self._oprot.writeMessageEnd()
1454 
    self._oprot.trans.flush()
1455 
 
1456 
  def recv_updateNonDeliveryReason(self, ):
1457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1458 
    if mtype == TMessageType.EXCEPTION:
1459 
      x = TApplicationException()
1460 
      x.read(self._iprot)
1461 
      self._iprot.readMessageEnd()
1462 
      raise x
1463 
    result = updateNonDeliveryReason_result()
1464 
    result.read(self._iprot)
1465 
    self._iprot.readMessageEnd()
1466 
    if result.ex != None:
1467 
      raise result.ex
1468 
    return
1469 
 
1408 ankur.sing 1470 
  def getUndeliveredOrders(self, providerId, warehouseId):
1471 
    """
1472 
    Returns the list of orders whose delivery time has passed but have not been
1473 
    delivered yet for the given provider and warehouse. To get a complete list of
1474 
    undelivered orders, pass them as -1.
1475 
    Returns an empty list if no such orders exist.
1476 
 
1477 
    Parameters:
1478 
     - providerId
1479 
     - warehouseId
1480 
    """
1481 
    self.send_getUndeliveredOrders(providerId, warehouseId)
1482 
    return self.recv_getUndeliveredOrders()
1483 
 
1484 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
1485 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
1486 
    args = getUndeliveredOrders_args()
1487 
    args.providerId = providerId
1488 
    args.warehouseId = warehouseId
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_getUndeliveredOrders(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = getUndeliveredOrders_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
1503 
    if result.success != None:
1504 
      return result.success
1505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1506 
 
483 rajveer 1507 
  def getAlerts(self, orderId, valid):
94 ashish 1508 
    """
1509 
    Parameters:
483 rajveer 1510 
     - orderId
304 ashish 1511 
     - valid
1512 
    """
483 rajveer 1513 
    self.send_getAlerts(orderId, valid)
304 ashish 1514 
    return self.recv_getAlerts()
94 ashish 1515 
 
483 rajveer 1516 
  def send_getAlerts(self, orderId, valid):
304 ashish 1517 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1518 
    args = getAlerts_args()
483 rajveer 1519 
    args.orderId = orderId
304 ashish 1520 
    args.valid = valid
1521 
    args.write(self._oprot)
1522 
    self._oprot.writeMessageEnd()
1523 
    self._oprot.trans.flush()
1524 
 
1525 
  def recv_getAlerts(self, ):
1526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1527 
    if mtype == TMessageType.EXCEPTION:
1528 
      x = TApplicationException()
1529 
      x.read(self._iprot)
1530 
      self._iprot.readMessageEnd()
1531 
      raise x
1532 
    result = getAlerts_result()
1533 
    result.read(self._iprot)
1534 
    self._iprot.readMessageEnd()
1535 
    if result.success != None:
1536 
      return result.success
1537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1538 
 
483 rajveer 1539 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 1540 
    """
1541 
    Parameters:
483 rajveer 1542 
     - orderId
304 ashish 1543 
     - unset
1544 
     - type
1545 
     - comment
1546 
    """
483 rajveer 1547 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 1548 
    self.recv_setAlert()
1549 
 
483 rajveer 1550 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 1551 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1552 
    args = setAlert_args()
483 rajveer 1553 
    args.orderId = orderId
304 ashish 1554 
    args.unset = unset
1555 
    args.type = type
1556 
    args.comment = comment
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_setAlert(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = setAlert_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
1571 
    return
1572 
 
1596 ankur.sing 1573 
  def getValidOrderCount(self, ):
1574 
    """
1575 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1576 
    """
1577 
    self.send_getValidOrderCount()
1578 
    return self.recv_getValidOrderCount()
304 ashish 1579 
 
1596 ankur.sing 1580 
  def send_getValidOrderCount(self, ):
1581 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1582 
    args = getValidOrderCount_args()
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getValidOrderCount(self, ):
1588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1589 
    if mtype == TMessageType.EXCEPTION:
1590 
      x = TApplicationException()
1591 
      x.read(self._iprot)
1592 
      self._iprot.readMessageEnd()
1593 
      raise x
1594 
    result = getValidOrderCount_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
1597 
    if result.success != None:
1598 
      return result.success
1599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1600 
 
1627 ankur.sing 1601 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1602 
    """
1603 
    Returns the number of distinct customers who have done successful transactions
1604 
    """
1605 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1606 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1596 ankur.sing 1607 
 
1627 ankur.sing 1608 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1609 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1610 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
1615 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
1622 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
1625 
    if result.success != None:
1626 
      return result.success
1627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1628 
 
1731 ankur.sing 1629 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 1630 
    """
1731 ankur.sing 1631 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1632 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 1633 
    """
1731 ankur.sing 1634 
    self.send_getValidOrdersAmountRange()
1635 
    return self.recv_getValidOrdersAmountRange()
1627 ankur.sing 1636 
 
1731 ankur.sing 1637 
  def send_getValidOrdersAmountRange(self, ):
1638 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1639 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1731 ankur.sing 1644 
  def recv_getValidOrdersAmountRange(self, ):
1627 ankur.sing 1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1731 ankur.sing 1651 
    result = getValidOrdersAmountRange_result()
1627 ankur.sing 1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
1654 
    if result.success != None:
1655 
      return result.success
1731 ankur.sing 1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1627 ankur.sing 1657 
 
1886 ankur.sing 1658 
  def getValidOrders(self, limit):
1659 
    """
1660 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1661 
    If limit is passed as 0, then all valid Orders are returned.
1662 
 
1663 
    Parameters:
1664 
     - limit
1665 
    """
1666 
    self.send_getValidOrders(limit)
1667 
    return self.recv_getValidOrders()
1627 ankur.sing 1668 
 
1886 ankur.sing 1669 
  def send_getValidOrders(self, limit):
1670 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1671 
    args = getValidOrders_args()
1672 
    args.limit = limit
1673 
    args.write(self._oprot)
1674 
    self._oprot.writeMessageEnd()
1675 
    self._oprot.trans.flush()
1676 
 
1677 
  def recv_getValidOrders(self, ):
1678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1679 
    if mtype == TMessageType.EXCEPTION:
1680 
      x = TApplicationException()
1681 
      x.read(self._iprot)
1682 
      self._iprot.readMessageEnd()
1683 
      raise x
1684 
    result = getValidOrders_result()
1685 
    result.read(self._iprot)
1686 
    self._iprot.readMessageEnd()
1687 
    if result.success != None:
1688 
      return result.success
1689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1690 
 
2536 chandransh 1691 
  def toggleDOAFlag(self, orderId):
1692 
    """
1693 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
1694 
    Returns the final flag status.
1695 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
1696 
 
1697 
    Parameters:
1698 
     - orderId
1699 
    """
1700 
    self.send_toggleDOAFlag(orderId)
1701 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 1702 
 
2536 chandransh 1703 
  def send_toggleDOAFlag(self, orderId):
1704 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
1705 
    args = toggleDOAFlag_args()
1706 
    args.orderId = orderId
1707 
    args.write(self._oprot)
1708 
    self._oprot.writeMessageEnd()
1709 
    self._oprot.trans.flush()
1710 
 
1711 
  def recv_toggleDOAFlag(self, ):
1712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1713 
    if mtype == TMessageType.EXCEPTION:
1714 
      x = TApplicationException()
1715 
      x.read(self._iprot)
1716 
      self._iprot.readMessageEnd()
1717 
      raise x
1718 
    result = toggleDOAFlag_result()
1719 
    result.read(self._iprot)
1720 
    self._iprot.readMessageEnd()
1721 
    if result.success != None:
1722 
      return result.success
1723 
    if result.ex != None:
1724 
      raise result.ex
1725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
1726 
 
1727 
  def requestPickupNumber(self, orderId):
1728 
    """
1729 
    Sends out an email to the account manager of the original courier provider used to ship the order.
1730 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
1731 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
1732 
    For any other status, it returns false.
1733 
    Throws an exception if the order with the given id couldn't be found.
1734 
 
1735 
    Parameters:
1736 
     - orderId
1737 
    """
1738 
    self.send_requestPickupNumber(orderId)
1739 
    return self.recv_requestPickupNumber()
1740 
 
1741 
  def send_requestPickupNumber(self, orderId):
1742 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
1743 
    args = requestPickupNumber_args()
1744 
    args.orderId = orderId
1745 
    args.write(self._oprot)
1746 
    self._oprot.writeMessageEnd()
1747 
    self._oprot.trans.flush()
1748 
 
1749 
  def recv_requestPickupNumber(self, ):
1750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1751 
    if mtype == TMessageType.EXCEPTION:
1752 
      x = TApplicationException()
1753 
      x.read(self._iprot)
1754 
      self._iprot.readMessageEnd()
1755 
      raise x
1756 
    result = requestPickupNumber_result()
1757 
    result.read(self._iprot)
1758 
    self._iprot.readMessageEnd()
1759 
    if result.success != None:
1760 
      return result.success
1761 
    if result.ex != None:
1762 
      raise result.ex
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
1764 
 
1765 
  def authorizePickup(self, orderId, pickupNumber):
1766 
    """
1767 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
1768 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
1769 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
1770 
    	3. Returns true
2591 chandransh 1771 
    If the order is in any other status, it returns false.
2536 chandransh 1772 
    Throws an exception if the order with the given id couldn't be found.
1773 
 
1774 
    Parameters:
1775 
     - orderId
1776 
     - pickupNumber
1777 
    """
1778 
    self.send_authorizePickup(orderId, pickupNumber)
1779 
    return self.recv_authorizePickup()
1780 
 
1781 
  def send_authorizePickup(self, orderId, pickupNumber):
1782 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
1783 
    args = authorizePickup_args()
1784 
    args.orderId = orderId
1785 
    args.pickupNumber = pickupNumber
1786 
    args.write(self._oprot)
1787 
    self._oprot.writeMessageEnd()
1788 
    self._oprot.trans.flush()
1789 
 
1790 
  def recv_authorizePickup(self, ):
1791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1792 
    if mtype == TMessageType.EXCEPTION:
1793 
      x = TApplicationException()
1794 
      x.read(self._iprot)
1795 
      self._iprot.readMessageEnd()
1796 
      raise x
1797 
    result = authorizePickup_result()
1798 
    result.read(self._iprot)
1799 
    self._iprot.readMessageEnd()
1800 
    if result.success != None:
1801 
      return result.success
1802 
    if result.ex != None:
1803 
      raise result.ex
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
1805 
 
2591 chandransh 1806 
  def acceptDoa(self, orderId):
1807 
    """
1808 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RETURNED and returns true.
1809 
    If the order is in any other state, it returns false.
1810 
    Throws an exception if the order with the given id couldn't be found.
1811 
 
1812 
    Parameters:
1813 
     - orderId
1814 
    """
1815 
    self.send_acceptDoa(orderId)
1816 
    return self.recv_acceptDoa()
2536 chandransh 1817 
 
2591 chandransh 1818 
  def send_acceptDoa(self, orderId):
1819 
    self._oprot.writeMessageBegin('acceptDoa', TMessageType.CALL, self._seqid)
1820 
    args = acceptDoa_args()
1821 
    args.orderId = orderId
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_acceptDoa(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = acceptDoa_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.success != None:
1837 
      return result.success
1838 
    if result.ex != None:
1839 
      raise result.ex
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptDoa failed: unknown result");
1841 
 
1842 
  def validateDoa(self, orderId, isValid):
1843 
    """
1844 
    Used to validate the DOA certificate for an order in the DOA_RETURNED state. If the certificate is valid,
1845 
    the order state is changed to DOA_PENDING and the warehouse executive gets to print a return receiving letter.
1846 
    If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
1847 
    If the order is in any other state, it returns false.
1848 
    Throws an exception if the order with the given id couldn't be found.
1849 
 
1850 
    Parameters:
1851 
     - orderId
1852 
     - isValid
1853 
    """
1854 
    self.send_validateDoa(orderId, isValid)
1855 
    return self.recv_validateDoa()
1856 
 
1857 
  def send_validateDoa(self, orderId, isValid):
1858 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
1859 
    args = validateDoa_args()
1860 
    args.orderId = orderId
1861 
    args.isValid = isValid
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_validateDoa(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = validateDoa_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    if result.success != None:
1877 
      return result.success
1878 
    if result.ex != None:
1879 
      raise result.ex
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
1881 
 
1882 
 
94 ashish 1883 
class Processor(Iface, TProcessor):
1884 
  def __init__(self, handler):
1885 
    self._handler = handler
1886 
    self._processMap = {}
765 rajveer 1887 
    self._processMap["closeSession"] = Processor.process_closeSession
94 ashish 1888 
    self._processMap["createTransaction"] = Processor.process_createTransaction
1889 
    self._processMap["getTransaction"] = Processor.process_getTransaction
1890 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 1891 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 1892 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
1893 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 1894 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 1895 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 1896 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
1382 varun.gupt 1897 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
1898 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 1899 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 1900 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
1149 chandransh 1901 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
921 rajveer 1902 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
1903 
    self._processMap["billOrder"] = Processor.process_billOrder
483 rajveer 1904 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
1905 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
1906 
    self._processMap["createOrder"] = Processor.process_createOrder
1907 
    self._processMap["getOrder"] = Processor.process_getOrder
1908 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 1909 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
1220 chandransh 1910 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 1911 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
759 chandransh 1912 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 1913 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 1914 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 1915 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 1916 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 1917 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
304 ashish 1918 
    self._processMap["getAlerts"] = Processor.process_getAlerts
1919 
    self._processMap["setAlert"] = Processor.process_setAlert
1596 ankur.sing 1920 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
1627 ankur.sing 1921 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
1731 ankur.sing 1922 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
1886 ankur.sing 1923 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
2536 chandransh 1924 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
1925 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
1926 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2591 chandransh 1927 
    self._processMap["acceptDoa"] = Processor.process_acceptDoa
1928 
    self._processMap["validateDoa"] = Processor.process_validateDoa
94 ashish 1929 
 
1930 
  def process(self, iprot, oprot):
1931 
    (name, type, seqid) = iprot.readMessageBegin()
1932 
    if name not in self._processMap:
1933 
      iprot.skip(TType.STRUCT)
1934 
      iprot.readMessageEnd()
1935 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1936 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1937 
      x.write(oprot)
1938 
      oprot.writeMessageEnd()
1939 
      oprot.trans.flush()
1940 
      return
1941 
    else:
1942 
      self._processMap[name](self, seqid, iprot, oprot)
1943 
    return True
1944 
 
765 rajveer 1945 
  def process_closeSession(self, seqid, iprot, oprot):
1946 
    args = closeSession_args()
1947 
    args.read(iprot)
1948 
    iprot.readMessageEnd()
1949 
    result = closeSession_result()
1950 
    self._handler.closeSession()
1951 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
1952 
    result.write(oprot)
1953 
    oprot.writeMessageEnd()
1954 
    oprot.trans.flush()
1955 
 
94 ashish 1956 
  def process_createTransaction(self, seqid, iprot, oprot):
1957 
    args = createTransaction_args()
1958 
    args.read(iprot)
1959 
    iprot.readMessageEnd()
1960 
    result = createTransaction_result()
1961 
    try:
132 ashish 1962 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 1963 
    except TransactionServiceException, ex:
1964 
      result.ex = ex
1965 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
1966 
    result.write(oprot)
1967 
    oprot.writeMessageEnd()
1968 
    oprot.trans.flush()
1969 
 
1970 
  def process_getTransaction(self, seqid, iprot, oprot):
1971 
    args = getTransaction_args()
1972 
    args.read(iprot)
1973 
    iprot.readMessageEnd()
1974 
    result = getTransaction_result()
1975 
    try:
1976 
      result.success = self._handler.getTransaction(args.id)
1977 
    except TransactionServiceException, ex:
1978 
      result.ex = ex
1979 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
1980 
    result.write(oprot)
1981 
    oprot.writeMessageEnd()
1982 
    oprot.trans.flush()
1983 
 
1984 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
1985 
    args = getTransactionsForCustomer_args()
1986 
    args.read(iprot)
1987 
    iprot.readMessageEnd()
1988 
    result = getTransactionsForCustomer_result()
1989 
    try:
1990 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
1991 
    except TransactionServiceException, ex:
1992 
      result.ex = ex
1993 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
1994 
    result.write(oprot)
1995 
    oprot.writeMessageEnd()
1996 
    oprot.trans.flush()
1997 
 
132 ashish 1998 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
1999 
    args = getTransactionsForShoppingCartId_args()
2000 
    args.read(iprot)
2001 
    iprot.readMessageEnd()
2002 
    result = getTransactionsForShoppingCartId_result()
2003 
    try:
2004 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
2005 
    except TransactionServiceException, ex:
2006 
      result.ex = ex
2007 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
2008 
    result.write(oprot)
2009 
    oprot.writeMessageEnd()
2010 
    oprot.trans.flush()
2011 
 
94 ashish 2012 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
2013 
    args = getTransactionStatus_args()
2014 
    args.read(iprot)
2015 
    iprot.readMessageEnd()
2016 
    result = getTransactionStatus_result()
2017 
    try:
2018 
      result.success = self._handler.getTransactionStatus(args.transactionId)
2019 
    except TransactionServiceException, ex:
2020 
      result.ex = ex
2021 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
2022 
    result.write(oprot)
2023 
    oprot.writeMessageEnd()
2024 
    oprot.trans.flush()
2025 
 
2026 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
2027 
    args = changeTransactionStatus_args()
2028 
    args.read(iprot)
2029 
    iprot.readMessageEnd()
2030 
    result = changeTransactionStatus_result()
2031 
    try:
2032 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
2033 
    except TransactionServiceException, ex:
2034 
      result.ex = ex
2035 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
2036 
    result.write(oprot)
2037 
    oprot.writeMessageEnd()
2038 
    oprot.trans.flush()
2039 
 
1398 varun.gupt 2040 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
2041 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 2042 
    args.read(iprot)
2043 
    iprot.readMessageEnd()
1398 varun.gupt 2044 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 2045 
    try:
1398 varun.gupt 2046 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 2047 
    except TransactionServiceException, ex:
2048 
      result.ex = ex
1398 varun.gupt 2049 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 2050 
    result.write(oprot)
2051 
    oprot.writeMessageEnd()
2052 
    oprot.trans.flush()
2053 
 
483 rajveer 2054 
  def process_getAllOrders(self, seqid, iprot, oprot):
2055 
    args = getAllOrders_args()
94 ashish 2056 
    args.read(iprot)
2057 
    iprot.readMessageEnd()
483 rajveer 2058 
    result = getAllOrders_result()
94 ashish 2059 
    try:
483 rajveer 2060 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 2061 
    except TransactionServiceException, ex:
2062 
      result.ex = ex
483 rajveer 2063 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 2064 
    result.write(oprot)
2065 
    oprot.writeMessageEnd()
2066 
    oprot.trans.flush()
2067 
 
999 varun.gupt 2068 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
2069 
    args = getOrdersByBillingDate_args()
2070 
    args.read(iprot)
2071 
    iprot.readMessageEnd()
2072 
    result = getOrdersByBillingDate_result()
2073 
    try:
2074 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
2075 
    except TransactionServiceException, ex:
2076 
      result.ex = ex
2077 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
2078 
    result.write(oprot)
2079 
    oprot.writeMessageEnd()
2080 
    oprot.trans.flush()
2081 
 
1382 varun.gupt 2082 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
2083 
    args = getReturnableOrdersForCustomer_args()
2084 
    args.read(iprot)
2085 
    iprot.readMessageEnd()
2086 
    result = getReturnableOrdersForCustomer_result()
2087 
    try:
2088 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
2089 
    except TransactionServiceException, ex:
2090 
      result.ex = ex
2091 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
2092 
    result.write(oprot)
2093 
    oprot.writeMessageEnd()
2094 
    oprot.trans.flush()
2095 
 
2096 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
2097 
    args = getCancellableOrdersForCustomer_args()
2098 
    args.read(iprot)
2099 
    iprot.readMessageEnd()
2100 
    result = getCancellableOrdersForCustomer_result()
2101 
    try:
2102 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
2103 
    except TransactionServiceException, ex:
2104 
      result.ex = ex
2105 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
2106 
    result.write(oprot)
2107 
    oprot.writeMessageEnd()
2108 
    oprot.trans.flush()
2109 
 
483 rajveer 2110 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
2111 
    args = changeOrderStatus_args()
94 ashish 2112 
    args.read(iprot)
2113 
    iprot.readMessageEnd()
483 rajveer 2114 
    result = changeOrderStatus_result()
94 ashish 2115 
    try:
483 rajveer 2116 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 2117 
    except TransactionServiceException, ex:
2118 
      result.ex = ex
483 rajveer 2119 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 2120 
    result.write(oprot)
2121 
    oprot.writeMessageEnd()
2122 
    oprot.trans.flush()
2123 
 
494 rajveer 2124 
  def process_addBillingDetails(self, seqid, iprot, oprot):
2125 
    args = addBillingDetails_args()
2126 
    args.read(iprot)
2127 
    iprot.readMessageEnd()
2128 
    result = addBillingDetails_result()
2129 
    try:
1149 chandransh 2130 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
494 rajveer 2131 
    except TransactionServiceException, ex:
2132 
      result.ex = ex
2133 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
2134 
    result.write(oprot)
2135 
    oprot.writeMessageEnd()
2136 
    oprot.trans.flush()
2137 
 
1149 chandransh 2138 
  def process_addJacketNumber(self, seqid, iprot, oprot):
2139 
    args = addJacketNumber_args()
2140 
    args.read(iprot)
2141 
    iprot.readMessageEnd()
2142 
    result = addJacketNumber_result()
2143 
    try:
2144 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber)
2145 
    except TransactionServiceException, ex:
2146 
      result.ex = ex
2147 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
2148 
    result.write(oprot)
2149 
    oprot.writeMessageEnd()
2150 
    oprot.trans.flush()
2151 
 
921 rajveer 2152 
  def process_acceptOrder(self, seqid, iprot, oprot):
2153 
    args = acceptOrder_args()
2154 
    args.read(iprot)
2155 
    iprot.readMessageEnd()
2156 
    result = acceptOrder_result()
2157 
    try:
2158 
      result.success = self._handler.acceptOrder(args.orderId)
2159 
    except TransactionServiceException, ex:
2160 
      result.ex = ex
2161 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
2162 
    result.write(oprot)
2163 
    oprot.writeMessageEnd()
2164 
    oprot.trans.flush()
2165 
 
2166 
  def process_billOrder(self, seqid, iprot, oprot):
2167 
    args = billOrder_args()
2168 
    args.read(iprot)
2169 
    iprot.readMessageEnd()
2170 
    result = billOrder_result()
2171 
    try:
2172 
      result.success = self._handler.billOrder(args.orderId)
2173 
    except TransactionServiceException, ex:
2174 
      result.ex = ex
2175 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
2176 
    result.write(oprot)
2177 
    oprot.writeMessageEnd()
2178 
    oprot.trans.flush()
2179 
 
483 rajveer 2180 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
2181 
    args = getOrdersForTransaction_args()
94 ashish 2182 
    args.read(iprot)
2183 
    iprot.readMessageEnd()
483 rajveer 2184 
    result = getOrdersForTransaction_result()
94 ashish 2185 
    try:
1528 ankur.sing 2186 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 2187 
    except TransactionServiceException, ex:
2188 
      result.ex = ex
483 rajveer 2189 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 2190 
    result.write(oprot)
2191 
    oprot.writeMessageEnd()
2192 
    oprot.trans.flush()
2193 
 
483 rajveer 2194 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
2195 
    args = getOrdersForCustomer_args()
94 ashish 2196 
    args.read(iprot)
2197 
    iprot.readMessageEnd()
483 rajveer 2198 
    result = getOrdersForCustomer_result()
94 ashish 2199 
    try:
483 rajveer 2200 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status)
94 ashish 2201 
    except TransactionServiceException, ex:
2202 
      result.ex = ex
483 rajveer 2203 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 2204 
    result.write(oprot)
2205 
    oprot.writeMessageEnd()
2206 
    oprot.trans.flush()
2207 
 
483 rajveer 2208 
  def process_createOrder(self, seqid, iprot, oprot):
2209 
    args = createOrder_args()
94 ashish 2210 
    args.read(iprot)
2211 
    iprot.readMessageEnd()
483 rajveer 2212 
    result = createOrder_result()
94 ashish 2213 
    try:
483 rajveer 2214 
      result.success = self._handler.createOrder(args.order)
94 ashish 2215 
    except TransactionServiceException, ex:
2216 
      result.ex = ex
483 rajveer 2217 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 2218 
    result.write(oprot)
2219 
    oprot.writeMessageEnd()
2220 
    oprot.trans.flush()
2221 
 
483 rajveer 2222 
  def process_getOrder(self, seqid, iprot, oprot):
2223 
    args = getOrder_args()
94 ashish 2224 
    args.read(iprot)
2225 
    iprot.readMessageEnd()
483 rajveer 2226 
    result = getOrder_result()
94 ashish 2227 
    try:
483 rajveer 2228 
      result.success = self._handler.getOrder(args.id)
94 ashish 2229 
    except TransactionServiceException, ex:
2230 
      result.ex = ex
483 rajveer 2231 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 2232 
    result.write(oprot)
2233 
    oprot.writeMessageEnd()
2234 
    oprot.trans.flush()
2235 
 
483 rajveer 2236 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
2237 
    args = getLineItemsForOrder_args()
94 ashish 2238 
    args.read(iprot)
2239 
    iprot.readMessageEnd()
483 rajveer 2240 
    result = getLineItemsForOrder_result()
94 ashish 2241 
    try:
483 rajveer 2242 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 2243 
    except TransactionServiceException, ex:
2244 
      result.ex = ex
483 rajveer 2245 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 2246 
    result.write(oprot)
2247 
    oprot.writeMessageEnd()
2248 
    oprot.trans.flush()
2249 
 
1528 ankur.sing 2250 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
2251 
    args = getOrderForCustomer_args()
2252 
    args.read(iprot)
2253 
    iprot.readMessageEnd()
2254 
    result = getOrderForCustomer_result()
2255 
    try:
2256 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
2257 
    except TransactionServiceException, ex:
2258 
      result.ex = ex
2259 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
2260 
    result.write(oprot)
2261 
    oprot.writeMessageEnd()
2262 
    oprot.trans.flush()
2263 
 
1220 chandransh 2264 
  def process_batchOrders(self, seqid, iprot, oprot):
2265 
    args = batchOrders_args()
2266 
    args.read(iprot)
2267 
    iprot.readMessageEnd()
2268 
    result = batchOrders_result()
2269 
    try:
2270 
      result.success = self._handler.batchOrders(args.warehouseId)
2271 
    except TransactionServiceException, ex:
2272 
      result.ex = ex
2273 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
2274 
    result.write(oprot)
2275 
    oprot.writeMessageEnd()
2276 
    oprot.trans.flush()
2277 
 
1208 chandransh 2278 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
2279 
    args = markOrderAsOutOfStock_args()
2280 
    args.read(iprot)
2281 
    iprot.readMessageEnd()
2282 
    result = markOrderAsOutOfStock_result()
2283 
    try:
2284 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
2285 
    except TransactionServiceException, ex:
2286 
      result.ex = ex
2287 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
2288 
    result.write(oprot)
2289 
    oprot.writeMessageEnd()
2290 
    oprot.trans.flush()
2291 
 
759 chandransh 2292 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
2293 
    args = markOrdersAsManifested_args()
2294 
    args.read(iprot)
2295 
    iprot.readMessageEnd()
2296 
    result = markOrdersAsManifested_result()
2297 
    try:
2298 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
2299 
    except TransactionServiceException, ex:
2300 
      result.ex = ex
2301 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
2302 
    result.write(oprot)
2303 
    oprot.writeMessageEnd()
2304 
    oprot.trans.flush()
2305 
 
1113 chandransh 2306 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
2307 
    args = markOrdersAsPickedUp_args()
2308 
    args.read(iprot)
2309 
    iprot.readMessageEnd()
2310 
    result = markOrdersAsPickedUp_result()
2311 
    try:
2312 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
2313 
    except TransactionServiceException, ex:
2314 
      result.ex = ex
2315 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
2316 
    result.write(oprot)
2317 
    oprot.writeMessageEnd()
2318 
    oprot.trans.flush()
2319 
 
1132 chandransh 2320 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
2321 
    args = markOrdersAsDelivered_args()
2322 
    args.read(iprot)
2323 
    iprot.readMessageEnd()
2324 
    result = markOrdersAsDelivered_result()
2325 
    try:
2326 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
2327 
    except TransactionServiceException, ex:
2328 
      result.ex = ex
2329 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
2330 
    result.write(oprot)
2331 
    oprot.writeMessageEnd()
2332 
    oprot.trans.flush()
2333 
 
1135 chandransh 2334 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
2335 
    args = markOrdersAsFailed_args()
2336 
    args.read(iprot)
2337 
    iprot.readMessageEnd()
2338 
    result = markOrdersAsFailed_result()
2339 
    try:
2340 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
2341 
    except TransactionServiceException, ex:
2342 
      result.ex = ex
2343 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
2344 
    result.write(oprot)
2345 
    oprot.writeMessageEnd()
2346 
    oprot.trans.flush()
2347 
 
1246 chandransh 2348 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
2349 
    args = updateNonDeliveryReason_args()
2350 
    args.read(iprot)
2351 
    iprot.readMessageEnd()
2352 
    result = updateNonDeliveryReason_result()
2353 
    try:
2354 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
2355 
    except TransactionServiceException, ex:
2356 
      result.ex = ex
2357 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
2358 
    result.write(oprot)
2359 
    oprot.writeMessageEnd()
2360 
    oprot.trans.flush()
2361 
 
1408 ankur.sing 2362 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
2363 
    args = getUndeliveredOrders_args()
2364 
    args.read(iprot)
2365 
    iprot.readMessageEnd()
2366 
    result = getUndeliveredOrders_result()
2367 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
2368 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
2369 
    result.write(oprot)
2370 
    oprot.writeMessageEnd()
2371 
    oprot.trans.flush()
2372 
 
304 ashish 2373 
  def process_getAlerts(self, seqid, iprot, oprot):
2374 
    args = getAlerts_args()
2375 
    args.read(iprot)
2376 
    iprot.readMessageEnd()
2377 
    result = getAlerts_result()
483 rajveer 2378 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 2379 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
2380 
    result.write(oprot)
2381 
    oprot.writeMessageEnd()
2382 
    oprot.trans.flush()
94 ashish 2383 
 
304 ashish 2384 
  def process_setAlert(self, seqid, iprot, oprot):
2385 
    args = setAlert_args()
2386 
    args.read(iprot)
2387 
    iprot.readMessageEnd()
2388 
    result = setAlert_result()
483 rajveer 2389 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 2390 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
2391 
    result.write(oprot)
2392 
    oprot.writeMessageEnd()
2393 
    oprot.trans.flush()
2394 
 
1596 ankur.sing 2395 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
2396 
    args = getValidOrderCount_args()
2397 
    args.read(iprot)
2398 
    iprot.readMessageEnd()
2399 
    result = getValidOrderCount_result()
2400 
    result.success = self._handler.getValidOrderCount()
2401 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
2402 
    result.write(oprot)
2403 
    oprot.writeMessageEnd()
2404 
    oprot.trans.flush()
304 ashish 2405 
 
1627 ankur.sing 2406 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
2407 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2408 
    args.read(iprot)
2409 
    iprot.readMessageEnd()
2410 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2411 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
2412 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
2413 
    result.write(oprot)
2414 
    oprot.writeMessageEnd()
2415 
    oprot.trans.flush()
1596 ankur.sing 2416 
 
1731 ankur.sing 2417 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
2418 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 2419 
    args.read(iprot)
2420 
    iprot.readMessageEnd()
1731 ankur.sing 2421 
    result = getValidOrdersAmountRange_result()
2422 
    result.success = self._handler.getValidOrdersAmountRange()
2423 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
1627 ankur.sing 2424 
    result.write(oprot)
2425 
    oprot.writeMessageEnd()
2426 
    oprot.trans.flush()
2427 
 
1886 ankur.sing 2428 
  def process_getValidOrders(self, seqid, iprot, oprot):
2429 
    args = getValidOrders_args()
2430 
    args.read(iprot)
2431 
    iprot.readMessageEnd()
2432 
    result = getValidOrders_result()
2433 
    result.success = self._handler.getValidOrders(args.limit)
2434 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
2435 
    result.write(oprot)
2436 
    oprot.writeMessageEnd()
2437 
    oprot.trans.flush()
1627 ankur.sing 2438 
 
2536 chandransh 2439 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
2440 
    args = toggleDOAFlag_args()
2441 
    args.read(iprot)
2442 
    iprot.readMessageEnd()
2443 
    result = toggleDOAFlag_result()
2444 
    try:
2445 
      result.success = self._handler.toggleDOAFlag(args.orderId)
2446 
    except TransactionServiceException, ex:
2447 
      result.ex = ex
2448 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
2449 
    result.write(oprot)
2450 
    oprot.writeMessageEnd()
2451 
    oprot.trans.flush()
1886 ankur.sing 2452 
 
2536 chandransh 2453 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
2454 
    args = requestPickupNumber_args()
2455 
    args.read(iprot)
2456 
    iprot.readMessageEnd()
2457 
    result = requestPickupNumber_result()
2458 
    try:
2459 
      result.success = self._handler.requestPickupNumber(args.orderId)
2460 
    except TransactionServiceException, ex:
2461 
      result.ex = ex
2462 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
2463 
    result.write(oprot)
2464 
    oprot.writeMessageEnd()
2465 
    oprot.trans.flush()
2466 
 
2467 
  def process_authorizePickup(self, seqid, iprot, oprot):
2468 
    args = authorizePickup_args()
2469 
    args.read(iprot)
2470 
    iprot.readMessageEnd()
2471 
    result = authorizePickup_result()
2472 
    try:
2473 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
2474 
    except TransactionServiceException, ex:
2475 
      result.ex = ex
2476 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
2477 
    result.write(oprot)
2478 
    oprot.writeMessageEnd()
2479 
    oprot.trans.flush()
2480 
 
2591 chandransh 2481 
  def process_acceptDoa(self, seqid, iprot, oprot):
2482 
    args = acceptDoa_args()
2483 
    args.read(iprot)
2484 
    iprot.readMessageEnd()
2485 
    result = acceptDoa_result()
2486 
    try:
2487 
      result.success = self._handler.acceptDoa(args.orderId)
2488 
    except TransactionServiceException, ex:
2489 
      result.ex = ex
2490 
    oprot.writeMessageBegin("acceptDoa", TMessageType.REPLY, seqid)
2491 
    result.write(oprot)
2492 
    oprot.writeMessageEnd()
2493 
    oprot.trans.flush()
2536 chandransh 2494 
 
2591 chandransh 2495 
  def process_validateDoa(self, seqid, iprot, oprot):
2496 
    args = validateDoa_args()
2497 
    args.read(iprot)
2498 
    iprot.readMessageEnd()
2499 
    result = validateDoa_result()
2500 
    try:
2501 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
2502 
    except TransactionServiceException, ex:
2503 
      result.ex = ex
2504 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
2505 
    result.write(oprot)
2506 
    oprot.writeMessageEnd()
2507 
    oprot.trans.flush()
2508 
 
2509 
 
94 ashish 2510 
# HELPER FUNCTIONS AND STRUCTURES
2511 
 
765 rajveer 2512 
class closeSession_args:
2513 
 
2514 
  thrift_spec = (
2515 
  )
2516 
 
2517 
  def read(self, iprot):
2518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2520 
      return
2521 
    iprot.readStructBegin()
2522 
    while True:
2523 
      (fname, ftype, fid) = iprot.readFieldBegin()
2524 
      if ftype == TType.STOP:
2525 
        break
2526 
      else:
2527 
        iprot.skip(ftype)
2528 
      iprot.readFieldEnd()
2529 
    iprot.readStructEnd()
2530 
 
2531 
  def write(self, oprot):
2532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2534 
      return
2535 
    oprot.writeStructBegin('closeSession_args')
2536 
    oprot.writeFieldStop()
2537 
    oprot.writeStructEnd()
2538 
 
2539 
  def __repr__(self):
2540 
    L = ['%s=%r' % (key, value)
2541 
      for key, value in self.__dict__.iteritems()]
2542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2543 
 
2544 
  def __eq__(self, other):
2545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2546 
 
2547 
  def __ne__(self, other):
2548 
    return not (self == other)
2549 
 
2550 
class closeSession_result:
2551 
 
2552 
  thrift_spec = (
2553 
  )
2554 
 
2555 
  def read(self, iprot):
2556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2558 
      return
2559 
    iprot.readStructBegin()
2560 
    while True:
2561 
      (fname, ftype, fid) = iprot.readFieldBegin()
2562 
      if ftype == TType.STOP:
2563 
        break
2564 
      else:
2565 
        iprot.skip(ftype)
2566 
      iprot.readFieldEnd()
2567 
    iprot.readStructEnd()
2568 
 
2569 
  def write(self, oprot):
2570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2572 
      return
2573 
    oprot.writeStructBegin('closeSession_result')
2574 
    oprot.writeFieldStop()
2575 
    oprot.writeStructEnd()
2576 
 
2577 
  def __repr__(self):
2578 
    L = ['%s=%r' % (key, value)
2579 
      for key, value in self.__dict__.iteritems()]
2580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2581 
 
2582 
  def __eq__(self, other):
2583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2584 
 
2585 
  def __ne__(self, other):
2586 
    return not (self == other)
2587 
 
94 ashish 2588 
class createTransaction_args:
2589 
  """
2590 
  Attributes:
2591 
   - transaction
2592 
  """
2593 
 
2594 
  thrift_spec = (
2595 
    None, # 0
2596 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
2597 
  )
2598 
 
2599 
  def __init__(self, transaction=None,):
2600 
    self.transaction = transaction
2601 
 
2602 
  def read(self, iprot):
2603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2605 
      return
2606 
    iprot.readStructBegin()
2607 
    while True:
2608 
      (fname, ftype, fid) = iprot.readFieldBegin()
2609 
      if ftype == TType.STOP:
2610 
        break
2611 
      if fid == 1:
2612 
        if ftype == TType.STRUCT:
2613 
          self.transaction = Transaction()
2614 
          self.transaction.read(iprot)
2615 
        else:
2616 
          iprot.skip(ftype)
2617 
      else:
2618 
        iprot.skip(ftype)
2619 
      iprot.readFieldEnd()
2620 
    iprot.readStructEnd()
2621 
 
2622 
  def write(self, oprot):
2623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2625 
      return
2626 
    oprot.writeStructBegin('createTransaction_args')
2627 
    if self.transaction != None:
2628 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
2629 
      self.transaction.write(oprot)
2630 
      oprot.writeFieldEnd()
2631 
    oprot.writeFieldStop()
2632 
    oprot.writeStructEnd()
2633 
 
2634 
  def __repr__(self):
2635 
    L = ['%s=%r' % (key, value)
2636 
      for key, value in self.__dict__.iteritems()]
2637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2638 
 
2639 
  def __eq__(self, other):
2640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2641 
 
2642 
  def __ne__(self, other):
2643 
    return not (self == other)
2644 
 
2645 
class createTransaction_result:
2646 
  """
2647 
  Attributes:
132 ashish 2648 
   - success
94 ashish 2649 
   - ex
2650 
  """
2651 
 
2652 
  thrift_spec = (
132 ashish 2653 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 2654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2655 
  )
2656 
 
132 ashish 2657 
  def __init__(self, success=None, ex=None,):
2658 
    self.success = success
94 ashish 2659 
    self.ex = ex
2660 
 
2661 
  def read(self, iprot):
2662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2664 
      return
2665 
    iprot.readStructBegin()
2666 
    while True:
2667 
      (fname, ftype, fid) = iprot.readFieldBegin()
2668 
      if ftype == TType.STOP:
2669 
        break
132 ashish 2670 
      if fid == 0:
2671 
        if ftype == TType.I64:
2672 
          self.success = iprot.readI64();
2673 
        else:
2674 
          iprot.skip(ftype)
2675 
      elif fid == 1:
94 ashish 2676 
        if ftype == TType.STRUCT:
2677 
          self.ex = TransactionServiceException()
2678 
          self.ex.read(iprot)
2679 
        else:
2680 
          iprot.skip(ftype)
2681 
      else:
2682 
        iprot.skip(ftype)
2683 
      iprot.readFieldEnd()
2684 
    iprot.readStructEnd()
2685 
 
2686 
  def write(self, oprot):
2687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2689 
      return
2690 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 2691 
    if self.success != None:
2692 
      oprot.writeFieldBegin('success', TType.I64, 0)
2693 
      oprot.writeI64(self.success)
2694 
      oprot.writeFieldEnd()
94 ashish 2695 
    if self.ex != None:
2696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2697 
      self.ex.write(oprot)
2698 
      oprot.writeFieldEnd()
2699 
    oprot.writeFieldStop()
2700 
    oprot.writeStructEnd()
2701 
 
2702 
  def __repr__(self):
2703 
    L = ['%s=%r' % (key, value)
2704 
      for key, value in self.__dict__.iteritems()]
2705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2706 
 
2707 
  def __eq__(self, other):
2708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2709 
 
2710 
  def __ne__(self, other):
2711 
    return not (self == other)
2712 
 
2713 
class getTransaction_args:
2714 
  """
2715 
  Attributes:
2716 
   - id
2717 
  """
2718 
 
2719 
  thrift_spec = (
2720 
    None, # 0
2721 
    (1, TType.I64, 'id', None, None, ), # 1
2722 
  )
2723 
 
2724 
  def __init__(self, id=None,):
2725 
    self.id = id
2726 
 
2727 
  def read(self, iprot):
2728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2730 
      return
2731 
    iprot.readStructBegin()
2732 
    while True:
2733 
      (fname, ftype, fid) = iprot.readFieldBegin()
2734 
      if ftype == TType.STOP:
2735 
        break
2736 
      if fid == 1:
2737 
        if ftype == TType.I64:
2738 
          self.id = iprot.readI64();
2739 
        else:
2740 
          iprot.skip(ftype)
2741 
      else:
2742 
        iprot.skip(ftype)
2743 
      iprot.readFieldEnd()
2744 
    iprot.readStructEnd()
2745 
 
2746 
  def write(self, oprot):
2747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2749 
      return
2750 
    oprot.writeStructBegin('getTransaction_args')
2751 
    if self.id != None:
2752 
      oprot.writeFieldBegin('id', TType.I64, 1)
2753 
      oprot.writeI64(self.id)
2754 
      oprot.writeFieldEnd()
2755 
    oprot.writeFieldStop()
2756 
    oprot.writeStructEnd()
2757 
 
2758 
  def __repr__(self):
2759 
    L = ['%s=%r' % (key, value)
2760 
      for key, value in self.__dict__.iteritems()]
2761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2762 
 
2763 
  def __eq__(self, other):
2764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2765 
 
2766 
  def __ne__(self, other):
2767 
    return not (self == other)
2768 
 
2769 
class getTransaction_result:
2770 
  """
2771 
  Attributes:
2772 
   - success
2773 
   - ex
2774 
  """
2775 
 
2776 
  thrift_spec = (
2777 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
2778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2779 
  )
2780 
 
2781 
  def __init__(self, success=None, ex=None,):
2782 
    self.success = success
2783 
    self.ex = ex
2784 
 
2785 
  def read(self, iprot):
2786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2788 
      return
2789 
    iprot.readStructBegin()
2790 
    while True:
2791 
      (fname, ftype, fid) = iprot.readFieldBegin()
2792 
      if ftype == TType.STOP:
2793 
        break
2794 
      if fid == 0:
2795 
        if ftype == TType.STRUCT:
2796 
          self.success = Transaction()
2797 
          self.success.read(iprot)
2798 
        else:
2799 
          iprot.skip(ftype)
2800 
      elif fid == 1:
2801 
        if ftype == TType.STRUCT:
2802 
          self.ex = TransactionServiceException()
2803 
          self.ex.read(iprot)
2804 
        else:
2805 
          iprot.skip(ftype)
2806 
      else:
2807 
        iprot.skip(ftype)
2808 
      iprot.readFieldEnd()
2809 
    iprot.readStructEnd()
2810 
 
2811 
  def write(self, oprot):
2812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2814 
      return
2815 
    oprot.writeStructBegin('getTransaction_result')
2816 
    if self.success != None:
2817 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2818 
      self.success.write(oprot)
2819 
      oprot.writeFieldEnd()
2820 
    if self.ex != None:
2821 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2822 
      self.ex.write(oprot)
2823 
      oprot.writeFieldEnd()
2824 
    oprot.writeFieldStop()
2825 
    oprot.writeStructEnd()
2826 
 
2827 
  def __repr__(self):
2828 
    L = ['%s=%r' % (key, value)
2829 
      for key, value in self.__dict__.iteritems()]
2830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2831 
 
2832 
  def __eq__(self, other):
2833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2834 
 
2835 
  def __ne__(self, other):
2836 
    return not (self == other)
2837 
 
2838 
class getTransactionsForCustomer_args:
2839 
  """
2840 
  Attributes:
2841 
   - customerId
2842 
   - from_date
2843 
   - to_date
2844 
   - status
2845 
  """
2846 
 
2847 
  thrift_spec = (
2848 
    None, # 0
2849 
    (1, TType.I64, 'customerId', None, None, ), # 1
2850 
    (2, TType.I64, 'from_date', None, None, ), # 2
2851 
    (3, TType.I64, 'to_date', None, None, ), # 3
2852 
    (4, TType.I32, 'status', None, None, ), # 4
2853 
  )
2854 
 
2855 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
2856 
    self.customerId = customerId
2857 
    self.from_date = from_date
2858 
    self.to_date = to_date
2859 
    self.status = status
2860 
 
2861 
  def read(self, iprot):
2862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2864 
      return
2865 
    iprot.readStructBegin()
2866 
    while True:
2867 
      (fname, ftype, fid) = iprot.readFieldBegin()
2868 
      if ftype == TType.STOP:
2869 
        break
2870 
      if fid == 1:
2871 
        if ftype == TType.I64:
2872 
          self.customerId = iprot.readI64();
2873 
        else:
2874 
          iprot.skip(ftype)
2875 
      elif fid == 2:
2876 
        if ftype == TType.I64:
2877 
          self.from_date = iprot.readI64();
2878 
        else:
2879 
          iprot.skip(ftype)
2880 
      elif fid == 3:
2881 
        if ftype == TType.I64:
2882 
          self.to_date = iprot.readI64();
2883 
        else:
2884 
          iprot.skip(ftype)
2885 
      elif fid == 4:
2886 
        if ftype == TType.I32:
2887 
          self.status = iprot.readI32();
2888 
        else:
2889 
          iprot.skip(ftype)
2890 
      else:
2891 
        iprot.skip(ftype)
2892 
      iprot.readFieldEnd()
2893 
    iprot.readStructEnd()
2894 
 
2895 
  def write(self, oprot):
2896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2898 
      return
2899 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
2900 
    if self.customerId != None:
2901 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
2902 
      oprot.writeI64(self.customerId)
2903 
      oprot.writeFieldEnd()
2904 
    if self.from_date != None:
2905 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
2906 
      oprot.writeI64(self.from_date)
2907 
      oprot.writeFieldEnd()
2908 
    if self.to_date != None:
2909 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
2910 
      oprot.writeI64(self.to_date)
2911 
      oprot.writeFieldEnd()
2912 
    if self.status != None:
2913 
      oprot.writeFieldBegin('status', TType.I32, 4)
2914 
      oprot.writeI32(self.status)
2915 
      oprot.writeFieldEnd()
2916 
    oprot.writeFieldStop()
2917 
    oprot.writeStructEnd()
2918 
 
2919 
  def __repr__(self):
2920 
    L = ['%s=%r' % (key, value)
2921 
      for key, value in self.__dict__.iteritems()]
2922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2923 
 
2924 
  def __eq__(self, other):
2925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2926 
 
2927 
  def __ne__(self, other):
2928 
    return not (self == other)
2929 
 
2930 
class getTransactionsForCustomer_result:
2931 
  """
2932 
  Attributes:
2933 
   - success
2934 
   - ex
2935 
  """
2936 
 
2937 
  thrift_spec = (
2938 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
2939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2940 
  )
2941 
 
2942 
  def __init__(self, success=None, ex=None,):
2943 
    self.success = success
2944 
    self.ex = ex
2945 
 
2946 
  def read(self, iprot):
2947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2949 
      return
2950 
    iprot.readStructBegin()
2951 
    while True:
2952 
      (fname, ftype, fid) = iprot.readFieldBegin()
2953 
      if ftype == TType.STOP:
2954 
        break
2955 
      if fid == 0:
2956 
        if ftype == TType.LIST:
2957 
          self.success = []
685 chandransh 2958 
          (_etype17, _size14) = iprot.readListBegin()
2959 
          for _i18 in xrange(_size14):
2960 
            _elem19 = Transaction()
2961 
            _elem19.read(iprot)
2962 
            self.success.append(_elem19)
94 ashish 2963 
          iprot.readListEnd()
2964 
        else:
2965 
          iprot.skip(ftype)
2966 
      elif fid == 1:
2967 
        if ftype == TType.STRUCT:
2968 
          self.ex = TransactionServiceException()
2969 
          self.ex.read(iprot)
2970 
        else:
2971 
          iprot.skip(ftype)
2972 
      else:
2973 
        iprot.skip(ftype)
2974 
      iprot.readFieldEnd()
2975 
    iprot.readStructEnd()
2976 
 
2977 
  def write(self, oprot):
2978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2980 
      return
2981 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
2982 
    if self.success != None:
2983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2984 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 2985 
      for iter20 in self.success:
2986 
        iter20.write(oprot)
94 ashish 2987 
      oprot.writeListEnd()
2988 
      oprot.writeFieldEnd()
2989 
    if self.ex != None:
2990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2991 
      self.ex.write(oprot)
2992 
      oprot.writeFieldEnd()
2993 
    oprot.writeFieldStop()
2994 
    oprot.writeStructEnd()
2995 
 
2996 
  def __repr__(self):
2997 
    L = ['%s=%r' % (key, value)
2998 
      for key, value in self.__dict__.iteritems()]
2999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3000 
 
3001 
  def __eq__(self, other):
3002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3003 
 
3004 
  def __ne__(self, other):
3005 
    return not (self == other)
3006 
 
132 ashish 3007 
class getTransactionsForShoppingCartId_args:
3008 
  """
3009 
  Attributes:
3010 
   - shoppingCartId
3011 
  """
3012 
 
3013 
  thrift_spec = (
3014 
    None, # 0
3015 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
3016 
  )
3017 
 
3018 
  def __init__(self, shoppingCartId=None,):
3019 
    self.shoppingCartId = shoppingCartId
3020 
 
3021 
  def read(self, iprot):
3022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3024 
      return
3025 
    iprot.readStructBegin()
3026 
    while True:
3027 
      (fname, ftype, fid) = iprot.readFieldBegin()
3028 
      if ftype == TType.STOP:
3029 
        break
3030 
      if fid == 1:
3031 
        if ftype == TType.I64:
3032 
          self.shoppingCartId = iprot.readI64();
3033 
        else:
3034 
          iprot.skip(ftype)
3035 
      else:
3036 
        iprot.skip(ftype)
3037 
      iprot.readFieldEnd()
3038 
    iprot.readStructEnd()
3039 
 
3040 
  def write(self, oprot):
3041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3043 
      return
3044 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3045 
    if self.shoppingCartId != None:
3046 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
3047 
      oprot.writeI64(self.shoppingCartId)
3048 
      oprot.writeFieldEnd()
3049 
    oprot.writeFieldStop()
3050 
    oprot.writeStructEnd()
3051 
 
3052 
  def __repr__(self):
3053 
    L = ['%s=%r' % (key, value)
3054 
      for key, value in self.__dict__.iteritems()]
3055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3056 
 
3057 
  def __eq__(self, other):
3058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3059 
 
3060 
  def __ne__(self, other):
3061 
    return not (self == other)
3062 
 
3063 
class getTransactionsForShoppingCartId_result:
3064 
  """
3065 
  Attributes:
3066 
   - success
3067 
   - ex
3068 
  """
3069 
 
3070 
  thrift_spec = (
3071 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3073 
  )
3074 
 
3075 
  def __init__(self, success=None, ex=None,):
3076 
    self.success = success
3077 
    self.ex = ex
3078 
 
3079 
  def read(self, iprot):
3080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3082 
      return
3083 
    iprot.readStructBegin()
3084 
    while True:
3085 
      (fname, ftype, fid) = iprot.readFieldBegin()
3086 
      if ftype == TType.STOP:
3087 
        break
3088 
      if fid == 0:
3089 
        if ftype == TType.LIST:
3090 
          self.success = []
685 chandransh 3091 
          (_etype24, _size21) = iprot.readListBegin()
3092 
          for _i25 in xrange(_size21):
3093 
            _elem26 = Transaction()
3094 
            _elem26.read(iprot)
3095 
            self.success.append(_elem26)
132 ashish 3096 
          iprot.readListEnd()
3097 
        else:
3098 
          iprot.skip(ftype)
3099 
      elif fid == 1:
3100 
        if ftype == TType.STRUCT:
3101 
          self.ex = TransactionServiceException()
3102 
          self.ex.read(iprot)
3103 
        else:
3104 
          iprot.skip(ftype)
3105 
      else:
3106 
        iprot.skip(ftype)
3107 
      iprot.readFieldEnd()
3108 
    iprot.readStructEnd()
3109 
 
3110 
  def write(self, oprot):
3111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3113 
      return
3114 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3115 
    if self.success != None:
3116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3118 
      for iter27 in self.success:
3119 
        iter27.write(oprot)
132 ashish 3120 
      oprot.writeListEnd()
3121 
      oprot.writeFieldEnd()
3122 
    if self.ex != None:
3123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3124 
      self.ex.write(oprot)
3125 
      oprot.writeFieldEnd()
3126 
    oprot.writeFieldStop()
3127 
    oprot.writeStructEnd()
3128 
 
3129 
  def __repr__(self):
3130 
    L = ['%s=%r' % (key, value)
3131 
      for key, value in self.__dict__.iteritems()]
3132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3133 
 
3134 
  def __eq__(self, other):
3135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3136 
 
3137 
  def __ne__(self, other):
3138 
    return not (self == other)
3139 
 
94 ashish 3140 
class getTransactionStatus_args:
3141 
  """
3142 
  Attributes:
3143 
   - transactionId
3144 
  """
3145 
 
3146 
  thrift_spec = (
3147 
    None, # 0
3148 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3149 
  )
3150 
 
3151 
  def __init__(self, transactionId=None,):
3152 
    self.transactionId = transactionId
3153 
 
3154 
  def read(self, iprot):
3155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3157 
      return
3158 
    iprot.readStructBegin()
3159 
    while True:
3160 
      (fname, ftype, fid) = iprot.readFieldBegin()
3161 
      if ftype == TType.STOP:
3162 
        break
3163 
      if fid == 1:
3164 
        if ftype == TType.I64:
3165 
          self.transactionId = iprot.readI64();
3166 
        else:
3167 
          iprot.skip(ftype)
3168 
      else:
3169 
        iprot.skip(ftype)
3170 
      iprot.readFieldEnd()
3171 
    iprot.readStructEnd()
3172 
 
3173 
  def write(self, oprot):
3174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3176 
      return
3177 
    oprot.writeStructBegin('getTransactionStatus_args')
3178 
    if self.transactionId != None:
3179 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3180 
      oprot.writeI64(self.transactionId)
3181 
      oprot.writeFieldEnd()
3182 
    oprot.writeFieldStop()
3183 
    oprot.writeStructEnd()
3184 
 
3185 
  def __repr__(self):
3186 
    L = ['%s=%r' % (key, value)
3187 
      for key, value in self.__dict__.iteritems()]
3188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3189 
 
3190 
  def __eq__(self, other):
3191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3192 
 
3193 
  def __ne__(self, other):
3194 
    return not (self == other)
3195 
 
3196 
class getTransactionStatus_result:
3197 
  """
3198 
  Attributes:
3199 
   - success
3200 
   - ex
3201 
  """
3202 
 
3203 
  thrift_spec = (
3204 
    (0, TType.I32, 'success', None, None, ), # 0
3205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3206 
  )
3207 
 
3208 
  def __init__(self, success=None, ex=None,):
3209 
    self.success = success
3210 
    self.ex = ex
3211 
 
3212 
  def read(self, iprot):
3213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3215 
      return
3216 
    iprot.readStructBegin()
3217 
    while True:
3218 
      (fname, ftype, fid) = iprot.readFieldBegin()
3219 
      if ftype == TType.STOP:
3220 
        break
3221 
      if fid == 0:
3222 
        if ftype == TType.I32:
3223 
          self.success = iprot.readI32();
3224 
        else:
3225 
          iprot.skip(ftype)
3226 
      elif fid == 1:
3227 
        if ftype == TType.STRUCT:
3228 
          self.ex = TransactionServiceException()
3229 
          self.ex.read(iprot)
3230 
        else:
3231 
          iprot.skip(ftype)
3232 
      else:
3233 
        iprot.skip(ftype)
3234 
      iprot.readFieldEnd()
3235 
    iprot.readStructEnd()
3236 
 
3237 
  def write(self, oprot):
3238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3240 
      return
3241 
    oprot.writeStructBegin('getTransactionStatus_result')
3242 
    if self.success != None:
3243 
      oprot.writeFieldBegin('success', TType.I32, 0)
3244 
      oprot.writeI32(self.success)
3245 
      oprot.writeFieldEnd()
3246 
    if self.ex != None:
3247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3248 
      self.ex.write(oprot)
3249 
      oprot.writeFieldEnd()
3250 
    oprot.writeFieldStop()
3251 
    oprot.writeStructEnd()
3252 
 
3253 
  def __repr__(self):
3254 
    L = ['%s=%r' % (key, value)
3255 
      for key, value in self.__dict__.iteritems()]
3256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3257 
 
3258 
  def __eq__(self, other):
3259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3260 
 
3261 
  def __ne__(self, other):
3262 
    return not (self == other)
3263 
 
3264 
class changeTransactionStatus_args:
3265 
  """
3266 
  Attributes:
3267 
   - transactionId
3268 
   - status
3269 
   - description
3270 
  """
3271 
 
3272 
  thrift_spec = (
3273 
    None, # 0
3274 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3275 
    (2, TType.I32, 'status', None, None, ), # 2
3276 
    (3, TType.STRING, 'description', None, None, ), # 3
3277 
  )
3278 
 
3279 
  def __init__(self, transactionId=None, status=None, description=None,):
3280 
    self.transactionId = transactionId
3281 
    self.status = status
3282 
    self.description = description
3283 
 
3284 
  def read(self, iprot):
3285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3287 
      return
3288 
    iprot.readStructBegin()
3289 
    while True:
3290 
      (fname, ftype, fid) = iprot.readFieldBegin()
3291 
      if ftype == TType.STOP:
3292 
        break
3293 
      if fid == 1:
3294 
        if ftype == TType.I64:
3295 
          self.transactionId = iprot.readI64();
3296 
        else:
3297 
          iprot.skip(ftype)
3298 
      elif fid == 2:
3299 
        if ftype == TType.I32:
3300 
          self.status = iprot.readI32();
3301 
        else:
3302 
          iprot.skip(ftype)
3303 
      elif fid == 3:
3304 
        if ftype == TType.STRING:
3305 
          self.description = iprot.readString();
3306 
        else:
3307 
          iprot.skip(ftype)
3308 
      else:
3309 
        iprot.skip(ftype)
3310 
      iprot.readFieldEnd()
3311 
    iprot.readStructEnd()
3312 
 
3313 
  def write(self, oprot):
3314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3316 
      return
3317 
    oprot.writeStructBegin('changeTransactionStatus_args')
3318 
    if self.transactionId != None:
3319 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3320 
      oprot.writeI64(self.transactionId)
3321 
      oprot.writeFieldEnd()
3322 
    if self.status != None:
3323 
      oprot.writeFieldBegin('status', TType.I32, 2)
3324 
      oprot.writeI32(self.status)
3325 
      oprot.writeFieldEnd()
3326 
    if self.description != None:
3327 
      oprot.writeFieldBegin('description', TType.STRING, 3)
3328 
      oprot.writeString(self.description)
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 changeTransactionStatus_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('changeTransactionStatus_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 
 
1398 varun.gupt 3412 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 3413 
  """
3414 
  Attributes:
3415 
   - transactionId
3416 
  """
3417 
 
3418 
  thrift_spec = (
3419 
    None, # 0
3420 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3421 
  )
3422 
 
3423 
  def __init__(self, transactionId=None,):
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
1398 varun.gupt 3449 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
1382 varun.gupt 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 
 
1398 varun.gupt 3468 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 3469 
  """
3470 
  Attributes:
3471 
   - success
3472 
   - ex
3473 
  """
3474 
 
3475 
  thrift_spec = (
3476 
    (0, TType.BOOL, 'success', None, None, ), # 0
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:
3494 
        if ftype == TType.BOOL:
3495 
          self.success = iprot.readBool();
3496 
        else:
3497 
          iprot.skip(ftype)
3498 
      elif fid == 1:
3499 
        if ftype == TType.STRUCT:
3500 
          self.ex = TransactionServiceException()
3501 
          self.ex.read(iprot)
3502 
        else:
3503 
          iprot.skip(ftype)
3504 
      else:
3505 
        iprot.skip(ftype)
3506 
      iprot.readFieldEnd()
3507 
    iprot.readStructEnd()
3508 
 
3509 
  def write(self, oprot):
3510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3512 
      return
1398 varun.gupt 3513 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
1382 varun.gupt 3514 
    if self.success != None:
3515 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3516 
      oprot.writeBool(self.success)
3517 
      oprot.writeFieldEnd()
3518 
    if self.ex != None:
3519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3520 
      self.ex.write(oprot)
3521 
      oprot.writeFieldEnd()
3522 
    oprot.writeFieldStop()
3523 
    oprot.writeStructEnd()
3524 
 
3525 
  def __repr__(self):
3526 
    L = ['%s=%r' % (key, value)
3527 
      for key, value in self.__dict__.iteritems()]
3528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3529 
 
3530 
  def __eq__(self, other):
3531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3532 
 
3533 
  def __ne__(self, other):
3534 
    return not (self == other)
3535 
 
483 rajveer 3536 
class getAllOrders_args:
94 ashish 3537 
  """
3538 
  Attributes:
483 rajveer 3539 
   - status
3540 
   - from_date
3541 
   - to_date
3542 
   - warehouse_id
94 ashish 3543 
  """
3544 
 
3545 
  thrift_spec = (
3546 
    None, # 0
483 rajveer 3547 
    (1, TType.I32, 'status', None, None, ), # 1
3548 
    (2, TType.I64, 'from_date', None, None, ), # 2
3549 
    (3, TType.I64, 'to_date', None, None, ), # 3
3550 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 3551 
  )
3552 
 
483 rajveer 3553 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
3554 
    self.status = status
3555 
    self.from_date = from_date
3556 
    self.to_date = to_date
3557 
    self.warehouse_id = warehouse_id
94 ashish 3558 
 
3559 
  def read(self, iprot):
3560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3562 
      return
3563 
    iprot.readStructBegin()
3564 
    while True:
3565 
      (fname, ftype, fid) = iprot.readFieldBegin()
3566 
      if ftype == TType.STOP:
3567 
        break
3568 
      if fid == 1:
483 rajveer 3569 
        if ftype == TType.I32:
3570 
          self.status = iprot.readI32();
94 ashish 3571 
        else:
3572 
          iprot.skip(ftype)
483 rajveer 3573 
      elif fid == 2:
3574 
        if ftype == TType.I64:
3575 
          self.from_date = iprot.readI64();
94 ashish 3576 
        else:
3577 
          iprot.skip(ftype)
483 rajveer 3578 
      elif fid == 3:
3579 
        if ftype == TType.I64:
3580 
          self.to_date = iprot.readI64();
94 ashish 3581 
        else:
3582 
          iprot.skip(ftype)
483 rajveer 3583 
      elif fid == 4:
94 ashish 3584 
        if ftype == TType.I64:
483 rajveer 3585 
          self.warehouse_id = iprot.readI64();
94 ashish 3586 
        else:
3587 
          iprot.skip(ftype)
3588 
      else:
3589 
        iprot.skip(ftype)
3590 
      iprot.readFieldEnd()
3591 
    iprot.readStructEnd()
3592 
 
3593 
  def write(self, oprot):
3594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3596 
      return
483 rajveer 3597 
    oprot.writeStructBegin('getAllOrders_args')
3598 
    if self.status != None:
3599 
      oprot.writeFieldBegin('status', TType.I32, 1)
3600 
      oprot.writeI32(self.status)
94 ashish 3601 
      oprot.writeFieldEnd()
483 rajveer 3602 
    if self.from_date != None:
3603 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3604 
      oprot.writeI64(self.from_date)
94 ashish 3605 
      oprot.writeFieldEnd()
483 rajveer 3606 
    if self.to_date != None:
3607 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3608 
      oprot.writeI64(self.to_date)
94 ashish 3609 
      oprot.writeFieldEnd()
483 rajveer 3610 
    if self.warehouse_id != None:
3611 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
3612 
      oprot.writeI64(self.warehouse_id)
94 ashish 3613 
      oprot.writeFieldEnd()
3614 
    oprot.writeFieldStop()
3615 
    oprot.writeStructEnd()
3616 
 
3617 
  def __repr__(self):
3618 
    L = ['%s=%r' % (key, value)
3619 
      for key, value in self.__dict__.iteritems()]
3620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3621 
 
3622 
  def __eq__(self, other):
3623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3624 
 
3625 
  def __ne__(self, other):
3626 
    return not (self == other)
3627 
 
483 rajveer 3628 
class getAllOrders_result:
94 ashish 3629 
  """
3630 
  Attributes:
3631 
   - success
3632 
   - ex
3633 
  """
3634 
 
3635 
  thrift_spec = (
483 rajveer 3636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 3637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3638 
  )
3639 
 
3640 
  def __init__(self, success=None, ex=None,):
3641 
    self.success = success
3642 
    self.ex = ex
3643 
 
3644 
  def read(self, iprot):
3645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3647 
      return
3648 
    iprot.readStructBegin()
3649 
    while True:
3650 
      (fname, ftype, fid) = iprot.readFieldBegin()
3651 
      if ftype == TType.STOP:
3652 
        break
3653 
      if fid == 0:
483 rajveer 3654 
        if ftype == TType.LIST:
3655 
          self.success = []
685 chandransh 3656 
          (_etype31, _size28) = iprot.readListBegin()
3657 
          for _i32 in xrange(_size28):
3658 
            _elem33 = Order()
3659 
            _elem33.read(iprot)
3660 
            self.success.append(_elem33)
483 rajveer 3661 
          iprot.readListEnd()
94 ashish 3662 
        else:
3663 
          iprot.skip(ftype)
3664 
      elif fid == 1:
3665 
        if ftype == TType.STRUCT:
3666 
          self.ex = TransactionServiceException()
3667 
          self.ex.read(iprot)
3668 
        else:
3669 
          iprot.skip(ftype)
3670 
      else:
3671 
        iprot.skip(ftype)
3672 
      iprot.readFieldEnd()
3673 
    iprot.readStructEnd()
3674 
 
3675 
  def write(self, oprot):
3676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3678 
      return
483 rajveer 3679 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 3680 
    if self.success != None:
483 rajveer 3681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3682 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3683 
      for iter34 in self.success:
3684 
        iter34.write(oprot)
483 rajveer 3685 
      oprot.writeListEnd()
94 ashish 3686 
      oprot.writeFieldEnd()
3687 
    if self.ex != None:
3688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3689 
      self.ex.write(oprot)
3690 
      oprot.writeFieldEnd()
3691 
    oprot.writeFieldStop()
3692 
    oprot.writeStructEnd()
3693 
 
3694 
  def __repr__(self):
3695 
    L = ['%s=%r' % (key, value)
3696 
      for key, value in self.__dict__.iteritems()]
3697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3698 
 
3699 
  def __eq__(self, other):
3700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3701 
 
3702 
  def __ne__(self, other):
3703 
    return not (self == other)
3704 
 
999 varun.gupt 3705 
class getOrdersByBillingDate_args:
3706 
  """
3707 
  Attributes:
3708 
   - status
3709 
   - start_billing_date
3710 
   - end_billing_date
3711 
   - warehouse_id
3712 
  """
3713 
 
3714 
  thrift_spec = (
3715 
    None, # 0
3716 
    (1, TType.I32, 'status', None, None, ), # 1
3717 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
3718 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
3719 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
3720 
  )
3721 
 
3722 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
3723 
    self.status = status
3724 
    self.start_billing_date = start_billing_date
3725 
    self.end_billing_date = end_billing_date
3726 
    self.warehouse_id = warehouse_id
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:
3738 
        if ftype == TType.I32:
3739 
          self.status = iprot.readI32();
3740 
        else:
3741 
          iprot.skip(ftype)
3742 
      elif fid == 2:
3743 
        if ftype == TType.I64:
3744 
          self.start_billing_date = iprot.readI64();
3745 
        else:
3746 
          iprot.skip(ftype)
3747 
      elif fid == 3:
3748 
        if ftype == TType.I64:
3749 
          self.end_billing_date = iprot.readI64();
3750 
        else:
3751 
          iprot.skip(ftype)
3752 
      elif fid == 4:
3753 
        if ftype == TType.I64:
3754 
          self.warehouse_id = iprot.readI64();
3755 
        else:
3756 
          iprot.skip(ftype)
3757 
      else:
3758 
        iprot.skip(ftype)
3759 
      iprot.readFieldEnd()
3760 
    iprot.readStructEnd()
3761 
 
3762 
  def write(self, oprot):
3763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3765 
      return
3766 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3767 
    if self.status != None:
3768 
      oprot.writeFieldBegin('status', TType.I32, 1)
3769 
      oprot.writeI32(self.status)
3770 
      oprot.writeFieldEnd()
3771 
    if self.start_billing_date != None:
3772 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
3773 
      oprot.writeI64(self.start_billing_date)
3774 
      oprot.writeFieldEnd()
3775 
    if self.end_billing_date != None:
3776 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
3777 
      oprot.writeI64(self.end_billing_date)
3778 
      oprot.writeFieldEnd()
3779 
    if self.warehouse_id != None:
3780 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
3781 
      oprot.writeI64(self.warehouse_id)
3782 
      oprot.writeFieldEnd()
3783 
    oprot.writeFieldStop()
3784 
    oprot.writeStructEnd()
3785 
 
3786 
  def __repr__(self):
3787 
    L = ['%s=%r' % (key, value)
3788 
      for key, value in self.__dict__.iteritems()]
3789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3790 
 
3791 
  def __eq__(self, other):
3792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3793 
 
3794 
  def __ne__(self, other):
3795 
    return not (self == other)
3796 
 
3797 
class getOrdersByBillingDate_result:
3798 
  """
3799 
  Attributes:
3800 
   - success
3801 
   - ex
3802 
  """
3803 
 
3804 
  thrift_spec = (
3805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3807 
  )
3808 
 
3809 
  def __init__(self, success=None, ex=None,):
3810 
    self.success = success
3811 
    self.ex = ex
3812 
 
3813 
  def read(self, iprot):
3814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3816 
      return
3817 
    iprot.readStructBegin()
3818 
    while True:
3819 
      (fname, ftype, fid) = iprot.readFieldBegin()
3820 
      if ftype == TType.STOP:
3821 
        break
3822 
      if fid == 0:
3823 
        if ftype == TType.LIST:
3824 
          self.success = []
3825 
          (_etype38, _size35) = iprot.readListBegin()
3826 
          for _i39 in xrange(_size35):
3827 
            _elem40 = Order()
3828 
            _elem40.read(iprot)
3829 
            self.success.append(_elem40)
3830 
          iprot.readListEnd()
3831 
        else:
3832 
          iprot.skip(ftype)
3833 
      elif fid == 1:
3834 
        if ftype == TType.STRUCT:
3835 
          self.ex = TransactionServiceException()
3836 
          self.ex.read(iprot)
3837 
        else:
3838 
          iprot.skip(ftype)
3839 
      else:
3840 
        iprot.skip(ftype)
3841 
      iprot.readFieldEnd()
3842 
    iprot.readStructEnd()
3843 
 
3844 
  def write(self, oprot):
3845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3847 
      return
3848 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3849 
    if self.success != None:
3850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3852 
      for iter41 in self.success:
3853 
        iter41.write(oprot)
3854 
      oprot.writeListEnd()
3855 
      oprot.writeFieldEnd()
3856 
    if self.ex != None:
3857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3858 
      self.ex.write(oprot)
3859 
      oprot.writeFieldEnd()
3860 
    oprot.writeFieldStop()
3861 
    oprot.writeStructEnd()
3862 
 
3863 
  def __repr__(self):
3864 
    L = ['%s=%r' % (key, value)
3865 
      for key, value in self.__dict__.iteritems()]
3866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3867 
 
3868 
  def __eq__(self, other):
3869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3870 
 
3871 
  def __ne__(self, other):
3872 
    return not (self == other)
3873 
 
1382 varun.gupt 3874 
class getReturnableOrdersForCustomer_args:
3875 
  """
3876 
  Attributes:
3877 
   - customer_id
3878 
   - limit
3879 
  """
3880 
 
3881 
  thrift_spec = (
3882 
    None, # 0
3883 
    (1, TType.I64, 'customer_id', None, None, ), # 1
3884 
    (2, TType.I64, 'limit', None, None, ), # 2
3885 
  )
3886 
 
3887 
  def __init__(self, customer_id=None, limit=None,):
3888 
    self.customer_id = customer_id
3889 
    self.limit = limit
3890 
 
3891 
  def read(self, iprot):
3892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3894 
      return
3895 
    iprot.readStructBegin()
3896 
    while True:
3897 
      (fname, ftype, fid) = iprot.readFieldBegin()
3898 
      if ftype == TType.STOP:
3899 
        break
3900 
      if fid == 1:
3901 
        if ftype == TType.I64:
3902 
          self.customer_id = iprot.readI64();
3903 
        else:
3904 
          iprot.skip(ftype)
3905 
      elif fid == 2:
3906 
        if ftype == TType.I64:
3907 
          self.limit = iprot.readI64();
3908 
        else:
3909 
          iprot.skip(ftype)
3910 
      else:
3911 
        iprot.skip(ftype)
3912 
      iprot.readFieldEnd()
3913 
    iprot.readStructEnd()
3914 
 
3915 
  def write(self, oprot):
3916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3918 
      return
3919 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3920 
    if self.customer_id != None:
3921 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
3922 
      oprot.writeI64(self.customer_id)
3923 
      oprot.writeFieldEnd()
3924 
    if self.limit != None:
3925 
      oprot.writeFieldBegin('limit', TType.I64, 2)
3926 
      oprot.writeI64(self.limit)
3927 
      oprot.writeFieldEnd()
3928 
    oprot.writeFieldStop()
3929 
    oprot.writeStructEnd()
3930 
 
3931 
  def __repr__(self):
3932 
    L = ['%s=%r' % (key, value)
3933 
      for key, value in self.__dict__.iteritems()]
3934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3935 
 
3936 
  def __eq__(self, other):
3937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3938 
 
3939 
  def __ne__(self, other):
3940 
    return not (self == other)
3941 
 
3942 
class getReturnableOrdersForCustomer_result:
3943 
  """
3944 
  Attributes:
3945 
   - success
3946 
   - ex
3947 
  """
3948 
 
3949 
  thrift_spec = (
3950 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
3951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3952 
  )
3953 
 
3954 
  def __init__(self, success=None, ex=None,):
3955 
    self.success = success
3956 
    self.ex = ex
3957 
 
3958 
  def read(self, iprot):
3959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3961 
      return
3962 
    iprot.readStructBegin()
3963 
    while True:
3964 
      (fname, ftype, fid) = iprot.readFieldBegin()
3965 
      if ftype == TType.STOP:
3966 
        break
3967 
      if fid == 0:
3968 
        if ftype == TType.LIST:
3969 
          self.success = []
3970 
          (_etype45, _size42) = iprot.readListBegin()
3971 
          for _i46 in xrange(_size42):
3972 
            _elem47 = iprot.readI64();
3973 
            self.success.append(_elem47)
3974 
          iprot.readListEnd()
3975 
        else:
3976 
          iprot.skip(ftype)
3977 
      elif fid == 1:
3978 
        if ftype == TType.STRUCT:
3979 
          self.ex = TransactionServiceException()
3980 
          self.ex.read(iprot)
3981 
        else:
3982 
          iprot.skip(ftype)
3983 
      else:
3984 
        iprot.skip(ftype)
3985 
      iprot.readFieldEnd()
3986 
    iprot.readStructEnd()
3987 
 
3988 
  def write(self, oprot):
3989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3991 
      return
3992 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3993 
    if self.success != None:
3994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3995 
      oprot.writeListBegin(TType.I64, len(self.success))
3996 
      for iter48 in self.success:
3997 
        oprot.writeI64(iter48)
3998 
      oprot.writeListEnd()
3999 
      oprot.writeFieldEnd()
4000 
    if self.ex != None:
4001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4002 
      self.ex.write(oprot)
4003 
      oprot.writeFieldEnd()
4004 
    oprot.writeFieldStop()
4005 
    oprot.writeStructEnd()
4006 
 
4007 
  def __repr__(self):
4008 
    L = ['%s=%r' % (key, value)
4009 
      for key, value in self.__dict__.iteritems()]
4010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4011 
 
4012 
  def __eq__(self, other):
4013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4014 
 
4015 
  def __ne__(self, other):
4016 
    return not (self == other)
4017 
 
4018 
class getCancellableOrdersForCustomer_args:
4019 
  """
4020 
  Attributes:
4021 
   - customer_id
4022 
   - limit
4023 
  """
4024 
 
4025 
  thrift_spec = (
4026 
    None, # 0
4027 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4028 
    (2, TType.I64, 'limit', None, None, ), # 2
4029 
  )
4030 
 
4031 
  def __init__(self, customer_id=None, limit=None,):
4032 
    self.customer_id = customer_id
4033 
    self.limit = limit
4034 
 
4035 
  def read(self, iprot):
4036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4038 
      return
4039 
    iprot.readStructBegin()
4040 
    while True:
4041 
      (fname, ftype, fid) = iprot.readFieldBegin()
4042 
      if ftype == TType.STOP:
4043 
        break
4044 
      if fid == 1:
4045 
        if ftype == TType.I64:
4046 
          self.customer_id = iprot.readI64();
4047 
        else:
4048 
          iprot.skip(ftype)
4049 
      elif fid == 2:
4050 
        if ftype == TType.I64:
4051 
          self.limit = iprot.readI64();
4052 
        else:
4053 
          iprot.skip(ftype)
4054 
      else:
4055 
        iprot.skip(ftype)
4056 
      iprot.readFieldEnd()
4057 
    iprot.readStructEnd()
4058 
 
4059 
  def write(self, oprot):
4060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4062 
      return
4063 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
4064 
    if self.customer_id != None:
4065 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4066 
      oprot.writeI64(self.customer_id)
4067 
      oprot.writeFieldEnd()
4068 
    if self.limit != None:
4069 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4070 
      oprot.writeI64(self.limit)
4071 
      oprot.writeFieldEnd()
4072 
    oprot.writeFieldStop()
4073 
    oprot.writeStructEnd()
4074 
 
4075 
  def __repr__(self):
4076 
    L = ['%s=%r' % (key, value)
4077 
      for key, value in self.__dict__.iteritems()]
4078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4079 
 
4080 
  def __eq__(self, other):
4081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4082 
 
4083 
  def __ne__(self, other):
4084 
    return not (self == other)
4085 
 
4086 
class getCancellableOrdersForCustomer_result:
4087 
  """
4088 
  Attributes:
4089 
   - success
4090 
   - ex
4091 
  """
4092 
 
4093 
  thrift_spec = (
4094 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4096 
  )
4097 
 
4098 
  def __init__(self, success=None, ex=None,):
4099 
    self.success = success
4100 
    self.ex = ex
4101 
 
4102 
  def read(self, iprot):
4103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4105 
      return
4106 
    iprot.readStructBegin()
4107 
    while True:
4108 
      (fname, ftype, fid) = iprot.readFieldBegin()
4109 
      if ftype == TType.STOP:
4110 
        break
4111 
      if fid == 0:
4112 
        if ftype == TType.LIST:
4113 
          self.success = []
4114 
          (_etype52, _size49) = iprot.readListBegin()
4115 
          for _i53 in xrange(_size49):
4116 
            _elem54 = iprot.readI64();
4117 
            self.success.append(_elem54)
4118 
          iprot.readListEnd()
4119 
        else:
4120 
          iprot.skip(ftype)
4121 
      elif fid == 1:
4122 
        if ftype == TType.STRUCT:
4123 
          self.ex = TransactionServiceException()
4124 
          self.ex.read(iprot)
4125 
        else:
4126 
          iprot.skip(ftype)
4127 
      else:
4128 
        iprot.skip(ftype)
4129 
      iprot.readFieldEnd()
4130 
    iprot.readStructEnd()
4131 
 
4132 
  def write(self, oprot):
4133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4135 
      return
4136 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
4137 
    if self.success != None:
4138 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4139 
      oprot.writeListBegin(TType.I64, len(self.success))
4140 
      for iter55 in self.success:
4141 
        oprot.writeI64(iter55)
4142 
      oprot.writeListEnd()
4143 
      oprot.writeFieldEnd()
4144 
    if self.ex != None:
4145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4146 
      self.ex.write(oprot)
4147 
      oprot.writeFieldEnd()
4148 
    oprot.writeFieldStop()
4149 
    oprot.writeStructEnd()
4150 
 
4151 
  def __repr__(self):
4152 
    L = ['%s=%r' % (key, value)
4153 
      for key, value in self.__dict__.iteritems()]
4154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4155 
 
4156 
  def __eq__(self, other):
4157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4158 
 
4159 
  def __ne__(self, other):
4160 
    return not (self == other)
4161 
 
483 rajveer 4162 
class changeOrderStatus_args:
94 ashish 4163 
  """
4164 
  Attributes:
483 rajveer 4165 
   - orderId
4166 
   - status
4167 
   - description
94 ashish 4168 
  """
4169 
 
4170 
  thrift_spec = (
4171 
    None, # 0
483 rajveer 4172 
    (1, TType.I64, 'orderId', None, None, ), # 1
4173 
    (2, TType.I32, 'status', None, None, ), # 2
4174 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 4175 
  )
4176 
 
483 rajveer 4177 
  def __init__(self, orderId=None, status=None, description=None,):
4178 
    self.orderId = orderId
4179 
    self.status = status
4180 
    self.description = description
94 ashish 4181 
 
4182 
  def read(self, iprot):
4183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4185 
      return
4186 
    iprot.readStructBegin()
4187 
    while True:
4188 
      (fname, ftype, fid) = iprot.readFieldBegin()
4189 
      if ftype == TType.STOP:
4190 
        break
4191 
      if fid == 1:
4192 
        if ftype == TType.I64:
483 rajveer 4193 
          self.orderId = iprot.readI64();
94 ashish 4194 
        else:
4195 
          iprot.skip(ftype)
4196 
      elif fid == 2:
483 rajveer 4197 
        if ftype == TType.I32:
4198 
          self.status = iprot.readI32();
94 ashish 4199 
        else:
4200 
          iprot.skip(ftype)
483 rajveer 4201 
      elif fid == 3:
4202 
        if ftype == TType.STRING:
4203 
          self.description = iprot.readString();
4204 
        else:
4205 
          iprot.skip(ftype)
94 ashish 4206 
      else:
4207 
        iprot.skip(ftype)
4208 
      iprot.readFieldEnd()
4209 
    iprot.readStructEnd()
4210 
 
4211 
  def write(self, oprot):
4212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4214 
      return
483 rajveer 4215 
    oprot.writeStructBegin('changeOrderStatus_args')
4216 
    if self.orderId != None:
4217 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4218 
      oprot.writeI64(self.orderId)
94 ashish 4219 
      oprot.writeFieldEnd()
483 rajveer 4220 
    if self.status != None:
4221 
      oprot.writeFieldBegin('status', TType.I32, 2)
4222 
      oprot.writeI32(self.status)
94 ashish 4223 
      oprot.writeFieldEnd()
483 rajveer 4224 
    if self.description != None:
4225 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4226 
      oprot.writeString(self.description)
4227 
      oprot.writeFieldEnd()
94 ashish 4228 
    oprot.writeFieldStop()
4229 
    oprot.writeStructEnd()
4230 
 
4231 
  def __repr__(self):
4232 
    L = ['%s=%r' % (key, value)
4233 
      for key, value in self.__dict__.iteritems()]
4234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4235 
 
4236 
  def __eq__(self, other):
4237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4238 
 
4239 
  def __ne__(self, other):
4240 
    return not (self == other)
4241 
 
483 rajveer 4242 
class changeOrderStatus_result:
94 ashish 4243 
  """
4244 
  Attributes:
4245 
   - success
4246 
   - ex
4247 
  """
4248 
 
4249 
  thrift_spec = (
4250 
    (0, TType.BOOL, 'success', None, None, ), # 0
4251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4252 
  )
4253 
 
4254 
  def __init__(self, success=None, ex=None,):
4255 
    self.success = success
4256 
    self.ex = ex
4257 
 
4258 
  def read(self, iprot):
4259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4261 
      return
4262 
    iprot.readStructBegin()
4263 
    while True:
4264 
      (fname, ftype, fid) = iprot.readFieldBegin()
4265 
      if ftype == TType.STOP:
4266 
        break
4267 
      if fid == 0:
4268 
        if ftype == TType.BOOL:
4269 
          self.success = iprot.readBool();
4270 
        else:
4271 
          iprot.skip(ftype)
4272 
      elif fid == 1:
4273 
        if ftype == TType.STRUCT:
4274 
          self.ex = TransactionServiceException()
4275 
          self.ex.read(iprot)
4276 
        else:
4277 
          iprot.skip(ftype)
4278 
      else:
4279 
        iprot.skip(ftype)
4280 
      iprot.readFieldEnd()
4281 
    iprot.readStructEnd()
4282 
 
4283 
  def write(self, oprot):
4284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4286 
      return
483 rajveer 4287 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 4288 
    if self.success != None:
4289 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4290 
      oprot.writeBool(self.success)
4291 
      oprot.writeFieldEnd()
4292 
    if self.ex != None:
4293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4294 
      self.ex.write(oprot)
4295 
      oprot.writeFieldEnd()
4296 
    oprot.writeFieldStop()
4297 
    oprot.writeStructEnd()
4298 
 
4299 
  def __repr__(self):
4300 
    L = ['%s=%r' % (key, value)
4301 
      for key, value in self.__dict__.iteritems()]
4302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4303 
 
4304 
  def __eq__(self, other):
4305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4306 
 
4307 
  def __ne__(self, other):
4308 
    return not (self == other)
4309 
 
494 rajveer 4310 
class addBillingDetails_args:
4311 
  """
4312 
  Attributes:
4313 
   - orderId
4314 
   - invoice_number
4315 
   - billed_by
4316 
  """
4317 
 
4318 
  thrift_spec = (
4319 
    None, # 0
4320 
    (1, TType.I64, 'orderId', None, None, ), # 1
4321 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
1149 chandransh 4322 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
494 rajveer 4323 
  )
4324 
 
1149 chandransh 4325 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
494 rajveer 4326 
    self.orderId = orderId
4327 
    self.invoice_number = invoice_number
4328 
    self.billed_by = billed_by
4329 
 
4330 
  def read(self, iprot):
4331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4333 
      return
4334 
    iprot.readStructBegin()
4335 
    while True:
4336 
      (fname, ftype, fid) = iprot.readFieldBegin()
4337 
      if ftype == TType.STOP:
4338 
        break
4339 
      if fid == 1:
4340 
        if ftype == TType.I64:
4341 
          self.orderId = iprot.readI64();
4342 
        else:
4343 
          iprot.skip(ftype)
4344 
      elif fid == 2:
4345 
        if ftype == TType.STRING:
4346 
          self.invoice_number = iprot.readString();
4347 
        else:
4348 
          iprot.skip(ftype)
4349 
      elif fid == 3:
4350 
        if ftype == TType.STRING:
4351 
          self.billed_by = iprot.readString();
4352 
        else:
4353 
          iprot.skip(ftype)
4354 
      else:
4355 
        iprot.skip(ftype)
4356 
      iprot.readFieldEnd()
4357 
    iprot.readStructEnd()
4358 
 
4359 
  def write(self, oprot):
4360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4362 
      return
4363 
    oprot.writeStructBegin('addBillingDetails_args')
4364 
    if self.orderId != None:
4365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4366 
      oprot.writeI64(self.orderId)
4367 
      oprot.writeFieldEnd()
4368 
    if self.invoice_number != None:
4369 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
4370 
      oprot.writeString(self.invoice_number)
4371 
      oprot.writeFieldEnd()
4372 
    if self.billed_by != None:
1149 chandransh 4373 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
494 rajveer 4374 
      oprot.writeString(self.billed_by)
4375 
      oprot.writeFieldEnd()
4376 
    oprot.writeFieldStop()
4377 
    oprot.writeStructEnd()
4378 
 
4379 
  def __repr__(self):
4380 
    L = ['%s=%r' % (key, value)
4381 
      for key, value in self.__dict__.iteritems()]
4382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4383 
 
4384 
  def __eq__(self, other):
4385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4386 
 
4387 
  def __ne__(self, other):
4388 
    return not (self == other)
4389 
 
4390 
class addBillingDetails_result:
4391 
  """
4392 
  Attributes:
4393 
   - success
4394 
   - ex
4395 
  """
4396 
 
4397 
  thrift_spec = (
4398 
    (0, TType.BOOL, 'success', None, None, ), # 0
4399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4400 
  )
4401 
 
4402 
  def __init__(self, success=None, ex=None,):
4403 
    self.success = success
4404 
    self.ex = ex
4405 
 
4406 
  def read(self, iprot):
4407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4409 
      return
4410 
    iprot.readStructBegin()
4411 
    while True:
4412 
      (fname, ftype, fid) = iprot.readFieldBegin()
4413 
      if ftype == TType.STOP:
4414 
        break
4415 
      if fid == 0:
4416 
        if ftype == TType.BOOL:
4417 
          self.success = iprot.readBool();
4418 
        else:
4419 
          iprot.skip(ftype)
4420 
      elif fid == 1:
4421 
        if ftype == TType.STRUCT:
4422 
          self.ex = TransactionServiceException()
4423 
          self.ex.read(iprot)
4424 
        else:
4425 
          iprot.skip(ftype)
4426 
      else:
4427 
        iprot.skip(ftype)
4428 
      iprot.readFieldEnd()
4429 
    iprot.readStructEnd()
4430 
 
4431 
  def write(self, oprot):
4432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4434 
      return
4435 
    oprot.writeStructBegin('addBillingDetails_result')
4436 
    if self.success != None:
4437 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4438 
      oprot.writeBool(self.success)
4439 
      oprot.writeFieldEnd()
4440 
    if self.ex != None:
4441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4442 
      self.ex.write(oprot)
4443 
      oprot.writeFieldEnd()
4444 
    oprot.writeFieldStop()
4445 
    oprot.writeStructEnd()
4446 
 
4447 
  def __repr__(self):
4448 
    L = ['%s=%r' % (key, value)
4449 
      for key, value in self.__dict__.iteritems()]
4450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4451 
 
4452 
  def __eq__(self, other):
4453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4454 
 
4455 
  def __ne__(self, other):
4456 
    return not (self == other)
4457 
 
1149 chandransh 4458 
class addJacketNumber_args:
4459 
  """
4460 
  Attributes:
4461 
   - orderId
4462 
   - jacketNumber
4463 
  """
4464 
 
4465 
  thrift_spec = (
4466 
    None, # 0
4467 
    (1, TType.I64, 'orderId', None, None, ), # 1
4468 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
4469 
  )
4470 
 
4471 
  def __init__(self, orderId=None, jacketNumber=None,):
4472 
    self.orderId = orderId
4473 
    self.jacketNumber = jacketNumber
4474 
 
4475 
  def read(self, iprot):
4476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4478 
      return
4479 
    iprot.readStructBegin()
4480 
    while True:
4481 
      (fname, ftype, fid) = iprot.readFieldBegin()
4482 
      if ftype == TType.STOP:
4483 
        break
4484 
      if fid == 1:
4485 
        if ftype == TType.I64:
4486 
          self.orderId = iprot.readI64();
4487 
        else:
4488 
          iprot.skip(ftype)
4489 
      elif fid == 2:
4490 
        if ftype == TType.I64:
4491 
          self.jacketNumber = iprot.readI64();
4492 
        else:
4493 
          iprot.skip(ftype)
4494 
      else:
4495 
        iprot.skip(ftype)
4496 
      iprot.readFieldEnd()
4497 
    iprot.readStructEnd()
4498 
 
4499 
  def write(self, oprot):
4500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4502 
      return
4503 
    oprot.writeStructBegin('addJacketNumber_args')
4504 
    if self.orderId != None:
4505 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4506 
      oprot.writeI64(self.orderId)
4507 
      oprot.writeFieldEnd()
4508 
    if self.jacketNumber != None:
4509 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
4510 
      oprot.writeI64(self.jacketNumber)
4511 
      oprot.writeFieldEnd()
4512 
    oprot.writeFieldStop()
4513 
    oprot.writeStructEnd()
4514 
 
4515 
  def __repr__(self):
4516 
    L = ['%s=%r' % (key, value)
4517 
      for key, value in self.__dict__.iteritems()]
4518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4519 
 
4520 
  def __eq__(self, other):
4521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4522 
 
4523 
  def __ne__(self, other):
4524 
    return not (self == other)
4525 
 
4526 
class addJacketNumber_result:
4527 
  """
4528 
  Attributes:
4529 
   - success
4530 
   - ex
4531 
  """
4532 
 
4533 
  thrift_spec = (
4534 
    (0, TType.BOOL, 'success', None, None, ), # 0
4535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4536 
  )
4537 
 
4538 
  def __init__(self, success=None, ex=None,):
4539 
    self.success = success
4540 
    self.ex = ex
4541 
 
4542 
  def read(self, iprot):
4543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4545 
      return
4546 
    iprot.readStructBegin()
4547 
    while True:
4548 
      (fname, ftype, fid) = iprot.readFieldBegin()
4549 
      if ftype == TType.STOP:
4550 
        break
4551 
      if fid == 0:
4552 
        if ftype == TType.BOOL:
4553 
          self.success = iprot.readBool();
4554 
        else:
4555 
          iprot.skip(ftype)
4556 
      elif fid == 1:
4557 
        if ftype == TType.STRUCT:
4558 
          self.ex = TransactionServiceException()
4559 
          self.ex.read(iprot)
4560 
        else:
4561 
          iprot.skip(ftype)
4562 
      else:
4563 
        iprot.skip(ftype)
4564 
      iprot.readFieldEnd()
4565 
    iprot.readStructEnd()
4566 
 
4567 
  def write(self, oprot):
4568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4570 
      return
4571 
    oprot.writeStructBegin('addJacketNumber_result')
4572 
    if self.success != None:
4573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4574 
      oprot.writeBool(self.success)
4575 
      oprot.writeFieldEnd()
4576 
    if self.ex != None:
4577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4578 
      self.ex.write(oprot)
4579 
      oprot.writeFieldEnd()
4580 
    oprot.writeFieldStop()
4581 
    oprot.writeStructEnd()
4582 
 
4583 
  def __repr__(self):
4584 
    L = ['%s=%r' % (key, value)
4585 
      for key, value in self.__dict__.iteritems()]
4586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4587 
 
4588 
  def __eq__(self, other):
4589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4590 
 
4591 
  def __ne__(self, other):
4592 
    return not (self == other)
4593 
 
921 rajveer 4594 
class acceptOrder_args:
4595 
  """
4596 
  Attributes:
4597 
   - orderId
4598 
  """
4599 
 
4600 
  thrift_spec = (
4601 
    None, # 0
4602 
    (1, TType.I64, 'orderId', None, None, ), # 1
4603 
  )
4604 
 
4605 
  def __init__(self, orderId=None,):
4606 
    self.orderId = orderId
4607 
 
4608 
  def read(self, iprot):
4609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4611 
      return
4612 
    iprot.readStructBegin()
4613 
    while True:
4614 
      (fname, ftype, fid) = iprot.readFieldBegin()
4615 
      if ftype == TType.STOP:
4616 
        break
4617 
      if fid == 1:
4618 
        if ftype == TType.I64:
4619 
          self.orderId = iprot.readI64();
4620 
        else:
4621 
          iprot.skip(ftype)
4622 
      else:
4623 
        iprot.skip(ftype)
4624 
      iprot.readFieldEnd()
4625 
    iprot.readStructEnd()
4626 
 
4627 
  def write(self, oprot):
4628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4630 
      return
4631 
    oprot.writeStructBegin('acceptOrder_args')
4632 
    if self.orderId != None:
4633 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4634 
      oprot.writeI64(self.orderId)
4635 
      oprot.writeFieldEnd()
4636 
    oprot.writeFieldStop()
4637 
    oprot.writeStructEnd()
4638 
 
4639 
  def __repr__(self):
4640 
    L = ['%s=%r' % (key, value)
4641 
      for key, value in self.__dict__.iteritems()]
4642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4643 
 
4644 
  def __eq__(self, other):
4645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4646 
 
4647 
  def __ne__(self, other):
4648 
    return not (self == other)
4649 
 
4650 
class acceptOrder_result:
4651 
  """
4652 
  Attributes:
4653 
   - success
4654 
   - ex
4655 
  """
4656 
 
4657 
  thrift_spec = (
4658 
    (0, TType.BOOL, 'success', None, None, ), # 0
4659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4660 
  )
4661 
 
4662 
  def __init__(self, success=None, ex=None,):
4663 
    self.success = success
4664 
    self.ex = ex
4665 
 
4666 
  def read(self, iprot):
4667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4669 
      return
4670 
    iprot.readStructBegin()
4671 
    while True:
4672 
      (fname, ftype, fid) = iprot.readFieldBegin()
4673 
      if ftype == TType.STOP:
4674 
        break
4675 
      if fid == 0:
4676 
        if ftype == TType.BOOL:
4677 
          self.success = iprot.readBool();
4678 
        else:
4679 
          iprot.skip(ftype)
4680 
      elif fid == 1:
4681 
        if ftype == TType.STRUCT:
4682 
          self.ex = TransactionServiceException()
4683 
          self.ex.read(iprot)
4684 
        else:
4685 
          iprot.skip(ftype)
4686 
      else:
4687 
        iprot.skip(ftype)
4688 
      iprot.readFieldEnd()
4689 
    iprot.readStructEnd()
4690 
 
4691 
  def write(self, oprot):
4692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4694 
      return
4695 
    oprot.writeStructBegin('acceptOrder_result')
4696 
    if self.success != None:
4697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4698 
      oprot.writeBool(self.success)
4699 
      oprot.writeFieldEnd()
4700 
    if self.ex != None:
4701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4702 
      self.ex.write(oprot)
4703 
      oprot.writeFieldEnd()
4704 
    oprot.writeFieldStop()
4705 
    oprot.writeStructEnd()
4706 
 
4707 
  def __repr__(self):
4708 
    L = ['%s=%r' % (key, value)
4709 
      for key, value in self.__dict__.iteritems()]
4710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4711 
 
4712 
  def __eq__(self, other):
4713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4714 
 
4715 
  def __ne__(self, other):
4716 
    return not (self == other)
4717 
 
4718 
class billOrder_args:
4719 
  """
4720 
  Attributes:
4721 
   - orderId
4722 
  """
4723 
 
4724 
  thrift_spec = (
4725 
    None, # 0
4726 
    (1, TType.I64, 'orderId', None, None, ), # 1
4727 
  )
4728 
 
4729 
  def __init__(self, orderId=None,):
4730 
    self.orderId = orderId
4731 
 
4732 
  def read(self, iprot):
4733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4735 
      return
4736 
    iprot.readStructBegin()
4737 
    while True:
4738 
      (fname, ftype, fid) = iprot.readFieldBegin()
4739 
      if ftype == TType.STOP:
4740 
        break
4741 
      if fid == 1:
4742 
        if ftype == TType.I64:
4743 
          self.orderId = iprot.readI64();
4744 
        else:
4745 
          iprot.skip(ftype)
4746 
      else:
4747 
        iprot.skip(ftype)
4748 
      iprot.readFieldEnd()
4749 
    iprot.readStructEnd()
4750 
 
4751 
  def write(self, oprot):
4752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4754 
      return
4755 
    oprot.writeStructBegin('billOrder_args')
4756 
    if self.orderId != None:
4757 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4758 
      oprot.writeI64(self.orderId)
4759 
      oprot.writeFieldEnd()
4760 
    oprot.writeFieldStop()
4761 
    oprot.writeStructEnd()
4762 
 
4763 
  def __repr__(self):
4764 
    L = ['%s=%r' % (key, value)
4765 
      for key, value in self.__dict__.iteritems()]
4766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4767 
 
4768 
  def __eq__(self, other):
4769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4770 
 
4771 
  def __ne__(self, other):
4772 
    return not (self == other)
4773 
 
4774 
class billOrder_result:
4775 
  """
4776 
  Attributes:
4777 
   - success
4778 
   - ex
4779 
  """
4780 
 
4781 
  thrift_spec = (
4782 
    (0, TType.BOOL, 'success', None, None, ), # 0
4783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4784 
  )
4785 
 
4786 
  def __init__(self, success=None, ex=None,):
4787 
    self.success = success
4788 
    self.ex = ex
4789 
 
4790 
  def read(self, iprot):
4791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4793 
      return
4794 
    iprot.readStructBegin()
4795 
    while True:
4796 
      (fname, ftype, fid) = iprot.readFieldBegin()
4797 
      if ftype == TType.STOP:
4798 
        break
4799 
      if fid == 0:
4800 
        if ftype == TType.BOOL:
4801 
          self.success = iprot.readBool();
4802 
        else:
4803 
          iprot.skip(ftype)
4804 
      elif fid == 1:
4805 
        if ftype == TType.STRUCT:
4806 
          self.ex = TransactionServiceException()
4807 
          self.ex.read(iprot)
4808 
        else:
4809 
          iprot.skip(ftype)
4810 
      else:
4811 
        iprot.skip(ftype)
4812 
      iprot.readFieldEnd()
4813 
    iprot.readStructEnd()
4814 
 
4815 
  def write(self, oprot):
4816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4818 
      return
4819 
    oprot.writeStructBegin('billOrder_result')
4820 
    if self.success != None:
4821 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4822 
      oprot.writeBool(self.success)
4823 
      oprot.writeFieldEnd()
4824 
    if self.ex != None:
4825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4826 
      self.ex.write(oprot)
4827 
      oprot.writeFieldEnd()
4828 
    oprot.writeFieldStop()
4829 
    oprot.writeStructEnd()
4830 
 
4831 
  def __repr__(self):
4832 
    L = ['%s=%r' % (key, value)
4833 
      for key, value in self.__dict__.iteritems()]
4834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4835 
 
4836 
  def __eq__(self, other):
4837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4838 
 
4839 
  def __ne__(self, other):
4840 
    return not (self == other)
4841 
 
483 rajveer 4842 
class getOrdersForTransaction_args:
94 ashish 4843 
  """
4844 
  Attributes:
4845 
   - transactionId
1528 ankur.sing 4846 
   - customerId
94 ashish 4847 
  """
4848 
 
4849 
  thrift_spec = (
4850 
    None, # 0
4851 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1528 ankur.sing 4852 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 4853 
  )
4854 
 
1528 ankur.sing 4855 
  def __init__(self, transactionId=None, customerId=None,):
94 ashish 4856 
    self.transactionId = transactionId
1528 ankur.sing 4857 
    self.customerId = customerId
94 ashish 4858 
 
4859 
  def read(self, iprot):
4860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4862 
      return
4863 
    iprot.readStructBegin()
4864 
    while True:
4865 
      (fname, ftype, fid) = iprot.readFieldBegin()
4866 
      if ftype == TType.STOP:
4867 
        break
4868 
      if fid == 1:
4869 
        if ftype == TType.I64:
4870 
          self.transactionId = iprot.readI64();
4871 
        else:
4872 
          iprot.skip(ftype)
1528 ankur.sing 4873 
      elif fid == 2:
4874 
        if ftype == TType.I64:
4875 
          self.customerId = iprot.readI64();
4876 
        else:
4877 
          iprot.skip(ftype)
94 ashish 4878 
      else:
4879 
        iprot.skip(ftype)
4880 
      iprot.readFieldEnd()
4881 
    iprot.readStructEnd()
4882 
 
4883 
  def write(self, oprot):
4884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4886 
      return
483 rajveer 4887 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 4888 
    if self.transactionId != None:
4889 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4890 
      oprot.writeI64(self.transactionId)
4891 
      oprot.writeFieldEnd()
1528 ankur.sing 4892 
    if self.customerId != None:
4893 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
4894 
      oprot.writeI64(self.customerId)
4895 
      oprot.writeFieldEnd()
94 ashish 4896 
    oprot.writeFieldStop()
4897 
    oprot.writeStructEnd()
4898 
 
4899 
  def __repr__(self):
4900 
    L = ['%s=%r' % (key, value)
4901 
      for key, value in self.__dict__.iteritems()]
4902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4903 
 
4904 
  def __eq__(self, other):
4905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4906 
 
4907 
  def __ne__(self, other):
4908 
    return not (self == other)
4909 
 
483 rajveer 4910 
class getOrdersForTransaction_result:
94 ashish 4911 
  """
4912 
  Attributes:
4913 
   - success
4914 
   - ex
4915 
  """
4916 
 
4917 
  thrift_spec = (
483 rajveer 4918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 4919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4920 
  )
4921 
 
4922 
  def __init__(self, success=None, ex=None,):
4923 
    self.success = success
4924 
    self.ex = ex
4925 
 
4926 
  def read(self, iprot):
4927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4929 
      return
4930 
    iprot.readStructBegin()
4931 
    while True:
4932 
      (fname, ftype, fid) = iprot.readFieldBegin()
4933 
      if ftype == TType.STOP:
4934 
        break
4935 
      if fid == 0:
483 rajveer 4936 
        if ftype == TType.LIST:
4937 
          self.success = []
1382 varun.gupt 4938 
          (_etype59, _size56) = iprot.readListBegin()
4939 
          for _i60 in xrange(_size56):
4940 
            _elem61 = Order()
4941 
            _elem61.read(iprot)
4942 
            self.success.append(_elem61)
483 rajveer 4943 
          iprot.readListEnd()
94 ashish 4944 
        else:
4945 
          iprot.skip(ftype)
4946 
      elif fid == 1:
4947 
        if ftype == TType.STRUCT:
4948 
          self.ex = TransactionServiceException()
4949 
          self.ex.read(iprot)
4950 
        else:
4951 
          iprot.skip(ftype)
4952 
      else:
4953 
        iprot.skip(ftype)
4954 
      iprot.readFieldEnd()
4955 
    iprot.readStructEnd()
4956 
 
4957 
  def write(self, oprot):
4958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4960 
      return
483 rajveer 4961 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 4962 
    if self.success != None:
483 rajveer 4963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 4965 
      for iter62 in self.success:
4966 
        iter62.write(oprot)
483 rajveer 4967 
      oprot.writeListEnd()
94 ashish 4968 
      oprot.writeFieldEnd()
4969 
    if self.ex != None:
4970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4971 
      self.ex.write(oprot)
4972 
      oprot.writeFieldEnd()
4973 
    oprot.writeFieldStop()
4974 
    oprot.writeStructEnd()
4975 
 
4976 
  def __repr__(self):
4977 
    L = ['%s=%r' % (key, value)
4978 
      for key, value in self.__dict__.iteritems()]
4979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4980 
 
4981 
  def __eq__(self, other):
4982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4983 
 
4984 
  def __ne__(self, other):
4985 
    return not (self == other)
4986 
 
483 rajveer 4987 
class getOrdersForCustomer_args:
94 ashish 4988 
  """
4989 
  Attributes:
483 rajveer 4990 
   - customerId
4991 
   - from_date
4992 
   - to_date
4993 
   - status
94 ashish 4994 
  """
4995 
 
4996 
  thrift_spec = (
4997 
    None, # 0
483 rajveer 4998 
    (1, TType.I64, 'customerId', None, None, ), # 1
4999 
    (2, TType.I64, 'from_date', None, None, ), # 2
5000 
    (3, TType.I64, 'to_date', None, None, ), # 3
5001 
    (4, TType.I32, 'status', None, None, ), # 4
94 ashish 5002 
  )
5003 
 
483 rajveer 5004 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5005 
    self.customerId = customerId
5006 
    self.from_date = from_date
5007 
    self.to_date = to_date
5008 
    self.status = status
94 ashish 5009 
 
5010 
  def read(self, iprot):
5011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5013 
      return
5014 
    iprot.readStructBegin()
5015 
    while True:
5016 
      (fname, ftype, fid) = iprot.readFieldBegin()
5017 
      if ftype == TType.STOP:
5018 
        break
5019 
      if fid == 1:
5020 
        if ftype == TType.I64:
483 rajveer 5021 
          self.customerId = iprot.readI64();
94 ashish 5022 
        else:
5023 
          iprot.skip(ftype)
5024 
      elif fid == 2:
5025 
        if ftype == TType.I64:
483 rajveer 5026 
          self.from_date = iprot.readI64();
94 ashish 5027 
        else:
5028 
          iprot.skip(ftype)
5029 
      elif fid == 3:
5030 
        if ftype == TType.I64:
483 rajveer 5031 
          self.to_date = iprot.readI64();
94 ashish 5032 
        else:
5033 
          iprot.skip(ftype)
483 rajveer 5034 
      elif fid == 4:
5035 
        if ftype == TType.I32:
5036 
          self.status = iprot.readI32();
5037 
        else:
5038 
          iprot.skip(ftype)
94 ashish 5039 
      else:
5040 
        iprot.skip(ftype)
5041 
      iprot.readFieldEnd()
5042 
    iprot.readStructEnd()
5043 
 
5044 
  def write(self, oprot):
5045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5047 
      return
483 rajveer 5048 
    oprot.writeStructBegin('getOrdersForCustomer_args')
5049 
    if self.customerId != None:
5050 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5051 
      oprot.writeI64(self.customerId)
94 ashish 5052 
      oprot.writeFieldEnd()
483 rajveer 5053 
    if self.from_date != None:
5054 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5055 
      oprot.writeI64(self.from_date)
94 ashish 5056 
      oprot.writeFieldEnd()
483 rajveer 5057 
    if self.to_date != None:
5058 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5059 
      oprot.writeI64(self.to_date)
94 ashish 5060 
      oprot.writeFieldEnd()
483 rajveer 5061 
    if self.status != None:
5062 
      oprot.writeFieldBegin('status', TType.I32, 4)
5063 
      oprot.writeI32(self.status)
5064 
      oprot.writeFieldEnd()
94 ashish 5065 
    oprot.writeFieldStop()
5066 
    oprot.writeStructEnd()
5067 
 
5068 
  def __repr__(self):
5069 
    L = ['%s=%r' % (key, value)
5070 
      for key, value in self.__dict__.iteritems()]
5071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5072 
 
5073 
  def __eq__(self, other):
5074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5075 
 
5076 
  def __ne__(self, other):
5077 
    return not (self == other)
5078 
 
483 rajveer 5079 
class getOrdersForCustomer_result:
94 ashish 5080 
  """
5081 
  Attributes:
5082 
   - success
5083 
   - ex
5084 
  """
5085 
 
5086 
  thrift_spec = (
483 rajveer 5087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5089 
  )
5090 
 
5091 
  def __init__(self, success=None, ex=None,):
5092 
    self.success = success
5093 
    self.ex = ex
5094 
 
5095 
  def read(self, iprot):
5096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5098 
      return
5099 
    iprot.readStructBegin()
5100 
    while True:
5101 
      (fname, ftype, fid) = iprot.readFieldBegin()
5102 
      if ftype == TType.STOP:
5103 
        break
5104 
      if fid == 0:
483 rajveer 5105 
        if ftype == TType.LIST:
5106 
          self.success = []
1382 varun.gupt 5107 
          (_etype66, _size63) = iprot.readListBegin()
5108 
          for _i67 in xrange(_size63):
5109 
            _elem68 = Order()
5110 
            _elem68.read(iprot)
5111 
            self.success.append(_elem68)
483 rajveer 5112 
          iprot.readListEnd()
94 ashish 5113 
        else:
5114 
          iprot.skip(ftype)
5115 
      elif fid == 1:
5116 
        if ftype == TType.STRUCT:
5117 
          self.ex = TransactionServiceException()
5118 
          self.ex.read(iprot)
5119 
        else:
5120 
          iprot.skip(ftype)
5121 
      else:
5122 
        iprot.skip(ftype)
5123 
      iprot.readFieldEnd()
5124 
    iprot.readStructEnd()
5125 
 
5126 
  def write(self, oprot):
5127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5129 
      return
483 rajveer 5130 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 5131 
    if self.success != None:
483 rajveer 5132 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5133 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5134 
      for iter69 in self.success:
5135 
        iter69.write(oprot)
483 rajveer 5136 
      oprot.writeListEnd()
94 ashish 5137 
      oprot.writeFieldEnd()
5138 
    if self.ex != None:
5139 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5140 
      self.ex.write(oprot)
5141 
      oprot.writeFieldEnd()
5142 
    oprot.writeFieldStop()
5143 
    oprot.writeStructEnd()
5144 
 
5145 
  def __repr__(self):
5146 
    L = ['%s=%r' % (key, value)
5147 
      for key, value in self.__dict__.iteritems()]
5148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5149 
 
5150 
  def __eq__(self, other):
5151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5152 
 
5153 
  def __ne__(self, other):
5154 
    return not (self == other)
5155 
 
483 rajveer 5156 
class createOrder_args:
94 ashish 5157 
  """
5158 
  Attributes:
483 rajveer 5159 
   - order
94 ashish 5160 
  """
5161 
 
5162 
  thrift_spec = (
5163 
    None, # 0
483 rajveer 5164 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 5165 
  )
5166 
 
483 rajveer 5167 
  def __init__(self, order=None,):
5168 
    self.order = order
94 ashish 5169 
 
5170 
  def read(self, iprot):
5171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5173 
      return
5174 
    iprot.readStructBegin()
5175 
    while True:
5176 
      (fname, ftype, fid) = iprot.readFieldBegin()
5177 
      if ftype == TType.STOP:
5178 
        break
5179 
      if fid == 1:
483 rajveer 5180 
        if ftype == TType.STRUCT:
5181 
          self.order = Order()
5182 
          self.order.read(iprot)
94 ashish 5183 
        else:
5184 
          iprot.skip(ftype)
5185 
      else:
5186 
        iprot.skip(ftype)
5187 
      iprot.readFieldEnd()
5188 
    iprot.readStructEnd()
5189 
 
5190 
  def write(self, oprot):
5191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5193 
      return
483 rajveer 5194 
    oprot.writeStructBegin('createOrder_args')
5195 
    if self.order != None:
5196 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
5197 
      self.order.write(oprot)
94 ashish 5198 
      oprot.writeFieldEnd()
5199 
    oprot.writeFieldStop()
5200 
    oprot.writeStructEnd()
5201 
 
5202 
  def __repr__(self):
5203 
    L = ['%s=%r' % (key, value)
5204 
      for key, value in self.__dict__.iteritems()]
5205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5206 
 
5207 
  def __eq__(self, other):
5208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5209 
 
5210 
  def __ne__(self, other):
5211 
    return not (self == other)
5212 
 
483 rajveer 5213 
class createOrder_result:
94 ashish 5214 
  """
5215 
  Attributes:
5216 
   - success
5217 
   - ex
5218 
  """
5219 
 
5220 
  thrift_spec = (
483 rajveer 5221 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5223 
  )
5224 
 
5225 
  def __init__(self, success=None, ex=None,):
5226 
    self.success = success
5227 
    self.ex = ex
5228 
 
5229 
  def read(self, iprot):
5230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5232 
      return
5233 
    iprot.readStructBegin()
5234 
    while True:
5235 
      (fname, ftype, fid) = iprot.readFieldBegin()
5236 
      if ftype == TType.STOP:
5237 
        break
5238 
      if fid == 0:
483 rajveer 5239 
        if ftype == TType.I64:
5240 
          self.success = iprot.readI64();
94 ashish 5241 
        else:
5242 
          iprot.skip(ftype)
5243 
      elif fid == 1:
5244 
        if ftype == TType.STRUCT:
5245 
          self.ex = TransactionServiceException()
5246 
          self.ex.read(iprot)
5247 
        else:
5248 
          iprot.skip(ftype)
5249 
      else:
5250 
        iprot.skip(ftype)
5251 
      iprot.readFieldEnd()
5252 
    iprot.readStructEnd()
5253 
 
5254 
  def write(self, oprot):
5255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5257 
      return
483 rajveer 5258 
    oprot.writeStructBegin('createOrder_result')
94 ashish 5259 
    if self.success != None:
483 rajveer 5260 
      oprot.writeFieldBegin('success', TType.I64, 0)
5261 
      oprot.writeI64(self.success)
94 ashish 5262 
      oprot.writeFieldEnd()
5263 
    if self.ex != None:
5264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5265 
      self.ex.write(oprot)
5266 
      oprot.writeFieldEnd()
5267 
    oprot.writeFieldStop()
5268 
    oprot.writeStructEnd()
5269 
 
5270 
  def __repr__(self):
5271 
    L = ['%s=%r' % (key, value)
5272 
      for key, value in self.__dict__.iteritems()]
5273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5274 
 
5275 
  def __eq__(self, other):
5276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5277 
 
5278 
  def __ne__(self, other):
5279 
    return not (self == other)
5280 
 
483 rajveer 5281 
class getOrder_args:
94 ashish 5282 
  """
5283 
  Attributes:
483 rajveer 5284 
   - id
94 ashish 5285 
  """
5286 
 
5287 
  thrift_spec = (
5288 
    None, # 0
483 rajveer 5289 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 5290 
  )
5291 
 
483 rajveer 5292 
  def __init__(self, id=None,):
5293 
    self.id = id
94 ashish 5294 
 
5295 
  def read(self, iprot):
5296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5298 
      return
5299 
    iprot.readStructBegin()
5300 
    while True:
5301 
      (fname, ftype, fid) = iprot.readFieldBegin()
5302 
      if ftype == TType.STOP:
5303 
        break
5304 
      if fid == 1:
5305 
        if ftype == TType.I64:
483 rajveer 5306 
          self.id = iprot.readI64();
94 ashish 5307 
        else:
5308 
          iprot.skip(ftype)
5309 
      else:
5310 
        iprot.skip(ftype)
5311 
      iprot.readFieldEnd()
5312 
    iprot.readStructEnd()
5313 
 
5314 
  def write(self, oprot):
5315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5317 
      return
483 rajveer 5318 
    oprot.writeStructBegin('getOrder_args')
5319 
    if self.id != None:
5320 
      oprot.writeFieldBegin('id', TType.I64, 1)
5321 
      oprot.writeI64(self.id)
94 ashish 5322 
      oprot.writeFieldEnd()
5323 
    oprot.writeFieldStop()
5324 
    oprot.writeStructEnd()
5325 
 
5326 
  def __repr__(self):
5327 
    L = ['%s=%r' % (key, value)
5328 
      for key, value in self.__dict__.iteritems()]
5329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5330 
 
5331 
  def __eq__(self, other):
5332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5333 
 
5334 
  def __ne__(self, other):
5335 
    return not (self == other)
5336 
 
483 rajveer 5337 
class getOrder_result:
94 ashish 5338 
  """
5339 
  Attributes:
5340 
   - success
5341 
   - ex
5342 
  """
5343 
 
5344 
  thrift_spec = (
483 rajveer 5345 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 5346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5347 
  )
5348 
 
5349 
  def __init__(self, success=None, ex=None,):
5350 
    self.success = success
5351 
    self.ex = ex
5352 
 
5353 
  def read(self, iprot):
5354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5356 
      return
5357 
    iprot.readStructBegin()
5358 
    while True:
5359 
      (fname, ftype, fid) = iprot.readFieldBegin()
5360 
      if ftype == TType.STOP:
5361 
        break
5362 
      if fid == 0:
483 rajveer 5363 
        if ftype == TType.STRUCT:
5364 
          self.success = Order()
5365 
          self.success.read(iprot)
94 ashish 5366 
        else:
5367 
          iprot.skip(ftype)
5368 
      elif fid == 1:
5369 
        if ftype == TType.STRUCT:
5370 
          self.ex = TransactionServiceException()
5371 
          self.ex.read(iprot)
5372 
        else:
5373 
          iprot.skip(ftype)
5374 
      else:
5375 
        iprot.skip(ftype)
5376 
      iprot.readFieldEnd()
5377 
    iprot.readStructEnd()
5378 
 
5379 
  def write(self, oprot):
5380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5382 
      return
483 rajveer 5383 
    oprot.writeStructBegin('getOrder_result')
94 ashish 5384 
    if self.success != None:
483 rajveer 5385 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5386 
      self.success.write(oprot)
94 ashish 5387 
      oprot.writeFieldEnd()
5388 
    if self.ex != None:
5389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5390 
      self.ex.write(oprot)
5391 
      oprot.writeFieldEnd()
5392 
    oprot.writeFieldStop()
5393 
    oprot.writeStructEnd()
5394 
 
5395 
  def __repr__(self):
5396 
    L = ['%s=%r' % (key, value)
5397 
      for key, value in self.__dict__.iteritems()]
5398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5399 
 
5400 
  def __eq__(self, other):
5401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5402 
 
5403 
  def __ne__(self, other):
5404 
    return not (self == other)
5405 
 
483 rajveer 5406 
class getLineItemsForOrder_args:
94 ashish 5407 
  """
5408 
  Attributes:
483 rajveer 5409 
   - orderId
94 ashish 5410 
  """
5411 
 
5412 
  thrift_spec = (
5413 
    None, # 0
483 rajveer 5414 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 5415 
  )
5416 
 
483 rajveer 5417 
  def __init__(self, orderId=None,):
5418 
    self.orderId = orderId
94 ashish 5419 
 
5420 
  def read(self, iprot):
5421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5423 
      return
5424 
    iprot.readStructBegin()
5425 
    while True:
5426 
      (fname, ftype, fid) = iprot.readFieldBegin()
5427 
      if ftype == TType.STOP:
5428 
        break
5429 
      if fid == 1:
5430 
        if ftype == TType.I64:
483 rajveer 5431 
          self.orderId = iprot.readI64();
94 ashish 5432 
        else:
5433 
          iprot.skip(ftype)
5434 
      else:
5435 
        iprot.skip(ftype)
5436 
      iprot.readFieldEnd()
5437 
    iprot.readStructEnd()
5438 
 
5439 
  def write(self, oprot):
5440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5442 
      return
483 rajveer 5443 
    oprot.writeStructBegin('getLineItemsForOrder_args')
5444 
    if self.orderId != None:
5445 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5446 
      oprot.writeI64(self.orderId)
94 ashish 5447 
      oprot.writeFieldEnd()
5448 
    oprot.writeFieldStop()
5449 
    oprot.writeStructEnd()
5450 
 
5451 
  def __repr__(self):
5452 
    L = ['%s=%r' % (key, value)
5453 
      for key, value in self.__dict__.iteritems()]
5454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5455 
 
5456 
  def __eq__(self, other):
5457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5458 
 
5459 
  def __ne__(self, other):
5460 
    return not (self == other)
5461 
 
483 rajveer 5462 
class getLineItemsForOrder_result:
94 ashish 5463 
  """
5464 
  Attributes:
5465 
   - success
5466 
   - ex
5467 
  """
5468 
 
5469 
  thrift_spec = (
483 rajveer 5470 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 5471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5472 
  )
5473 
 
5474 
  def __init__(self, success=None, ex=None,):
5475 
    self.success = success
5476 
    self.ex = ex
5477 
 
5478 
  def read(self, iprot):
5479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5481 
      return
5482 
    iprot.readStructBegin()
5483 
    while True:
5484 
      (fname, ftype, fid) = iprot.readFieldBegin()
5485 
      if ftype == TType.STOP:
5486 
        break
5487 
      if fid == 0:
483 rajveer 5488 
        if ftype == TType.LIST:
5489 
          self.success = []
1382 varun.gupt 5490 
          (_etype73, _size70) = iprot.readListBegin()
5491 
          for _i74 in xrange(_size70):
5492 
            _elem75 = LineItem()
5493 
            _elem75.read(iprot)
5494 
            self.success.append(_elem75)
483 rajveer 5495 
          iprot.readListEnd()
94 ashish 5496 
        else:
5497 
          iprot.skip(ftype)
5498 
      elif fid == 1:
5499 
        if ftype == TType.STRUCT:
5500 
          self.ex = TransactionServiceException()
5501 
          self.ex.read(iprot)
5502 
        else:
5503 
          iprot.skip(ftype)
5504 
      else:
5505 
        iprot.skip(ftype)
5506 
      iprot.readFieldEnd()
5507 
    iprot.readStructEnd()
5508 
 
5509 
  def write(self, oprot):
5510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5512 
      return
483 rajveer 5513 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 5514 
    if self.success != None:
483 rajveer 5515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5517 
      for iter76 in self.success:
5518 
        iter76.write(oprot)
483 rajveer 5519 
      oprot.writeListEnd()
94 ashish 5520 
      oprot.writeFieldEnd()
5521 
    if self.ex != None:
5522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5523 
      self.ex.write(oprot)
5524 
      oprot.writeFieldEnd()
5525 
    oprot.writeFieldStop()
5526 
    oprot.writeStructEnd()
5527 
 
5528 
  def __repr__(self):
5529 
    L = ['%s=%r' % (key, value)
5530 
      for key, value in self.__dict__.iteritems()]
5531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5532 
 
5533 
  def __eq__(self, other):
5534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5535 
 
5536 
  def __ne__(self, other):
5537 
    return not (self == other)
5538 
 
1528 ankur.sing 5539 
class getOrderForCustomer_args:
5540 
  """
5541 
  Attributes:
5542 
   - orderId
5543 
   - customerId
5544 
  """
5545 
 
5546 
  thrift_spec = (
5547 
    None, # 0
5548 
    (1, TType.I64, 'orderId', None, None, ), # 1
5549 
    (2, TType.I64, 'customerId', None, None, ), # 2
5550 
  )
5551 
 
5552 
  def __init__(self, orderId=None, customerId=None,):
5553 
    self.orderId = orderId
5554 
    self.customerId = customerId
5555 
 
5556 
  def read(self, iprot):
5557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5559 
      return
5560 
    iprot.readStructBegin()
5561 
    while True:
5562 
      (fname, ftype, fid) = iprot.readFieldBegin()
5563 
      if ftype == TType.STOP:
5564 
        break
5565 
      if fid == 1:
5566 
        if ftype == TType.I64:
5567 
          self.orderId = iprot.readI64();
5568 
        else:
5569 
          iprot.skip(ftype)
5570 
      elif fid == 2:
5571 
        if ftype == TType.I64:
5572 
          self.customerId = iprot.readI64();
5573 
        else:
5574 
          iprot.skip(ftype)
5575 
      else:
5576 
        iprot.skip(ftype)
5577 
      iprot.readFieldEnd()
5578 
    iprot.readStructEnd()
5579 
 
5580 
  def write(self, oprot):
5581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5583 
      return
5584 
    oprot.writeStructBegin('getOrderForCustomer_args')
5585 
    if self.orderId != None:
5586 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5587 
      oprot.writeI64(self.orderId)
5588 
      oprot.writeFieldEnd()
5589 
    if self.customerId != None:
5590 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5591 
      oprot.writeI64(self.customerId)
5592 
      oprot.writeFieldEnd()
5593 
    oprot.writeFieldStop()
5594 
    oprot.writeStructEnd()
5595 
 
5596 
  def __repr__(self):
5597 
    L = ['%s=%r' % (key, value)
5598 
      for key, value in self.__dict__.iteritems()]
5599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5600 
 
5601 
  def __eq__(self, other):
5602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5603 
 
5604 
  def __ne__(self, other):
5605 
    return not (self == other)
5606 
 
5607 
class getOrderForCustomer_result:
5608 
  """
5609 
  Attributes:
5610 
   - success
5611 
   - ex
5612 
  """
5613 
 
5614 
  thrift_spec = (
5615 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
5616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5617 
  )
5618 
 
5619 
  def __init__(self, success=None, ex=None,):
5620 
    self.success = success
5621 
    self.ex = ex
5622 
 
5623 
  def read(self, iprot):
5624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5626 
      return
5627 
    iprot.readStructBegin()
5628 
    while True:
5629 
      (fname, ftype, fid) = iprot.readFieldBegin()
5630 
      if ftype == TType.STOP:
5631 
        break
5632 
      if fid == 0:
5633 
        if ftype == TType.STRUCT:
5634 
          self.success = Order()
5635 
          self.success.read(iprot)
5636 
        else:
5637 
          iprot.skip(ftype)
5638 
      elif fid == 1:
5639 
        if ftype == TType.STRUCT:
5640 
          self.ex = TransactionServiceException()
5641 
          self.ex.read(iprot)
5642 
        else:
5643 
          iprot.skip(ftype)
5644 
      else:
5645 
        iprot.skip(ftype)
5646 
      iprot.readFieldEnd()
5647 
    iprot.readStructEnd()
5648 
 
5649 
  def write(self, oprot):
5650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5652 
      return
5653 
    oprot.writeStructBegin('getOrderForCustomer_result')
5654 
    if self.success != None:
5655 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5656 
      self.success.write(oprot)
5657 
      oprot.writeFieldEnd()
5658 
    if self.ex != None:
5659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5660 
      self.ex.write(oprot)
5661 
      oprot.writeFieldEnd()
5662 
    oprot.writeFieldStop()
5663 
    oprot.writeStructEnd()
5664 
 
5665 
  def __repr__(self):
5666 
    L = ['%s=%r' % (key, value)
5667 
      for key, value in self.__dict__.iteritems()]
5668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5669 
 
5670 
  def __eq__(self, other):
5671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5672 
 
5673 
  def __ne__(self, other):
5674 
    return not (self == other)
5675 
 
1220 chandransh 5676 
class batchOrders_args:
5677 
  """
5678 
  Attributes:
5679 
   - warehouseId
5680 
  """
5681 
 
5682 
  thrift_spec = (
5683 
    None, # 0
5684 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
5685 
  )
5686 
 
5687 
  def __init__(self, warehouseId=None,):
5688 
    self.warehouseId = warehouseId
5689 
 
5690 
  def read(self, iprot):
5691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5693 
      return
5694 
    iprot.readStructBegin()
5695 
    while True:
5696 
      (fname, ftype, fid) = iprot.readFieldBegin()
5697 
      if ftype == TType.STOP:
5698 
        break
5699 
      if fid == 1:
5700 
        if ftype == TType.I64:
5701 
          self.warehouseId = iprot.readI64();
5702 
        else:
5703 
          iprot.skip(ftype)
5704 
      else:
5705 
        iprot.skip(ftype)
5706 
      iprot.readFieldEnd()
5707 
    iprot.readStructEnd()
5708 
 
5709 
  def write(self, oprot):
5710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5712 
      return
5713 
    oprot.writeStructBegin('batchOrders_args')
5714 
    if self.warehouseId != None:
5715 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
5716 
      oprot.writeI64(self.warehouseId)
5717 
      oprot.writeFieldEnd()
5718 
    oprot.writeFieldStop()
5719 
    oprot.writeStructEnd()
5720 
 
5721 
  def __repr__(self):
5722 
    L = ['%s=%r' % (key, value)
5723 
      for key, value in self.__dict__.iteritems()]
5724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5725 
 
5726 
  def __eq__(self, other):
5727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5728 
 
5729 
  def __ne__(self, other):
5730 
    return not (self == other)
5731 
 
5732 
class batchOrders_result:
5733 
  """
5734 
  Attributes:
5735 
   - success
5736 
   - ex
5737 
  """
5738 
 
5739 
  thrift_spec = (
5740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5742 
  )
5743 
 
5744 
  def __init__(self, success=None, ex=None,):
5745 
    self.success = success
5746 
    self.ex = ex
5747 
 
5748 
  def read(self, iprot):
5749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5751 
      return
5752 
    iprot.readStructBegin()
5753 
    while True:
5754 
      (fname, ftype, fid) = iprot.readFieldBegin()
5755 
      if ftype == TType.STOP:
5756 
        break
5757 
      if fid == 0:
5758 
        if ftype == TType.LIST:
5759 
          self.success = []
1382 varun.gupt 5760 
          (_etype80, _size77) = iprot.readListBegin()
5761 
          for _i81 in xrange(_size77):
5762 
            _elem82 = Order()
5763 
            _elem82.read(iprot)
5764 
            self.success.append(_elem82)
1220 chandransh 5765 
          iprot.readListEnd()
5766 
        else:
5767 
          iprot.skip(ftype)
5768 
      elif fid == 1:
5769 
        if ftype == TType.STRUCT:
5770 
          self.ex = TransactionServiceException()
5771 
          self.ex.read(iprot)
5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      else:
5775 
        iprot.skip(ftype)
5776 
      iprot.readFieldEnd()
5777 
    iprot.readStructEnd()
5778 
 
5779 
  def write(self, oprot):
5780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5782 
      return
5783 
    oprot.writeStructBegin('batchOrders_result')
5784 
    if self.success != None:
5785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5787 
      for iter83 in self.success:
5788 
        iter83.write(oprot)
1220 chandransh 5789 
      oprot.writeListEnd()
5790 
      oprot.writeFieldEnd()
5791 
    if self.ex != None:
5792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5793 
      self.ex.write(oprot)
5794 
      oprot.writeFieldEnd()
5795 
    oprot.writeFieldStop()
5796 
    oprot.writeStructEnd()
5797 
 
5798 
  def __repr__(self):
5799 
    L = ['%s=%r' % (key, value)
5800 
      for key, value in self.__dict__.iteritems()]
5801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5802 
 
5803 
  def __eq__(self, other):
5804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5805 
 
5806 
  def __ne__(self, other):
5807 
    return not (self == other)
5808 
 
1208 chandransh 5809 
class markOrderAsOutOfStock_args:
5810 
  """
5811 
  Attributes:
5812 
   - orderId
5813 
  """
5814 
 
5815 
  thrift_spec = (
5816 
    None, # 0
5817 
    (1, TType.I64, 'orderId', None, None, ), # 1
5818 
  )
5819 
 
5820 
  def __init__(self, orderId=None,):
5821 
    self.orderId = orderId
5822 
 
5823 
  def read(self, iprot):
5824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5826 
      return
5827 
    iprot.readStructBegin()
5828 
    while True:
5829 
      (fname, ftype, fid) = iprot.readFieldBegin()
5830 
      if ftype == TType.STOP:
5831 
        break
5832 
      if fid == 1:
5833 
        if ftype == TType.I64:
5834 
          self.orderId = iprot.readI64();
5835 
        else:
5836 
          iprot.skip(ftype)
5837 
      else:
5838 
        iprot.skip(ftype)
5839 
      iprot.readFieldEnd()
5840 
    iprot.readStructEnd()
5841 
 
5842 
  def write(self, oprot):
5843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5845 
      return
5846 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
5847 
    if self.orderId != None:
5848 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5849 
      oprot.writeI64(self.orderId)
5850 
      oprot.writeFieldEnd()
5851 
    oprot.writeFieldStop()
5852 
    oprot.writeStructEnd()
5853 
 
5854 
  def __repr__(self):
5855 
    L = ['%s=%r' % (key, value)
5856 
      for key, value in self.__dict__.iteritems()]
5857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5858 
 
5859 
  def __eq__(self, other):
5860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5861 
 
5862 
  def __ne__(self, other):
5863 
    return not (self == other)
5864 
 
5865 
class markOrderAsOutOfStock_result:
5866 
  """
5867 
  Attributes:
5868 
   - success
5869 
   - ex
5870 
  """
5871 
 
5872 
  thrift_spec = (
5873 
    (0, TType.BOOL, 'success', None, None, ), # 0
5874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5875 
  )
5876 
 
5877 
  def __init__(self, success=None, ex=None,):
5878 
    self.success = success
5879 
    self.ex = ex
5880 
 
5881 
  def read(self, iprot):
5882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5884 
      return
5885 
    iprot.readStructBegin()
5886 
    while True:
5887 
      (fname, ftype, fid) = iprot.readFieldBegin()
5888 
      if ftype == TType.STOP:
5889 
        break
5890 
      if fid == 0:
5891 
        if ftype == TType.BOOL:
5892 
          self.success = iprot.readBool();
5893 
        else:
5894 
          iprot.skip(ftype)
5895 
      elif fid == 1:
5896 
        if ftype == TType.STRUCT:
5897 
          self.ex = TransactionServiceException()
5898 
          self.ex.read(iprot)
5899 
        else:
5900 
          iprot.skip(ftype)
5901 
      else:
5902 
        iprot.skip(ftype)
5903 
      iprot.readFieldEnd()
5904 
    iprot.readStructEnd()
5905 
 
5906 
  def write(self, oprot):
5907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5909 
      return
5910 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
5911 
    if self.success != None:
5912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5913 
      oprot.writeBool(self.success)
5914 
      oprot.writeFieldEnd()
5915 
    if self.ex != None:
5916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5917 
      self.ex.write(oprot)
5918 
      oprot.writeFieldEnd()
5919 
    oprot.writeFieldStop()
5920 
    oprot.writeStructEnd()
5921 
 
5922 
  def __repr__(self):
5923 
    L = ['%s=%r' % (key, value)
5924 
      for key, value in self.__dict__.iteritems()]
5925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5926 
 
5927 
  def __eq__(self, other):
5928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5929 
 
5930 
  def __ne__(self, other):
5931 
    return not (self == other)
5932 
 
759 chandransh 5933 
class markOrdersAsManifested_args:
5934 
  """
5935 
  Attributes:
5936 
   - warehouseId
5937 
   - providerId
5938 
  """
5939 
 
5940 
  thrift_spec = (
5941 
    None, # 0
5942 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
5943 
    (2, TType.I64, 'providerId', None, None, ), # 2
5944 
  )
5945 
 
5946 
  def __init__(self, warehouseId=None, providerId=None,):
5947 
    self.warehouseId = warehouseId
5948 
    self.providerId = providerId
5949 
 
5950 
  def read(self, iprot):
5951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5953 
      return
5954 
    iprot.readStructBegin()
5955 
    while True:
5956 
      (fname, ftype, fid) = iprot.readFieldBegin()
5957 
      if ftype == TType.STOP:
5958 
        break
5959 
      if fid == 1:
5960 
        if ftype == TType.I64:
5961 
          self.warehouseId = iprot.readI64();
5962 
        else:
5963 
          iprot.skip(ftype)
5964 
      elif fid == 2:
5965 
        if ftype == TType.I64:
5966 
          self.providerId = iprot.readI64();
5967 
        else:
5968 
          iprot.skip(ftype)
5969 
      else:
5970 
        iprot.skip(ftype)
5971 
      iprot.readFieldEnd()
5972 
    iprot.readStructEnd()
5973 
 
5974 
  def write(self, oprot):
5975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5977 
      return
5978 
    oprot.writeStructBegin('markOrdersAsManifested_args')
5979 
    if self.warehouseId != None:
5980 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
5981 
      oprot.writeI64(self.warehouseId)
5982 
      oprot.writeFieldEnd()
5983 
    if self.providerId != None:
5984 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
5985 
      oprot.writeI64(self.providerId)
5986 
      oprot.writeFieldEnd()
5987 
    oprot.writeFieldStop()
5988 
    oprot.writeStructEnd()
5989 
 
5990 
  def __repr__(self):
5991 
    L = ['%s=%r' % (key, value)
5992 
      for key, value in self.__dict__.iteritems()]
5993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5994 
 
5995 
  def __eq__(self, other):
5996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5997 
 
5998 
  def __ne__(self, other):
5999 
    return not (self == other)
6000 
 
6001 
class markOrdersAsManifested_result:
6002 
  """
6003 
  Attributes:
6004 
   - success
6005 
   - ex
6006 
  """
6007 
 
6008 
  thrift_spec = (
6009 
    (0, TType.BOOL, 'success', None, None, ), # 0
6010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6011 
  )
6012 
 
6013 
  def __init__(self, success=None, ex=None,):
6014 
    self.success = success
6015 
    self.ex = ex
6016 
 
6017 
  def read(self, iprot):
6018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6020 
      return
6021 
    iprot.readStructBegin()
6022 
    while True:
6023 
      (fname, ftype, fid) = iprot.readFieldBegin()
6024 
      if ftype == TType.STOP:
6025 
        break
6026 
      if fid == 0:
6027 
        if ftype == TType.BOOL:
6028 
          self.success = iprot.readBool();
6029 
        else:
6030 
          iprot.skip(ftype)
6031 
      elif fid == 1:
6032 
        if ftype == TType.STRUCT:
6033 
          self.ex = TransactionServiceException()
6034 
          self.ex.read(iprot)
6035 
        else:
6036 
          iprot.skip(ftype)
6037 
      else:
6038 
        iprot.skip(ftype)
6039 
      iprot.readFieldEnd()
6040 
    iprot.readStructEnd()
6041 
 
6042 
  def write(self, oprot):
6043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6045 
      return
6046 
    oprot.writeStructBegin('markOrdersAsManifested_result')
6047 
    if self.success != None:
6048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6049 
      oprot.writeBool(self.success)
6050 
      oprot.writeFieldEnd()
6051 
    if self.ex != None:
6052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6053 
      self.ex.write(oprot)
6054 
      oprot.writeFieldEnd()
6055 
    oprot.writeFieldStop()
6056 
    oprot.writeStructEnd()
6057 
 
6058 
  def __repr__(self):
6059 
    L = ['%s=%r' % (key, value)
6060 
      for key, value in self.__dict__.iteritems()]
6061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6062 
 
6063 
  def __eq__(self, other):
6064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6065 
 
6066 
  def __ne__(self, other):
6067 
    return not (self == other)
6068 
 
1113 chandransh 6069 
class markOrdersAsPickedUp_args:
6070 
  """
6071 
  Attributes:
6072 
   - providerId
6073 
   - pickupDetails
6074 
  """
6075 
 
6076 
  thrift_spec = (
6077 
    None, # 0
6078 
    (1, TType.I64, 'providerId', None, None, ), # 1
1246 chandransh 6079 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
1113 chandransh 6080 
  )
6081 
 
6082 
  def __init__(self, providerId=None, pickupDetails=None,):
6083 
    self.providerId = providerId
6084 
    self.pickupDetails = pickupDetails
6085 
 
6086 
  def read(self, iprot):
6087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6089 
      return
6090 
    iprot.readStructBegin()
6091 
    while True:
6092 
      (fname, ftype, fid) = iprot.readFieldBegin()
6093 
      if ftype == TType.STOP:
6094 
        break
6095 
      if fid == 1:
6096 
        if ftype == TType.I64:
6097 
          self.providerId = iprot.readI64();
6098 
        else:
6099 
          iprot.skip(ftype)
6100 
      elif fid == 2:
6101 
        if ftype == TType.MAP:
6102 
          self.pickupDetails = {}
1382 varun.gupt 6103 
          (_ktype85, _vtype86, _size84 ) = iprot.readMapBegin()
6104 
          for _i88 in xrange(_size84):
6105 
            _key89 = iprot.readString();
6106 
            _val90 = iprot.readString();
6107 
            self.pickupDetails[_key89] = _val90
1113 chandransh 6108 
          iprot.readMapEnd()
6109 
        else:
6110 
          iprot.skip(ftype)
6111 
      else:
6112 
        iprot.skip(ftype)
6113 
      iprot.readFieldEnd()
6114 
    iprot.readStructEnd()
6115 
 
6116 
  def write(self, oprot):
6117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6119 
      return
6120 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
6121 
    if self.providerId != None:
6122 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6123 
      oprot.writeI64(self.providerId)
6124 
      oprot.writeFieldEnd()
6125 
    if self.pickupDetails != None:
6126 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
1246 chandransh 6127 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
1382 varun.gupt 6128 
      for kiter91,viter92 in self.pickupDetails.items():
6129 
        oprot.writeString(kiter91)
6130 
        oprot.writeString(viter92)
1113 chandransh 6131 
      oprot.writeMapEnd()
6132 
      oprot.writeFieldEnd()
6133 
    oprot.writeFieldStop()
6134 
    oprot.writeStructEnd()
6135 
 
6136 
  def __repr__(self):
6137 
    L = ['%s=%r' % (key, value)
6138 
      for key, value in self.__dict__.iteritems()]
6139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6140 
 
6141 
  def __eq__(self, other):
6142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6143 
 
6144 
  def __ne__(self, other):
6145 
    return not (self == other)
6146 
 
6147 
class markOrdersAsPickedUp_result:
6148 
  """
6149 
  Attributes:
6150 
   - success
6151 
   - ex
6152 
  """
6153 
 
6154 
  thrift_spec = (
6155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6157 
  )
6158 
 
6159 
  def __init__(self, success=None, ex=None,):
6160 
    self.success = success
6161 
    self.ex = ex
6162 
 
6163 
  def read(self, iprot):
6164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6166 
      return
6167 
    iprot.readStructBegin()
6168 
    while True:
6169 
      (fname, ftype, fid) = iprot.readFieldBegin()
6170 
      if ftype == TType.STOP:
6171 
        break
6172 
      if fid == 0:
6173 
        if ftype == TType.LIST:
6174 
          self.success = []
1382 varun.gupt 6175 
          (_etype96, _size93) = iprot.readListBegin()
6176 
          for _i97 in xrange(_size93):
6177 
            _elem98 = Order()
6178 
            _elem98.read(iprot)
6179 
            self.success.append(_elem98)
1113 chandransh 6180 
          iprot.readListEnd()
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      elif fid == 1:
6184 
        if ftype == TType.STRUCT:
6185 
          self.ex = TransactionServiceException()
6186 
          self.ex.read(iprot)
6187 
        else:
6188 
          iprot.skip(ftype)
6189 
      else:
6190 
        iprot.skip(ftype)
6191 
      iprot.readFieldEnd()
6192 
    iprot.readStructEnd()
6193 
 
6194 
  def write(self, oprot):
6195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6197 
      return
6198 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
6199 
    if self.success != None:
6200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 6202 
      for iter99 in self.success:
6203 
        iter99.write(oprot)
1113 chandransh 6204 
      oprot.writeListEnd()
6205 
      oprot.writeFieldEnd()
6206 
    if self.ex != None:
6207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6208 
      self.ex.write(oprot)
6209 
      oprot.writeFieldEnd()
6210 
    oprot.writeFieldStop()
6211 
    oprot.writeStructEnd()
6212 
 
6213 
  def __repr__(self):
6214 
    L = ['%s=%r' % (key, value)
6215 
      for key, value in self.__dict__.iteritems()]
6216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6217 
 
6218 
  def __eq__(self, other):
6219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6220 
 
6221 
  def __ne__(self, other):
6222 
    return not (self == other)
6223 
 
1132 chandransh 6224 
class markOrdersAsDelivered_args:
6225 
  """
6226 
  Attributes:
6227 
   - providerId
6228 
   - deliveredOrders
6229 
  """
6230 
 
6231 
  thrift_spec = (
6232 
    None, # 0
6233 
    (1, TType.I64, 'providerId', None, None, ), # 1
6234 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6235 
  )
6236 
 
6237 
  def __init__(self, providerId=None, deliveredOrders=None,):
6238 
    self.providerId = providerId
6239 
    self.deliveredOrders = deliveredOrders
6240 
 
6241 
  def read(self, iprot):
6242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6244 
      return
6245 
    iprot.readStructBegin()
6246 
    while True:
6247 
      (fname, ftype, fid) = iprot.readFieldBegin()
6248 
      if ftype == TType.STOP:
6249 
        break
6250 
      if fid == 1:
6251 
        if ftype == TType.I64:
6252 
          self.providerId = iprot.readI64();
6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      elif fid == 2:
6256 
        if ftype == TType.MAP:
6257 
          self.deliveredOrders = {}
1382 varun.gupt 6258 
          (_ktype101, _vtype102, _size100 ) = iprot.readMapBegin()
6259 
          for _i104 in xrange(_size100):
6260 
            _key105 = iprot.readString();
6261 
            _val106 = iprot.readString();
6262 
            self.deliveredOrders[_key105] = _val106
1132 chandransh 6263 
          iprot.readMapEnd()
6264 
        else:
6265 
          iprot.skip(ftype)
6266 
      else:
6267 
        iprot.skip(ftype)
6268 
      iprot.readFieldEnd()
6269 
    iprot.readStructEnd()
6270 
 
6271 
  def write(self, oprot):
6272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6274 
      return
6275 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
6276 
    if self.providerId != None:
6277 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6278 
      oprot.writeI64(self.providerId)
6279 
      oprot.writeFieldEnd()
6280 
    if self.deliveredOrders != None:
6281 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
6282 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
1382 varun.gupt 6283 
      for kiter107,viter108 in self.deliveredOrders.items():
6284 
        oprot.writeString(kiter107)
6285 
        oprot.writeString(viter108)
1132 chandransh 6286 
      oprot.writeMapEnd()
6287 
      oprot.writeFieldEnd()
6288 
    oprot.writeFieldStop()
6289 
    oprot.writeStructEnd()
6290 
 
6291 
  def __repr__(self):
6292 
    L = ['%s=%r' % (key, value)
6293 
      for key, value in self.__dict__.iteritems()]
6294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6295 
 
6296 
  def __eq__(self, other):
6297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6298 
 
6299 
  def __ne__(self, other):
6300 
    return not (self == other)
6301 
 
6302 
class markOrdersAsDelivered_result:
6303 
  """
6304 
  Attributes:
6305 
   - ex
6306 
  """
6307 
 
6308 
  thrift_spec = (
6309 
    None, # 0
6310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6311 
  )
6312 
 
6313 
  def __init__(self, ex=None,):
6314 
    self.ex = ex
6315 
 
6316 
  def read(self, iprot):
6317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6319 
      return
6320 
    iprot.readStructBegin()
6321 
    while True:
6322 
      (fname, ftype, fid) = iprot.readFieldBegin()
6323 
      if ftype == TType.STOP:
6324 
        break
6325 
      if fid == 1:
6326 
        if ftype == TType.STRUCT:
6327 
          self.ex = TransactionServiceException()
6328 
          self.ex.read(iprot)
6329 
        else:
6330 
          iprot.skip(ftype)
6331 
      else:
6332 
        iprot.skip(ftype)
6333 
      iprot.readFieldEnd()
6334 
    iprot.readStructEnd()
6335 
 
6336 
  def write(self, oprot):
6337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6339 
      return
6340 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
6341 
    if self.ex != None:
6342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6343 
      self.ex.write(oprot)
6344 
      oprot.writeFieldEnd()
6345 
    oprot.writeFieldStop()
6346 
    oprot.writeStructEnd()
6347 
 
6348 
  def __repr__(self):
6349 
    L = ['%s=%r' % (key, value)
6350 
      for key, value in self.__dict__.iteritems()]
6351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6352 
 
6353 
  def __eq__(self, other):
6354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6355 
 
6356 
  def __ne__(self, other):
6357 
    return not (self == other)
6358 
 
1135 chandransh 6359 
class markOrdersAsFailed_args:
6360 
  """
6361 
  Attributes:
6362 
   - providerId
6363 
   - returnedOrders
6364 
  """
6365 
 
6366 
  thrift_spec = (
6367 
    None, # 0
6368 
    (1, TType.I64, 'providerId', None, None, ), # 1
6369 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6370 
  )
6371 
 
6372 
  def __init__(self, providerId=None, returnedOrders=None,):
6373 
    self.providerId = providerId
6374 
    self.returnedOrders = returnedOrders
6375 
 
6376 
  def read(self, iprot):
6377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6379 
      return
6380 
    iprot.readStructBegin()
6381 
    while True:
6382 
      (fname, ftype, fid) = iprot.readFieldBegin()
6383 
      if ftype == TType.STOP:
6384 
        break
6385 
      if fid == 1:
6386 
        if ftype == TType.I64:
6387 
          self.providerId = iprot.readI64();
6388 
        else:
6389 
          iprot.skip(ftype)
6390 
      elif fid == 2:
6391 
        if ftype == TType.MAP:
6392 
          self.returnedOrders = {}
1382 varun.gupt 6393 
          (_ktype110, _vtype111, _size109 ) = iprot.readMapBegin()
6394 
          for _i113 in xrange(_size109):
6395 
            _key114 = iprot.readString();
6396 
            _val115 = iprot.readString();
6397 
            self.returnedOrders[_key114] = _val115
1135 chandransh 6398 
          iprot.readMapEnd()
6399 
        else:
6400 
          iprot.skip(ftype)
6401 
      else:
6402 
        iprot.skip(ftype)
6403 
      iprot.readFieldEnd()
6404 
    iprot.readStructEnd()
6405 
 
6406 
  def write(self, oprot):
6407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6409 
      return
6410 
    oprot.writeStructBegin('markOrdersAsFailed_args')
6411 
    if self.providerId != None:
6412 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6413 
      oprot.writeI64(self.providerId)
6414 
      oprot.writeFieldEnd()
6415 
    if self.returnedOrders != None:
6416 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
6417 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
1382 varun.gupt 6418 
      for kiter116,viter117 in self.returnedOrders.items():
6419 
        oprot.writeString(kiter116)
6420 
        oprot.writeString(viter117)
1135 chandransh 6421 
      oprot.writeMapEnd()
6422 
      oprot.writeFieldEnd()
6423 
    oprot.writeFieldStop()
6424 
    oprot.writeStructEnd()
6425 
 
6426 
  def __repr__(self):
6427 
    L = ['%s=%r' % (key, value)
6428 
      for key, value in self.__dict__.iteritems()]
6429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6430 
 
6431 
  def __eq__(self, other):
6432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6433 
 
6434 
  def __ne__(self, other):
6435 
    return not (self == other)
6436 
 
6437 
class markOrdersAsFailed_result:
6438 
  """
6439 
  Attributes:
6440 
   - ex
6441 
  """
6442 
 
6443 
  thrift_spec = (
6444 
    None, # 0
6445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6446 
  )
6447 
 
6448 
  def __init__(self, ex=None,):
6449 
    self.ex = ex
6450 
 
6451 
  def read(self, iprot):
6452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6454 
      return
6455 
    iprot.readStructBegin()
6456 
    while True:
6457 
      (fname, ftype, fid) = iprot.readFieldBegin()
6458 
      if ftype == TType.STOP:
6459 
        break
6460 
      if fid == 1:
6461 
        if ftype == TType.STRUCT:
6462 
          self.ex = TransactionServiceException()
6463 
          self.ex.read(iprot)
6464 
        else:
6465 
          iprot.skip(ftype)
6466 
      else:
6467 
        iprot.skip(ftype)
6468 
      iprot.readFieldEnd()
6469 
    iprot.readStructEnd()
6470 
 
6471 
  def write(self, oprot):
6472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6474 
      return
6475 
    oprot.writeStructBegin('markOrdersAsFailed_result')
6476 
    if self.ex != None:
6477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6478 
      self.ex.write(oprot)
6479 
      oprot.writeFieldEnd()
6480 
    oprot.writeFieldStop()
6481 
    oprot.writeStructEnd()
6482 
 
6483 
  def __repr__(self):
6484 
    L = ['%s=%r' % (key, value)
6485 
      for key, value in self.__dict__.iteritems()]
6486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6487 
 
6488 
  def __eq__(self, other):
6489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6490 
 
6491 
  def __ne__(self, other):
6492 
    return not (self == other)
6493 
 
1246 chandransh 6494 
class updateNonDeliveryReason_args:
6495 
  """
6496 
  Attributes:
6497 
   - providerId
6498 
   - undeliveredOrders
6499 
  """
6500 
 
6501 
  thrift_spec = (
6502 
    None, # 0
6503 
    (1, TType.I64, 'providerId', None, None, ), # 1
6504 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6505 
  )
6506 
 
6507 
  def __init__(self, providerId=None, undeliveredOrders=None,):
6508 
    self.providerId = providerId
6509 
    self.undeliveredOrders = undeliveredOrders
6510 
 
6511 
  def read(self, iprot):
6512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6514 
      return
6515 
    iprot.readStructBegin()
6516 
    while True:
6517 
      (fname, ftype, fid) = iprot.readFieldBegin()
6518 
      if ftype == TType.STOP:
6519 
        break
6520 
      if fid == 1:
6521 
        if ftype == TType.I64:
6522 
          self.providerId = iprot.readI64();
6523 
        else:
6524 
          iprot.skip(ftype)
6525 
      elif fid == 2:
6526 
        if ftype == TType.MAP:
6527 
          self.undeliveredOrders = {}
1382 varun.gupt 6528 
          (_ktype119, _vtype120, _size118 ) = iprot.readMapBegin()
6529 
          for _i122 in xrange(_size118):
6530 
            _key123 = iprot.readString();
6531 
            _val124 = iprot.readString();
6532 
            self.undeliveredOrders[_key123] = _val124
1246 chandransh 6533 
          iprot.readMapEnd()
6534 
        else:
6535 
          iprot.skip(ftype)
6536 
      else:
6537 
        iprot.skip(ftype)
6538 
      iprot.readFieldEnd()
6539 
    iprot.readStructEnd()
6540 
 
6541 
  def write(self, oprot):
6542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6544 
      return
6545 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
6546 
    if self.providerId != None:
6547 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6548 
      oprot.writeI64(self.providerId)
6549 
      oprot.writeFieldEnd()
6550 
    if self.undeliveredOrders != None:
6551 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
6552 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
1382 varun.gupt 6553 
      for kiter125,viter126 in self.undeliveredOrders.items():
6554 
        oprot.writeString(kiter125)
6555 
        oprot.writeString(viter126)
1246 chandransh 6556 
      oprot.writeMapEnd()
6557 
      oprot.writeFieldEnd()
6558 
    oprot.writeFieldStop()
6559 
    oprot.writeStructEnd()
6560 
 
6561 
  def __repr__(self):
6562 
    L = ['%s=%r' % (key, value)
6563 
      for key, value in self.__dict__.iteritems()]
6564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6565 
 
6566 
  def __eq__(self, other):
6567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6568 
 
6569 
  def __ne__(self, other):
6570 
    return not (self == other)
6571 
 
6572 
class updateNonDeliveryReason_result:
6573 
  """
6574 
  Attributes:
6575 
   - ex
6576 
  """
6577 
 
6578 
  thrift_spec = (
6579 
    None, # 0
6580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6581 
  )
6582 
 
6583 
  def __init__(self, ex=None,):
6584 
    self.ex = ex
6585 
 
6586 
  def read(self, iprot):
6587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6589 
      return
6590 
    iprot.readStructBegin()
6591 
    while True:
6592 
      (fname, ftype, fid) = iprot.readFieldBegin()
6593 
      if ftype == TType.STOP:
6594 
        break
6595 
      if fid == 1:
6596 
        if ftype == TType.STRUCT:
6597 
          self.ex = TransactionServiceException()
6598 
          self.ex.read(iprot)
6599 
        else:
6600 
          iprot.skip(ftype)
6601 
      else:
6602 
        iprot.skip(ftype)
6603 
      iprot.readFieldEnd()
6604 
    iprot.readStructEnd()
6605 
 
6606 
  def write(self, oprot):
6607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6609 
      return
6610 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
6611 
    if self.ex != None:
6612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6613 
      self.ex.write(oprot)
6614 
      oprot.writeFieldEnd()
6615 
    oprot.writeFieldStop()
6616 
    oprot.writeStructEnd()
6617 
 
6618 
  def __repr__(self):
6619 
    L = ['%s=%r' % (key, value)
6620 
      for key, value in self.__dict__.iteritems()]
6621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6622 
 
6623 
  def __eq__(self, other):
6624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6625 
 
6626 
  def __ne__(self, other):
6627 
    return not (self == other)
6628 
 
1408 ankur.sing 6629 
class getUndeliveredOrders_args:
6630 
  """
6631 
  Attributes:
6632 
   - providerId
6633 
   - warehouseId
6634 
  """
6635 
 
6636 
  thrift_spec = (
6637 
    None, # 0
6638 
    (1, TType.I64, 'providerId', None, None, ), # 1
6639 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6640 
  )
6641 
 
6642 
  def __init__(self, providerId=None, warehouseId=None,):
6643 
    self.providerId = providerId
6644 
    self.warehouseId = warehouseId
6645 
 
6646 
  def read(self, iprot):
6647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6649 
      return
6650 
    iprot.readStructBegin()
6651 
    while True:
6652 
      (fname, ftype, fid) = iprot.readFieldBegin()
6653 
      if ftype == TType.STOP:
6654 
        break
6655 
      if fid == 1:
6656 
        if ftype == TType.I64:
6657 
          self.providerId = iprot.readI64();
6658 
        else:
6659 
          iprot.skip(ftype)
6660 
      elif fid == 2:
6661 
        if ftype == TType.I64:
6662 
          self.warehouseId = iprot.readI64();
6663 
        else:
6664 
          iprot.skip(ftype)
6665 
      else:
6666 
        iprot.skip(ftype)
6667 
      iprot.readFieldEnd()
6668 
    iprot.readStructEnd()
6669 
 
6670 
  def write(self, oprot):
6671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6673 
      return
6674 
    oprot.writeStructBegin('getUndeliveredOrders_args')
6675 
    if self.providerId != None:
6676 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6677 
      oprot.writeI64(self.providerId)
6678 
      oprot.writeFieldEnd()
6679 
    if self.warehouseId != None:
6680 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6681 
      oprot.writeI64(self.warehouseId)
6682 
      oprot.writeFieldEnd()
6683 
    oprot.writeFieldStop()
6684 
    oprot.writeStructEnd()
6685 
 
6686 
  def __repr__(self):
6687 
    L = ['%s=%r' % (key, value)
6688 
      for key, value in self.__dict__.iteritems()]
6689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6690 
 
6691 
  def __eq__(self, other):
6692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6693 
 
6694 
  def __ne__(self, other):
6695 
    return not (self == other)
6696 
 
6697 
class getUndeliveredOrders_result:
6698 
  """
6699 
  Attributes:
6700 
   - success
6701 
  """
6702 
 
6703 
  thrift_spec = (
6704 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6705 
  )
6706 
 
6707 
  def __init__(self, success=None,):
6708 
    self.success = success
6709 
 
6710 
  def read(self, iprot):
6711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6713 
      return
6714 
    iprot.readStructBegin()
6715 
    while True:
6716 
      (fname, ftype, fid) = iprot.readFieldBegin()
6717 
      if ftype == TType.STOP:
6718 
        break
6719 
      if fid == 0:
6720 
        if ftype == TType.LIST:
6721 
          self.success = []
6722 
          (_etype130, _size127) = iprot.readListBegin()
6723 
          for _i131 in xrange(_size127):
6724 
            _elem132 = Order()
6725 
            _elem132.read(iprot)
6726 
            self.success.append(_elem132)
6727 
          iprot.readListEnd()
6728 
        else:
6729 
          iprot.skip(ftype)
6730 
      else:
6731 
        iprot.skip(ftype)
6732 
      iprot.readFieldEnd()
6733 
    iprot.readStructEnd()
6734 
 
6735 
  def write(self, oprot):
6736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6738 
      return
6739 
    oprot.writeStructBegin('getUndeliveredOrders_result')
6740 
    if self.success != None:
6741 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6742 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6743 
      for iter133 in self.success:
6744 
        iter133.write(oprot)
6745 
      oprot.writeListEnd()
6746 
      oprot.writeFieldEnd()
6747 
    oprot.writeFieldStop()
6748 
    oprot.writeStructEnd()
6749 
 
6750 
  def __repr__(self):
6751 
    L = ['%s=%r' % (key, value)
6752 
      for key, value in self.__dict__.iteritems()]
6753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6754 
 
6755 
  def __eq__(self, other):
6756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6757 
 
6758 
  def __ne__(self, other):
6759 
    return not (self == other)
6760 
 
304 ashish 6761 
class getAlerts_args:
6762 
  """
6763 
  Attributes:
483 rajveer 6764 
   - orderId
304 ashish 6765 
   - valid
6766 
  """
94 ashish 6767 
 
304 ashish 6768 
  thrift_spec = (
6769 
    None, # 0
483 rajveer 6770 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 6771 
    (2, TType.BOOL, 'valid', None, None, ), # 2
6772 
  )
6773 
 
483 rajveer 6774 
  def __init__(self, orderId=None, valid=None,):
6775 
    self.orderId = orderId
304 ashish 6776 
    self.valid = valid
6777 
 
6778 
  def read(self, iprot):
6779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6781 
      return
6782 
    iprot.readStructBegin()
6783 
    while True:
6784 
      (fname, ftype, fid) = iprot.readFieldBegin()
6785 
      if ftype == TType.STOP:
6786 
        break
6787 
      if fid == 1:
6788 
        if ftype == TType.I64:
483 rajveer 6789 
          self.orderId = iprot.readI64();
304 ashish 6790 
        else:
6791 
          iprot.skip(ftype)
6792 
      elif fid == 2:
6793 
        if ftype == TType.BOOL:
6794 
          self.valid = iprot.readBool();
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
6806 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 6807 
    if self.orderId != None:
6808 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6809 
      oprot.writeI64(self.orderId)
304 ashish 6810 
      oprot.writeFieldEnd()
6811 
    if self.valid != None:
6812 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
6813 
      oprot.writeBool(self.valid)
6814 
      oprot.writeFieldEnd()
6815 
    oprot.writeFieldStop()
6816 
    oprot.writeStructEnd()
6817 
 
6818 
  def __repr__(self):
6819 
    L = ['%s=%r' % (key, value)
6820 
      for key, value in self.__dict__.iteritems()]
6821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6822 
 
6823 
  def __eq__(self, other):
6824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6825 
 
6826 
  def __ne__(self, other):
6827 
    return not (self == other)
6828 
 
6829 
class getAlerts_result:
6830 
  """
6831 
  Attributes:
6832 
   - success
6833 
  """
6834 
 
6835 
  thrift_spec = (
6836 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
6837 
  )
6838 
 
6839 
  def __init__(self, success=None,):
6840 
    self.success = success
6841 
 
6842 
  def read(self, iprot):
6843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6845 
      return
6846 
    iprot.readStructBegin()
6847 
    while True:
6848 
      (fname, ftype, fid) = iprot.readFieldBegin()
6849 
      if ftype == TType.STOP:
6850 
        break
6851 
      if fid == 0:
6852 
        if ftype == TType.LIST:
6853 
          self.success = []
1408 ankur.sing 6854 
          (_etype137, _size134) = iprot.readListBegin()
6855 
          for _i138 in xrange(_size134):
6856 
            _elem139 = Alert()
6857 
            _elem139.read(iprot)
6858 
            self.success.append(_elem139)
304 ashish 6859 
          iprot.readListEnd()
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      else:
6863 
        iprot.skip(ftype)
6864 
      iprot.readFieldEnd()
6865 
    iprot.readStructEnd()
6866 
 
6867 
  def write(self, oprot):
6868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6870 
      return
6871 
    oprot.writeStructBegin('getAlerts_result')
6872 
    if self.success != None:
6873 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6874 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1408 ankur.sing 6875 
      for iter140 in self.success:
6876 
        iter140.write(oprot)
304 ashish 6877 
      oprot.writeListEnd()
6878 
      oprot.writeFieldEnd()
6879 
    oprot.writeFieldStop()
6880 
    oprot.writeStructEnd()
6881 
 
6882 
  def __repr__(self):
6883 
    L = ['%s=%r' % (key, value)
6884 
      for key, value in self.__dict__.iteritems()]
6885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6886 
 
6887 
  def __eq__(self, other):
6888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6889 
 
6890 
  def __ne__(self, other):
6891 
    return not (self == other)
6892 
 
6893 
class setAlert_args:
6894 
  """
6895 
  Attributes:
483 rajveer 6896 
   - orderId
304 ashish 6897 
   - unset
6898 
   - type
6899 
   - comment
6900 
  """
6901 
 
6902 
  thrift_spec = (
6903 
    None, # 0
483 rajveer 6904 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 6905 
    (2, TType.BOOL, 'unset', None, None, ), # 2
6906 
    (3, TType.I64, 'type', None, None, ), # 3
6907 
    (4, TType.STRING, 'comment', None, None, ), # 4
6908 
  )
6909 
 
483 rajveer 6910 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
6911 
    self.orderId = orderId
304 ashish 6912 
    self.unset = unset
6913 
    self.type = type
6914 
    self.comment = comment
6915 
 
6916 
  def read(self, iprot):
6917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6919 
      return
6920 
    iprot.readStructBegin()
6921 
    while True:
6922 
      (fname, ftype, fid) = iprot.readFieldBegin()
6923 
      if ftype == TType.STOP:
6924 
        break
6925 
      if fid == 1:
6926 
        if ftype == TType.I64:
483 rajveer 6927 
          self.orderId = iprot.readI64();
304 ashish 6928 
        else:
6929 
          iprot.skip(ftype)
6930 
      elif fid == 2:
6931 
        if ftype == TType.BOOL:
6932 
          self.unset = iprot.readBool();
6933 
        else:
6934 
          iprot.skip(ftype)
6935 
      elif fid == 3:
6936 
        if ftype == TType.I64:
6937 
          self.type = iprot.readI64();
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      elif fid == 4:
6941 
        if ftype == TType.STRING:
6942 
          self.comment = iprot.readString();
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      else:
6946 
        iprot.skip(ftype)
6947 
      iprot.readFieldEnd()
6948 
    iprot.readStructEnd()
6949 
 
6950 
  def write(self, oprot):
6951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6953 
      return
6954 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 6955 
    if self.orderId != None:
6956 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6957 
      oprot.writeI64(self.orderId)
304 ashish 6958 
      oprot.writeFieldEnd()
6959 
    if self.unset != None:
6960 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
6961 
      oprot.writeBool(self.unset)
6962 
      oprot.writeFieldEnd()
6963 
    if self.type != None:
6964 
      oprot.writeFieldBegin('type', TType.I64, 3)
6965 
      oprot.writeI64(self.type)
6966 
      oprot.writeFieldEnd()
6967 
    if self.comment != None:
6968 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
6969 
      oprot.writeString(self.comment)
6970 
      oprot.writeFieldEnd()
6971 
    oprot.writeFieldStop()
6972 
    oprot.writeStructEnd()
6973 
 
6974 
  def __repr__(self):
6975 
    L = ['%s=%r' % (key, value)
6976 
      for key, value in self.__dict__.iteritems()]
6977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6978 
 
6979 
  def __eq__(self, other):
6980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6981 
 
6982 
  def __ne__(self, other):
6983 
    return not (self == other)
6984 
 
6985 
class setAlert_result:
6986 
 
6987 
  thrift_spec = (
6988 
  )
6989 
 
6990 
  def read(self, iprot):
6991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6993 
      return
6994 
    iprot.readStructBegin()
6995 
    while True:
6996 
      (fname, ftype, fid) = iprot.readFieldBegin()
6997 
      if ftype == TType.STOP:
6998 
        break
6999 
      else:
7000 
        iprot.skip(ftype)
7001 
      iprot.readFieldEnd()
7002 
    iprot.readStructEnd()
7003 
 
7004 
  def write(self, oprot):
7005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7007 
      return
7008 
    oprot.writeStructBegin('setAlert_result')
7009 
    oprot.writeFieldStop()
7010 
    oprot.writeStructEnd()
7011 
 
7012 
  def __repr__(self):
7013 
    L = ['%s=%r' % (key, value)
7014 
      for key, value in self.__dict__.iteritems()]
7015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7016 
 
7017 
  def __eq__(self, other):
7018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7019 
 
7020 
  def __ne__(self, other):
7021 
    return not (self == other)
7022 
 
1596 ankur.sing 7023 
class getValidOrderCount_args:
304 ashish 7024 
 
1596 ankur.sing 7025 
  thrift_spec = (
7026 
  )
7027 
 
7028 
  def read(self, iprot):
7029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7031 
      return
7032 
    iprot.readStructBegin()
7033 
    while True:
7034 
      (fname, ftype, fid) = iprot.readFieldBegin()
7035 
      if ftype == TType.STOP:
7036 
        break
7037 
      else:
7038 
        iprot.skip(ftype)
7039 
      iprot.readFieldEnd()
7040 
    iprot.readStructEnd()
7041 
 
7042 
  def write(self, oprot):
7043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7045 
      return
7046 
    oprot.writeStructBegin('getValidOrderCount_args')
7047 
    oprot.writeFieldStop()
7048 
    oprot.writeStructEnd()
7049 
 
7050 
  def __repr__(self):
7051 
    L = ['%s=%r' % (key, value)
7052 
      for key, value in self.__dict__.iteritems()]
7053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7054 
 
7055 
  def __eq__(self, other):
7056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7057 
 
7058 
  def __ne__(self, other):
7059 
    return not (self == other)
7060 
 
7061 
class getValidOrderCount_result:
7062 
  """
7063 
  Attributes:
7064 
   - success
7065 
  """
7066 
 
7067 
  thrift_spec = (
7068 
    (0, TType.I64, 'success', None, None, ), # 0
7069 
  )
7070 
 
7071 
  def __init__(self, success=None,):
7072 
    self.success = success
7073 
 
7074 
  def read(self, iprot):
7075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7077 
      return
7078 
    iprot.readStructBegin()
7079 
    while True:
7080 
      (fname, ftype, fid) = iprot.readFieldBegin()
7081 
      if ftype == TType.STOP:
7082 
        break
7083 
      if fid == 0:
7084 
        if ftype == TType.I64:
7085 
          self.success = iprot.readI64();
7086 
        else:
7087 
          iprot.skip(ftype)
7088 
      else:
7089 
        iprot.skip(ftype)
7090 
      iprot.readFieldEnd()
7091 
    iprot.readStructEnd()
7092 
 
7093 
  def write(self, oprot):
7094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7096 
      return
7097 
    oprot.writeStructBegin('getValidOrderCount_result')
7098 
    if self.success != None:
7099 
      oprot.writeFieldBegin('success', TType.I64, 0)
7100 
      oprot.writeI64(self.success)
7101 
      oprot.writeFieldEnd()
7102 
    oprot.writeFieldStop()
7103 
    oprot.writeStructEnd()
7104 
 
7105 
  def __repr__(self):
7106 
    L = ['%s=%r' % (key, value)
7107 
      for key, value in self.__dict__.iteritems()]
7108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7109 
 
7110 
  def __eq__(self, other):
7111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7112 
 
7113 
  def __ne__(self, other):
7114 
    return not (self == other)
7115 
 
1627 ankur.sing 7116 
class getNoOfCustomersWithSuccessfulTransaction_args:
1596 ankur.sing 7117 
 
1627 ankur.sing 7118 
  thrift_spec = (
7119 
  )
7120 
 
7121 
  def read(self, iprot):
7122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7124 
      return
7125 
    iprot.readStructBegin()
7126 
    while True:
7127 
      (fname, ftype, fid) = iprot.readFieldBegin()
7128 
      if ftype == TType.STOP:
7129 
        break
7130 
      else:
7131 
        iprot.skip(ftype)
7132 
      iprot.readFieldEnd()
7133 
    iprot.readStructEnd()
7134 
 
7135 
  def write(self, oprot):
7136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7138 
      return
7139 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7140 
    oprot.writeFieldStop()
7141 
    oprot.writeStructEnd()
7142 
 
7143 
  def __repr__(self):
7144 
    L = ['%s=%r' % (key, value)
7145 
      for key, value in self.__dict__.iteritems()]
7146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7147 
 
7148 
  def __eq__(self, other):
7149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7150 
 
7151 
  def __ne__(self, other):
7152 
    return not (self == other)
7153 
 
7154 
class getNoOfCustomersWithSuccessfulTransaction_result:
7155 
  """
7156 
  Attributes:
7157 
   - success
7158 
  """
7159 
 
7160 
  thrift_spec = (
7161 
    (0, TType.I64, 'success', None, None, ), # 0
7162 
  )
7163 
 
7164 
  def __init__(self, success=None,):
7165 
    self.success = success
7166 
 
7167 
  def read(self, iprot):
7168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7170 
      return
7171 
    iprot.readStructBegin()
7172 
    while True:
7173 
      (fname, ftype, fid) = iprot.readFieldBegin()
7174 
      if ftype == TType.STOP:
7175 
        break
7176 
      if fid == 0:
7177 
        if ftype == TType.I64:
7178 
          self.success = iprot.readI64();
7179 
        else:
7180 
          iprot.skip(ftype)
7181 
      else:
7182 
        iprot.skip(ftype)
7183 
      iprot.readFieldEnd()
7184 
    iprot.readStructEnd()
7185 
 
7186 
  def write(self, oprot):
7187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7189 
      return
7190 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
7191 
    if self.success != None:
7192 
      oprot.writeFieldBegin('success', TType.I64, 0)
7193 
      oprot.writeI64(self.success)
7194 
      oprot.writeFieldEnd()
7195 
    oprot.writeFieldStop()
7196 
    oprot.writeStructEnd()
7197 
 
7198 
  def __repr__(self):
7199 
    L = ['%s=%r' % (key, value)
7200 
      for key, value in self.__dict__.iteritems()]
7201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7202 
 
7203 
  def __eq__(self, other):
7204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7205 
 
7206 
  def __ne__(self, other):
7207 
    return not (self == other)
7208 
 
1731 ankur.sing 7209 
class getValidOrdersAmountRange_args:
1627 ankur.sing 7210 
 
7211 
  thrift_spec = (
7212 
  )
7213 
 
7214 
  def read(self, iprot):
7215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7217 
      return
7218 
    iprot.readStructBegin()
7219 
    while True:
7220 
      (fname, ftype, fid) = iprot.readFieldBegin()
7221 
      if ftype == TType.STOP:
7222 
        break
7223 
      else:
7224 
        iprot.skip(ftype)
7225 
      iprot.readFieldEnd()
7226 
    iprot.readStructEnd()
7227 
 
7228 
  def write(self, oprot):
7229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7231 
      return
1731 ankur.sing 7232 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
1627 ankur.sing 7233 
    oprot.writeFieldStop()
7234 
    oprot.writeStructEnd()
7235 
 
7236 
  def __repr__(self):
7237 
    L = ['%s=%r' % (key, value)
7238 
      for key, value in self.__dict__.iteritems()]
7239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7240 
 
7241 
  def __eq__(self, other):
7242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7243 
 
7244 
  def __ne__(self, other):
7245 
    return not (self == other)
7246 
 
1731 ankur.sing 7247 
class getValidOrdersAmountRange_result:
1627 ankur.sing 7248 
  """
7249 
  Attributes:
7250 
   - success
7251 
  """
7252 
 
7253 
  thrift_spec = (
1731 ankur.sing 7254 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
1627 ankur.sing 7255 
  )
7256 
 
7257 
  def __init__(self, success=None,):
7258 
    self.success = success
7259 
 
7260 
  def read(self, iprot):
7261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7263 
      return
7264 
    iprot.readStructBegin()
7265 
    while True:
7266 
      (fname, ftype, fid) = iprot.readFieldBegin()
7267 
      if ftype == TType.STOP:
7268 
        break
7269 
      if fid == 0:
1731 ankur.sing 7270 
        if ftype == TType.LIST:
7271 
          self.success = []
7272 
          (_etype144, _size141) = iprot.readListBegin()
7273 
          for _i145 in xrange(_size141):
7274 
            _elem146 = iprot.readDouble();
7275 
            self.success.append(_elem146)
7276 
          iprot.readListEnd()
1627 ankur.sing 7277 
        else:
7278 
          iprot.skip(ftype)
7279 
      else:
7280 
        iprot.skip(ftype)
7281 
      iprot.readFieldEnd()
7282 
    iprot.readStructEnd()
7283 
 
7284 
  def write(self, oprot):
7285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7287 
      return
1731 ankur.sing 7288 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
1627 ankur.sing 7289 
    if self.success != None:
1731 ankur.sing 7290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7291 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
7292 
      for iter147 in self.success:
7293 
        oprot.writeDouble(iter147)
7294 
      oprot.writeListEnd()
1627 ankur.sing 7295 
      oprot.writeFieldEnd()
7296 
    oprot.writeFieldStop()
7297 
    oprot.writeStructEnd()
7298 
 
7299 
  def __repr__(self):
7300 
    L = ['%s=%r' % (key, value)
7301 
      for key, value in self.__dict__.iteritems()]
7302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7303 
 
7304 
  def __eq__(self, other):
7305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7306 
 
7307 
  def __ne__(self, other):
7308 
    return not (self == other)
7309 
 
1886 ankur.sing 7310 
class getValidOrders_args:
7311 
  """
7312 
  Attributes:
7313 
   - limit
7314 
  """
1627 ankur.sing 7315 
 
1886 ankur.sing 7316 
  thrift_spec = (
7317 
    None, # 0
7318 
    (1, TType.I64, 'limit', None, None, ), # 1
7319 
  )
7320 
 
7321 
  def __init__(self, limit=None,):
7322 
    self.limit = limit
7323 
 
7324 
  def read(self, iprot):
7325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7327 
      return
7328 
    iprot.readStructBegin()
7329 
    while True:
7330 
      (fname, ftype, fid) = iprot.readFieldBegin()
7331 
      if ftype == TType.STOP:
7332 
        break
7333 
      if fid == 1:
7334 
        if ftype == TType.I64:
7335 
          self.limit = iprot.readI64();
7336 
        else:
7337 
          iprot.skip(ftype)
7338 
      else:
7339 
        iprot.skip(ftype)
7340 
      iprot.readFieldEnd()
7341 
    iprot.readStructEnd()
7342 
 
7343 
  def write(self, oprot):
7344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7346 
      return
7347 
    oprot.writeStructBegin('getValidOrders_args')
7348 
    if self.limit != None:
7349 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7350 
      oprot.writeI64(self.limit)
7351 
      oprot.writeFieldEnd()
7352 
    oprot.writeFieldStop()
7353 
    oprot.writeStructEnd()
7354 
 
7355 
  def __repr__(self):
7356 
    L = ['%s=%r' % (key, value)
7357 
      for key, value in self.__dict__.iteritems()]
7358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7359 
 
7360 
  def __eq__(self, other):
7361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7362 
 
7363 
  def __ne__(self, other):
7364 
    return not (self == other)
7365 
 
7366 
class getValidOrders_result:
7367 
  """
7368 
  Attributes:
7369 
   - success
7370 
  """
7371 
 
7372 
  thrift_spec = (
7373 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7374 
  )
7375 
 
7376 
  def __init__(self, success=None,):
7377 
    self.success = success
7378 
 
7379 
  def read(self, iprot):
7380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7382 
      return
7383 
    iprot.readStructBegin()
7384 
    while True:
7385 
      (fname, ftype, fid) = iprot.readFieldBegin()
7386 
      if ftype == TType.STOP:
7387 
        break
7388 
      if fid == 0:
7389 
        if ftype == TType.LIST:
7390 
          self.success = []
7391 
          (_etype151, _size148) = iprot.readListBegin()
7392 
          for _i152 in xrange(_size148):
7393 
            _elem153 = Order()
7394 
            _elem153.read(iprot)
7395 
            self.success.append(_elem153)
7396 
          iprot.readListEnd()
7397 
        else:
7398 
          iprot.skip(ftype)
7399 
      else:
7400 
        iprot.skip(ftype)
7401 
      iprot.readFieldEnd()
7402 
    iprot.readStructEnd()
7403 
 
7404 
  def write(self, oprot):
7405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7407 
      return
7408 
    oprot.writeStructBegin('getValidOrders_result')
7409 
    if self.success != None:
7410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7411 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7412 
      for iter154 in self.success:
7413 
        iter154.write(oprot)
7414 
      oprot.writeListEnd()
7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
7419 
  def __repr__(self):
7420 
    L = ['%s=%r' % (key, value)
7421 
      for key, value in self.__dict__.iteritems()]
7422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7423 
 
7424 
  def __eq__(self, other):
7425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7426 
 
7427 
  def __ne__(self, other):
7428 
    return not (self == other)
7429 
 
2536 chandransh 7430 
class toggleDOAFlag_args:
7431 
  """
7432 
  Attributes:
7433 
   - orderId
7434 
  """
1886 ankur.sing 7435 
 
2536 chandransh 7436 
  thrift_spec = (
7437 
    None, # 0
7438 
    (1, TType.I64, 'orderId', None, None, ), # 1
7439 
  )
7440 
 
7441 
  def __init__(self, orderId=None,):
7442 
    self.orderId = orderId
7443 
 
7444 
  def read(self, iprot):
7445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7447 
      return
7448 
    iprot.readStructBegin()
7449 
    while True:
7450 
      (fname, ftype, fid) = iprot.readFieldBegin()
7451 
      if ftype == TType.STOP:
7452 
        break
7453 
      if fid == 1:
7454 
        if ftype == TType.I64:
7455 
          self.orderId = iprot.readI64();
7456 
        else:
7457 
          iprot.skip(ftype)
7458 
      else:
7459 
        iprot.skip(ftype)
7460 
      iprot.readFieldEnd()
7461 
    iprot.readStructEnd()
7462 
 
7463 
  def write(self, oprot):
7464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7466 
      return
7467 
    oprot.writeStructBegin('toggleDOAFlag_args')
7468 
    if self.orderId != None:
7469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7470 
      oprot.writeI64(self.orderId)
7471 
      oprot.writeFieldEnd()
7472 
    oprot.writeFieldStop()
7473 
    oprot.writeStructEnd()
7474 
 
7475 
  def __repr__(self):
7476 
    L = ['%s=%r' % (key, value)
7477 
      for key, value in self.__dict__.iteritems()]
7478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7479 
 
7480 
  def __eq__(self, other):
7481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7482 
 
7483 
  def __ne__(self, other):
7484 
    return not (self == other)
7485 
 
7486 
class toggleDOAFlag_result:
7487 
  """
7488 
  Attributes:
7489 
   - success
7490 
   - ex
7491 
  """
7492 
 
7493 
  thrift_spec = (
7494 
    (0, TType.BOOL, 'success', None, None, ), # 0
7495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7496 
  )
7497 
 
7498 
  def __init__(self, success=None, ex=None,):
7499 
    self.success = success
7500 
    self.ex = ex
7501 
 
7502 
  def read(self, iprot):
7503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7505 
      return
7506 
    iprot.readStructBegin()
7507 
    while True:
7508 
      (fname, ftype, fid) = iprot.readFieldBegin()
7509 
      if ftype == TType.STOP:
7510 
        break
7511 
      if fid == 0:
7512 
        if ftype == TType.BOOL:
7513 
          self.success = iprot.readBool();
7514 
        else:
7515 
          iprot.skip(ftype)
7516 
      elif fid == 1:
7517 
        if ftype == TType.STRUCT:
7518 
          self.ex = TransactionServiceException()
7519 
          self.ex.read(iprot)
7520 
        else:
7521 
          iprot.skip(ftype)
7522 
      else:
7523 
        iprot.skip(ftype)
7524 
      iprot.readFieldEnd()
7525 
    iprot.readStructEnd()
7526 
 
7527 
  def write(self, oprot):
7528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7530 
      return
7531 
    oprot.writeStructBegin('toggleDOAFlag_result')
7532 
    if self.success != None:
7533 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7534 
      oprot.writeBool(self.success)
7535 
      oprot.writeFieldEnd()
7536 
    if self.ex != None:
7537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7538 
      self.ex.write(oprot)
7539 
      oprot.writeFieldEnd()
7540 
    oprot.writeFieldStop()
7541 
    oprot.writeStructEnd()
7542 
 
7543 
  def __repr__(self):
7544 
    L = ['%s=%r' % (key, value)
7545 
      for key, value in self.__dict__.iteritems()]
7546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7547 
 
7548 
  def __eq__(self, other):
7549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7550 
 
7551 
  def __ne__(self, other):
7552 
    return not (self == other)
7553 
 
7554 
class requestPickupNumber_args:
7555 
  """
7556 
  Attributes:
7557 
   - orderId
7558 
  """
7559 
 
7560 
  thrift_spec = (
7561 
    None, # 0
7562 
    (1, TType.I64, 'orderId', None, None, ), # 1
7563 
  )
7564 
 
7565 
  def __init__(self, orderId=None,):
7566 
    self.orderId = orderId
7567 
 
7568 
  def read(self, iprot):
7569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7571 
      return
7572 
    iprot.readStructBegin()
7573 
    while True:
7574 
      (fname, ftype, fid) = iprot.readFieldBegin()
7575 
      if ftype == TType.STOP:
7576 
        break
7577 
      if fid == 1:
7578 
        if ftype == TType.I64:
7579 
          self.orderId = iprot.readI64();
7580 
        else:
7581 
          iprot.skip(ftype)
7582 
      else:
7583 
        iprot.skip(ftype)
7584 
      iprot.readFieldEnd()
7585 
    iprot.readStructEnd()
7586 
 
7587 
  def write(self, oprot):
7588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7590 
      return
7591 
    oprot.writeStructBegin('requestPickupNumber_args')
7592 
    if self.orderId != None:
7593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7594 
      oprot.writeI64(self.orderId)
7595 
      oprot.writeFieldEnd()
7596 
    oprot.writeFieldStop()
7597 
    oprot.writeStructEnd()
7598 
 
7599 
  def __repr__(self):
7600 
    L = ['%s=%r' % (key, value)
7601 
      for key, value in self.__dict__.iteritems()]
7602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7603 
 
7604 
  def __eq__(self, other):
7605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7606 
 
7607 
  def __ne__(self, other):
7608 
    return not (self == other)
7609 
 
7610 
class requestPickupNumber_result:
7611 
  """
7612 
  Attributes:
7613 
   - success
7614 
   - ex
7615 
  """
7616 
 
7617 
  thrift_spec = (
7618 
    (0, TType.BOOL, 'success', None, None, ), # 0
7619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7620 
  )
7621 
 
7622 
  def __init__(self, success=None, ex=None,):
7623 
    self.success = success
7624 
    self.ex = ex
7625 
 
7626 
  def read(self, iprot):
7627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7629 
      return
7630 
    iprot.readStructBegin()
7631 
    while True:
7632 
      (fname, ftype, fid) = iprot.readFieldBegin()
7633 
      if ftype == TType.STOP:
7634 
        break
7635 
      if fid == 0:
7636 
        if ftype == TType.BOOL:
7637 
          self.success = iprot.readBool();
7638 
        else:
7639 
          iprot.skip(ftype)
7640 
      elif fid == 1:
7641 
        if ftype == TType.STRUCT:
7642 
          self.ex = TransactionServiceException()
7643 
          self.ex.read(iprot)
7644 
        else:
7645 
          iprot.skip(ftype)
7646 
      else:
7647 
        iprot.skip(ftype)
7648 
      iprot.readFieldEnd()
7649 
    iprot.readStructEnd()
7650 
 
7651 
  def write(self, oprot):
7652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7654 
      return
7655 
    oprot.writeStructBegin('requestPickupNumber_result')
7656 
    if self.success != None:
7657 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7658 
      oprot.writeBool(self.success)
7659 
      oprot.writeFieldEnd()
7660 
    if self.ex != None:
7661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7662 
      self.ex.write(oprot)
7663 
      oprot.writeFieldEnd()
7664 
    oprot.writeFieldStop()
7665 
    oprot.writeStructEnd()
7666 
 
7667 
  def __repr__(self):
7668 
    L = ['%s=%r' % (key, value)
7669 
      for key, value in self.__dict__.iteritems()]
7670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7671 
 
7672 
  def __eq__(self, other):
7673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7674 
 
7675 
  def __ne__(self, other):
7676 
    return not (self == other)
7677 
 
7678 
class authorizePickup_args:
7679 
  """
7680 
  Attributes:
7681 
   - orderId
7682 
   - pickupNumber
7683 
  """
7684 
 
7685 
  thrift_spec = (
7686 
    None, # 0
7687 
    (1, TType.I64, 'orderId', None, None, ), # 1
7688 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
7689 
  )
7690 
 
7691 
  def __init__(self, orderId=None, pickupNumber=None,):
7692 
    self.orderId = orderId
7693 
    self.pickupNumber = pickupNumber
7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 1:
7705 
        if ftype == TType.I64:
7706 
          self.orderId = iprot.readI64();
7707 
        else:
7708 
          iprot.skip(ftype)
7709 
      elif fid == 2:
7710 
        if ftype == TType.STRING:
7711 
          self.pickupNumber = iprot.readString();
7712 
        else:
7713 
          iprot.skip(ftype)
7714 
      else:
7715 
        iprot.skip(ftype)
7716 
      iprot.readFieldEnd()
7717 
    iprot.readStructEnd()
7718 
 
7719 
  def write(self, oprot):
7720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7722 
      return
7723 
    oprot.writeStructBegin('authorizePickup_args')
7724 
    if self.orderId != None:
7725 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7726 
      oprot.writeI64(self.orderId)
7727 
      oprot.writeFieldEnd()
7728 
    if self.pickupNumber != None:
7729 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
7730 
      oprot.writeString(self.pickupNumber)
7731 
      oprot.writeFieldEnd()
7732 
    oprot.writeFieldStop()
7733 
    oprot.writeStructEnd()
7734 
 
7735 
  def __repr__(self):
7736 
    L = ['%s=%r' % (key, value)
7737 
      for key, value in self.__dict__.iteritems()]
7738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7739 
 
7740 
  def __eq__(self, other):
7741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7742 
 
7743 
  def __ne__(self, other):
7744 
    return not (self == other)
7745 
 
7746 
class authorizePickup_result:
7747 
  """
7748 
  Attributes:
7749 
   - success
7750 
   - ex
7751 
  """
7752 
 
7753 
  thrift_spec = (
7754 
    (0, TType.BOOL, 'success', None, None, ), # 0
7755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7756 
  )
7757 
 
7758 
  def __init__(self, success=None, ex=None,):
7759 
    self.success = success
7760 
    self.ex = ex
7761 
 
7762 
  def read(self, iprot):
7763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7765 
      return
7766 
    iprot.readStructBegin()
7767 
    while True:
7768 
      (fname, ftype, fid) = iprot.readFieldBegin()
7769 
      if ftype == TType.STOP:
7770 
        break
7771 
      if fid == 0:
7772 
        if ftype == TType.BOOL:
7773 
          self.success = iprot.readBool();
7774 
        else:
7775 
          iprot.skip(ftype)
7776 
      elif fid == 1:
7777 
        if ftype == TType.STRUCT:
7778 
          self.ex = TransactionServiceException()
7779 
          self.ex.read(iprot)
7780 
        else:
7781 
          iprot.skip(ftype)
7782 
      else:
7783 
        iprot.skip(ftype)
7784 
      iprot.readFieldEnd()
7785 
    iprot.readStructEnd()
7786 
 
7787 
  def write(self, oprot):
7788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7790 
      return
7791 
    oprot.writeStructBegin('authorizePickup_result')
7792 
    if self.success != None:
7793 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7794 
      oprot.writeBool(self.success)
7795 
      oprot.writeFieldEnd()
7796 
    if self.ex != None:
7797 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7798 
      self.ex.write(oprot)
7799 
      oprot.writeFieldEnd()
7800 
    oprot.writeFieldStop()
7801 
    oprot.writeStructEnd()
7802 
 
7803 
  def __repr__(self):
7804 
    L = ['%s=%r' % (key, value)
7805 
      for key, value in self.__dict__.iteritems()]
7806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7807 
 
7808 
  def __eq__(self, other):
7809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7810 
 
7811 
  def __ne__(self, other):
7812 
    return not (self == other)
7813 
 
2591 chandransh 7814 
class acceptDoa_args:
7815 
  """
7816 
  Attributes:
7817 
   - orderId
7818 
  """
2536 chandransh 7819 
 
2591 chandransh 7820 
  thrift_spec = (
7821 
    None, # 0
7822 
    (1, TType.I64, 'orderId', None, None, ), # 1
7823 
  )
7824 
 
7825 
  def __init__(self, orderId=None,):
7826 
    self.orderId = orderId
7827 
 
7828 
  def read(self, iprot):
7829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7831 
      return
7832 
    iprot.readStructBegin()
7833 
    while True:
7834 
      (fname, ftype, fid) = iprot.readFieldBegin()
7835 
      if ftype == TType.STOP:
7836 
        break
7837 
      if fid == 1:
7838 
        if ftype == TType.I64:
7839 
          self.orderId = iprot.readI64();
7840 
        else:
7841 
          iprot.skip(ftype)
7842 
      else:
7843 
        iprot.skip(ftype)
7844 
      iprot.readFieldEnd()
7845 
    iprot.readStructEnd()
7846 
 
7847 
  def write(self, oprot):
7848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7850 
      return
7851 
    oprot.writeStructBegin('acceptDoa_args')
7852 
    if self.orderId != None:
7853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7854 
      oprot.writeI64(self.orderId)
7855 
      oprot.writeFieldEnd()
7856 
    oprot.writeFieldStop()
7857 
    oprot.writeStructEnd()
7858 
 
7859 
  def __repr__(self):
7860 
    L = ['%s=%r' % (key, value)
7861 
      for key, value in self.__dict__.iteritems()]
7862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7863 
 
7864 
  def __eq__(self, other):
7865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7866 
 
7867 
  def __ne__(self, other):
7868 
    return not (self == other)
7869 
 
7870 
class acceptDoa_result:
7871 
  """
7872 
  Attributes:
7873 
   - success
7874 
   - ex
7875 
  """
7876 
 
7877 
  thrift_spec = (
7878 
    (0, TType.BOOL, 'success', None, None, ), # 0
7879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7880 
  )
7881 
 
7882 
  def __init__(self, success=None, ex=None,):
7883 
    self.success = success
7884 
    self.ex = ex
7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      if fid == 0:
7896 
        if ftype == TType.BOOL:
7897 
          self.success = iprot.readBool();
7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      elif fid == 1:
7901 
        if ftype == TType.STRUCT:
7902 
          self.ex = TransactionServiceException()
7903 
          self.ex.read(iprot)
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      else:
7907 
        iprot.skip(ftype)
7908 
      iprot.readFieldEnd()
7909 
    iprot.readStructEnd()
7910 
 
7911 
  def write(self, oprot):
7912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7914 
      return
7915 
    oprot.writeStructBegin('acceptDoa_result')
7916 
    if self.success != None:
7917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7918 
      oprot.writeBool(self.success)
7919 
      oprot.writeFieldEnd()
7920 
    if self.ex != None:
7921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7922 
      self.ex.write(oprot)
7923 
      oprot.writeFieldEnd()
7924 
    oprot.writeFieldStop()
7925 
    oprot.writeStructEnd()
7926 
 
7927 
  def __repr__(self):
7928 
    L = ['%s=%r' % (key, value)
7929 
      for key, value in self.__dict__.iteritems()]
7930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7931 
 
7932 
  def __eq__(self, other):
7933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7934 
 
7935 
  def __ne__(self, other):
7936 
    return not (self == other)
7937 
 
7938 
class validateDoa_args:
7939 
  """
7940 
  Attributes:
7941 
   - orderId
7942 
   - isValid
7943 
  """
7944 
 
7945 
  thrift_spec = (
7946 
    None, # 0
7947 
    (1, TType.I64, 'orderId', None, None, ), # 1
7948 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
7949 
  )
7950 
 
7951 
  def __init__(self, orderId=None, isValid=None,):
7952 
    self.orderId = orderId
7953 
    self.isValid = isValid
7954 
 
7955 
  def read(self, iprot):
7956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7958 
      return
7959 
    iprot.readStructBegin()
7960 
    while True:
7961 
      (fname, ftype, fid) = iprot.readFieldBegin()
7962 
      if ftype == TType.STOP:
7963 
        break
7964 
      if fid == 1:
7965 
        if ftype == TType.I64:
7966 
          self.orderId = iprot.readI64();
7967 
        else:
7968 
          iprot.skip(ftype)
7969 
      elif fid == 2:
7970 
        if ftype == TType.BOOL:
7971 
          self.isValid = iprot.readBool();
7972 
        else:
7973 
          iprot.skip(ftype)
7974 
      else:
7975 
        iprot.skip(ftype)
7976 
      iprot.readFieldEnd()
7977 
    iprot.readStructEnd()
7978 
 
7979 
  def write(self, oprot):
7980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7982 
      return
7983 
    oprot.writeStructBegin('validateDoa_args')
7984 
    if self.orderId != None:
7985 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7986 
      oprot.writeI64(self.orderId)
7987 
      oprot.writeFieldEnd()
7988 
    if self.isValid != None:
7989 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
7990 
      oprot.writeBool(self.isValid)
7991 
      oprot.writeFieldEnd()
7992 
    oprot.writeFieldStop()
7993 
    oprot.writeStructEnd()
7994 
 
7995 
  def __repr__(self):
7996 
    L = ['%s=%r' % (key, value)
7997 
      for key, value in self.__dict__.iteritems()]
7998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7999 
 
8000 
  def __eq__(self, other):
8001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8002 
 
8003 
  def __ne__(self, other):
8004 
    return not (self == other)
8005 
 
8006 
class validateDoa_result:
8007 
  """
8008 
  Attributes:
8009 
   - success
8010 
   - ex
8011 
  """
8012 
 
8013 
  thrift_spec = (
8014 
    (0, TType.BOOL, 'success', None, None, ), # 0
8015 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8016 
  )
8017 
 
8018 
  def __init__(self, success=None, ex=None,):
8019 
    self.success = success
8020 
    self.ex = ex
8021 
 
8022 
  def read(self, iprot):
8023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8025 
      return
8026 
    iprot.readStructBegin()
8027 
    while True:
8028 
      (fname, ftype, fid) = iprot.readFieldBegin()
8029 
      if ftype == TType.STOP:
8030 
        break
8031 
      if fid == 0:
8032 
        if ftype == TType.BOOL:
8033 
          self.success = iprot.readBool();
8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      elif fid == 1:
8037 
        if ftype == TType.STRUCT:
8038 
          self.ex = TransactionServiceException()
8039 
          self.ex.read(iprot)
8040 
        else:
8041 
          iprot.skip(ftype)
8042 
      else:
8043 
        iprot.skip(ftype)
8044 
      iprot.readFieldEnd()
8045 
    iprot.readStructEnd()
8046 
 
8047 
  def write(self, oprot):
8048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8050 
      return
8051 
    oprot.writeStructBegin('validateDoa_result')
8052 
    if self.success != None:
8053 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8054 
      oprot.writeBool(self.success)
8055 
      oprot.writeFieldEnd()
8056 
    if self.ex != None:
8057 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8058 
      self.ex.write(oprot)
8059 
      oprot.writeFieldEnd()
8060 
    oprot.writeFieldStop()
8061 
    oprot.writeStructEnd()
8062 
 
8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
8074