Subversion Repositories SmartDukaan

Rev

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