Subversion Repositories SmartDukaan

Rev

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