Subversion Repositories SmartDukaan

Rev

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