Subversion Repositories SmartDukaan

Rev

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