Subversion Repositories SmartDukaan

Rev

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

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