Subversion Repositories SmartDukaan

Rev

Rev 4369 | Rev 4394 | 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 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    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.
404 
    Returns the final flag status.
405 
    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 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    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 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    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 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	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.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    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 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4295 varun.gupt 659 
  def getOrdersForItemIds(self, itemIds):
660 
    """
661 
    Returns a list of all orders which have items with given id
662 
 
663 
    Parameters:
664 
     - itemIds
665 
    """
666 
    pass
667 
 
4247 rajveer 668 
  def markOrderCancellationRequestReceived(self, orderId):
669 
    """
670 
    Mark order as cancellation request received. If customer sends request of cancellation of
671 
    a particular order, this method will be called. It will just change status of the order
672 
    depending on its current status. It also records the previous status, so that we can move
673 
    back to that status if cancellation request is denied.
4018 chandransh 674 
 
4247 rajveer 675 
    Parameters:
676 
     - orderId
677 
    """
678 
    pass
679 
 
680 
  def markOrderCancellationRequestConfirmed(self, orderId):
681 
    """
682 
    If we decide to to cancel order, CRM will call this method to move the status of order to
683 
    cancellation request confirmed. After this OM will be able to cancel the order.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
690 
  def markOrderCancellationRequestDenied(self, orderId):
691 
    """
692 
    If we decide to not to cancel order, we will move the order ro previous status.
693 
 
694 
    Parameters:
695 
     - orderId
696 
    """
697 
    pass
698 
 
4258 rajveer 699 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 700 
    """
4258 rajveer 701 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
702 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 703 
 
704 
    Parameters:
4258 rajveer 705 
     - transactionId
4247 rajveer 706 
    """
707 
    pass
708 
 
4259 anupam.sin 709 
  def refundTransaction(self, transactionId, refundedBy, reason):
710 
    """
711 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
712 
    need to be cancelled
4247 rajveer 713 
 
4259 anupam.sin 714 
    Parameters:
715 
     - transactionId
716 
     - refundedBy
717 
     - reason
718 
    """
719 
    pass
720 
 
4324 mandeep.dh 721 
  def updateShipmentAddress(self, orderId, addressId):
722 
    """
723 
    Updates shipment address of an order. Delivery and shipping date estimates
724 
    etc. are also updated here.
725 
 
726 
    Throws TransactionServiceException in case address change is not
727 
    possible due to certain reasons such as new pincode in address is
728 
    not serviceable etc.
729 
 
730 
    Parameters:
731 
     - orderId
732 
     - addressId
733 
    """
734 
    pass
735 
 
4285 rajveer 736 
  def acceptOrdersForItemId(self, itemId, inventory):
737 
    """
738 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
739 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 740 
 
4285 rajveer 741 
    Parameters:
742 
     - itemId
743 
     - inventory
744 
    """
745 
    pass
746 
 
4369 rajveer 747 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 748 
    """
749 
    Parameters:
750 
     - vendorId
751 
     - itemId
752 
     - quantity
753 
     - estimate
4369 rajveer 754 
     - isReminder
4303 rajveer 755 
    """
756 
    pass
4285 rajveer 757 
 
4369 rajveer 758 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 759 
    """
760 
    Parameters:
761 
     - vendorId
762 
     - itemId
763 
     - quantity
764 
     - estimate
4369 rajveer 765 
     - isReminder
4303 rajveer 766 
    """
767 
    pass
768 
 
4369 rajveer 769 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 770 
    """
771 
    Parameters:
772 
     - vendorId
773 
     - itemId
774 
     - quantity
775 
     - estimate
4369 rajveer 776 
     - isReminder
4303 rajveer 777 
    """
778 
    pass
779 
 
4369 rajveer 780 
  def markOrdersAsTimeout(self, vendorId):
781 
    """
782 
    Parameters:
783 
     - vendorId
784 
    """
785 
    pass
4303 rajveer 786 
 
4386 anupam.sin 787 
  def getOrderForAwb(self, awb):
788 
    """
789 
    Returns the order corresponding to an AWB number
4369 rajveer 790 
 
4386 anupam.sin 791 
    Parameters:
792 
     - awb
793 
    """
794 
    pass
795 
 
796 
 
3376 rajveer 797 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 798 
  def __init__(self, iprot, oprot=None):
3376 rajveer 799 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 800 
 
801 
  def createTransaction(self, transaction):
802 
    """
803 
    Parameters:
804 
     - transaction
805 
    """
806 
    self.send_createTransaction(transaction)
132 ashish 807 
    return self.recv_createTransaction()
94 ashish 808 
 
809 
  def send_createTransaction(self, transaction):
810 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
811 
    args = createTransaction_args()
812 
    args.transaction = transaction
813 
    args.write(self._oprot)
814 
    self._oprot.writeMessageEnd()
815 
    self._oprot.trans.flush()
816 
 
817 
  def recv_createTransaction(self, ):
818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
819 
    if mtype == TMessageType.EXCEPTION:
820 
      x = TApplicationException()
821 
      x.read(self._iprot)
822 
      self._iprot.readMessageEnd()
823 
      raise x
824 
    result = createTransaction_result()
825 
    result.read(self._iprot)
826 
    self._iprot.readMessageEnd()
3431 rajveer 827 
    if result.success is not None:
132 ashish 828 
      return result.success
3431 rajveer 829 
    if result.ex is not None:
94 ashish 830 
      raise result.ex
132 ashish 831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 832 
 
833 
  def getTransaction(self, id):
834 
    """
835 
    Parameters:
836 
     - id
837 
    """
838 
    self.send_getTransaction(id)
839 
    return self.recv_getTransaction()
840 
 
841 
  def send_getTransaction(self, id):
842 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
843 
    args = getTransaction_args()
844 
    args.id = id
845 
    args.write(self._oprot)
846 
    self._oprot.writeMessageEnd()
847 
    self._oprot.trans.flush()
848 
 
849 
  def recv_getTransaction(self, ):
850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
851 
    if mtype == TMessageType.EXCEPTION:
852 
      x = TApplicationException()
853 
      x.read(self._iprot)
854 
      self._iprot.readMessageEnd()
855 
      raise x
856 
    result = getTransaction_result()
857 
    result.read(self._iprot)
858 
    self._iprot.readMessageEnd()
3431 rajveer 859 
    if result.success is not None:
94 ashish 860 
      return result.success
3431 rajveer 861 
    if result.ex is not None:
94 ashish 862 
      raise result.ex
863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
864 
 
865 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
866 
    """
867 
    Parameters:
868 
     - customerId
869 
     - from_date
870 
     - to_date
871 
     - status
872 
    """
873 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
874 
    return self.recv_getTransactionsForCustomer()
875 
 
876 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
877 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
878 
    args = getTransactionsForCustomer_args()
879 
    args.customerId = customerId
880 
    args.from_date = from_date
881 
    args.to_date = to_date
882 
    args.status = status
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getTransactionsForCustomer(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getTransactionsForCustomer_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
3431 rajveer 897 
    if result.success is not None:
94 ashish 898 
      return result.success
3431 rajveer 899 
    if result.ex is not None:
94 ashish 900 
      raise result.ex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
902 
 
132 ashish 903 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
904 
    """
905 
    Parameters:
906 
     - shoppingCartId
907 
    """
908 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
909 
    return self.recv_getTransactionsForShoppingCartId()
910 
 
911 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
912 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
913 
    args = getTransactionsForShoppingCartId_args()
914 
    args.shoppingCartId = shoppingCartId
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_getTransactionsForShoppingCartId(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = getTransactionsForShoppingCartId_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
3431 rajveer 929 
    if result.success is not None:
132 ashish 930 
      return result.success
3431 rajveer 931 
    if result.ex is not None:
132 ashish 932 
      raise result.ex
933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
934 
 
94 ashish 935 
  def getTransactionStatus(self, transactionId):
936 
    """
937 
    Parameters:
938 
     - transactionId
939 
    """
940 
    self.send_getTransactionStatus(transactionId)
941 
    return self.recv_getTransactionStatus()
942 
 
943 
  def send_getTransactionStatus(self, transactionId):
944 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
945 
    args = getTransactionStatus_args()
946 
    args.transactionId = transactionId
947 
    args.write(self._oprot)
948 
    self._oprot.writeMessageEnd()
949 
    self._oprot.trans.flush()
950 
 
951 
  def recv_getTransactionStatus(self, ):
952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
953 
    if mtype == TMessageType.EXCEPTION:
954 
      x = TApplicationException()
955 
      x.read(self._iprot)
956 
      self._iprot.readMessageEnd()
957 
      raise x
958 
    result = getTransactionStatus_result()
959 
    result.read(self._iprot)
960 
    self._iprot.readMessageEnd()
3431 rajveer 961 
    if result.success is not None:
94 ashish 962 
      return result.success
3431 rajveer 963 
    if result.ex is not None:
94 ashish 964 
      raise result.ex
965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
966 
 
967 
  def changeTransactionStatus(self, transactionId, status, description):
968 
    """
969 
    Parameters:
970 
     - transactionId
971 
     - status
972 
     - description
973 
    """
974 
    self.send_changeTransactionStatus(transactionId, status, description)
975 
    return self.recv_changeTransactionStatus()
976 
 
977 
  def send_changeTransactionStatus(self, transactionId, status, description):
978 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
979 
    args = changeTransactionStatus_args()
980 
    args.transactionId = transactionId
981 
    args.status = status
982 
    args.description = description
983 
    args.write(self._oprot)
984 
    self._oprot.writeMessageEnd()
985 
    self._oprot.trans.flush()
986 
 
987 
  def recv_changeTransactionStatus(self, ):
988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
989 
    if mtype == TMessageType.EXCEPTION:
990 
      x = TApplicationException()
991 
      x.read(self._iprot)
992 
      self._iprot.readMessageEnd()
993 
      raise x
994 
    result = changeTransactionStatus_result()
995 
    result.read(self._iprot)
996 
    self._iprot.readMessageEnd()
3431 rajveer 997 
    if result.success is not None:
94 ashish 998 
      return result.success
3431 rajveer 999 
    if result.ex is not None:
94 ashish 1000 
      raise result.ex
1001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1002 
 
1398 varun.gupt 1003 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1004 
    """
1005 
    Parameters:
1006 
     - transactionId
1007 
    """
1398 varun.gupt 1008 
    self.send_enqueueTransactionInfoEmail(transactionId)
1009 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1010 
 
1398 varun.gupt 1011 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1012 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1013 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1014 
    args.transactionId = transactionId
1015 
    args.write(self._oprot)
1016 
    self._oprot.writeMessageEnd()
1017 
    self._oprot.trans.flush()
1018 
 
1398 varun.gupt 1019 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1021 
    if mtype == TMessageType.EXCEPTION:
1022 
      x = TApplicationException()
1023 
      x.read(self._iprot)
1024 
      self._iprot.readMessageEnd()
1025 
      raise x
1398 varun.gupt 1026 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1027 
    result.read(self._iprot)
1028 
    self._iprot.readMessageEnd()
3431 rajveer 1029 
    if result.success is not None:
1382 varun.gupt 1030 
      return result.success
3431 rajveer 1031 
    if result.ex is not None:
1382 varun.gupt 1032 
      raise result.ex
1398 varun.gupt 1033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1034 
 
483 rajveer 1035 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1036 
    """
1037 
    Parameters:
483 rajveer 1038 
     - status
1039 
     - from_date
1040 
     - to_date
1041 
     - warehouse_id
94 ashish 1042 
    """
483 rajveer 1043 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1044 
    return self.recv_getAllOrders()
94 ashish 1045 
 
483 rajveer 1046 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1047 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1048 
    args = getAllOrders_args()
1049 
    args.status = status
1050 
    args.from_date = from_date
1051 
    args.to_date = to_date
1052 
    args.warehouse_id = warehouse_id
94 ashish 1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
483 rajveer 1057 
  def recv_getAllOrders(self, ):
94 ashish 1058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1059 
    if mtype == TMessageType.EXCEPTION:
1060 
      x = TApplicationException()
1061 
      x.read(self._iprot)
1062 
      self._iprot.readMessageEnd()
1063 
      raise x
483 rajveer 1064 
    result = getAllOrders_result()
94 ashish 1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
3431 rajveer 1067 
    if result.success is not None:
94 ashish 1068 
      return result.success
3431 rajveer 1069 
    if result.ex is not None:
94 ashish 1070 
      raise result.ex
483 rajveer 1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1072 
 
4133 chandransh 1073 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1074 
    """
1075 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1076 
    Pass the status as null and the limit as 0 to ignore them.
1077 
 
1078 
    Parameters:
1079 
     - statuses
1080 
     - offset
1081 
     - limit
1082 
     - warehouse_id
1083 
    """
1084 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1085 
    return self.recv_getOrdersInBatch()
1086 
 
1087 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1088 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1089 
    args = getOrdersInBatch_args()
1090 
    args.statuses = statuses
1091 
    args.offset = offset
1092 
    args.limit = limit
1093 
    args.warehouse_id = warehouse_id
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_getOrdersInBatch(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = getOrdersInBatch_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
1108 
    if result.success is not None:
1109 
      return result.success
1110 
    if result.ex is not None:
1111 
      raise result.ex
1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1113 
 
1114 
  def getOrderCount(self, statuses, warehouseId):
1115 
    """
1116 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1117 
 
1118 
    Parameters:
1119 
     - statuses
1120 
     - warehouseId
1121 
    """
1122 
    self.send_getOrderCount(statuses, warehouseId)
1123 
    return self.recv_getOrderCount()
1124 
 
1125 
  def send_getOrderCount(self, statuses, warehouseId):
1126 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1127 
    args = getOrderCount_args()
1128 
    args.statuses = statuses
1129 
    args.warehouseId = warehouseId
1130 
    args.write(self._oprot)
1131 
    self._oprot.writeMessageEnd()
1132 
    self._oprot.trans.flush()
1133 
 
1134 
  def recv_getOrderCount(self, ):
1135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1136 
    if mtype == TMessageType.EXCEPTION:
1137 
      x = TApplicationException()
1138 
      x.read(self._iprot)
1139 
      self._iprot.readMessageEnd()
1140 
      raise x
1141 
    result = getOrderCount_result()
1142 
    result.read(self._iprot)
1143 
    self._iprot.readMessageEnd()
1144 
    if result.success is not None:
1145 
      return result.success
1146 
    if result.ex is not None:
1147 
      raise result.ex
1148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1149 
 
999 varun.gupt 1150 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1151 
    """
1132 chandransh 1152 
    Returns orders within a range of their billing dates
3431 rajveer 1153 
 
999 varun.gupt 1154 
    Parameters:
1155 
     - status
1156 
     - start_billing_date
1157 
     - end_billing_date
1158 
     - warehouse_id
1159 
    """
1160 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1161 
    return self.recv_getOrdersByBillingDate()
1162 
 
1163 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1164 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1165 
    args = getOrdersByBillingDate_args()
1166 
    args.status = status
1167 
    args.start_billing_date = start_billing_date
1168 
    args.end_billing_date = end_billing_date
1169 
    args.warehouse_id = warehouse_id
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_getOrdersByBillingDate(self, ):
1175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1176 
    if mtype == TMessageType.EXCEPTION:
1177 
      x = TApplicationException()
1178 
      x.read(self._iprot)
1179 
      self._iprot.readMessageEnd()
1180 
      raise x
1181 
    result = getOrdersByBillingDate_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
3431 rajveer 1184 
    if result.success is not None:
999 varun.gupt 1185 
      return result.success
3431 rajveer 1186 
    if result.ex is not None:
999 varun.gupt 1187 
      raise result.ex
1188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1189 
 
3451 chandransh 1190 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1191 
    """
1192 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1193 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1194 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1195 
 
3427 chandransh 1196 
    Parameters:
1197 
     - fromShippingDate
1198 
     - toShippingDate
1199 
     - providerId
1200 
     - warehouseId
3451 chandransh 1201 
     - cod
3427 chandransh 1202 
    """
3451 chandransh 1203 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1204 
    return self.recv_getOrdersByShippingDate()
1205 
 
3451 chandransh 1206 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1207 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1208 
    args = getOrdersByShippingDate_args()
1209 
    args.fromShippingDate = fromShippingDate
1210 
    args.toShippingDate = toShippingDate
1211 
    args.providerId = providerId
1212 
    args.warehouseId = warehouseId
3451 chandransh 1213 
    args.cod = cod
3427 chandransh 1214 
    args.write(self._oprot)
1215 
    self._oprot.writeMessageEnd()
1216 
    self._oprot.trans.flush()
1217 
 
1218 
  def recv_getOrdersByShippingDate(self, ):
1219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1220 
    if mtype == TMessageType.EXCEPTION:
1221 
      x = TApplicationException()
1222 
      x.read(self._iprot)
1223 
      self._iprot.readMessageEnd()
1224 
      raise x
1225 
    result = getOrdersByShippingDate_result()
1226 
    result.read(self._iprot)
1227 
    self._iprot.readMessageEnd()
3431 rajveer 1228 
    if result.success is not None:
3427 chandransh 1229 
      return result.success
3431 rajveer 1230 
    if result.ex is not None:
3427 chandransh 1231 
      raise result.ex
1232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1233 
 
1382 varun.gupt 1234 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1235 
    """
1236 
    Returns order ids for orders which can be returned
3431 rajveer 1237 
 
1382 varun.gupt 1238 
    Parameters:
1239 
     - customer_id
1240 
     - limit
1241 
    """
1242 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1243 
    return self.recv_getReturnableOrdersForCustomer()
1244 
 
1245 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1246 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1247 
    args = getReturnableOrdersForCustomer_args()
1248 
    args.customer_id = customer_id
1249 
    args.limit = limit
1250 
    args.write(self._oprot)
1251 
    self._oprot.writeMessageEnd()
1252 
    self._oprot.trans.flush()
1253 
 
1254 
  def recv_getReturnableOrdersForCustomer(self, ):
1255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1256 
    if mtype == TMessageType.EXCEPTION:
1257 
      x = TApplicationException()
1258 
      x.read(self._iprot)
1259 
      self._iprot.readMessageEnd()
1260 
      raise x
1261 
    result = getReturnableOrdersForCustomer_result()
1262 
    result.read(self._iprot)
1263 
    self._iprot.readMessageEnd()
3431 rajveer 1264 
    if result.success is not None:
1382 varun.gupt 1265 
      return result.success
3431 rajveer 1266 
    if result.ex is not None:
1382 varun.gupt 1267 
      raise result.ex
1268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1269 
 
1270 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1271 
    """
1272 
    Returns order ids for orders which can be cancelled
3431 rajveer 1273 
 
1382 varun.gupt 1274 
    Parameters:
1275 
     - customer_id
1276 
     - limit
1277 
    """
1278 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1279 
    return self.recv_getCancellableOrdersForCustomer()
1280 
 
1281 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1282 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1283 
    args = getCancellableOrdersForCustomer_args()
1284 
    args.customer_id = customer_id
1285 
    args.limit = limit
1286 
    args.write(self._oprot)
1287 
    self._oprot.writeMessageEnd()
1288 
    self._oprot.trans.flush()
1289 
 
1290 
  def recv_getCancellableOrdersForCustomer(self, ):
1291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1292 
    if mtype == TMessageType.EXCEPTION:
1293 
      x = TApplicationException()
1294 
      x.read(self._iprot)
1295 
      self._iprot.readMessageEnd()
1296 
      raise x
1297 
    result = getCancellableOrdersForCustomer_result()
1298 
    result.read(self._iprot)
1299 
    self._iprot.readMessageEnd()
3431 rajveer 1300 
    if result.success is not None:
1382 varun.gupt 1301 
      return result.success
3431 rajveer 1302 
    if result.ex is not None:
1382 varun.gupt 1303 
      raise result.ex
1304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1305 
 
483 rajveer 1306 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1307 
    """
1308 
    Parameters:
483 rajveer 1309 
     - orderId
1310 
     - status
1311 
     - description
94 ashish 1312 
    """
483 rajveer 1313 
    self.send_changeOrderStatus(orderId, status, description)
1314 
    return self.recv_changeOrderStatus()
94 ashish 1315 
 
483 rajveer 1316 
  def send_changeOrderStatus(self, orderId, status, description):
1317 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1318 
    args = changeOrderStatus_args()
1319 
    args.orderId = orderId
1320 
    args.status = status
1321 
    args.description = description
94 ashish 1322 
    args.write(self._oprot)
1323 
    self._oprot.writeMessageEnd()
1324 
    self._oprot.trans.flush()
1325 
 
483 rajveer 1326 
  def recv_changeOrderStatus(self, ):
94 ashish 1327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1328 
    if mtype == TMessageType.EXCEPTION:
1329 
      x = TApplicationException()
1330 
      x.read(self._iprot)
1331 
      self._iprot.readMessageEnd()
1332 
      raise x
483 rajveer 1333 
    result = changeOrderStatus_result()
94 ashish 1334 
    result.read(self._iprot)
1335 
    self._iprot.readMessageEnd()
3431 rajveer 1336 
    if result.success is not None:
94 ashish 1337 
      return result.success
3431 rajveer 1338 
    if result.ex is not None:
94 ashish 1339 
      raise result.ex
483 rajveer 1340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1341 
 
1528 ankur.sing 1342 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1343 
    """
1528 ankur.sing 1344 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1345 
    only user who owns the transaction can view its order details.
3431 rajveer 1346 
 
94 ashish 1347 
    Parameters:
1348 
     - transactionId
1528 ankur.sing 1349 
     - customerId
94 ashish 1350 
    """
1528 ankur.sing 1351 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1352 
    return self.recv_getOrdersForTransaction()
94 ashish 1353 
 
1528 ankur.sing 1354 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1355 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1356 
    args = getOrdersForTransaction_args()
94 ashish 1357 
    args.transactionId = transactionId
1528 ankur.sing 1358 
    args.customerId = customerId
94 ashish 1359 
    args.write(self._oprot)
1360 
    self._oprot.writeMessageEnd()
1361 
    self._oprot.trans.flush()
1362 
 
483 rajveer 1363 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1365 
    if mtype == TMessageType.EXCEPTION:
1366 
      x = TApplicationException()
1367 
      x.read(self._iprot)
1368 
      self._iprot.readMessageEnd()
1369 
      raise x
483 rajveer 1370 
    result = getOrdersForTransaction_result()
94 ashish 1371 
    result.read(self._iprot)
1372 
    self._iprot.readMessageEnd()
3431 rajveer 1373 
    if result.success is not None:
94 ashish 1374 
      return result.success
3431 rajveer 1375 
    if result.ex is not None:
94 ashish 1376 
      raise result.ex
483 rajveer 1377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1378 
 
3014 chandransh 1379 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1380 
    """
3014 chandransh 1381 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1382 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1383 
 
94 ashish 1384 
    Parameters:
483 rajveer 1385 
     - customerId
1386 
     - from_date
1387 
     - to_date
3014 chandransh 1388 
     - statuses
94 ashish 1389 
    """
3014 chandransh 1390 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1391 
    return self.recv_getOrdersForCustomer()
94 ashish 1392 
 
3014 chandransh 1393 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1394 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1395 
    args = getOrdersForCustomer_args()
1396 
    args.customerId = customerId
1397 
    args.from_date = from_date
1398 
    args.to_date = to_date
3014 chandransh 1399 
    args.statuses = statuses
94 ashish 1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
483 rajveer 1404 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
483 rajveer 1411 
    result = getOrdersForCustomer_result()
94 ashish 1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
3431 rajveer 1414 
    if result.success is not None:
94 ashish 1415 
      return result.success
3431 rajveer 1416 
    if result.ex is not None:
94 ashish 1417 
      raise result.ex
483 rajveer 1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1419 
 
483 rajveer 1420 
  def createOrder(self, order):
94 ashish 1421 
    """
1422 
    Parameters:
483 rajveer 1423 
     - order
94 ashish 1424 
    """
483 rajveer 1425 
    self.send_createOrder(order)
1426 
    return self.recv_createOrder()
94 ashish 1427 
 
483 rajveer 1428 
  def send_createOrder(self, order):
1429 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1430 
    args = createOrder_args()
1431 
    args.order = order
94 ashish 1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
483 rajveer 1436 
  def recv_createOrder(self, ):
94 ashish 1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
483 rajveer 1443 
    result = createOrder_result()
94 ashish 1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
3431 rajveer 1446 
    if result.success is not None:
94 ashish 1447 
      return result.success
3431 rajveer 1448 
    if result.ex is not None:
94 ashish 1449 
      raise result.ex
483 rajveer 1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1451 
 
483 rajveer 1452 
  def getOrder(self, id):
94 ashish 1453 
    """
1454 
    Parameters:
483 rajveer 1455 
     - id
94 ashish 1456 
    """
483 rajveer 1457 
    self.send_getOrder(id)
1458 
    return self.recv_getOrder()
94 ashish 1459 
 
483 rajveer 1460 
  def send_getOrder(self, id):
1461 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1462 
    args = getOrder_args()
1463 
    args.id = id
94 ashish 1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
483 rajveer 1468 
  def recv_getOrder(self, ):
94 ashish 1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
483 rajveer 1475 
    result = getOrder_result()
94 ashish 1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
3431 rajveer 1478 
    if result.success is not None:
94 ashish 1479 
      return result.success
3431 rajveer 1480 
    if result.ex is not None:
94 ashish 1481 
      raise result.ex
483 rajveer 1482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1483 
 
483 rajveer 1484 
  def getLineItemsForOrder(self, orderId):
94 ashish 1485 
    """
1486 
    Parameters:
483 rajveer 1487 
     - orderId
94 ashish 1488 
    """
483 rajveer 1489 
    self.send_getLineItemsForOrder(orderId)
1490 
    return self.recv_getLineItemsForOrder()
94 ashish 1491 
 
483 rajveer 1492 
  def send_getLineItemsForOrder(self, orderId):
1493 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1494 
    args = getLineItemsForOrder_args()
1495 
    args.orderId = orderId
94 ashish 1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
483 rajveer 1500 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
483 rajveer 1507 
    result = getLineItemsForOrder_result()
94 ashish 1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
3431 rajveer 1510 
    if result.success is not None:
94 ashish 1511 
      return result.success
3431 rajveer 1512 
    if result.ex is not None:
94 ashish 1513 
      raise result.ex
483 rajveer 1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1515 
 
1528 ankur.sing 1516 
  def getOrderForCustomer(self, orderId, customerId):
1517 
    """
1518 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1519 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1520 
 
1528 ankur.sing 1521 
    Parameters:
1522 
     - orderId
1523 
     - customerId
1524 
    """
1525 
    self.send_getOrderForCustomer(orderId, customerId)
1526 
    return self.recv_getOrderForCustomer()
1527 
 
1528 
  def send_getOrderForCustomer(self, orderId, customerId):
1529 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1530 
    args = getOrderForCustomer_args()
1531 
    args.orderId = orderId
1532 
    args.customerId = customerId
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getOrderForCustomer(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getOrderForCustomer_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
3431 rajveer 1547 
    if result.success is not None:
1528 ankur.sing 1548 
      return result.success
3431 rajveer 1549 
    if result.ex is not None:
1528 ankur.sing 1550 
      raise result.ex
1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1552 
 
3064 chandransh 1553 
  def getAlerts(self, orderId, valid):
1554 
    """
1555 
    Parameters:
1556 
     - orderId
1557 
     - valid
1558 
    """
1559 
    self.send_getAlerts(orderId, valid)
1560 
    return self.recv_getAlerts()
1561 
 
1562 
  def send_getAlerts(self, orderId, valid):
1563 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1564 
    args = getAlerts_args()
1565 
    args.orderId = orderId
1566 
    args.valid = valid
1567 
    args.write(self._oprot)
1568 
    self._oprot.writeMessageEnd()
1569 
    self._oprot.trans.flush()
1570 
 
1571 
  def recv_getAlerts(self, ):
1572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1573 
    if mtype == TMessageType.EXCEPTION:
1574 
      x = TApplicationException()
1575 
      x.read(self._iprot)
1576 
      self._iprot.readMessageEnd()
1577 
      raise x
1578 
    result = getAlerts_result()
1579 
    result.read(self._iprot)
1580 
    self._iprot.readMessageEnd()
3431 rajveer 1581 
    if result.success is not None:
3064 chandransh 1582 
      return result.success
1583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1584 
 
1585 
  def setAlert(self, orderId, unset, type, comment):
1586 
    """
1587 
    Parameters:
1588 
     - orderId
1589 
     - unset
1590 
     - type
1591 
     - comment
1592 
    """
1593 
    self.send_setAlert(orderId, unset, type, comment)
1594 
    self.recv_setAlert()
1595 
 
1596 
  def send_setAlert(self, orderId, unset, type, comment):
1597 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1598 
    args = setAlert_args()
1599 
    args.orderId = orderId
1600 
    args.unset = unset
1601 
    args.type = type
1602 
    args.comment = comment
1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
1607 
  def recv_setAlert(self, ):
1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
1614 
    result = setAlert_result()
1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
1617 
    return
1618 
 
1619 
  def getValidOrderCount(self, ):
1620 
    """
1621 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1622 
    """
1623 
    self.send_getValidOrderCount()
1624 
    return self.recv_getValidOrderCount()
1625 
 
1626 
  def send_getValidOrderCount(self, ):
1627 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1628 
    args = getValidOrderCount_args()
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getValidOrderCount(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getValidOrderCount_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
3064 chandransh 1644 
      return result.success
1645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1646 
 
1647 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1648 
    """
1649 
    Returns the number of distinct customers who have done successful transactions
1650 
    """
1651 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1652 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1653 
 
1654 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1655 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1656 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
1661 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
1668 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
3431 rajveer 1671 
    if result.success is not None:
3064 chandransh 1672 
      return result.success
1673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1674 
 
1675 
  def getValidOrdersAmountRange(self, ):
1676 
    """
1677 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1678 
    List contains two values, first minimum amount and second maximum amount.
1679 
    """
1680 
    self.send_getValidOrdersAmountRange()
1681 
    return self.recv_getValidOrdersAmountRange()
1682 
 
1683 
  def send_getValidOrdersAmountRange(self, ):
1684 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1685 
    args = getValidOrdersAmountRange_args()
1686 
    args.write(self._oprot)
1687 
    self._oprot.writeMessageEnd()
1688 
    self._oprot.trans.flush()
1689 
 
1690 
  def recv_getValidOrdersAmountRange(self, ):
1691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1692 
    if mtype == TMessageType.EXCEPTION:
1693 
      x = TApplicationException()
1694 
      x.read(self._iprot)
1695 
      self._iprot.readMessageEnd()
1696 
      raise x
1697 
    result = getValidOrdersAmountRange_result()
1698 
    result.read(self._iprot)
1699 
    self._iprot.readMessageEnd()
3431 rajveer 1700 
    if result.success is not None:
3064 chandransh 1701 
      return result.success
1702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1703 
 
1704 
  def getValidOrders(self, limit):
1705 
    """
1706 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1707 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1708 
 
3064 chandransh 1709 
    Parameters:
1710 
     - limit
1711 
    """
1712 
    self.send_getValidOrders(limit)
1713 
    return self.recv_getValidOrders()
1714 
 
1715 
  def send_getValidOrders(self, limit):
1716 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1717 
    args = getValidOrders_args()
1718 
    args.limit = limit
1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1723 
  def recv_getValidOrders(self, ):
1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1730 
    result = getValidOrders_result()
1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
3064 chandransh 1734 
      return result.success
1735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1736 
 
1220 chandransh 1737 
  def batchOrders(self, warehouseId):
1738 
    """
1739 
    Create a batch of all the pending orders for the given warehouse.
1740 
    The returned list is orderd by created_timestamp.
1741 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1742 
 
1220 chandransh 1743 
    Parameters:
1744 
     - warehouseId
1745 
    """
1746 
    self.send_batchOrders(warehouseId)
1747 
    return self.recv_batchOrders()
1748 
 
1749 
  def send_batchOrders(self, warehouseId):
1750 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1751 
    args = batchOrders_args()
1752 
    args.warehouseId = warehouseId
1753 
    args.write(self._oprot)
1754 
    self._oprot.writeMessageEnd()
1755 
    self._oprot.trans.flush()
1756 
 
1757 
  def recv_batchOrders(self, ):
1758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1759 
    if mtype == TMessageType.EXCEPTION:
1760 
      x = TApplicationException()
1761 
      x.read(self._iprot)
1762 
      self._iprot.readMessageEnd()
1763 
      raise x
1764 
    result = batchOrders_result()
1765 
    result.read(self._iprot)
1766 
    self._iprot.readMessageEnd()
3431 rajveer 1767 
    if result.success is not None:
1220 chandransh 1768 
      return result.success
3431 rajveer 1769 
    if result.ex is not None:
1220 chandransh 1770 
      raise result.ex
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1772 
 
1208 chandransh 1773 
  def markOrderAsOutOfStock(self, orderId):
1774 
    """
1775 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1776 
 
1208 chandransh 1777 
    Parameters:
1778 
     - orderId
1779 
    """
1780 
    self.send_markOrderAsOutOfStock(orderId)
1781 
    return self.recv_markOrderAsOutOfStock()
1782 
 
1783 
  def send_markOrderAsOutOfStock(self, orderId):
1784 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1785 
    args = markOrderAsOutOfStock_args()
1786 
    args.orderId = orderId
1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_markOrderAsOutOfStock(self, ):
1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1798 
    result = markOrderAsOutOfStock_result()
1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
3431 rajveer 1801 
    if result.success is not None:
1208 chandransh 1802 
      return result.success
3431 rajveer 1803 
    if result.ex is not None:
1208 chandransh 1804 
      raise result.ex
1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1806 
 
3064 chandransh 1807 
  def verifyOrder(self, orderId):
759 chandransh 1808 
    """
3064 chandransh 1809 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1810 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1811 
    used for all other orders as well.
1812 
    Throws an exception if no such order exists.
3431 rajveer 1813 
 
759 chandransh 1814 
    Parameters:
3064 chandransh 1815 
     - orderId
759 chandransh 1816 
    """
3064 chandransh 1817 
    self.send_verifyOrder(orderId)
1818 
    return self.recv_verifyOrder()
759 chandransh 1819 
 
3064 chandransh 1820 
  def send_verifyOrder(self, orderId):
1821 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1822 
    args = verifyOrder_args()
1823 
    args.orderId = orderId
759 chandransh 1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
3064 chandransh 1828 
  def recv_verifyOrder(self, ):
759 chandransh 1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
3064 chandransh 1835 
    result = verifyOrder_result()
759 chandransh 1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
3431 rajveer 1838 
    if result.success is not None:
759 chandransh 1839 
      return result.success
3431 rajveer 1840 
    if result.ex is not None:
759 chandransh 1841 
      raise result.ex
3064 chandransh 1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1843 
 
3064 chandransh 1844 
  def acceptOrder(self, orderId):
1113 chandransh 1845 
    """
3064 chandransh 1846 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1847 
    given order is not a COD order, it also captures the payment if the same has
1848 
    not been captured.
1849 
    Throws an exception if no such order exists.
3431 rajveer 1850 
 
1113 chandransh 1851 
    Parameters:
3064 chandransh 1852 
     - orderId
1113 chandransh 1853 
    """
3064 chandransh 1854 
    self.send_acceptOrder(orderId)
1855 
    return self.recv_acceptOrder()
1113 chandransh 1856 
 
3064 chandransh 1857 
  def send_acceptOrder(self, orderId):
1858 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1859 
    args = acceptOrder_args()
1860 
    args.orderId = orderId
1113 chandransh 1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
3064 chandransh 1865 
  def recv_acceptOrder(self, ):
1113 chandransh 1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
3064 chandransh 1872 
    result = acceptOrder_result()
1113 chandransh 1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
3431 rajveer 1875 
    if result.success is not None:
1113 chandransh 1876 
      return result.success
3431 rajveer 1877 
    if result.ex is not None:
1113 chandransh 1878 
      raise result.ex
3064 chandransh 1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1880 
 
4283 anupam.sin 1881 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1882 
    """
3064 chandransh 1883 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1884 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1885 
    the IMEI no. if a -1 is supplied.
1886 
    Also, it generates an invoice number for the order, marks the order as
1887 
    BILLED and sets the billing timestamp.
1888 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1889 
 
1135 chandransh 1890 
    Parameters:
3064 chandransh 1891 
     - orderId
1892 
     - invoice_number
4283 anupam.sin 1893 
     - imeiNumber
1894 
     - itemNumber
3064 chandransh 1895 
     - billed_by
4264 rajveer 1896 
     - jacketNumber
4283 anupam.sin 1897 
     - billingType
1898 
     - vendorId
1135 chandransh 1899 
    """
4283 anupam.sin 1900 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1901 
    return self.recv_addBillingDetails()
1135 chandransh 1902 
 
4283 anupam.sin 1903 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1904 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1905 
    args = addBillingDetails_args()
1906 
    args.orderId = orderId
1907 
    args.invoice_number = invoice_number
4283 anupam.sin 1908 
    args.imeiNumber = imeiNumber
1909 
    args.itemNumber = itemNumber
3064 chandransh 1910 
    args.billed_by = billed_by
4264 rajveer 1911 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1912 
    args.billingType = billingType
1913 
    args.vendorId = vendorId
1135 chandransh 1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
3064 chandransh 1918 
  def recv_addBillingDetails(self, ):
1135 chandransh 1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
3064 chandransh 1925 
    result = addBillingDetails_result()
1135 chandransh 1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
3431 rajveer 1928 
    if result.success is not None:
3064 chandransh 1929 
      return result.success
3431 rajveer 1930 
    if result.ex is not None:
1135 chandransh 1931 
      raise result.ex
3064 chandransh 1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1933 
 
3064 chandransh 1934 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1935 
    """
3064 chandransh 1936 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1937 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1938 
 
1408 ankur.sing 1939 
    Parameters:
3064 chandransh 1940 
     - warehouseId
1408 ankur.sing 1941 
     - providerId
3064 chandransh 1942 
     - cod
1408 ankur.sing 1943 
    """
3064 chandransh 1944 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1945 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1946 
 
3064 chandransh 1947 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1948 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1949 
    args = markOrdersAsManifested_args()
1950 
    args.warehouseId = warehouseId
1408 ankur.sing 1951 
    args.providerId = providerId
3064 chandransh 1952 
    args.cod = cod
1408 ankur.sing 1953 
    args.write(self._oprot)
1954 
    self._oprot.writeMessageEnd()
1955 
    self._oprot.trans.flush()
1956 
 
3064 chandransh 1957 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1959 
    if mtype == TMessageType.EXCEPTION:
1960 
      x = TApplicationException()
1961 
      x.read(self._iprot)
1962 
      self._iprot.readMessageEnd()
1963 
      raise x
3064 chandransh 1964 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1965 
    result.read(self._iprot)
1966 
    self._iprot.readMessageEnd()
3431 rajveer 1967 
    if result.success is not None:
1408 ankur.sing 1968 
      return result.success
3431 rajveer 1969 
    if result.ex is not None:
3064 chandransh 1970 
      raise result.ex
1971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1972 
 
3064 chandransh 1973 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1974 
    """
3064 chandransh 1975 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1976 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1977 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1978 
 
94 ashish 1979 
    Parameters:
3064 chandransh 1980 
     - providerId
1981 
     - pickupDetails
304 ashish 1982 
    """
3064 chandransh 1983 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1984 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1985 
 
3064 chandransh 1986 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1987 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1988 
    args = markOrdersAsPickedUp_args()
1989 
    args.providerId = providerId
1990 
    args.pickupDetails = pickupDetails
304 ashish 1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
3064 chandransh 1995 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
3064 chandransh 2002 
    result = markOrdersAsPickedUp_result()
304 ashish 2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
3431 rajveer 2005 
    if result.success is not None:
304 ashish 2006 
      return result.success
3431 rajveer 2007 
    if result.ex is not None:
3064 chandransh 2008 
      raise result.ex
2009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2010 
 
3064 chandransh 2011 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2012 
    """
3064 chandransh 2013 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2014 
    the name of the receiver.
2015 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2016 
 
304 ashish 2017 
    Parameters:
3064 chandransh 2018 
     - providerId
2019 
     - deliveredOrders
304 ashish 2020 
    """
3064 chandransh 2021 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2022 
    self.recv_markOrdersAsDelivered()
304 ashish 2023 
 
3064 chandransh 2024 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2025 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2026 
    args = markOrdersAsDelivered_args()
2027 
    args.providerId = providerId
2028 
    args.deliveredOrders = deliveredOrders
304 ashish 2029 
    args.write(self._oprot)
2030 
    self._oprot.writeMessageEnd()
2031 
    self._oprot.trans.flush()
2032 
 
3064 chandransh 2033 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2035 
    if mtype == TMessageType.EXCEPTION:
2036 
      x = TApplicationException()
2037 
      x.read(self._iprot)
2038 
      self._iprot.readMessageEnd()
2039 
      raise x
3064 chandransh 2040 
    result = markOrdersAsDelivered_result()
304 ashish 2041 
    result.read(self._iprot)
2042 
    self._iprot.readMessageEnd()
3431 rajveer 2043 
    if result.ex is not None:
3064 chandransh 2044 
      raise result.ex
304 ashish 2045 
    return
2046 
 
3064 chandransh 2047 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2048 
    """
3064 chandransh 2049 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2050 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2051 
 
3064 chandransh 2052 
    Parameters:
2053 
     - providerId
2054 
     - returnedOrders
1596 ankur.sing 2055 
    """
3064 chandransh 2056 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2057 
    self.recv_markOrdersAsFailed()
304 ashish 2058 
 
3064 chandransh 2059 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2060 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2061 
    args = markOrdersAsFailed_args()
2062 
    args.providerId = providerId
2063 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
3064 chandransh 2068 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
3064 chandransh 2075 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
3431 rajveer 2078 
    if result.ex is not None:
3064 chandransh 2079 
      raise result.ex
2080 
    return
1596 ankur.sing 2081 
 
3064 chandransh 2082 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2083 
    """
3064 chandransh 2084 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2085 
 
3064 chandransh 2086 
    Parameters:
2087 
     - providerId
2088 
     - undeliveredOrders
1627 ankur.sing 2089 
    """
3064 chandransh 2090 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2091 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2092 
 
3064 chandransh 2093 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2094 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2095 
    args = updateNonDeliveryReason_args()
2096 
    args.providerId = providerId
2097 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
3064 chandransh 2102 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
3064 chandransh 2109 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
3431 rajveer 2112 
    if result.ex is not None:
3064 chandransh 2113 
      raise result.ex
2114 
    return
1627 ankur.sing 2115 
 
3064 chandransh 2116 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2117 
    """
3064 chandransh 2118 
    Returns the list of orders whose delivery time has passed but have not been
2119 
    delivered yet for the given provider and warehouse. To get a complete list of
2120 
    undelivered orders, pass them as -1.
2121 
    Returns an empty list if no such orders exist.
3431 rajveer 2122 
 
1886 ankur.sing 2123 
    Parameters:
3064 chandransh 2124 
     - providerId
2125 
     - warehouseId
1886 ankur.sing 2126 
    """
3064 chandransh 2127 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2128 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2129 
 
3064 chandransh 2130 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2131 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2132 
    args = getUndeliveredOrders_args()
2133 
    args.providerId = providerId
2134 
    args.warehouseId = warehouseId
1886 ankur.sing 2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
3064 chandransh 2139 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
3064 chandransh 2146 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
3431 rajveer 2149 
    if result.success is not None:
1886 ankur.sing 2150 
      return result.success
3064 chandransh 2151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2152 
 
2536 chandransh 2153 
  def toggleDOAFlag(self, orderId):
2154 
    """
2155 
    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.
2156 
    Returns the final flag status.
2157 
    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 2158 
 
2536 chandransh 2159 
    Parameters:
2160 
     - orderId
2161 
    """
2162 
    self.send_toggleDOAFlag(orderId)
2163 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2164 
 
2536 chandransh 2165 
  def send_toggleDOAFlag(self, orderId):
2166 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2167 
    args = toggleDOAFlag_args()
2168 
    args.orderId = orderId
2169 
    args.write(self._oprot)
2170 
    self._oprot.writeMessageEnd()
2171 
    self._oprot.trans.flush()
2172 
 
2173 
  def recv_toggleDOAFlag(self, ):
2174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2175 
    if mtype == TMessageType.EXCEPTION:
2176 
      x = TApplicationException()
2177 
      x.read(self._iprot)
2178 
      self._iprot.readMessageEnd()
2179 
      raise x
2180 
    result = toggleDOAFlag_result()
2181 
    result.read(self._iprot)
2182 
    self._iprot.readMessageEnd()
3431 rajveer 2183 
    if result.success is not None:
2536 chandransh 2184 
      return result.success
3431 rajveer 2185 
    if result.ex is not None:
2536 chandransh 2186 
      raise result.ex
2187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2188 
 
2189 
  def requestPickupNumber(self, orderId):
2190 
    """
2191 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2192 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2193 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2194 
    For any other status, it returns false.
2195 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2196 
 
2536 chandransh 2197 
    Parameters:
2198 
     - orderId
2199 
    """
2200 
    self.send_requestPickupNumber(orderId)
2201 
    return self.recv_requestPickupNumber()
2202 
 
2203 
  def send_requestPickupNumber(self, orderId):
2204 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2205 
    args = requestPickupNumber_args()
2206 
    args.orderId = orderId
2207 
    args.write(self._oprot)
2208 
    self._oprot.writeMessageEnd()
2209 
    self._oprot.trans.flush()
2210 
 
2211 
  def recv_requestPickupNumber(self, ):
2212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2213 
    if mtype == TMessageType.EXCEPTION:
2214 
      x = TApplicationException()
2215 
      x.read(self._iprot)
2216 
      self._iprot.readMessageEnd()
2217 
      raise x
2218 
    result = requestPickupNumber_result()
2219 
    result.read(self._iprot)
2220 
    self._iprot.readMessageEnd()
3431 rajveer 2221 
    if result.success is not None:
2536 chandransh 2222 
      return result.success
3431 rajveer 2223 
    if result.ex is not None:
2536 chandransh 2224 
      raise result.ex
2225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2226 
 
2227 
  def authorizePickup(self, orderId, pickupNumber):
2228 
    """
2229 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2230 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2231 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2232 
    	3. Returns true
2591 chandransh 2233 
    If the order is in any other status, it returns false.
2536 chandransh 2234 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2235 
 
2536 chandransh 2236 
    Parameters:
2237 
     - orderId
2238 
     - pickupNumber
2239 
    """
2240 
    self.send_authorizePickup(orderId, pickupNumber)
2241 
    return self.recv_authorizePickup()
2242 
 
2243 
  def send_authorizePickup(self, orderId, pickupNumber):
2244 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2245 
    args = authorizePickup_args()
2246 
    args.orderId = orderId
2247 
    args.pickupNumber = pickupNumber
2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
2252 
  def recv_authorizePickup(self, ):
2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
2259 
    result = authorizePickup_result()
2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
3431 rajveer 2262 
    if result.success is not None:
2536 chandransh 2263 
      return result.success
3431 rajveer 2264 
    if result.ex is not None:
2536 chandransh 2265 
      raise result.ex
2266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2267 
 
2764 chandransh 2268 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2269 
    """
2270 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2271 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2272 
 
2764 chandransh 2273 
    Parameters:
2274 
     - providerId
2275 
     - pickupDetails
2276 
    """
2277 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2278 
    return self.recv_markDoasAsPickedUp()
2279 
 
2280 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2281 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2282 
    args = markDoasAsPickedUp_args()
2283 
    args.providerId = providerId
2284 
    args.pickupDetails = pickupDetails
2285 
    args.write(self._oprot)
2286 
    self._oprot.writeMessageEnd()
2287 
    self._oprot.trans.flush()
2288 
 
2289 
  def recv_markDoasAsPickedUp(self, ):
2290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2291 
    if mtype == TMessageType.EXCEPTION:
2292 
      x = TApplicationException()
2293 
      x.read(self._iprot)
2294 
      self._iprot.readMessageEnd()
2295 
      raise x
2296 
    result = markDoasAsPickedUp_result()
2297 
    result.read(self._iprot)
2298 
    self._iprot.readMessageEnd()
3431 rajveer 2299 
    if result.success is not None:
2764 chandransh 2300 
      return result.success
2301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2302 
 
2616 chandransh 2303 
  def receiveReturn(self, orderId):
2591 chandransh 2304 
    """
2599 chandransh 2305 
    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 2306 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2307 
    If the order is in any other state, it returns false.
2308 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2309 
 
2591 chandransh 2310 
    Parameters:
2311 
     - orderId
2312 
    """
2616 chandransh 2313 
    self.send_receiveReturn(orderId)
2314 
    return self.recv_receiveReturn()
2536 chandransh 2315 
 
2616 chandransh 2316 
  def send_receiveReturn(self, orderId):
2317 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2318 
    args = receiveReturn_args()
2591 chandransh 2319 
    args.orderId = orderId
2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
2616 chandransh 2324 
  def recv_receiveReturn(self, ):
2591 chandransh 2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
2616 chandransh 2331 
    result = receiveReturn_result()
2591 chandransh 2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
3431 rajveer 2334 
    if result.success is not None:
2591 chandransh 2335 
      return result.success
3431 rajveer 2336 
    if result.ex is not None:
2591 chandransh 2337 
      raise result.ex
2616 chandransh 2338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2339 
 
2340 
  def validateDoa(self, orderId, isValid):
2341 
    """
2599 chandransh 2342 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2343 
    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 2344 
    If the order is in any other state, it returns false.
2345 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2346 
 
2591 chandransh 2347 
    Parameters:
2348 
     - orderId
2349 
     - isValid
2350 
    """
2351 
    self.send_validateDoa(orderId, isValid)
2352 
    return self.recv_validateDoa()
2353 
 
2354 
  def send_validateDoa(self, orderId, isValid):
2355 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2356 
    args = validateDoa_args()
2357 
    args.orderId = orderId
2358 
    args.isValid = isValid
2359 
    args.write(self._oprot)
2360 
    self._oprot.writeMessageEnd()
2361 
    self._oprot.trans.flush()
2362 
 
2363 
  def recv_validateDoa(self, ):
2364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2365 
    if mtype == TMessageType.EXCEPTION:
2366 
      x = TApplicationException()
2367 
      x.read(self._iprot)
2368 
      self._iprot.readMessageEnd()
2369 
      raise x
2370 
    result = validateDoa_result()
2371 
    result.read(self._iprot)
2372 
    self._iprot.readMessageEnd()
3431 rajveer 2373 
    if result.success is not None:
2591 chandransh 2374 
      return result.success
3431 rajveer 2375 
    if result.ex is not None:
2591 chandransh 2376 
      raise result.ex
2377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2378 
 
2616 chandransh 2379 
  def reshipOrder(self, orderId):
2380 
    """
2381 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2382 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2383 
    	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.
2384 
 
2385 
    If the order is in DOA_CERT_VALID state, it does the following:
2386 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2387 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2388 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2389 
 
2616 chandransh 2390 
    Returns the id of the newly created order.
3431 rajveer 2391 
 
2616 chandransh 2392 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2393 
 
2616 chandransh 2394 
    Parameters:
2395 
     - orderId
2396 
    """
2397 
    self.send_reshipOrder(orderId)
2398 
    return self.recv_reshipOrder()
2591 chandransh 2399 
 
2616 chandransh 2400 
  def send_reshipOrder(self, orderId):
2401 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2402 
    args = reshipOrder_args()
2403 
    args.orderId = orderId
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_reshipOrder(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = reshipOrder_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
3431 rajveer 2418 
    if result.success is not None:
2616 chandransh 2419 
      return result.success
3431 rajveer 2420 
    if result.ex is not None:
2616 chandransh 2421 
      raise result.ex
2422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2423 
 
3226 chandransh 2424 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2425 
    """
2426 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2427 
    	1. Creates a refund request for batch processing.
2428 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2429 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2430 
 
2616 chandransh 2431 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2432 
    	1. Creates a refund request for batch processing.
3226 chandransh 2433 
    	2. Cancels the reservation of the item in the warehouse.
2434 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2435 
 
3226 chandransh 2436 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2437 
    	1. Cancels the reservation of the item in the warehouse.
2438 
    	2. Marks the current order as CANCELED.
2439 
 
2440 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2441 
 
2616 chandransh 2442 
    Returns True if it is successful, False otherwise.
3431 rajveer 2443 
 
2616 chandransh 2444 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2445 
 
2616 chandransh 2446 
    Parameters:
2447 
     - orderId
3226 chandransh 2448 
     - refundedBy
2449 
     - reason
2616 chandransh 2450 
    """
3226 chandransh 2451 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2452 
    return self.recv_refundOrder()
2453 
 
3226 chandransh 2454 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2455 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2456 
    args = refundOrder_args()
2457 
    args.orderId = orderId
3226 chandransh 2458 
    args.refundedBy = refundedBy
2459 
    args.reason = reason
2616 chandransh 2460 
    args.write(self._oprot)
2461 
    self._oprot.writeMessageEnd()
2462 
    self._oprot.trans.flush()
2463 
 
2464 
  def recv_refundOrder(self, ):
2465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2466 
    if mtype == TMessageType.EXCEPTION:
2467 
      x = TApplicationException()
2468 
      x.read(self._iprot)
2469 
      self._iprot.readMessageEnd()
2470 
      raise x
2471 
    result = refundOrder_result()
2472 
    result.read(self._iprot)
2473 
    self._iprot.readMessageEnd()
3431 rajveer 2474 
    if result.success is not None:
2616 chandransh 2475 
      return result.success
3431 rajveer 2476 
    if result.ex is not None:
2616 chandransh 2477 
      raise result.ex
2478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2479 
 
2690 chandransh 2480 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2481 
    """
2482 
    Get all return orders created between the from and to dates for the given warehouse.
2483 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2484 
 
2690 chandransh 2485 
    Parameters:
2486 
     - warehouseId
2487 
     - fromDate
2488 
     - toDate
2489 
    """
2490 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2491 
    return self.recv_getReturnOrders()
2616 chandransh 2492 
 
2690 chandransh 2493 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2494 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2495 
    args = getReturnOrders_args()
2496 
    args.warehouseId = warehouseId
2497 
    args.fromDate = fromDate
2498 
    args.toDate = toDate
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_getReturnOrders(self, ):
2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
2510 
    result = getReturnOrders_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
3431 rajveer 2513 
    if result.success is not None:
2690 chandransh 2514 
      return result.success
2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2516 
 
2700 chandransh 2517 
  def getReturnOrder(self, id):
2518 
    """
2519 
    Returns the ReturnOrder corresponding to the given id.
2520 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2521 
 
2700 chandransh 2522 
    Parameters:
2523 
     - id
2524 
    """
2525 
    self.send_getReturnOrder(id)
2526 
    return self.recv_getReturnOrder()
2527 
 
2528 
  def send_getReturnOrder(self, id):
2529 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2530 
    args = getReturnOrder_args()
2531 
    args.id = id
2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
2536 
  def recv_getReturnOrder(self, ):
2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
2543 
    result = getReturnOrder_result()
2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
3431 rajveer 2546 
    if result.success is not None:
2700 chandransh 2547 
      return result.success
3431 rajveer 2548 
    if result.ex is not None:
2700 chandransh 2549 
      raise result.ex
2550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2551 
 
2690 chandransh 2552 
  def processReturn(self, returnOrderId):
2553 
    """
2554 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2555 
 
2690 chandransh 2556 
    Parameters:
2557 
     - returnOrderId
2558 
    """
2559 
    self.send_processReturn(returnOrderId)
2560 
    self.recv_processReturn()
2561 
 
2562 
  def send_processReturn(self, returnOrderId):
2563 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2564 
    args = processReturn_args()
2565 
    args.returnOrderId = returnOrderId
2566 
    args.write(self._oprot)
2567 
    self._oprot.writeMessageEnd()
2568 
    self._oprot.trans.flush()
2569 
 
2570 
  def recv_processReturn(self, ):
2571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2572 
    if mtype == TMessageType.EXCEPTION:
2573 
      x = TApplicationException()
2574 
      x.read(self._iprot)
2575 
      self._iprot.readMessageEnd()
2576 
      raise x
2577 
    result = processReturn_result()
2578 
    result.read(self._iprot)
2579 
    self._iprot.readMessageEnd()
3431 rajveer 2580 
    if result.ex is not None:
2690 chandransh 2581 
      raise result.ex
2582 
    return
2583 
 
2819 chandransh 2584 
  def createPurchaseOrder(self, warehouseId):
2585 
    """
2586 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2587 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2588 
 
2819 chandransh 2589 
    Parameters:
2590 
     - warehouseId
2591 
    """
2592 
    self.send_createPurchaseOrder(warehouseId)
2593 
    return self.recv_createPurchaseOrder()
2690 chandransh 2594 
 
2819 chandransh 2595 
  def send_createPurchaseOrder(self, warehouseId):
2596 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2597 
    args = createPurchaseOrder_args()
2598 
    args.warehouseId = warehouseId
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_createPurchaseOrder(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = createPurchaseOrder_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.success is not None:
2819 chandransh 2614 
      return result.success
3431 rajveer 2615 
    if result.ex is not None:
2819 chandransh 2616 
      raise result.ex
2617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2618 
 
3451 chandransh 2619 
  def updateWeight(self, orderId, weight):
2620 
    """
2621 
    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 2622 
 
3451 chandransh 2623 
    Parameters:
2624 
     - orderId
2625 
     - weight
2626 
    """
2627 
    self.send_updateWeight(orderId, weight)
2628 
    return self.recv_updateWeight()
2629 
 
2630 
  def send_updateWeight(self, orderId, weight):
2631 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2632 
    args = updateWeight_args()
2633 
    args.orderId = orderId
2634 
    args.weight = weight
2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
2639 
  def recv_updateWeight(self, ):
2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
2646 
    result = updateWeight_result()
2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
2649 
    if result.success is not None:
2650 
      return result.success
2651 
    if result.ex is not None:
2652 
      raise result.ex
2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2654 
 
3469 chandransh 2655 
  def changeItem(self, orderId, itemId):
2656 
    """
2657 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2658 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2659 
 
3469 chandransh 2660 
    Parameters:
2661 
     - orderId
2662 
     - itemId
2663 
    """
2664 
    self.send_changeItem(orderId, itemId)
2665 
    return self.recv_changeItem()
2666 
 
2667 
  def send_changeItem(self, orderId, itemId):
2668 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2669 
    args = changeItem_args()
2670 
    args.orderId = orderId
2671 
    args.itemId = itemId
2672 
    args.write(self._oprot)
2673 
    self._oprot.writeMessageEnd()
2674 
    self._oprot.trans.flush()
2675 
 
2676 
  def recv_changeItem(self, ):
2677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2678 
    if mtype == TMessageType.EXCEPTION:
2679 
      x = TApplicationException()
2680 
      x.read(self._iprot)
2681 
      self._iprot.readMessageEnd()
2682 
      raise x
2683 
    result = changeItem_result()
2684 
    result.read(self._iprot)
2685 
    self._iprot.readMessageEnd()
2686 
    if result.success is not None:
2687 
      return result.success
2688 
    if result.ex is not None:
2689 
      raise result.ex
2690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2691 
 
2692 
  def shiftToWarehouse(self, orderId, warehouseId):
2693 
    """
2694 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2695 
 
2696 
    Parameters:
2697 
     - orderId
2698 
     - warehouseId
2699 
    """
2700 
    self.send_shiftToWarehouse(orderId, warehouseId)
2701 
    return self.recv_shiftToWarehouse()
2702 
 
2703 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2704 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2705 
    args = shiftToWarehouse_args()
2706 
    args.orderId = orderId
2707 
    args.warehouseId = warehouseId
2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_shiftToWarehouse(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = shiftToWarehouse_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    if result.success is not None:
2723 
      return result.success
2724 
    if result.ex is not None:
2725 
      raise result.ex
2726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2727 
 
3986 chandransh 2728 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2729 
    """
2730 
    Adds the given delay reason to the given order.
3986 chandransh 2731 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2732 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2733 
 
3553 chandransh 2734 
    Parameters:
2735 
     - orderId
2736 
     - delayReason
3986 chandransh 2737 
     - furtherDelay
3553 chandransh 2738 
    """
3986 chandransh 2739 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2740 
    return self.recv_addDelayReason()
2741 
 
3986 chandransh 2742 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2743 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2744 
    args = addDelayReason_args()
2745 
    args.orderId = orderId
2746 
    args.delayReason = delayReason
3986 chandransh 2747 
    args.furtherDelay = furtherDelay
3553 chandransh 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
2752 
  def recv_addDelayReason(self, ):
2753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2754 
    if mtype == TMessageType.EXCEPTION:
2755 
      x = TApplicationException()
2756 
      x.read(self._iprot)
2757 
      self._iprot.readMessageEnd()
2758 
      raise x
2759 
    result = addDelayReason_result()
2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
2762 
    if result.success is not None:
2763 
      return result.success
2764 
    if result.ex is not None:
2765 
      raise result.ex
2766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2767 
 
3956 chandransh 2768 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2769 
    """
2770 
    Marks the COD orders with given AWB nos. as having been processed.
2771 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2772 
 
3956 chandransh 2773 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2774 
    1. There is no order corresponding to an AWB number.
2775 
    2. The captured amount for a payment exceeds the total payment.
2776 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2777 
 
2778 
    Parameters:
2779 
     - collectedAmountMap
2780 
     - xferBy
2781 
     - xferTxnId
2782 
     - xferDate
2783 
    """
2784 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2785 
    return self.recv_reconcileCodCollection()
2786 
 
2787 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2788 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2789 
    args = reconcileCodCollection_args()
2790 
    args.collectedAmountMap = collectedAmountMap
2791 
    args.xferBy = xferBy
2792 
    args.xferTxnId = xferTxnId
2793 
    args.xferDate = xferDate
2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2798 
  def recv_reconcileCodCollection(self, ):
2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
2805 
    result = reconcileCodCollection_result()
2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
2808 
    if result.success is not None:
2809 
      return result.success
2810 
    if result.ex is not None:
2811 
      raise result.ex
2812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2813 
 
4008 mandeep.dh 2814 
  def getTransactionsRequiringExtraProcessing(self, category):
2815 
    """
4065 mandeep.dh 2816 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2817 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2818 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2819 
 
4008 mandeep.dh 2820 
    Parameters:
2821 
     - category
2822 
    """
2823 
    self.send_getTransactionsRequiringExtraProcessing(category)
2824 
    return self.recv_getTransactionsRequiringExtraProcessing()
2825 
 
2826 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2827 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2828 
    args = getTransactionsRequiringExtraProcessing_args()
2829 
    args.category = category
2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2834 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2841 
    result = getTransactionsRequiringExtraProcessing_result()
2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    if result.success is not None:
2845 
      return result.success
2846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2847 
 
2848 
  def markTransactionAsProcessed(self, transactionId, category):
2849 
    """
2850 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2851 
    It essentially deletes the transaction id record for a particular
2852 
    processing type category (if present) from DB.
2853 
    This is currently used by CRM application.
4008 mandeep.dh 2854 
 
2855 
    Parameters:
2856 
     - transactionId
2857 
     - category
2858 
    """
2859 
    self.send_markTransactionAsProcessed(transactionId, category)
2860 
    self.recv_markTransactionAsProcessed()
2861 
 
2862 
  def send_markTransactionAsProcessed(self, transactionId, category):
2863 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2864 
    args = markTransactionAsProcessed_args()
2865 
    args.transactionId = transactionId
2866 
    args.category = category
2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
2871 
  def recv_markTransactionAsProcessed(self, ):
2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
2878 
    result = markTransactionAsProcessed_result()
2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
2881 
    return
2882 
 
4018 chandransh 2883 
  def getItemWiseRiskyOrdersCount(self, ):
2884 
    """
2885 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2886 
    is defined as one whose shipping date is about to expire.
2887 
    """
2888 
    self.send_getItemWiseRiskyOrdersCount()
2889 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2890 
 
4018 chandransh 2891 
  def send_getItemWiseRiskyOrdersCount(self, ):
2892 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2893 
    args = getItemWiseRiskyOrdersCount_args()
2894 
    args.write(self._oprot)
2895 
    self._oprot.writeMessageEnd()
2896 
    self._oprot.trans.flush()
2897 
 
2898 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2900 
    if mtype == TMessageType.EXCEPTION:
2901 
      x = TApplicationException()
2902 
      x.read(self._iprot)
2903 
      self._iprot.readMessageEnd()
2904 
      raise x
2905 
    result = getItemWiseRiskyOrdersCount_result()
2906 
    result.read(self._iprot)
2907 
    self._iprot.readMessageEnd()
2908 
    if result.success is not None:
2909 
      return result.success
2910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2911 
 
4295 varun.gupt 2912 
  def getOrdersForItemIds(self, itemIds):
2913 
    """
2914 
    Returns a list of all orders which have items with given id
2915 
 
2916 
    Parameters:
2917 
     - itemIds
2918 
    """
2919 
    self.send_getOrdersForItemIds(itemIds)
2920 
    return self.recv_getOrdersForItemIds()
2921 
 
2922 
  def send_getOrdersForItemIds(self, itemIds):
2923 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2924 
    args = getOrdersForItemIds_args()
2925 
    args.itemIds = itemIds
2926 
    args.write(self._oprot)
2927 
    self._oprot.writeMessageEnd()
2928 
    self._oprot.trans.flush()
2929 
 
2930 
  def recv_getOrdersForItemIds(self, ):
2931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2932 
    if mtype == TMessageType.EXCEPTION:
2933 
      x = TApplicationException()
2934 
      x.read(self._iprot)
2935 
      self._iprot.readMessageEnd()
2936 
      raise x
2937 
    result = getOrdersForItemIds_result()
2938 
    result.read(self._iprot)
2939 
    self._iprot.readMessageEnd()
2940 
    if result.success is not None:
2941 
      return result.success
2942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2943 
 
4247 rajveer 2944 
  def markOrderCancellationRequestReceived(self, orderId):
2945 
    """
2946 
    Mark order as cancellation request received. If customer sends request of cancellation of
2947 
    a particular order, this method will be called. It will just change status of the order
2948 
    depending on its current status. It also records the previous status, so that we can move
2949 
    back to that status if cancellation request is denied.
4018 chandransh 2950 
 
4247 rajveer 2951 
    Parameters:
2952 
     - orderId
2953 
    """
2954 
    self.send_markOrderCancellationRequestReceived(orderId)
2955 
    self.recv_markOrderCancellationRequestReceived()
2956 
 
2957 
  def send_markOrderCancellationRequestReceived(self, orderId):
2958 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2959 
    args = markOrderCancellationRequestReceived_args()
2960 
    args.orderId = orderId
2961 
    args.write(self._oprot)
2962 
    self._oprot.writeMessageEnd()
2963 
    self._oprot.trans.flush()
2964 
 
2965 
  def recv_markOrderCancellationRequestReceived(self, ):
2966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2967 
    if mtype == TMessageType.EXCEPTION:
2968 
      x = TApplicationException()
2969 
      x.read(self._iprot)
2970 
      self._iprot.readMessageEnd()
2971 
      raise x
2972 
    result = markOrderCancellationRequestReceived_result()
2973 
    result.read(self._iprot)
2974 
    self._iprot.readMessageEnd()
2975 
    if result.ex is not None:
2976 
      raise result.ex
2977 
    return
2978 
 
2979 
  def markOrderCancellationRequestConfirmed(self, orderId):
2980 
    """
2981 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2982 
    cancellation request confirmed. After this OM will be able to cancel the order.
2983 
 
2984 
    Parameters:
2985 
     - orderId
2986 
    """
2987 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2988 
    self.recv_markOrderCancellationRequestConfirmed()
2989 
 
2990 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2991 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2992 
    args = markOrderCancellationRequestConfirmed_args()
2993 
    args.orderId = orderId
2994 
    args.write(self._oprot)
2995 
    self._oprot.writeMessageEnd()
2996 
    self._oprot.trans.flush()
2997 
 
2998 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3000 
    if mtype == TMessageType.EXCEPTION:
3001 
      x = TApplicationException()
3002 
      x.read(self._iprot)
3003 
      self._iprot.readMessageEnd()
3004 
      raise x
3005 
    result = markOrderCancellationRequestConfirmed_result()
3006 
    result.read(self._iprot)
3007 
    self._iprot.readMessageEnd()
3008 
    if result.ex is not None:
3009 
      raise result.ex
3010 
    return
3011 
 
3012 
  def markOrderCancellationRequestDenied(self, orderId):
3013 
    """
3014 
    If we decide to not to cancel order, we will move the order ro previous status.
3015 
 
3016 
    Parameters:
3017 
     - orderId
3018 
    """
3019 
    self.send_markOrderCancellationRequestDenied(orderId)
3020 
    self.recv_markOrderCancellationRequestDenied()
3021 
 
3022 
  def send_markOrderCancellationRequestDenied(self, orderId):
3023 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3024 
    args = markOrderCancellationRequestDenied_args()
3025 
    args.orderId = orderId
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_markOrderCancellationRequestDenied(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = markOrderCancellationRequestDenied_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3040 
    if result.ex is not None:
3041 
      raise result.ex
3042 
    return
3043 
 
4258 rajveer 3044 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3045 
    """
4258 rajveer 3046 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3047 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3048 
 
3049 
    Parameters:
4258 rajveer 3050 
     - transactionId
4247 rajveer 3051 
    """
4258 rajveer 3052 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3053 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3054 
 
4258 rajveer 3055 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3056 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3057 
    args = markTransactionAsPaymentFlagRemoved_args()
3058 
    args.transactionId = transactionId
4247 rajveer 3059 
    args.write(self._oprot)
3060 
    self._oprot.writeMessageEnd()
3061 
    self._oprot.trans.flush()
3062 
 
4258 rajveer 3063 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3065 
    if mtype == TMessageType.EXCEPTION:
3066 
      x = TApplicationException()
3067 
      x.read(self._iprot)
3068 
      self._iprot.readMessageEnd()
3069 
      raise x
4258 rajveer 3070 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3071 
    result.read(self._iprot)
3072 
    self._iprot.readMessageEnd()
3073 
    if result.ex is not None:
3074 
      raise result.ex
3075 
    return
3076 
 
4259 anupam.sin 3077 
  def refundTransaction(self, transactionId, refundedBy, reason):
3078 
    """
3079 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3080 
    need to be cancelled
4247 rajveer 3081 
 
4259 anupam.sin 3082 
    Parameters:
3083 
     - transactionId
3084 
     - refundedBy
3085 
     - reason
3086 
    """
3087 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3088 
    self.recv_refundTransaction()
3089 
 
3090 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3091 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3092 
    args = refundTransaction_args()
3093 
    args.transactionId = transactionId
3094 
    args.refundedBy = refundedBy
3095 
    args.reason = reason
3096 
    args.write(self._oprot)
3097 
    self._oprot.writeMessageEnd()
3098 
    self._oprot.trans.flush()
3099 
 
3100 
  def recv_refundTransaction(self, ):
3101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3102 
    if mtype == TMessageType.EXCEPTION:
3103 
      x = TApplicationException()
3104 
      x.read(self._iprot)
3105 
      self._iprot.readMessageEnd()
3106 
      raise x
3107 
    result = refundTransaction_result()
3108 
    result.read(self._iprot)
3109 
    self._iprot.readMessageEnd()
3110 
    if result.ex is not None:
3111 
      raise result.ex
3112 
    return
3113 
 
4324 mandeep.dh 3114 
  def updateShipmentAddress(self, orderId, addressId):
3115 
    """
3116 
    Updates shipment address of an order. Delivery and shipping date estimates
3117 
    etc. are also updated here.
3118 
 
3119 
    Throws TransactionServiceException in case address change is not
3120 
    possible due to certain reasons such as new pincode in address is
3121 
    not serviceable etc.
3122 
 
3123 
    Parameters:
3124 
     - orderId
3125 
     - addressId
3126 
    """
3127 
    self.send_updateShipmentAddress(orderId, addressId)
3128 
    self.recv_updateShipmentAddress()
3129 
 
3130 
  def send_updateShipmentAddress(self, orderId, addressId):
3131 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3132 
    args = updateShipmentAddress_args()
3133 
    args.orderId = orderId
3134 
    args.addressId = addressId
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_updateShipmentAddress(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = updateShipmentAddress_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.ex is not None:
3150 
      raise result.ex
3151 
    return
3152 
 
4285 rajveer 3153 
  def acceptOrdersForItemId(self, itemId, inventory):
3154 
    """
3155 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3156 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3157 
 
4285 rajveer 3158 
    Parameters:
3159 
     - itemId
3160 
     - inventory
3161 
    """
3162 
    self.send_acceptOrdersForItemId(itemId, inventory)
3163 
    return self.recv_acceptOrdersForItemId()
3164 
 
3165 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3166 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3167 
    args = acceptOrdersForItemId_args()
3168 
    args.itemId = itemId
3169 
    args.inventory = inventory
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_acceptOrdersForItemId(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = acceptOrdersForItemId_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3184 
    if result.success is not None:
3185 
      return result.success
3186 
    if result.ex is not None:
3187 
      raise result.ex
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3189 
 
4369 rajveer 3190 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3191 
    """
3192 
    Parameters:
3193 
     - vendorId
3194 
     - itemId
3195 
     - quantity
3196 
     - estimate
4369 rajveer 3197 
     - isReminder
4303 rajveer 3198 
    """
4369 rajveer 3199 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3200 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3201 
 
4369 rajveer 3202 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3203 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3204 
    args = markOrdersAsPORaised_args()
3205 
    args.vendorId = vendorId
3206 
    args.itemId = itemId
3207 
    args.quantity = quantity
3208 
    args.estimate = estimate
4369 rajveer 3209 
    args.isReminder = isReminder
4303 rajveer 3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_markOrdersAsPORaised(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = markOrdersAsPORaised_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.ex is not None:
3225 
      raise result.ex
3226 
    return
3227 
 
4369 rajveer 3228 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3229 
    """
3230 
    Parameters:
3231 
     - vendorId
3232 
     - itemId
3233 
     - quantity
3234 
     - estimate
4369 rajveer 3235 
     - isReminder
4303 rajveer 3236 
    """
4369 rajveer 3237 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3238 
    self.recv_markOrdersAsReversalInitiated()
3239 
 
4369 rajveer 3240 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3241 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3242 
    args = markOrdersAsReversalInitiated_args()
3243 
    args.vendorId = vendorId
3244 
    args.itemId = itemId
3245 
    args.quantity = quantity
3246 
    args.estimate = estimate
4369 rajveer 3247 
    args.isReminder = isReminder
4303 rajveer 3248 
    args.write(self._oprot)
3249 
    self._oprot.writeMessageEnd()
3250 
    self._oprot.trans.flush()
3251 
 
3252 
  def recv_markOrdersAsReversalInitiated(self, ):
3253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3254 
    if mtype == TMessageType.EXCEPTION:
3255 
      x = TApplicationException()
3256 
      x.read(self._iprot)
3257 
      self._iprot.readMessageEnd()
3258 
      raise x
3259 
    result = markOrdersAsReversalInitiated_result()
3260 
    result.read(self._iprot)
3261 
    self._iprot.readMessageEnd()
3262 
    if result.ex is not None:
3263 
      raise result.ex
3264 
    return
3265 
 
4369 rajveer 3266 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3267 
    """
3268 
    Parameters:
3269 
     - vendorId
3270 
     - itemId
3271 
     - quantity
3272 
     - estimate
4369 rajveer 3273 
     - isReminder
4303 rajveer 3274 
    """
4369 rajveer 3275 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3276 
    self.recv_markOrdersAsNotAvailabke()
3277 
 
4369 rajveer 3278 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3279 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3280 
    args = markOrdersAsNotAvailabke_args()
3281 
    args.vendorId = vendorId
3282 
    args.itemId = itemId
3283 
    args.quantity = quantity
3284 
    args.estimate = estimate
4369 rajveer 3285 
    args.isReminder = isReminder
4303 rajveer 3286 
    args.write(self._oprot)
3287 
    self._oprot.writeMessageEnd()
3288 
    self._oprot.trans.flush()
3289 
 
3290 
  def recv_markOrdersAsNotAvailabke(self, ):
3291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3292 
    if mtype == TMessageType.EXCEPTION:
3293 
      x = TApplicationException()
3294 
      x.read(self._iprot)
3295 
      self._iprot.readMessageEnd()
3296 
      raise x
3297 
    result = markOrdersAsNotAvailabke_result()
3298 
    result.read(self._iprot)
3299 
    self._iprot.readMessageEnd()
3300 
    if result.ex is not None:
3301 
      raise result.ex
3302 
    return
3303 
 
4369 rajveer 3304 
  def markOrdersAsTimeout(self, vendorId):
3305 
    """
3306 
    Parameters:
3307 
     - vendorId
3308 
    """
3309 
    self.send_markOrdersAsTimeout(vendorId)
3310 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3311 
 
4369 rajveer 3312 
  def send_markOrdersAsTimeout(self, vendorId):
3313 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3314 
    args = markOrdersAsTimeout_args()
3315 
    args.vendorId = vendorId
3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_markOrdersAsTimeout(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = markOrdersAsTimeout_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3330 
    if result.success is not None:
3331 
      return result.success
3332 
    if result.ex is not None:
3333 
      raise result.ex
3334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3335 
 
4386 anupam.sin 3336 
  def getOrderForAwb(self, awb):
3337 
    """
3338 
    Returns the order corresponding to an AWB number
4369 rajveer 3339 
 
4386 anupam.sin 3340 
    Parameters:
3341 
     - awb
3342 
    """
3343 
    self.send_getOrderForAwb(awb)
3344 
    return self.recv_getOrderForAwb()
3345 
 
3346 
  def send_getOrderForAwb(self, awb):
3347 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3348 
    args = getOrderForAwb_args()
3349 
    args.awb = awb
3350 
    args.write(self._oprot)
3351 
    self._oprot.writeMessageEnd()
3352 
    self._oprot.trans.flush()
3353 
 
3354 
  def recv_getOrderForAwb(self, ):
3355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3356 
    if mtype == TMessageType.EXCEPTION:
3357 
      x = TApplicationException()
3358 
      x.read(self._iprot)
3359 
      self._iprot.readMessageEnd()
3360 
      raise x
3361 
    result = getOrderForAwb_result()
3362 
    result.read(self._iprot)
3363 
    self._iprot.readMessageEnd()
3364 
    if result.success is not None:
3365 
      return result.success
3366 
    if result.ex is not None:
3367 
      raise result.ex
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3369 
 
3370 
 
3376 rajveer 3371 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3372 
  def __init__(self, handler):
3376 rajveer 3373 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3374 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3375 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3376 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3377 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3378 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3379 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3380 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3381 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3382 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3383 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3384 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3385 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3386 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3387 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3388 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3389 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3390 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3391 
    self._processMap["createOrder"] = Processor.process_createOrder
3392 
    self._processMap["getOrder"] = Processor.process_getOrder
3393 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3394 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3395 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3396 
    self._processMap["setAlert"] = Processor.process_setAlert
3397 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3398 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3399 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3400 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3401 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3402 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3403 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3404 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3405 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3406 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3407 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3408 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3409 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3410 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3411 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3412 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3413 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3414 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3415 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3416 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3417 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3418 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3419 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3420 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3421 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3422 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3423 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3424 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3425 
    self._processMap["changeItem"] = Processor.process_changeItem
3426 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3427 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3428 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3429 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3430 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3431 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3432 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3433 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3434 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3435 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3436 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3437 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3438 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3439 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3440 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3441 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3442 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3443 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3444 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3445 
 
3446 
  def process(self, iprot, oprot):
3447 
    (name, type, seqid) = iprot.readMessageBegin()
3448 
    if name not in self._processMap:
3449 
      iprot.skip(TType.STRUCT)
3450 
      iprot.readMessageEnd()
3451 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3452 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3453 
      x.write(oprot)
3454 
      oprot.writeMessageEnd()
3455 
      oprot.trans.flush()
3456 
      return
3457 
    else:
3458 
      self._processMap[name](self, seqid, iprot, oprot)
3459 
    return True
3460 
 
3461 
  def process_createTransaction(self, seqid, iprot, oprot):
3462 
    args = createTransaction_args()
3463 
    args.read(iprot)
3464 
    iprot.readMessageEnd()
3465 
    result = createTransaction_result()
3466 
    try:
132 ashish 3467 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3468 
    except TransactionServiceException, ex:
3469 
      result.ex = ex
3470 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3471 
    result.write(oprot)
3472 
    oprot.writeMessageEnd()
3473 
    oprot.trans.flush()
3474 
 
3475 
  def process_getTransaction(self, seqid, iprot, oprot):
3476 
    args = getTransaction_args()
3477 
    args.read(iprot)
3478 
    iprot.readMessageEnd()
3479 
    result = getTransaction_result()
3480 
    try:
3481 
      result.success = self._handler.getTransaction(args.id)
3482 
    except TransactionServiceException, ex:
3483 
      result.ex = ex
3484 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3485 
    result.write(oprot)
3486 
    oprot.writeMessageEnd()
3487 
    oprot.trans.flush()
3488 
 
3489 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3490 
    args = getTransactionsForCustomer_args()
3491 
    args.read(iprot)
3492 
    iprot.readMessageEnd()
3493 
    result = getTransactionsForCustomer_result()
3494 
    try:
3495 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3496 
    except TransactionServiceException, ex:
3497 
      result.ex = ex
3498 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3499 
    result.write(oprot)
3500 
    oprot.writeMessageEnd()
3501 
    oprot.trans.flush()
3502 
 
132 ashish 3503 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3504 
    args = getTransactionsForShoppingCartId_args()
3505 
    args.read(iprot)
3506 
    iprot.readMessageEnd()
3507 
    result = getTransactionsForShoppingCartId_result()
3508 
    try:
3509 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3510 
    except TransactionServiceException, ex:
3511 
      result.ex = ex
3512 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3513 
    result.write(oprot)
3514 
    oprot.writeMessageEnd()
3515 
    oprot.trans.flush()
3516 
 
94 ashish 3517 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3518 
    args = getTransactionStatus_args()
3519 
    args.read(iprot)
3520 
    iprot.readMessageEnd()
3521 
    result = getTransactionStatus_result()
3522 
    try:
3523 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3524 
    except TransactionServiceException, ex:
3525 
      result.ex = ex
3526 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3527 
    result.write(oprot)
3528 
    oprot.writeMessageEnd()
3529 
    oprot.trans.flush()
3530 
 
3531 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3532 
    args = changeTransactionStatus_args()
3533 
    args.read(iprot)
3534 
    iprot.readMessageEnd()
3535 
    result = changeTransactionStatus_result()
3536 
    try:
3537 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3538 
    except TransactionServiceException, ex:
3539 
      result.ex = ex
3540 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3541 
    result.write(oprot)
3542 
    oprot.writeMessageEnd()
3543 
    oprot.trans.flush()
3544 
 
1398 varun.gupt 3545 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3546 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3547 
    args.read(iprot)
3548 
    iprot.readMessageEnd()
1398 varun.gupt 3549 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3550 
    try:
1398 varun.gupt 3551 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3552 
    except TransactionServiceException, ex:
3553 
      result.ex = ex
1398 varun.gupt 3554 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3555 
    result.write(oprot)
3556 
    oprot.writeMessageEnd()
3557 
    oprot.trans.flush()
3558 
 
483 rajveer 3559 
  def process_getAllOrders(self, seqid, iprot, oprot):
3560 
    args = getAllOrders_args()
94 ashish 3561 
    args.read(iprot)
3562 
    iprot.readMessageEnd()
483 rajveer 3563 
    result = getAllOrders_result()
94 ashish 3564 
    try:
483 rajveer 3565 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3566 
    except TransactionServiceException, ex:
3567 
      result.ex = ex
483 rajveer 3568 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3569 
    result.write(oprot)
3570 
    oprot.writeMessageEnd()
3571 
    oprot.trans.flush()
3572 
 
4133 chandransh 3573 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3574 
    args = getOrdersInBatch_args()
3575 
    args.read(iprot)
3576 
    iprot.readMessageEnd()
3577 
    result = getOrdersInBatch_result()
3578 
    try:
3579 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3580 
    except TransactionServiceException, ex:
3581 
      result.ex = ex
3582 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3583 
    result.write(oprot)
3584 
    oprot.writeMessageEnd()
3585 
    oprot.trans.flush()
3586 
 
3587 
  def process_getOrderCount(self, seqid, iprot, oprot):
3588 
    args = getOrderCount_args()
3589 
    args.read(iprot)
3590 
    iprot.readMessageEnd()
3591 
    result = getOrderCount_result()
3592 
    try:
3593 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3594 
    except TransactionServiceException, ex:
3595 
      result.ex = ex
3596 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3597 
    result.write(oprot)
3598 
    oprot.writeMessageEnd()
3599 
    oprot.trans.flush()
3600 
 
999 varun.gupt 3601 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3602 
    args = getOrdersByBillingDate_args()
3603 
    args.read(iprot)
3604 
    iprot.readMessageEnd()
3605 
    result = getOrdersByBillingDate_result()
3606 
    try:
3607 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3608 
    except TransactionServiceException, ex:
3609 
      result.ex = ex
3610 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3611 
    result.write(oprot)
3612 
    oprot.writeMessageEnd()
3613 
    oprot.trans.flush()
3614 
 
3427 chandransh 3615 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3616 
    args = getOrdersByShippingDate_args()
3617 
    args.read(iprot)
3618 
    iprot.readMessageEnd()
3619 
    result = getOrdersByShippingDate_result()
3620 
    try:
3451 chandransh 3621 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3622 
    except TransactionServiceException, ex:
3623 
      result.ex = ex
3624 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3625 
    result.write(oprot)
3626 
    oprot.writeMessageEnd()
3627 
    oprot.trans.flush()
3628 
 
1382 varun.gupt 3629 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3630 
    args = getReturnableOrdersForCustomer_args()
3631 
    args.read(iprot)
3632 
    iprot.readMessageEnd()
3633 
    result = getReturnableOrdersForCustomer_result()
3634 
    try:
3635 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3636 
    except TransactionServiceException, ex:
3637 
      result.ex = ex
3638 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3639 
    result.write(oprot)
3640 
    oprot.writeMessageEnd()
3641 
    oprot.trans.flush()
3642 
 
3643 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3644 
    args = getCancellableOrdersForCustomer_args()
3645 
    args.read(iprot)
3646 
    iprot.readMessageEnd()
3647 
    result = getCancellableOrdersForCustomer_result()
3648 
    try:
3649 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3650 
    except TransactionServiceException, ex:
3651 
      result.ex = ex
3652 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3653 
    result.write(oprot)
3654 
    oprot.writeMessageEnd()
3655 
    oprot.trans.flush()
3656 
 
483 rajveer 3657 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3658 
    args = changeOrderStatus_args()
94 ashish 3659 
    args.read(iprot)
3660 
    iprot.readMessageEnd()
483 rajveer 3661 
    result = changeOrderStatus_result()
94 ashish 3662 
    try:
483 rajveer 3663 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3664 
    except TransactionServiceException, ex:
3665 
      result.ex = ex
483 rajveer 3666 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3667 
    result.write(oprot)
3668 
    oprot.writeMessageEnd()
3669 
    oprot.trans.flush()
3670 
 
483 rajveer 3671 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3672 
    args = getOrdersForTransaction_args()
94 ashish 3673 
    args.read(iprot)
3674 
    iprot.readMessageEnd()
483 rajveer 3675 
    result = getOrdersForTransaction_result()
94 ashish 3676 
    try:
1528 ankur.sing 3677 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3678 
    except TransactionServiceException, ex:
3679 
      result.ex = ex
483 rajveer 3680 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3681 
    result.write(oprot)
3682 
    oprot.writeMessageEnd()
3683 
    oprot.trans.flush()
3684 
 
483 rajveer 3685 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3686 
    args = getOrdersForCustomer_args()
94 ashish 3687 
    args.read(iprot)
3688 
    iprot.readMessageEnd()
483 rajveer 3689 
    result = getOrdersForCustomer_result()
94 ashish 3690 
    try:
3014 chandransh 3691 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3692 
    except TransactionServiceException, ex:
3693 
      result.ex = ex
483 rajveer 3694 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3695 
    result.write(oprot)
3696 
    oprot.writeMessageEnd()
3697 
    oprot.trans.flush()
3698 
 
483 rajveer 3699 
  def process_createOrder(self, seqid, iprot, oprot):
3700 
    args = createOrder_args()
94 ashish 3701 
    args.read(iprot)
3702 
    iprot.readMessageEnd()
483 rajveer 3703 
    result = createOrder_result()
94 ashish 3704 
    try:
483 rajveer 3705 
      result.success = self._handler.createOrder(args.order)
94 ashish 3706 
    except TransactionServiceException, ex:
3707 
      result.ex = ex
483 rajveer 3708 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3709 
    result.write(oprot)
3710 
    oprot.writeMessageEnd()
3711 
    oprot.trans.flush()
3712 
 
483 rajveer 3713 
  def process_getOrder(self, seqid, iprot, oprot):
3714 
    args = getOrder_args()
94 ashish 3715 
    args.read(iprot)
3716 
    iprot.readMessageEnd()
483 rajveer 3717 
    result = getOrder_result()
94 ashish 3718 
    try:
483 rajveer 3719 
      result.success = self._handler.getOrder(args.id)
94 ashish 3720 
    except TransactionServiceException, ex:
3721 
      result.ex = ex
483 rajveer 3722 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3723 
    result.write(oprot)
3724 
    oprot.writeMessageEnd()
3725 
    oprot.trans.flush()
3726 
 
483 rajveer 3727 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3728 
    args = getLineItemsForOrder_args()
94 ashish 3729 
    args.read(iprot)
3730 
    iprot.readMessageEnd()
483 rajveer 3731 
    result = getLineItemsForOrder_result()
94 ashish 3732 
    try:
483 rajveer 3733 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3734 
    except TransactionServiceException, ex:
3735 
      result.ex = ex
483 rajveer 3736 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3737 
    result.write(oprot)
3738 
    oprot.writeMessageEnd()
3739 
    oprot.trans.flush()
3740 
 
1528 ankur.sing 3741 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3742 
    args = getOrderForCustomer_args()
3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
3745 
    result = getOrderForCustomer_result()
3746 
    try:
3747 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3748 
    except TransactionServiceException, ex:
3749 
      result.ex = ex
3750 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
3754 
 
3064 chandransh 3755 
  def process_getAlerts(self, seqid, iprot, oprot):
3756 
    args = getAlerts_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = getAlerts_result()
3760 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3761 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3762 
    result.write(oprot)
3763 
    oprot.writeMessageEnd()
3764 
    oprot.trans.flush()
3765 
 
3766 
  def process_setAlert(self, seqid, iprot, oprot):
3767 
    args = setAlert_args()
3768 
    args.read(iprot)
3769 
    iprot.readMessageEnd()
3770 
    result = setAlert_result()
3771 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3772 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3773 
    result.write(oprot)
3774 
    oprot.writeMessageEnd()
3775 
    oprot.trans.flush()
3776 
 
3777 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3778 
    args = getValidOrderCount_args()
3779 
    args.read(iprot)
3780 
    iprot.readMessageEnd()
3781 
    result = getValidOrderCount_result()
3782 
    result.success = self._handler.getValidOrderCount()
3783 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3784 
    result.write(oprot)
3785 
    oprot.writeMessageEnd()
3786 
    oprot.trans.flush()
3787 
 
3788 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3789 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3790 
    args.read(iprot)
3791 
    iprot.readMessageEnd()
3792 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3793 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3794 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3795 
    result.write(oprot)
3796 
    oprot.writeMessageEnd()
3797 
    oprot.trans.flush()
3798 
 
3799 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3800 
    args = getValidOrdersAmountRange_args()
3801 
    args.read(iprot)
3802 
    iprot.readMessageEnd()
3803 
    result = getValidOrdersAmountRange_result()
3804 
    result.success = self._handler.getValidOrdersAmountRange()
3805 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3806 
    result.write(oprot)
3807 
    oprot.writeMessageEnd()
3808 
    oprot.trans.flush()
3809 
 
3810 
  def process_getValidOrders(self, seqid, iprot, oprot):
3811 
    args = getValidOrders_args()
3812 
    args.read(iprot)
3813 
    iprot.readMessageEnd()
3814 
    result = getValidOrders_result()
3815 
    result.success = self._handler.getValidOrders(args.limit)
3816 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3817 
    result.write(oprot)
3818 
    oprot.writeMessageEnd()
3819 
    oprot.trans.flush()
3820 
 
1220 chandransh 3821 
  def process_batchOrders(self, seqid, iprot, oprot):
3822 
    args = batchOrders_args()
3823 
    args.read(iprot)
3824 
    iprot.readMessageEnd()
3825 
    result = batchOrders_result()
3826 
    try:
3827 
      result.success = self._handler.batchOrders(args.warehouseId)
3828 
    except TransactionServiceException, ex:
3829 
      result.ex = ex
3830 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3831 
    result.write(oprot)
3832 
    oprot.writeMessageEnd()
3833 
    oprot.trans.flush()
3834 
 
1208 chandransh 3835 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3836 
    args = markOrderAsOutOfStock_args()
3837 
    args.read(iprot)
3838 
    iprot.readMessageEnd()
3839 
    result = markOrderAsOutOfStock_result()
3840 
    try:
3841 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3842 
    except TransactionServiceException, ex:
3843 
      result.ex = ex
3844 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3845 
    result.write(oprot)
3846 
    oprot.writeMessageEnd()
3847 
    oprot.trans.flush()
3848 
 
3064 chandransh 3849 
  def process_verifyOrder(self, seqid, iprot, oprot):
3850 
    args = verifyOrder_args()
759 chandransh 3851 
    args.read(iprot)
3852 
    iprot.readMessageEnd()
3064 chandransh 3853 
    result = verifyOrder_result()
759 chandransh 3854 
    try:
3064 chandransh 3855 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3856 
    except TransactionServiceException, ex:
3857 
      result.ex = ex
3064 chandransh 3858 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3859 
    result.write(oprot)
3860 
    oprot.writeMessageEnd()
3861 
    oprot.trans.flush()
3862 
 
3064 chandransh 3863 
  def process_acceptOrder(self, seqid, iprot, oprot):
3864 
    args = acceptOrder_args()
1113 chandransh 3865 
    args.read(iprot)
3866 
    iprot.readMessageEnd()
3064 chandransh 3867 
    result = acceptOrder_result()
1113 chandransh 3868 
    try:
3064 chandransh 3869 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3870 
    except TransactionServiceException, ex:
3871 
      result.ex = ex
3064 chandransh 3872 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3873 
    result.write(oprot)
3874 
    oprot.writeMessageEnd()
3875 
    oprot.trans.flush()
3876 
 
3064 chandransh 3877 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3878 
    args = addBillingDetails_args()
1135 chandransh 3879 
    args.read(iprot)
3880 
    iprot.readMessageEnd()
3064 chandransh 3881 
    result = addBillingDetails_result()
1135 chandransh 3882 
    try:
4283 anupam.sin 3883 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.imeiNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.vendorId)
1135 chandransh 3884 
    except TransactionServiceException, ex:
3885 
      result.ex = ex
3064 chandransh 3886 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3887 
    result.write(oprot)
3888 
    oprot.writeMessageEnd()
3889 
    oprot.trans.flush()
3890 
 
3064 chandransh 3891 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3892 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3893 
    args.read(iprot)
3894 
    iprot.readMessageEnd()
3064 chandransh 3895 
    result = markOrdersAsManifested_result()
3896 
    try:
3897 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3898 
    except TransactionServiceException, ex:
3899 
      result.ex = ex
3900 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3901 
    result.write(oprot)
3902 
    oprot.writeMessageEnd()
3903 
    oprot.trans.flush()
3904 
 
3064 chandransh 3905 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3906 
    args = markOrdersAsPickedUp_args()
304 ashish 3907 
    args.read(iprot)
3908 
    iprot.readMessageEnd()
3064 chandransh 3909 
    result = markOrdersAsPickedUp_result()
3910 
    try:
3911 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3912 
    except TransactionServiceException, ex:
3913 
      result.ex = ex
3914 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3915 
    result.write(oprot)
3916 
    oprot.writeMessageEnd()
3917 
    oprot.trans.flush()
94 ashish 3918 
 
3064 chandransh 3919 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3920 
    args = markOrdersAsDelivered_args()
304 ashish 3921 
    args.read(iprot)
3922 
    iprot.readMessageEnd()
3064 chandransh 3923 
    result = markOrdersAsDelivered_result()
3924 
    try:
3925 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3926 
    except TransactionServiceException, ex:
3927 
      result.ex = ex
3928 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3929 
    result.write(oprot)
3930 
    oprot.writeMessageEnd()
3931 
    oprot.trans.flush()
3932 
 
3064 chandransh 3933 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3934 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3935 
    args.read(iprot)
3936 
    iprot.readMessageEnd()
3064 chandransh 3937 
    result = markOrdersAsFailed_result()
3938 
    try:
3939 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3940 
    except TransactionServiceException, ex:
3941 
      result.ex = ex
3942 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3943 
    result.write(oprot)
3944 
    oprot.writeMessageEnd()
3945 
    oprot.trans.flush()
304 ashish 3946 
 
3064 chandransh 3947 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3948 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3949 
    args.read(iprot)
3950 
    iprot.readMessageEnd()
3064 chandransh 3951 
    result = updateNonDeliveryReason_result()
3952 
    try:
3953 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3954 
    except TransactionServiceException, ex:
3955 
      result.ex = ex
3956 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
1596 ankur.sing 3960 
 
3064 chandransh 3961 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3962 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3064 chandransh 3965 
    result = getUndeliveredOrders_result()
3966 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3967 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3968 
    result.write(oprot)
3969 
    oprot.writeMessageEnd()
3970 
    oprot.trans.flush()
3971 
 
2536 chandransh 3972 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3973 
    args = toggleDOAFlag_args()
3974 
    args.read(iprot)
3975 
    iprot.readMessageEnd()
3976 
    result = toggleDOAFlag_result()
3977 
    try:
3978 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3979 
    except TransactionServiceException, ex:
3980 
      result.ex = ex
3981 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3982 
    result.write(oprot)
3983 
    oprot.writeMessageEnd()
3984 
    oprot.trans.flush()
1886 ankur.sing 3985 
 
2536 chandransh 3986 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3987 
    args = requestPickupNumber_args()
3988 
    args.read(iprot)
3989 
    iprot.readMessageEnd()
3990 
    result = requestPickupNumber_result()
3991 
    try:
3992 
      result.success = self._handler.requestPickupNumber(args.orderId)
3993 
    except TransactionServiceException, ex:
3994 
      result.ex = ex
3995 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3996 
    result.write(oprot)
3997 
    oprot.writeMessageEnd()
3998 
    oprot.trans.flush()
3999 
 
4000 
  def process_authorizePickup(self, seqid, iprot, oprot):
4001 
    args = authorizePickup_args()
4002 
    args.read(iprot)
4003 
    iprot.readMessageEnd()
4004 
    result = authorizePickup_result()
4005 
    try:
4006 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4007 
    except TransactionServiceException, ex:
4008 
      result.ex = ex
4009 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4010 
    result.write(oprot)
4011 
    oprot.writeMessageEnd()
4012 
    oprot.trans.flush()
4013 
 
2764 chandransh 4014 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4015 
    args = markDoasAsPickedUp_args()
4016 
    args.read(iprot)
4017 
    iprot.readMessageEnd()
4018 
    result = markDoasAsPickedUp_result()
4019 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4020 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
2616 chandransh 4025 
  def process_receiveReturn(self, seqid, iprot, oprot):
4026 
    args = receiveReturn_args()
2591 chandransh 4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
2616 chandransh 4029 
    result = receiveReturn_result()
2591 chandransh 4030 
    try:
2616 chandransh 4031 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 4032 
    except TransactionServiceException, ex:
4033 
      result.ex = ex
2616 chandransh 4034 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
2536 chandransh 4038 
 
2591 chandransh 4039 
  def process_validateDoa(self, seqid, iprot, oprot):
4040 
    args = validateDoa_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = validateDoa_result()
4044 
    try:
4045 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4046 
    except TransactionServiceException, ex:
4047 
      result.ex = ex
4048 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
2616 chandransh 4053 
  def process_reshipOrder(self, seqid, iprot, oprot):
4054 
    args = reshipOrder_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = reshipOrder_result()
4058 
    try:
4059 
      result.success = self._handler.reshipOrder(args.orderId)
4060 
    except TransactionServiceException, ex:
4061 
      result.ex = ex
4062 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
2591 chandransh 4066 
 
2616 chandransh 4067 
  def process_refundOrder(self, seqid, iprot, oprot):
4068 
    args = refundOrder_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = refundOrder_result()
4072 
    try:
3226 chandransh 4073 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4074 
    except TransactionServiceException, ex:
4075 
      result.ex = ex
4076 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
2690 chandransh 4081 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4082 
    args = getReturnOrders_args()
4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
4085 
    result = getReturnOrders_result()
4086 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4087 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4088 
    result.write(oprot)
4089 
    oprot.writeMessageEnd()
4090 
    oprot.trans.flush()
2616 chandransh 4091 
 
2700 chandransh 4092 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4093 
    args = getReturnOrder_args()
4094 
    args.read(iprot)
4095 
    iprot.readMessageEnd()
4096 
    result = getReturnOrder_result()
4097 
    try:
4098 
      result.success = self._handler.getReturnOrder(args.id)
4099 
    except TransactionServiceException, ex:
4100 
      result.ex = ex
4101 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4102 
    result.write(oprot)
4103 
    oprot.writeMessageEnd()
4104 
    oprot.trans.flush()
4105 
 
2690 chandransh 4106 
  def process_processReturn(self, seqid, iprot, oprot):
4107 
    args = processReturn_args()
4108 
    args.read(iprot)
4109 
    iprot.readMessageEnd()
4110 
    result = processReturn_result()
4111 
    try:
4112 
      self._handler.processReturn(args.returnOrderId)
4113 
    except TransactionServiceException, ex:
4114 
      result.ex = ex
4115 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4116 
    result.write(oprot)
4117 
    oprot.writeMessageEnd()
4118 
    oprot.trans.flush()
4119 
 
2819 chandransh 4120 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4121 
    args = createPurchaseOrder_args()
4122 
    args.read(iprot)
4123 
    iprot.readMessageEnd()
4124 
    result = createPurchaseOrder_result()
4125 
    try:
4126 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4127 
    except TransactionServiceException, ex:
4128 
      result.ex = ex
4129 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4130 
    result.write(oprot)
4131 
    oprot.writeMessageEnd()
4132 
    oprot.trans.flush()
2690 chandransh 4133 
 
3451 chandransh 4134 
  def process_updateWeight(self, seqid, iprot, oprot):
4135 
    args = updateWeight_args()
4136 
    args.read(iprot)
4137 
    iprot.readMessageEnd()
4138 
    result = updateWeight_result()
4139 
    try:
4140 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4141 
    except TransactionServiceException, ex:
4142 
      result.ex = ex
4143 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4144 
    result.write(oprot)
4145 
    oprot.writeMessageEnd()
4146 
    oprot.trans.flush()
2819 chandransh 4147 
 
3469 chandransh 4148 
  def process_changeItem(self, seqid, iprot, oprot):
4149 
    args = changeItem_args()
4150 
    args.read(iprot)
4151 
    iprot.readMessageEnd()
4152 
    result = changeItem_result()
4153 
    try:
4154 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4155 
    except TransactionServiceException, ex:
4156 
      result.ex = ex
4157 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4158 
    result.write(oprot)
4159 
    oprot.writeMessageEnd()
4160 
    oprot.trans.flush()
3451 chandransh 4161 
 
3469 chandransh 4162 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4163 
    args = shiftToWarehouse_args()
4164 
    args.read(iprot)
4165 
    iprot.readMessageEnd()
4166 
    result = shiftToWarehouse_result()
4167 
    try:
4168 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4169 
    except TransactionServiceException, ex:
4170 
      result.ex = ex
4171 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4172 
    result.write(oprot)
4173 
    oprot.writeMessageEnd()
4174 
    oprot.trans.flush()
4175 
 
3553 chandransh 4176 
  def process_addDelayReason(self, seqid, iprot, oprot):
4177 
    args = addDelayReason_args()
4178 
    args.read(iprot)
4179 
    iprot.readMessageEnd()
4180 
    result = addDelayReason_result()
4181 
    try:
3986 chandransh 4182 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4183 
    except TransactionServiceException, ex:
4184 
      result.ex = ex
4185 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
3469 chandransh 4189 
 
3956 chandransh 4190 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4191 
    args = reconcileCodCollection_args()
4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
4194 
    result = reconcileCodCollection_result()
4195 
    try:
4196 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4197 
    except TransactionServiceException, ex:
4198 
      result.ex = ex
4199 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
3553 chandransh 4203 
 
4008 mandeep.dh 4204 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4205 
    args = getTransactionsRequiringExtraProcessing_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = getTransactionsRequiringExtraProcessing_result()
4209 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4210 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4211 
    result.write(oprot)
4212 
    oprot.writeMessageEnd()
4213 
    oprot.trans.flush()
3956 chandransh 4214 
 
4008 mandeep.dh 4215 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4216 
    args = markTransactionAsProcessed_args()
4217 
    args.read(iprot)
4218 
    iprot.readMessageEnd()
4219 
    result = markTransactionAsProcessed_result()
4220 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4221 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
4225 
 
4018 chandransh 4226 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4227 
    args = getItemWiseRiskyOrdersCount_args()
4228 
    args.read(iprot)
4229 
    iprot.readMessageEnd()
4230 
    result = getItemWiseRiskyOrdersCount_result()
4231 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4232 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4008 mandeep.dh 4236 
 
4295 varun.gupt 4237 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4238 
    args = getOrdersForItemIds_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = getOrdersForItemIds_result()
4242 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4243 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
4247 
 
4247 rajveer 4248 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4249 
    args = markOrderCancellationRequestReceived_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = markOrderCancellationRequestReceived_result()
4253 
    try:
4254 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4255 
    except TransactionServiceException, ex:
4256 
      result.ex = ex
4257 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4018 chandransh 4261 
 
4247 rajveer 4262 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4263 
    args = markOrderCancellationRequestConfirmed_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = markOrderCancellationRequestConfirmed_result()
4267 
    try:
4268 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4269 
    except TransactionServiceException, ex:
4270 
      result.ex = ex
4271 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
4276 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4277 
    args = markOrderCancellationRequestDenied_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = markOrderCancellationRequestDenied_result()
4281 
    try:
4282 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4283 
    except TransactionServiceException, ex:
4284 
      result.ex = ex
4285 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
4289 
 
4258 rajveer 4290 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4291 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4258 rajveer 4294 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4295 
    try:
4258 rajveer 4296 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4297 
    except TransactionServiceException, ex:
4298 
      result.ex = ex
4258 rajveer 4299 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
4303 
 
4259 anupam.sin 4304 
  def process_refundTransaction(self, seqid, iprot, oprot):
4305 
    args = refundTransaction_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = refundTransaction_result()
4309 
    try:
4310 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4311 
    except TransactionServiceException, ex:
4312 
      result.ex = ex
4313 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4314 
    result.write(oprot)
4315 
    oprot.writeMessageEnd()
4316 
    oprot.trans.flush()
4247 rajveer 4317 
 
4324 mandeep.dh 4318 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4319 
    args = updateShipmentAddress_args()
4320 
    args.read(iprot)
4321 
    iprot.readMessageEnd()
4322 
    result = updateShipmentAddress_result()
4323 
    try:
4324 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4325 
    except TransactionServiceException, ex:
4326 
      result.ex = ex
4327 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
4331 
 
4285 rajveer 4332 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4333 
    args = acceptOrdersForItemId_args()
4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
4336 
    result = acceptOrdersForItemId_result()
4337 
    try:
4338 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4339 
    except TransactionServiceException, ex:
4340 
      result.ex = ex
4341 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
4259 anupam.sin 4345 
 
4303 rajveer 4346 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4347 
    args = markOrdersAsPORaised_args()
4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
4350 
    result = markOrdersAsPORaised_result()
4351 
    try:
4369 rajveer 4352 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4353 
    except TransactionServiceException, ex:
4354 
      result.ex = ex
4355 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4285 rajveer 4359 
 
4303 rajveer 4360 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4361 
    args = markOrdersAsReversalInitiated_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = markOrdersAsReversalInitiated_result()
4365 
    try:
4369 rajveer 4366 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4367 
    except TransactionServiceException, ex:
4368 
      result.ex = ex
4369 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4375 
    args = markOrdersAsNotAvailabke_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = markOrdersAsNotAvailabke_result()
4379 
    try:
4369 rajveer 4380 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4381 
    except TransactionServiceException, ex:
4382 
      result.ex = ex
4383 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4384 
    result.write(oprot)
4385 
    oprot.writeMessageEnd()
4386 
    oprot.trans.flush()
4387 
 
4369 rajveer 4388 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4389 
    args = markOrdersAsTimeout_args()
4390 
    args.read(iprot)
4391 
    iprot.readMessageEnd()
4392 
    result = markOrdersAsTimeout_result()
4393 
    try:
4394 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4395 
    except TransactionServiceException, ex:
4396 
      result.ex = ex
4397 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
4303 rajveer 4401 
 
4386 anupam.sin 4402 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4403 
    args = getOrderForAwb_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = getOrderForAwb_result()
4407 
    try:
4408 
      result.success = self._handler.getOrderForAwb(args.awb)
4409 
    except TransactionServiceException, ex:
4410 
      result.ex = ex
4411 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4412 
    result.write(oprot)
4413 
    oprot.writeMessageEnd()
4414 
    oprot.trans.flush()
4369 rajveer 4415 
 
4386 anupam.sin 4416 
 
94 ashish 4417 
# HELPER FUNCTIONS AND STRUCTURES
4418 
 
4419 
class createTransaction_args:
4420 
  """
4421 
  Attributes:
4422 
   - transaction
4423 
  """
4424 
 
4425 
  thrift_spec = (
4426 
    None, # 0
4427 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4428 
  )
4429 
 
4430 
  def __init__(self, transaction=None,):
4431 
    self.transaction = transaction
4432 
 
4433 
  def read(self, iprot):
4434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4436 
      return
4437 
    iprot.readStructBegin()
4438 
    while True:
4439 
      (fname, ftype, fid) = iprot.readFieldBegin()
4440 
      if ftype == TType.STOP:
4441 
        break
4442 
      if fid == 1:
4443 
        if ftype == TType.STRUCT:
4444 
          self.transaction = Transaction()
4445 
          self.transaction.read(iprot)
4446 
        else:
4447 
          iprot.skip(ftype)
4448 
      else:
4449 
        iprot.skip(ftype)
4450 
      iprot.readFieldEnd()
4451 
    iprot.readStructEnd()
4452 
 
4453 
  def write(self, oprot):
4454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4456 
      return
4457 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4458 
    if self.transaction is not None:
94 ashish 4459 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4460 
      self.transaction.write(oprot)
4461 
      oprot.writeFieldEnd()
4462 
    oprot.writeFieldStop()
4463 
    oprot.writeStructEnd()
4464 
 
3431 rajveer 4465 
  def validate(self):
4466 
    return
4467 
 
4468 
 
94 ashish 4469 
  def __repr__(self):
4470 
    L = ['%s=%r' % (key, value)
4471 
      for key, value in self.__dict__.iteritems()]
4472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4473 
 
4474 
  def __eq__(self, other):
4475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4476 
 
4477 
  def __ne__(self, other):
4478 
    return not (self == other)
4479 
 
4480 
class createTransaction_result:
4481 
  """
4482 
  Attributes:
132 ashish 4483 
   - success
94 ashish 4484 
   - ex
4485 
  """
4486 
 
4487 
  thrift_spec = (
132 ashish 4488 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4490 
  )
4491 
 
132 ashish 4492 
  def __init__(self, success=None, ex=None,):
4493 
    self.success = success
94 ashish 4494 
    self.ex = ex
4495 
 
4496 
  def read(self, iprot):
4497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4499 
      return
4500 
    iprot.readStructBegin()
4501 
    while True:
4502 
      (fname, ftype, fid) = iprot.readFieldBegin()
4503 
      if ftype == TType.STOP:
4504 
        break
132 ashish 4505 
      if fid == 0:
4506 
        if ftype == TType.I64:
4507 
          self.success = iprot.readI64();
4508 
        else:
4509 
          iprot.skip(ftype)
4510 
      elif fid == 1:
94 ashish 4511 
        if ftype == TType.STRUCT:
4512 
          self.ex = TransactionServiceException()
4513 
          self.ex.read(iprot)
4514 
        else:
4515 
          iprot.skip(ftype)
4516 
      else:
4517 
        iprot.skip(ftype)
4518 
      iprot.readFieldEnd()
4519 
    iprot.readStructEnd()
4520 
 
4521 
  def write(self, oprot):
4522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4524 
      return
4525 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4526 
    if self.success is not None:
132 ashish 4527 
      oprot.writeFieldBegin('success', TType.I64, 0)
4528 
      oprot.writeI64(self.success)
4529 
      oprot.writeFieldEnd()
3431 rajveer 4530 
    if self.ex is not None:
94 ashish 4531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4532 
      self.ex.write(oprot)
4533 
      oprot.writeFieldEnd()
4534 
    oprot.writeFieldStop()
4535 
    oprot.writeStructEnd()
4536 
 
3431 rajveer 4537 
  def validate(self):
4538 
    return
4539 
 
4540 
 
94 ashish 4541 
  def __repr__(self):
4542 
    L = ['%s=%r' % (key, value)
4543 
      for key, value in self.__dict__.iteritems()]
4544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4545 
 
4546 
  def __eq__(self, other):
4547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4548 
 
4549 
  def __ne__(self, other):
4550 
    return not (self == other)
4551 
 
4552 
class getTransaction_args:
4553 
  """
4554 
  Attributes:
4555 
   - id
4556 
  """
4557 
 
4558 
  thrift_spec = (
4559 
    None, # 0
4560 
    (1, TType.I64, 'id', None, None, ), # 1
4561 
  )
4562 
 
4563 
  def __init__(self, id=None,):
4564 
    self.id = id
4565 
 
4566 
  def read(self, iprot):
4567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4569 
      return
4570 
    iprot.readStructBegin()
4571 
    while True:
4572 
      (fname, ftype, fid) = iprot.readFieldBegin()
4573 
      if ftype == TType.STOP:
4574 
        break
4575 
      if fid == 1:
4576 
        if ftype == TType.I64:
4577 
          self.id = iprot.readI64();
4578 
        else:
4579 
          iprot.skip(ftype)
4580 
      else:
4581 
        iprot.skip(ftype)
4582 
      iprot.readFieldEnd()
4583 
    iprot.readStructEnd()
4584 
 
4585 
  def write(self, oprot):
4586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4588 
      return
4589 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4590 
    if self.id is not None:
94 ashish 4591 
      oprot.writeFieldBegin('id', TType.I64, 1)
4592 
      oprot.writeI64(self.id)
4593 
      oprot.writeFieldEnd()
4594 
    oprot.writeFieldStop()
4595 
    oprot.writeStructEnd()
4596 
 
3431 rajveer 4597 
  def validate(self):
4598 
    return
4599 
 
4600 
 
94 ashish 4601 
  def __repr__(self):
4602 
    L = ['%s=%r' % (key, value)
4603 
      for key, value in self.__dict__.iteritems()]
4604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4605 
 
4606 
  def __eq__(self, other):
4607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4608 
 
4609 
  def __ne__(self, other):
4610 
    return not (self == other)
4611 
 
4612 
class getTransaction_result:
4613 
  """
4614 
  Attributes:
4615 
   - success
4616 
   - ex
4617 
  """
4618 
 
4619 
  thrift_spec = (
4620 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4622 
  )
4623 
 
4624 
  def __init__(self, success=None, ex=None,):
4625 
    self.success = success
4626 
    self.ex = ex
4627 
 
4628 
  def read(self, iprot):
4629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4631 
      return
4632 
    iprot.readStructBegin()
4633 
    while True:
4634 
      (fname, ftype, fid) = iprot.readFieldBegin()
4635 
      if ftype == TType.STOP:
4636 
        break
4637 
      if fid == 0:
4638 
        if ftype == TType.STRUCT:
4639 
          self.success = Transaction()
4640 
          self.success.read(iprot)
4641 
        else:
4642 
          iprot.skip(ftype)
4643 
      elif fid == 1:
4644 
        if ftype == TType.STRUCT:
4645 
          self.ex = TransactionServiceException()
4646 
          self.ex.read(iprot)
4647 
        else:
4648 
          iprot.skip(ftype)
4649 
      else:
4650 
        iprot.skip(ftype)
4651 
      iprot.readFieldEnd()
4652 
    iprot.readStructEnd()
4653 
 
4654 
  def write(self, oprot):
4655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4657 
      return
4658 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4659 
    if self.success is not None:
94 ashish 4660 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4661 
      self.success.write(oprot)
4662 
      oprot.writeFieldEnd()
3431 rajveer 4663 
    if self.ex is not None:
94 ashish 4664 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4665 
      self.ex.write(oprot)
4666 
      oprot.writeFieldEnd()
4667 
    oprot.writeFieldStop()
4668 
    oprot.writeStructEnd()
4669 
 
3431 rajveer 4670 
  def validate(self):
4671 
    return
4672 
 
4673 
 
94 ashish 4674 
  def __repr__(self):
4675 
    L = ['%s=%r' % (key, value)
4676 
      for key, value in self.__dict__.iteritems()]
4677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4678 
 
4679 
  def __eq__(self, other):
4680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4681 
 
4682 
  def __ne__(self, other):
4683 
    return not (self == other)
4684 
 
4685 
class getTransactionsForCustomer_args:
4686 
  """
4687 
  Attributes:
4688 
   - customerId
4689 
   - from_date
4690 
   - to_date
4691 
   - status
4692 
  """
4693 
 
4694 
  thrift_spec = (
4695 
    None, # 0
4696 
    (1, TType.I64, 'customerId', None, None, ), # 1
4697 
    (2, TType.I64, 'from_date', None, None, ), # 2
4698 
    (3, TType.I64, 'to_date', None, None, ), # 3
4699 
    (4, TType.I32, 'status', None, None, ), # 4
4700 
  )
4701 
 
4702 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4703 
    self.customerId = customerId
4704 
    self.from_date = from_date
4705 
    self.to_date = to_date
4706 
    self.status = status
4707 
 
4708 
  def read(self, iprot):
4709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4711 
      return
4712 
    iprot.readStructBegin()
4713 
    while True:
4714 
      (fname, ftype, fid) = iprot.readFieldBegin()
4715 
      if ftype == TType.STOP:
4716 
        break
4717 
      if fid == 1:
4718 
        if ftype == TType.I64:
4719 
          self.customerId = iprot.readI64();
4720 
        else:
4721 
          iprot.skip(ftype)
4722 
      elif fid == 2:
4723 
        if ftype == TType.I64:
4724 
          self.from_date = iprot.readI64();
4725 
        else:
4726 
          iprot.skip(ftype)
4727 
      elif fid == 3:
4728 
        if ftype == TType.I64:
4729 
          self.to_date = iprot.readI64();
4730 
        else:
4731 
          iprot.skip(ftype)
4732 
      elif fid == 4:
4733 
        if ftype == TType.I32:
4734 
          self.status = iprot.readI32();
4735 
        else:
4736 
          iprot.skip(ftype)
4737 
      else:
4738 
        iprot.skip(ftype)
4739 
      iprot.readFieldEnd()
4740 
    iprot.readStructEnd()
4741 
 
4742 
  def write(self, oprot):
4743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4745 
      return
4746 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4747 
    if self.customerId is not None:
94 ashish 4748 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4749 
      oprot.writeI64(self.customerId)
4750 
      oprot.writeFieldEnd()
3431 rajveer 4751 
    if self.from_date is not None:
94 ashish 4752 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4753 
      oprot.writeI64(self.from_date)
4754 
      oprot.writeFieldEnd()
3431 rajveer 4755 
    if self.to_date is not None:
94 ashish 4756 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4757 
      oprot.writeI64(self.to_date)
4758 
      oprot.writeFieldEnd()
3431 rajveer 4759 
    if self.status is not None:
94 ashish 4760 
      oprot.writeFieldBegin('status', TType.I32, 4)
4761 
      oprot.writeI32(self.status)
4762 
      oprot.writeFieldEnd()
4763 
    oprot.writeFieldStop()
4764 
    oprot.writeStructEnd()
4765 
 
3431 rajveer 4766 
  def validate(self):
4767 
    return
4768 
 
4769 
 
94 ashish 4770 
  def __repr__(self):
4771 
    L = ['%s=%r' % (key, value)
4772 
      for key, value in self.__dict__.iteritems()]
4773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4774 
 
4775 
  def __eq__(self, other):
4776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4777 
 
4778 
  def __ne__(self, other):
4779 
    return not (self == other)
4780 
 
4781 
class getTransactionsForCustomer_result:
4782 
  """
4783 
  Attributes:
4784 
   - success
4785 
   - ex
4786 
  """
4787 
 
4788 
  thrift_spec = (
4789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4791 
  )
4792 
 
4793 
  def __init__(self, success=None, ex=None,):
4794 
    self.success = success
4795 
    self.ex = ex
4796 
 
4797 
  def read(self, iprot):
4798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4800 
      return
4801 
    iprot.readStructBegin()
4802 
    while True:
4803 
      (fname, ftype, fid) = iprot.readFieldBegin()
4804 
      if ftype == TType.STOP:
4805 
        break
4806 
      if fid == 0:
4807 
        if ftype == TType.LIST:
4808 
          self.success = []
685 chandransh 4809 
          (_etype17, _size14) = iprot.readListBegin()
4810 
          for _i18 in xrange(_size14):
4811 
            _elem19 = Transaction()
4812 
            _elem19.read(iprot)
4813 
            self.success.append(_elem19)
94 ashish 4814 
          iprot.readListEnd()
4815 
        else:
4816 
          iprot.skip(ftype)
4817 
      elif fid == 1:
4818 
        if ftype == TType.STRUCT:
4819 
          self.ex = TransactionServiceException()
4820 
          self.ex.read(iprot)
4821 
        else:
4822 
          iprot.skip(ftype)
4823 
      else:
4824 
        iprot.skip(ftype)
4825 
      iprot.readFieldEnd()
4826 
    iprot.readStructEnd()
4827 
 
4828 
  def write(self, oprot):
4829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4831 
      return
4832 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4833 
    if self.success is not None:
94 ashish 4834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4836 
      for iter20 in self.success:
4837 
        iter20.write(oprot)
94 ashish 4838 
      oprot.writeListEnd()
4839 
      oprot.writeFieldEnd()
3431 rajveer 4840 
    if self.ex is not None:
94 ashish 4841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4842 
      self.ex.write(oprot)
4843 
      oprot.writeFieldEnd()
4844 
    oprot.writeFieldStop()
4845 
    oprot.writeStructEnd()
4846 
 
3431 rajveer 4847 
  def validate(self):
4848 
    return
4849 
 
4850 
 
94 ashish 4851 
  def __repr__(self):
4852 
    L = ['%s=%r' % (key, value)
4853 
      for key, value in self.__dict__.iteritems()]
4854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4855 
 
4856 
  def __eq__(self, other):
4857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4858 
 
4859 
  def __ne__(self, other):
4860 
    return not (self == other)
4861 
 
132 ashish 4862 
class getTransactionsForShoppingCartId_args:
4863 
  """
4864 
  Attributes:
4865 
   - shoppingCartId
4866 
  """
4867 
 
4868 
  thrift_spec = (
4869 
    None, # 0
4870 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4871 
  )
4872 
 
4873 
  def __init__(self, shoppingCartId=None,):
4874 
    self.shoppingCartId = shoppingCartId
4875 
 
4876 
  def read(self, iprot):
4877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4879 
      return
4880 
    iprot.readStructBegin()
4881 
    while True:
4882 
      (fname, ftype, fid) = iprot.readFieldBegin()
4883 
      if ftype == TType.STOP:
4884 
        break
4885 
      if fid == 1:
4886 
        if ftype == TType.I64:
4887 
          self.shoppingCartId = iprot.readI64();
4888 
        else:
4889 
          iprot.skip(ftype)
4890 
      else:
4891 
        iprot.skip(ftype)
4892 
      iprot.readFieldEnd()
4893 
    iprot.readStructEnd()
4894 
 
4895 
  def write(self, oprot):
4896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4898 
      return
4899 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4900 
    if self.shoppingCartId is not None:
132 ashish 4901 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4902 
      oprot.writeI64(self.shoppingCartId)
4903 
      oprot.writeFieldEnd()
4904 
    oprot.writeFieldStop()
4905 
    oprot.writeStructEnd()
4906 
 
3431 rajveer 4907 
  def validate(self):
4908 
    return
4909 
 
4910 
 
132 ashish 4911 
  def __repr__(self):
4912 
    L = ['%s=%r' % (key, value)
4913 
      for key, value in self.__dict__.iteritems()]
4914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4915 
 
4916 
  def __eq__(self, other):
4917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4918 
 
4919 
  def __ne__(self, other):
4920 
    return not (self == other)
4921 
 
4922 
class getTransactionsForShoppingCartId_result:
4923 
  """
4924 
  Attributes:
4925 
   - success
4926 
   - ex
4927 
  """
4928 
 
4929 
  thrift_spec = (
4930 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4932 
  )
4933 
 
4934 
  def __init__(self, success=None, ex=None,):
4935 
    self.success = success
4936 
    self.ex = ex
4937 
 
4938 
  def read(self, iprot):
4939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4941 
      return
4942 
    iprot.readStructBegin()
4943 
    while True:
4944 
      (fname, ftype, fid) = iprot.readFieldBegin()
4945 
      if ftype == TType.STOP:
4946 
        break
4947 
      if fid == 0:
4948 
        if ftype == TType.LIST:
4949 
          self.success = []
685 chandransh 4950 
          (_etype24, _size21) = iprot.readListBegin()
4951 
          for _i25 in xrange(_size21):
4952 
            _elem26 = Transaction()
4953 
            _elem26.read(iprot)
4954 
            self.success.append(_elem26)
132 ashish 4955 
          iprot.readListEnd()
4956 
        else:
4957 
          iprot.skip(ftype)
4958 
      elif fid == 1:
4959 
        if ftype == TType.STRUCT:
4960 
          self.ex = TransactionServiceException()
4961 
          self.ex.read(iprot)
4962 
        else:
4963 
          iprot.skip(ftype)
4964 
      else:
4965 
        iprot.skip(ftype)
4966 
      iprot.readFieldEnd()
4967 
    iprot.readStructEnd()
4968 
 
4969 
  def write(self, oprot):
4970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4972 
      return
4973 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4974 
    if self.success is not None:
132 ashish 4975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4976 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4977 
      for iter27 in self.success:
4978 
        iter27.write(oprot)
132 ashish 4979 
      oprot.writeListEnd()
4980 
      oprot.writeFieldEnd()
3431 rajveer 4981 
    if self.ex is not None:
132 ashish 4982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4983 
      self.ex.write(oprot)
4984 
      oprot.writeFieldEnd()
4985 
    oprot.writeFieldStop()
4986 
    oprot.writeStructEnd()
4987 
 
3431 rajveer 4988 
  def validate(self):
4989 
    return
4990 
 
4991 
 
132 ashish 4992 
  def __repr__(self):
4993 
    L = ['%s=%r' % (key, value)
4994 
      for key, value in self.__dict__.iteritems()]
4995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4996 
 
4997 
  def __eq__(self, other):
4998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4999 
 
5000 
  def __ne__(self, other):
5001 
    return not (self == other)
5002 
 
94 ashish 5003 
class getTransactionStatus_args:
5004 
  """
5005 
  Attributes:
5006 
   - transactionId
5007 
  """
5008 
 
5009 
  thrift_spec = (
5010 
    None, # 0
5011 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5012 
  )
5013 
 
5014 
  def __init__(self, transactionId=None,):
5015 
    self.transactionId = transactionId
5016 
 
5017 
  def read(self, iprot):
5018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5020 
      return
5021 
    iprot.readStructBegin()
5022 
    while True:
5023 
      (fname, ftype, fid) = iprot.readFieldBegin()
5024 
      if ftype == TType.STOP:
5025 
        break
5026 
      if fid == 1:
5027 
        if ftype == TType.I64:
5028 
          self.transactionId = iprot.readI64();
5029 
        else:
5030 
          iprot.skip(ftype)
5031 
      else:
5032 
        iprot.skip(ftype)
5033 
      iprot.readFieldEnd()
5034 
    iprot.readStructEnd()
5035 
 
5036 
  def write(self, oprot):
5037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5039 
      return
5040 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5041 
    if self.transactionId is not None:
94 ashish 5042 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5043 
      oprot.writeI64(self.transactionId)
5044 
      oprot.writeFieldEnd()
5045 
    oprot.writeFieldStop()
5046 
    oprot.writeStructEnd()
5047 
 
3431 rajveer 5048 
  def validate(self):
5049 
    return
5050 
 
5051 
 
94 ashish 5052 
  def __repr__(self):
5053 
    L = ['%s=%r' % (key, value)
5054 
      for key, value in self.__dict__.iteritems()]
5055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5056 
 
5057 
  def __eq__(self, other):
5058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5059 
 
5060 
  def __ne__(self, other):
5061 
    return not (self == other)
5062 
 
5063 
class getTransactionStatus_result:
5064 
  """
5065 
  Attributes:
5066 
   - success
5067 
   - ex
5068 
  """
5069 
 
5070 
  thrift_spec = (
5071 
    (0, TType.I32, 'success', None, None, ), # 0
5072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5073 
  )
5074 
 
5075 
  def __init__(self, success=None, ex=None,):
5076 
    self.success = success
5077 
    self.ex = ex
5078 
 
5079 
  def read(self, iprot):
5080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5082 
      return
5083 
    iprot.readStructBegin()
5084 
    while True:
5085 
      (fname, ftype, fid) = iprot.readFieldBegin()
5086 
      if ftype == TType.STOP:
5087 
        break
5088 
      if fid == 0:
5089 
        if ftype == TType.I32:
5090 
          self.success = iprot.readI32();
5091 
        else:
5092 
          iprot.skip(ftype)
5093 
      elif fid == 1:
5094 
        if ftype == TType.STRUCT:
5095 
          self.ex = TransactionServiceException()
5096 
          self.ex.read(iprot)
5097 
        else:
5098 
          iprot.skip(ftype)
5099 
      else:
5100 
        iprot.skip(ftype)
5101 
      iprot.readFieldEnd()
5102 
    iprot.readStructEnd()
5103 
 
5104 
  def write(self, oprot):
5105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5107 
      return
5108 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5109 
    if self.success is not None:
94 ashish 5110 
      oprot.writeFieldBegin('success', TType.I32, 0)
5111 
      oprot.writeI32(self.success)
5112 
      oprot.writeFieldEnd()
3431 rajveer 5113 
    if self.ex is not None:
94 ashish 5114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5115 
      self.ex.write(oprot)
5116 
      oprot.writeFieldEnd()
5117 
    oprot.writeFieldStop()
5118 
    oprot.writeStructEnd()
5119 
 
3431 rajveer 5120 
  def validate(self):
5121 
    return
5122 
 
5123 
 
94 ashish 5124 
  def __repr__(self):
5125 
    L = ['%s=%r' % (key, value)
5126 
      for key, value in self.__dict__.iteritems()]
5127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5128 
 
5129 
  def __eq__(self, other):
5130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5131 
 
5132 
  def __ne__(self, other):
5133 
    return not (self == other)
5134 
 
5135 
class changeTransactionStatus_args:
5136 
  """
5137 
  Attributes:
5138 
   - transactionId
5139 
   - status
5140 
   - description
5141 
  """
5142 
 
5143 
  thrift_spec = (
5144 
    None, # 0
5145 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5146 
    (2, TType.I32, 'status', None, None, ), # 2
5147 
    (3, TType.STRING, 'description', None, None, ), # 3
5148 
  )
5149 
 
5150 
  def __init__(self, transactionId=None, status=None, description=None,):
5151 
    self.transactionId = transactionId
5152 
    self.status = status
5153 
    self.description = description
5154 
 
5155 
  def read(self, iprot):
5156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5158 
      return
5159 
    iprot.readStructBegin()
5160 
    while True:
5161 
      (fname, ftype, fid) = iprot.readFieldBegin()
5162 
      if ftype == TType.STOP:
5163 
        break
5164 
      if fid == 1:
5165 
        if ftype == TType.I64:
5166 
          self.transactionId = iprot.readI64();
5167 
        else:
5168 
          iprot.skip(ftype)
5169 
      elif fid == 2:
5170 
        if ftype == TType.I32:
5171 
          self.status = iprot.readI32();
5172 
        else:
5173 
          iprot.skip(ftype)
5174 
      elif fid == 3:
5175 
        if ftype == TType.STRING:
5176 
          self.description = iprot.readString();
5177 
        else:
5178 
          iprot.skip(ftype)
5179 
      else:
5180 
        iprot.skip(ftype)
5181 
      iprot.readFieldEnd()
5182 
    iprot.readStructEnd()
5183 
 
5184 
  def write(self, oprot):
5185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5187 
      return
5188 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5189 
    if self.transactionId is not None:
94 ashish 5190 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5191 
      oprot.writeI64(self.transactionId)
5192 
      oprot.writeFieldEnd()
3431 rajveer 5193 
    if self.status is not None:
94 ashish 5194 
      oprot.writeFieldBegin('status', TType.I32, 2)
5195 
      oprot.writeI32(self.status)
5196 
      oprot.writeFieldEnd()
3431 rajveer 5197 
    if self.description is not None:
94 ashish 5198 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5199 
      oprot.writeString(self.description)
5200 
      oprot.writeFieldEnd()
5201 
    oprot.writeFieldStop()
5202 
    oprot.writeStructEnd()
5203 
 
3431 rajveer 5204 
  def validate(self):
5205 
    return
5206 
 
5207 
 
94 ashish 5208 
  def __repr__(self):
5209 
    L = ['%s=%r' % (key, value)
5210 
      for key, value in self.__dict__.iteritems()]
5211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5212 
 
5213 
  def __eq__(self, other):
5214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5215 
 
5216 
  def __ne__(self, other):
5217 
    return not (self == other)
5218 
 
5219 
class changeTransactionStatus_result:
5220 
  """
5221 
  Attributes:
5222 
   - success
5223 
   - ex
5224 
  """
5225 
 
5226 
  thrift_spec = (
5227 
    (0, TType.BOOL, 'success', None, None, ), # 0
5228 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5229 
  )
5230 
 
5231 
  def __init__(self, success=None, ex=None,):
5232 
    self.success = success
5233 
    self.ex = ex
5234 
 
5235 
  def read(self, iprot):
5236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5238 
      return
5239 
    iprot.readStructBegin()
5240 
    while True:
5241 
      (fname, ftype, fid) = iprot.readFieldBegin()
5242 
      if ftype == TType.STOP:
5243 
        break
5244 
      if fid == 0:
5245 
        if ftype == TType.BOOL:
5246 
          self.success = iprot.readBool();
5247 
        else:
5248 
          iprot.skip(ftype)
5249 
      elif fid == 1:
5250 
        if ftype == TType.STRUCT:
5251 
          self.ex = TransactionServiceException()
5252 
          self.ex.read(iprot)
5253 
        else:
5254 
          iprot.skip(ftype)
5255 
      else:
5256 
        iprot.skip(ftype)
5257 
      iprot.readFieldEnd()
5258 
    iprot.readStructEnd()
5259 
 
5260 
  def write(self, oprot):
5261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5263 
      return
5264 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5265 
    if self.success is not None:
94 ashish 5266 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5267 
      oprot.writeBool(self.success)
5268 
      oprot.writeFieldEnd()
3431 rajveer 5269 
    if self.ex is not None:
94 ashish 5270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5271 
      self.ex.write(oprot)
5272 
      oprot.writeFieldEnd()
5273 
    oprot.writeFieldStop()
5274 
    oprot.writeStructEnd()
5275 
 
3431 rajveer 5276 
  def validate(self):
5277 
    return
5278 
 
5279 
 
94 ashish 5280 
  def __repr__(self):
5281 
    L = ['%s=%r' % (key, value)
5282 
      for key, value in self.__dict__.iteritems()]
5283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5284 
 
5285 
  def __eq__(self, other):
5286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5287 
 
5288 
  def __ne__(self, other):
5289 
    return not (self == other)
5290 
 
1398 varun.gupt 5291 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5292 
  """
5293 
  Attributes:
5294 
   - transactionId
5295 
  """
5296 
 
5297 
  thrift_spec = (
5298 
    None, # 0
5299 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5300 
  )
5301 
 
5302 
  def __init__(self, transactionId=None,):
5303 
    self.transactionId = transactionId
5304 
 
5305 
  def read(self, iprot):
5306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5308 
      return
5309 
    iprot.readStructBegin()
5310 
    while True:
5311 
      (fname, ftype, fid) = iprot.readFieldBegin()
5312 
      if ftype == TType.STOP:
5313 
        break
5314 
      if fid == 1:
5315 
        if ftype == TType.I64:
5316 
          self.transactionId = iprot.readI64();
5317 
        else:
5318 
          iprot.skip(ftype)
5319 
      else:
5320 
        iprot.skip(ftype)
5321 
      iprot.readFieldEnd()
5322 
    iprot.readStructEnd()
5323 
 
5324 
  def write(self, oprot):
5325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5327 
      return
1398 varun.gupt 5328 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5329 
    if self.transactionId is not None:
1382 varun.gupt 5330 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5331 
      oprot.writeI64(self.transactionId)
5332 
      oprot.writeFieldEnd()
5333 
    oprot.writeFieldStop()
5334 
    oprot.writeStructEnd()
5335 
 
3431 rajveer 5336 
  def validate(self):
5337 
    return
5338 
 
5339 
 
1382 varun.gupt 5340 
  def __repr__(self):
5341 
    L = ['%s=%r' % (key, value)
5342 
      for key, value in self.__dict__.iteritems()]
5343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5344 
 
5345 
  def __eq__(self, other):
5346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5347 
 
5348 
  def __ne__(self, other):
5349 
    return not (self == other)
5350 
 
1398 varun.gupt 5351 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5352 
  """
5353 
  Attributes:
5354 
   - success
5355 
   - ex
5356 
  """
5357 
 
5358 
  thrift_spec = (
5359 
    (0, TType.BOOL, 'success', None, None, ), # 0
5360 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5361 
  )
5362 
 
5363 
  def __init__(self, success=None, ex=None,):
5364 
    self.success = success
5365 
    self.ex = ex
5366 
 
5367 
  def read(self, iprot):
5368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5370 
      return
5371 
    iprot.readStructBegin()
5372 
    while True:
5373 
      (fname, ftype, fid) = iprot.readFieldBegin()
5374 
      if ftype == TType.STOP:
5375 
        break
5376 
      if fid == 0:
5377 
        if ftype == TType.BOOL:
5378 
          self.success = iprot.readBool();
5379 
        else:
5380 
          iprot.skip(ftype)
5381 
      elif fid == 1:
5382 
        if ftype == TType.STRUCT:
5383 
          self.ex = TransactionServiceException()
5384 
          self.ex.read(iprot)
5385 
        else:
5386 
          iprot.skip(ftype)
5387 
      else:
5388 
        iprot.skip(ftype)
5389 
      iprot.readFieldEnd()
5390 
    iprot.readStructEnd()
5391 
 
5392 
  def write(self, oprot):
5393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5395 
      return
1398 varun.gupt 5396 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5397 
    if self.success is not None:
1382 varun.gupt 5398 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5399 
      oprot.writeBool(self.success)
5400 
      oprot.writeFieldEnd()
3431 rajveer 5401 
    if self.ex is not None:
1382 varun.gupt 5402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5403 
      self.ex.write(oprot)
5404 
      oprot.writeFieldEnd()
5405 
    oprot.writeFieldStop()
5406 
    oprot.writeStructEnd()
5407 
 
3431 rajveer 5408 
  def validate(self):
5409 
    return
5410 
 
5411 
 
1382 varun.gupt 5412 
  def __repr__(self):
5413 
    L = ['%s=%r' % (key, value)
5414 
      for key, value in self.__dict__.iteritems()]
5415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5416 
 
5417 
  def __eq__(self, other):
5418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5419 
 
5420 
  def __ne__(self, other):
5421 
    return not (self == other)
5422 
 
483 rajveer 5423 
class getAllOrders_args:
94 ashish 5424 
  """
5425 
  Attributes:
483 rajveer 5426 
   - status
5427 
   - from_date
5428 
   - to_date
5429 
   - warehouse_id
94 ashish 5430 
  """
5431 
 
5432 
  thrift_spec = (
5433 
    None, # 0
483 rajveer 5434 
    (1, TType.I32, 'status', None, None, ), # 1
5435 
    (2, TType.I64, 'from_date', None, None, ), # 2
5436 
    (3, TType.I64, 'to_date', None, None, ), # 3
5437 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5438 
  )
5439 
 
483 rajveer 5440 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5441 
    self.status = status
5442 
    self.from_date = from_date
5443 
    self.to_date = to_date
5444 
    self.warehouse_id = warehouse_id
94 ashish 5445 
 
5446 
  def read(self, iprot):
5447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5449 
      return
5450 
    iprot.readStructBegin()
5451 
    while True:
5452 
      (fname, ftype, fid) = iprot.readFieldBegin()
5453 
      if ftype == TType.STOP:
5454 
        break
5455 
      if fid == 1:
483 rajveer 5456 
        if ftype == TType.I32:
5457 
          self.status = iprot.readI32();
94 ashish 5458 
        else:
5459 
          iprot.skip(ftype)
483 rajveer 5460 
      elif fid == 2:
5461 
        if ftype == TType.I64:
5462 
          self.from_date = iprot.readI64();
94 ashish 5463 
        else:
5464 
          iprot.skip(ftype)
483 rajveer 5465 
      elif fid == 3:
5466 
        if ftype == TType.I64:
5467 
          self.to_date = iprot.readI64();
94 ashish 5468 
        else:
5469 
          iprot.skip(ftype)
483 rajveer 5470 
      elif fid == 4:
94 ashish 5471 
        if ftype == TType.I64:
483 rajveer 5472 
          self.warehouse_id = iprot.readI64();
94 ashish 5473 
        else:
5474 
          iprot.skip(ftype)
5475 
      else:
5476 
        iprot.skip(ftype)
5477 
      iprot.readFieldEnd()
5478 
    iprot.readStructEnd()
5479 
 
5480 
  def write(self, oprot):
5481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5483 
      return
483 rajveer 5484 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5485 
    if self.status is not None:
483 rajveer 5486 
      oprot.writeFieldBegin('status', TType.I32, 1)
5487 
      oprot.writeI32(self.status)
94 ashish 5488 
      oprot.writeFieldEnd()
3431 rajveer 5489 
    if self.from_date is not None:
483 rajveer 5490 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5491 
      oprot.writeI64(self.from_date)
94 ashish 5492 
      oprot.writeFieldEnd()
3431 rajveer 5493 
    if self.to_date is not None:
483 rajveer 5494 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5495 
      oprot.writeI64(self.to_date)
94 ashish 5496 
      oprot.writeFieldEnd()
3431 rajveer 5497 
    if self.warehouse_id is not None:
483 rajveer 5498 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5499 
      oprot.writeI64(self.warehouse_id)
94 ashish 5500 
      oprot.writeFieldEnd()
5501 
    oprot.writeFieldStop()
5502 
    oprot.writeStructEnd()
5503 
 
3431 rajveer 5504 
  def validate(self):
5505 
    return
5506 
 
5507 
 
94 ashish 5508 
  def __repr__(self):
5509 
    L = ['%s=%r' % (key, value)
5510 
      for key, value in self.__dict__.iteritems()]
5511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5512 
 
5513 
  def __eq__(self, other):
5514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5515 
 
5516 
  def __ne__(self, other):
5517 
    return not (self == other)
5518 
 
483 rajveer 5519 
class getAllOrders_result:
94 ashish 5520 
  """
5521 
  Attributes:
5522 
   - success
5523 
   - ex
5524 
  """
5525 
 
5526 
  thrift_spec = (
483 rajveer 5527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5529 
  )
5530 
 
5531 
  def __init__(self, success=None, ex=None,):
5532 
    self.success = success
5533 
    self.ex = ex
5534 
 
5535 
  def read(self, iprot):
5536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5538 
      return
5539 
    iprot.readStructBegin()
5540 
    while True:
5541 
      (fname, ftype, fid) = iprot.readFieldBegin()
5542 
      if ftype == TType.STOP:
5543 
        break
5544 
      if fid == 0:
483 rajveer 5545 
        if ftype == TType.LIST:
5546 
          self.success = []
685 chandransh 5547 
          (_etype31, _size28) = iprot.readListBegin()
5548 
          for _i32 in xrange(_size28):
5549 
            _elem33 = Order()
5550 
            _elem33.read(iprot)
5551 
            self.success.append(_elem33)
483 rajveer 5552 
          iprot.readListEnd()
94 ashish 5553 
        else:
5554 
          iprot.skip(ftype)
5555 
      elif fid == 1:
5556 
        if ftype == TType.STRUCT:
5557 
          self.ex = TransactionServiceException()
5558 
          self.ex.read(iprot)
5559 
        else:
5560 
          iprot.skip(ftype)
5561 
      else:
5562 
        iprot.skip(ftype)
5563 
      iprot.readFieldEnd()
5564 
    iprot.readStructEnd()
5565 
 
5566 
  def write(self, oprot):
5567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5569 
      return
483 rajveer 5570 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5571 
    if self.success is not None:
483 rajveer 5572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5574 
      for iter34 in self.success:
5575 
        iter34.write(oprot)
483 rajveer 5576 
      oprot.writeListEnd()
94 ashish 5577 
      oprot.writeFieldEnd()
3431 rajveer 5578 
    if self.ex is not None:
94 ashish 5579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5580 
      self.ex.write(oprot)
5581 
      oprot.writeFieldEnd()
5582 
    oprot.writeFieldStop()
5583 
    oprot.writeStructEnd()
5584 
 
3431 rajveer 5585 
  def validate(self):
5586 
    return
5587 
 
5588 
 
94 ashish 5589 
  def __repr__(self):
5590 
    L = ['%s=%r' % (key, value)
5591 
      for key, value in self.__dict__.iteritems()]
5592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5593 
 
5594 
  def __eq__(self, other):
5595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5596 
 
5597 
  def __ne__(self, other):
5598 
    return not (self == other)
5599 
 
4133 chandransh 5600 
class getOrdersInBatch_args:
5601 
  """
5602 
  Attributes:
5603 
   - statuses
5604 
   - offset
5605 
   - limit
5606 
   - warehouse_id
5607 
  """
5608 
 
5609 
  thrift_spec = (
5610 
    None, # 0
5611 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5612 
    (2, TType.I64, 'offset', None, None, ), # 2
5613 
    (3, TType.I64, 'limit', None, None, ), # 3
5614 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5615 
  )
5616 
 
5617 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5618 
    self.statuses = statuses
5619 
    self.offset = offset
5620 
    self.limit = limit
5621 
    self.warehouse_id = warehouse_id
5622 
 
5623 
  def read(self, iprot):
5624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5626 
      return
5627 
    iprot.readStructBegin()
5628 
    while True:
5629 
      (fname, ftype, fid) = iprot.readFieldBegin()
5630 
      if ftype == TType.STOP:
5631 
        break
5632 
      if fid == 1:
5633 
        if ftype == TType.LIST:
5634 
          self.statuses = []
5635 
          (_etype38, _size35) = iprot.readListBegin()
5636 
          for _i39 in xrange(_size35):
5637 
            _elem40 = iprot.readI32();
5638 
            self.statuses.append(_elem40)
5639 
          iprot.readListEnd()
5640 
        else:
5641 
          iprot.skip(ftype)
5642 
      elif fid == 2:
5643 
        if ftype == TType.I64:
5644 
          self.offset = iprot.readI64();
5645 
        else:
5646 
          iprot.skip(ftype)
5647 
      elif fid == 3:
5648 
        if ftype == TType.I64:
5649 
          self.limit = iprot.readI64();
5650 
        else:
5651 
          iprot.skip(ftype)
5652 
      elif fid == 4:
5653 
        if ftype == TType.I64:
5654 
          self.warehouse_id = iprot.readI64();
5655 
        else:
5656 
          iprot.skip(ftype)
5657 
      else:
5658 
        iprot.skip(ftype)
5659 
      iprot.readFieldEnd()
5660 
    iprot.readStructEnd()
5661 
 
5662 
  def write(self, oprot):
5663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5665 
      return
5666 
    oprot.writeStructBegin('getOrdersInBatch_args')
5667 
    if self.statuses is not None:
5668 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5669 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5670 
      for iter41 in self.statuses:
5671 
        oprot.writeI32(iter41)
5672 
      oprot.writeListEnd()
5673 
      oprot.writeFieldEnd()
5674 
    if self.offset is not None:
5675 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5676 
      oprot.writeI64(self.offset)
5677 
      oprot.writeFieldEnd()
5678 
    if self.limit is not None:
5679 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5680 
      oprot.writeI64(self.limit)
5681 
      oprot.writeFieldEnd()
5682 
    if self.warehouse_id is not None:
5683 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5684 
      oprot.writeI64(self.warehouse_id)
5685 
      oprot.writeFieldEnd()
5686 
    oprot.writeFieldStop()
5687 
    oprot.writeStructEnd()
5688 
 
5689 
  def validate(self):
5690 
    return
5691 
 
5692 
 
5693 
  def __repr__(self):
5694 
    L = ['%s=%r' % (key, value)
5695 
      for key, value in self.__dict__.iteritems()]
5696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5697 
 
5698 
  def __eq__(self, other):
5699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5700 
 
5701 
  def __ne__(self, other):
5702 
    return not (self == other)
5703 
 
5704 
class getOrdersInBatch_result:
5705 
  """
5706 
  Attributes:
5707 
   - success
5708 
   - ex
5709 
  """
5710 
 
5711 
  thrift_spec = (
5712 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5714 
  )
5715 
 
5716 
  def __init__(self, success=None, ex=None,):
5717 
    self.success = success
5718 
    self.ex = ex
5719 
 
5720 
  def read(self, iprot):
5721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5723 
      return
5724 
    iprot.readStructBegin()
5725 
    while True:
5726 
      (fname, ftype, fid) = iprot.readFieldBegin()
5727 
      if ftype == TType.STOP:
5728 
        break
5729 
      if fid == 0:
5730 
        if ftype == TType.LIST:
5731 
          self.success = []
5732 
          (_etype45, _size42) = iprot.readListBegin()
5733 
          for _i46 in xrange(_size42):
5734 
            _elem47 = Order()
5735 
            _elem47.read(iprot)
5736 
            self.success.append(_elem47)
5737 
          iprot.readListEnd()
5738 
        else:
5739 
          iprot.skip(ftype)
5740 
      elif fid == 1:
5741 
        if ftype == TType.STRUCT:
5742 
          self.ex = TransactionServiceException()
5743 
          self.ex.read(iprot)
5744 
        else:
5745 
          iprot.skip(ftype)
5746 
      else:
5747 
        iprot.skip(ftype)
5748 
      iprot.readFieldEnd()
5749 
    iprot.readStructEnd()
5750 
 
5751 
  def write(self, oprot):
5752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5754 
      return
5755 
    oprot.writeStructBegin('getOrdersInBatch_result')
5756 
    if self.success is not None:
5757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5759 
      for iter48 in self.success:
5760 
        iter48.write(oprot)
5761 
      oprot.writeListEnd()
5762 
      oprot.writeFieldEnd()
5763 
    if self.ex is not None:
5764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5765 
      self.ex.write(oprot)
5766 
      oprot.writeFieldEnd()
5767 
    oprot.writeFieldStop()
5768 
    oprot.writeStructEnd()
5769 
 
5770 
  def validate(self):
5771 
    return
5772 
 
5773 
 
5774 
  def __repr__(self):
5775 
    L = ['%s=%r' % (key, value)
5776 
      for key, value in self.__dict__.iteritems()]
5777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5778 
 
5779 
  def __eq__(self, other):
5780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5781 
 
5782 
  def __ne__(self, other):
5783 
    return not (self == other)
5784 
 
5785 
class getOrderCount_args:
5786 
  """
5787 
  Attributes:
5788 
   - statuses
5789 
   - warehouseId
5790 
  """
5791 
 
5792 
  thrift_spec = (
5793 
    None, # 0
5794 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5795 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5796 
  )
5797 
 
5798 
  def __init__(self, statuses=None, warehouseId=None,):
5799 
    self.statuses = statuses
5800 
    self.warehouseId = warehouseId
5801 
 
5802 
  def read(self, iprot):
5803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5805 
      return
5806 
    iprot.readStructBegin()
5807 
    while True:
5808 
      (fname, ftype, fid) = iprot.readFieldBegin()
5809 
      if ftype == TType.STOP:
5810 
        break
5811 
      if fid == 1:
5812 
        if ftype == TType.LIST:
5813 
          self.statuses = []
5814 
          (_etype52, _size49) = iprot.readListBegin()
5815 
          for _i53 in xrange(_size49):
5816 
            _elem54 = iprot.readI32();
5817 
            self.statuses.append(_elem54)
5818 
          iprot.readListEnd()
5819 
        else:
5820 
          iprot.skip(ftype)
5821 
      elif fid == 2:
5822 
        if ftype == TType.I64:
5823 
          self.warehouseId = iprot.readI64();
5824 
        else:
5825 
          iprot.skip(ftype)
5826 
      else:
5827 
        iprot.skip(ftype)
5828 
      iprot.readFieldEnd()
5829 
    iprot.readStructEnd()
5830 
 
5831 
  def write(self, oprot):
5832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5834 
      return
5835 
    oprot.writeStructBegin('getOrderCount_args')
5836 
    if self.statuses is not None:
5837 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5838 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5839 
      for iter55 in self.statuses:
5840 
        oprot.writeI32(iter55)
5841 
      oprot.writeListEnd()
5842 
      oprot.writeFieldEnd()
5843 
    if self.warehouseId is not None:
5844 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5845 
      oprot.writeI64(self.warehouseId)
5846 
      oprot.writeFieldEnd()
5847 
    oprot.writeFieldStop()
5848 
    oprot.writeStructEnd()
5849 
 
5850 
  def validate(self):
5851 
    return
5852 
 
5853 
 
5854 
  def __repr__(self):
5855 
    L = ['%s=%r' % (key, value)
5856 
      for key, value in self.__dict__.iteritems()]
5857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5858 
 
5859 
  def __eq__(self, other):
5860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5861 
 
5862 
  def __ne__(self, other):
5863 
    return not (self == other)
5864 
 
5865 
class getOrderCount_result:
5866 
  """
5867 
  Attributes:
5868 
   - success
5869 
   - ex
5870 
  """
5871 
 
5872 
  thrift_spec = (
5873 
    (0, TType.I32, 'success', None, None, ), # 0
5874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5875 
  )
5876 
 
5877 
  def __init__(self, success=None, ex=None,):
5878 
    self.success = success
5879 
    self.ex = ex
5880 
 
5881 
  def read(self, iprot):
5882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5884 
      return
5885 
    iprot.readStructBegin()
5886 
    while True:
5887 
      (fname, ftype, fid) = iprot.readFieldBegin()
5888 
      if ftype == TType.STOP:
5889 
        break
5890 
      if fid == 0:
5891 
        if ftype == TType.I32:
5892 
          self.success = iprot.readI32();
5893 
        else:
5894 
          iprot.skip(ftype)
5895 
      elif fid == 1:
5896 
        if ftype == TType.STRUCT:
5897 
          self.ex = TransactionServiceException()
5898 
          self.ex.read(iprot)
5899 
        else:
5900 
          iprot.skip(ftype)
5901 
      else:
5902 
        iprot.skip(ftype)
5903 
      iprot.readFieldEnd()
5904 
    iprot.readStructEnd()
5905 
 
5906 
  def write(self, oprot):
5907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5909 
      return
5910 
    oprot.writeStructBegin('getOrderCount_result')
5911 
    if self.success is not None:
5912 
      oprot.writeFieldBegin('success', TType.I32, 0)
5913 
      oprot.writeI32(self.success)
5914 
      oprot.writeFieldEnd()
5915 
    if self.ex is not None:
5916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5917 
      self.ex.write(oprot)
5918 
      oprot.writeFieldEnd()
5919 
    oprot.writeFieldStop()
5920 
    oprot.writeStructEnd()
5921 
 
5922 
  def validate(self):
5923 
    return
5924 
 
5925 
 
5926 
  def __repr__(self):
5927 
    L = ['%s=%r' % (key, value)
5928 
      for key, value in self.__dict__.iteritems()]
5929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5930 
 
5931 
  def __eq__(self, other):
5932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5933 
 
5934 
  def __ne__(self, other):
5935 
    return not (self == other)
5936 
 
999 varun.gupt 5937 
class getOrdersByBillingDate_args:
5938 
  """
5939 
  Attributes:
5940 
   - status
5941 
   - start_billing_date
5942 
   - end_billing_date
5943 
   - warehouse_id
5944 
  """
5945 
 
5946 
  thrift_spec = (
5947 
    None, # 0
5948 
    (1, TType.I32, 'status', None, None, ), # 1
5949 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5950 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5951 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5952 
  )
5953 
 
5954 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5955 
    self.status = status
5956 
    self.start_billing_date = start_billing_date
5957 
    self.end_billing_date = end_billing_date
5958 
    self.warehouse_id = warehouse_id
5959 
 
5960 
  def read(self, iprot):
5961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5963 
      return
5964 
    iprot.readStructBegin()
5965 
    while True:
5966 
      (fname, ftype, fid) = iprot.readFieldBegin()
5967 
      if ftype == TType.STOP:
5968 
        break
5969 
      if fid == 1:
5970 
        if ftype == TType.I32:
5971 
          self.status = iprot.readI32();
5972 
        else:
5973 
          iprot.skip(ftype)
5974 
      elif fid == 2:
5975 
        if ftype == TType.I64:
5976 
          self.start_billing_date = iprot.readI64();
5977 
        else:
5978 
          iprot.skip(ftype)
5979 
      elif fid == 3:
5980 
        if ftype == TType.I64:
5981 
          self.end_billing_date = iprot.readI64();
5982 
        else:
5983 
          iprot.skip(ftype)
5984 
      elif fid == 4:
5985 
        if ftype == TType.I64:
5986 
          self.warehouse_id = iprot.readI64();
5987 
        else:
5988 
          iprot.skip(ftype)
5989 
      else:
5990 
        iprot.skip(ftype)
5991 
      iprot.readFieldEnd()
5992 
    iprot.readStructEnd()
5993 
 
5994 
  def write(self, oprot):
5995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5997 
      return
5998 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5999 
    if self.status is not None:
999 varun.gupt 6000 
      oprot.writeFieldBegin('status', TType.I32, 1)
6001 
      oprot.writeI32(self.status)
6002 
      oprot.writeFieldEnd()
3431 rajveer 6003 
    if self.start_billing_date is not None:
999 varun.gupt 6004 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6005 
      oprot.writeI64(self.start_billing_date)
6006 
      oprot.writeFieldEnd()
3431 rajveer 6007 
    if self.end_billing_date is not None:
999 varun.gupt 6008 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6009 
      oprot.writeI64(self.end_billing_date)
6010 
      oprot.writeFieldEnd()
3431 rajveer 6011 
    if self.warehouse_id is not None:
999 varun.gupt 6012 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6013 
      oprot.writeI64(self.warehouse_id)
6014 
      oprot.writeFieldEnd()
6015 
    oprot.writeFieldStop()
6016 
    oprot.writeStructEnd()
6017 
 
3431 rajveer 6018 
  def validate(self):
6019 
    return
6020 
 
6021 
 
999 varun.gupt 6022 
  def __repr__(self):
6023 
    L = ['%s=%r' % (key, value)
6024 
      for key, value in self.__dict__.iteritems()]
6025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6026 
 
6027 
  def __eq__(self, other):
6028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6029 
 
6030 
  def __ne__(self, other):
6031 
    return not (self == other)
6032 
 
6033 
class getOrdersByBillingDate_result:
6034 
  """
6035 
  Attributes:
6036 
   - success
6037 
   - ex
6038 
  """
6039 
 
6040 
  thrift_spec = (
6041 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6043 
  )
6044 
 
6045 
  def __init__(self, success=None, ex=None,):
6046 
    self.success = success
6047 
    self.ex = ex
6048 
 
6049 
  def read(self, iprot):
6050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6052 
      return
6053 
    iprot.readStructBegin()
6054 
    while True:
6055 
      (fname, ftype, fid) = iprot.readFieldBegin()
6056 
      if ftype == TType.STOP:
6057 
        break
6058 
      if fid == 0:
6059 
        if ftype == TType.LIST:
6060 
          self.success = []
4133 chandransh 6061 
          (_etype59, _size56) = iprot.readListBegin()
6062 
          for _i60 in xrange(_size56):
6063 
            _elem61 = Order()
6064 
            _elem61.read(iprot)
6065 
            self.success.append(_elem61)
999 varun.gupt 6066 
          iprot.readListEnd()
6067 
        else:
6068 
          iprot.skip(ftype)
6069 
      elif fid == 1:
6070 
        if ftype == TType.STRUCT:
6071 
          self.ex = TransactionServiceException()
6072 
          self.ex.read(iprot)
6073 
        else:
6074 
          iprot.skip(ftype)
6075 
      else:
6076 
        iprot.skip(ftype)
6077 
      iprot.readFieldEnd()
6078 
    iprot.readStructEnd()
6079 
 
6080 
  def write(self, oprot):
6081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6083 
      return
6084 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6085 
    if self.success is not None:
999 varun.gupt 6086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6088 
      for iter62 in self.success:
6089 
        iter62.write(oprot)
999 varun.gupt 6090 
      oprot.writeListEnd()
6091 
      oprot.writeFieldEnd()
3431 rajveer 6092 
    if self.ex is not None:
999 varun.gupt 6093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6094 
      self.ex.write(oprot)
6095 
      oprot.writeFieldEnd()
6096 
    oprot.writeFieldStop()
6097 
    oprot.writeStructEnd()
6098 
 
3431 rajveer 6099 
  def validate(self):
6100 
    return
6101 
 
6102 
 
999 varun.gupt 6103 
  def __repr__(self):
6104 
    L = ['%s=%r' % (key, value)
6105 
      for key, value in self.__dict__.iteritems()]
6106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6107 
 
6108 
  def __eq__(self, other):
6109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6110 
 
6111 
  def __ne__(self, other):
6112 
    return not (self == other)
6113 
 
3427 chandransh 6114 
class getOrdersByShippingDate_args:
6115 
  """
6116 
  Attributes:
6117 
   - fromShippingDate
6118 
   - toShippingDate
6119 
   - providerId
6120 
   - warehouseId
3451 chandransh 6121 
   - cod
3427 chandransh 6122 
  """
6123 
 
6124 
  thrift_spec = (
6125 
    None, # 0
6126 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6127 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6128 
    (3, TType.I64, 'providerId', None, None, ), # 3
6129 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6130 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6131 
  )
6132 
 
3451 chandransh 6133 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6134 
    self.fromShippingDate = fromShippingDate
6135 
    self.toShippingDate = toShippingDate
6136 
    self.providerId = providerId
6137 
    self.warehouseId = warehouseId
3451 chandransh 6138 
    self.cod = cod
3427 chandransh 6139 
 
6140 
  def read(self, iprot):
6141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6143 
      return
6144 
    iprot.readStructBegin()
6145 
    while True:
6146 
      (fname, ftype, fid) = iprot.readFieldBegin()
6147 
      if ftype == TType.STOP:
6148 
        break
6149 
      if fid == 1:
6150 
        if ftype == TType.I64:
6151 
          self.fromShippingDate = iprot.readI64();
6152 
        else:
6153 
          iprot.skip(ftype)
6154 
      elif fid == 2:
6155 
        if ftype == TType.I64:
6156 
          self.toShippingDate = iprot.readI64();
6157 
        else:
6158 
          iprot.skip(ftype)
6159 
      elif fid == 3:
6160 
        if ftype == TType.I64:
6161 
          self.providerId = iprot.readI64();
6162 
        else:
6163 
          iprot.skip(ftype)
6164 
      elif fid == 4:
6165 
        if ftype == TType.I64:
6166 
          self.warehouseId = iprot.readI64();
6167 
        else:
6168 
          iprot.skip(ftype)
3451 chandransh 6169 
      elif fid == 5:
6170 
        if ftype == TType.BOOL:
6171 
          self.cod = iprot.readBool();
6172 
        else:
6173 
          iprot.skip(ftype)
3427 chandransh 6174 
      else:
6175 
        iprot.skip(ftype)
6176 
      iprot.readFieldEnd()
6177 
    iprot.readStructEnd()
6178 
 
6179 
  def write(self, oprot):
6180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6182 
      return
6183 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6184 
    if self.fromShippingDate is not None:
3427 chandransh 6185 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6186 
      oprot.writeI64(self.fromShippingDate)
6187 
      oprot.writeFieldEnd()
3431 rajveer 6188 
    if self.toShippingDate is not None:
3427 chandransh 6189 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6190 
      oprot.writeI64(self.toShippingDate)
6191 
      oprot.writeFieldEnd()
3431 rajveer 6192 
    if self.providerId is not None:
3427 chandransh 6193 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6194 
      oprot.writeI64(self.providerId)
6195 
      oprot.writeFieldEnd()
3431 rajveer 6196 
    if self.warehouseId is not None:
3427 chandransh 6197 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6198 
      oprot.writeI64(self.warehouseId)
6199 
      oprot.writeFieldEnd()
3451 chandransh 6200 
    if self.cod is not None:
6201 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6202 
      oprot.writeBool(self.cod)
6203 
      oprot.writeFieldEnd()
3427 chandransh 6204 
    oprot.writeFieldStop()
6205 
    oprot.writeStructEnd()
6206 
 
3431 rajveer 6207 
  def validate(self):
6208 
    return
6209 
 
6210 
 
3427 chandransh 6211 
  def __repr__(self):
6212 
    L = ['%s=%r' % (key, value)
6213 
      for key, value in self.__dict__.iteritems()]
6214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6215 
 
6216 
  def __eq__(self, other):
6217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6218 
 
6219 
  def __ne__(self, other):
6220 
    return not (self == other)
6221 
 
6222 
class getOrdersByShippingDate_result:
6223 
  """
6224 
  Attributes:
6225 
   - success
6226 
   - ex
6227 
  """
6228 
 
6229 
  thrift_spec = (
6230 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6232 
  )
6233 
 
6234 
  def __init__(self, success=None, ex=None,):
6235 
    self.success = success
6236 
    self.ex = ex
6237 
 
6238 
  def read(self, iprot):
6239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6241 
      return
6242 
    iprot.readStructBegin()
6243 
    while True:
6244 
      (fname, ftype, fid) = iprot.readFieldBegin()
6245 
      if ftype == TType.STOP:
6246 
        break
6247 
      if fid == 0:
6248 
        if ftype == TType.LIST:
6249 
          self.success = []
4133 chandransh 6250 
          (_etype66, _size63) = iprot.readListBegin()
6251 
          for _i67 in xrange(_size63):
6252 
            _elem68 = Order()
6253 
            _elem68.read(iprot)
6254 
            self.success.append(_elem68)
3427 chandransh 6255 
          iprot.readListEnd()
6256 
        else:
6257 
          iprot.skip(ftype)
6258 
      elif fid == 1:
6259 
        if ftype == TType.STRUCT:
6260 
          self.ex = TransactionServiceException()
6261 
          self.ex.read(iprot)
6262 
        else:
6263 
          iprot.skip(ftype)
6264 
      else:
6265 
        iprot.skip(ftype)
6266 
      iprot.readFieldEnd()
6267 
    iprot.readStructEnd()
6268 
 
6269 
  def write(self, oprot):
6270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6272 
      return
6273 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6274 
    if self.success is not None:
3427 chandransh 6275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6276 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6277 
      for iter69 in self.success:
6278 
        iter69.write(oprot)
3427 chandransh 6279 
      oprot.writeListEnd()
6280 
      oprot.writeFieldEnd()
3431 rajveer 6281 
    if self.ex is not None:
3427 chandransh 6282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6283 
      self.ex.write(oprot)
6284 
      oprot.writeFieldEnd()
6285 
    oprot.writeFieldStop()
6286 
    oprot.writeStructEnd()
6287 
 
3431 rajveer 6288 
  def validate(self):
6289 
    return
6290 
 
6291 
 
3427 chandransh 6292 
  def __repr__(self):
6293 
    L = ['%s=%r' % (key, value)
6294 
      for key, value in self.__dict__.iteritems()]
6295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6296 
 
6297 
  def __eq__(self, other):
6298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6299 
 
6300 
  def __ne__(self, other):
6301 
    return not (self == other)
6302 
 
1382 varun.gupt 6303 
class getReturnableOrdersForCustomer_args:
6304 
  """
6305 
  Attributes:
6306 
   - customer_id
6307 
   - limit
6308 
  """
6309 
 
6310 
  thrift_spec = (
6311 
    None, # 0
6312 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6313 
    (2, TType.I64, 'limit', None, None, ), # 2
6314 
  )
6315 
 
6316 
  def __init__(self, customer_id=None, limit=None,):
6317 
    self.customer_id = customer_id
6318 
    self.limit = limit
6319 
 
6320 
  def read(self, iprot):
6321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6323 
      return
6324 
    iprot.readStructBegin()
6325 
    while True:
6326 
      (fname, ftype, fid) = iprot.readFieldBegin()
6327 
      if ftype == TType.STOP:
6328 
        break
6329 
      if fid == 1:
6330 
        if ftype == TType.I64:
6331 
          self.customer_id = iprot.readI64();
6332 
        else:
6333 
          iprot.skip(ftype)
6334 
      elif fid == 2:
6335 
        if ftype == TType.I64:
6336 
          self.limit = iprot.readI64();
6337 
        else:
6338 
          iprot.skip(ftype)
6339 
      else:
6340 
        iprot.skip(ftype)
6341 
      iprot.readFieldEnd()
6342 
    iprot.readStructEnd()
6343 
 
6344 
  def write(self, oprot):
6345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6347 
      return
6348 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6349 
    if self.customer_id is not None:
1382 varun.gupt 6350 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6351 
      oprot.writeI64(self.customer_id)
6352 
      oprot.writeFieldEnd()
3431 rajveer 6353 
    if self.limit is not None:
1382 varun.gupt 6354 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6355 
      oprot.writeI64(self.limit)
6356 
      oprot.writeFieldEnd()
6357 
    oprot.writeFieldStop()
6358 
    oprot.writeStructEnd()
6359 
 
3431 rajveer 6360 
  def validate(self):
6361 
    return
6362 
 
6363 
 
1382 varun.gupt 6364 
  def __repr__(self):
6365 
    L = ['%s=%r' % (key, value)
6366 
      for key, value in self.__dict__.iteritems()]
6367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6368 
 
6369 
  def __eq__(self, other):
6370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6371 
 
6372 
  def __ne__(self, other):
6373 
    return not (self == other)
6374 
 
6375 
class getReturnableOrdersForCustomer_result:
6376 
  """
6377 
  Attributes:
6378 
   - success
6379 
   - ex
6380 
  """
6381 
 
6382 
  thrift_spec = (
6383 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6385 
  )
6386 
 
6387 
  def __init__(self, success=None, ex=None,):
6388 
    self.success = success
6389 
    self.ex = ex
6390 
 
6391 
  def read(self, iprot):
6392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6394 
      return
6395 
    iprot.readStructBegin()
6396 
    while True:
6397 
      (fname, ftype, fid) = iprot.readFieldBegin()
6398 
      if ftype == TType.STOP:
6399 
        break
6400 
      if fid == 0:
6401 
        if ftype == TType.LIST:
6402 
          self.success = []
4133 chandransh 6403 
          (_etype73, _size70) = iprot.readListBegin()
6404 
          for _i74 in xrange(_size70):
6405 
            _elem75 = iprot.readI64();
6406 
            self.success.append(_elem75)
1382 varun.gupt 6407 
          iprot.readListEnd()
6408 
        else:
6409 
          iprot.skip(ftype)
6410 
      elif fid == 1:
6411 
        if ftype == TType.STRUCT:
6412 
          self.ex = TransactionServiceException()
6413 
          self.ex.read(iprot)
6414 
        else:
6415 
          iprot.skip(ftype)
6416 
      else:
6417 
        iprot.skip(ftype)
6418 
      iprot.readFieldEnd()
6419 
    iprot.readStructEnd()
6420 
 
6421 
  def write(self, oprot):
6422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6424 
      return
6425 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6426 
    if self.success is not None:
1382 varun.gupt 6427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6428 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6429 
      for iter76 in self.success:
6430 
        oprot.writeI64(iter76)
1382 varun.gupt 6431 
      oprot.writeListEnd()
6432 
      oprot.writeFieldEnd()
3431 rajveer 6433 
    if self.ex is not None:
1382 varun.gupt 6434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6435 
      self.ex.write(oprot)
6436 
      oprot.writeFieldEnd()
6437 
    oprot.writeFieldStop()
6438 
    oprot.writeStructEnd()
6439 
 
3431 rajveer 6440 
  def validate(self):
6441 
    return
6442 
 
6443 
 
1382 varun.gupt 6444 
  def __repr__(self):
6445 
    L = ['%s=%r' % (key, value)
6446 
      for key, value in self.__dict__.iteritems()]
6447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6448 
 
6449 
  def __eq__(self, other):
6450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6451 
 
6452 
  def __ne__(self, other):
6453 
    return not (self == other)
6454 
 
6455 
class getCancellableOrdersForCustomer_args:
6456 
  """
6457 
  Attributes:
6458 
   - customer_id
6459 
   - limit
6460 
  """
6461 
 
6462 
  thrift_spec = (
6463 
    None, # 0
6464 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6465 
    (2, TType.I64, 'limit', None, None, ), # 2
6466 
  )
6467 
 
6468 
  def __init__(self, customer_id=None, limit=None,):
6469 
    self.customer_id = customer_id
6470 
    self.limit = limit
6471 
 
6472 
  def read(self, iprot):
6473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6475 
      return
6476 
    iprot.readStructBegin()
6477 
    while True:
6478 
      (fname, ftype, fid) = iprot.readFieldBegin()
6479 
      if ftype == TType.STOP:
6480 
        break
6481 
      if fid == 1:
6482 
        if ftype == TType.I64:
6483 
          self.customer_id = iprot.readI64();
6484 
        else:
6485 
          iprot.skip(ftype)
6486 
      elif fid == 2:
6487 
        if ftype == TType.I64:
6488 
          self.limit = iprot.readI64();
6489 
        else:
6490 
          iprot.skip(ftype)
6491 
      else:
6492 
        iprot.skip(ftype)
6493 
      iprot.readFieldEnd()
6494 
    iprot.readStructEnd()
6495 
 
6496 
  def write(self, oprot):
6497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6499 
      return
6500 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6501 
    if self.customer_id is not None:
1382 varun.gupt 6502 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6503 
      oprot.writeI64(self.customer_id)
6504 
      oprot.writeFieldEnd()
3431 rajveer 6505 
    if self.limit is not None:
1382 varun.gupt 6506 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6507 
      oprot.writeI64(self.limit)
6508 
      oprot.writeFieldEnd()
6509 
    oprot.writeFieldStop()
6510 
    oprot.writeStructEnd()
6511 
 
3431 rajveer 6512 
  def validate(self):
6513 
    return
6514 
 
6515 
 
1382 varun.gupt 6516 
  def __repr__(self):
6517 
    L = ['%s=%r' % (key, value)
6518 
      for key, value in self.__dict__.iteritems()]
6519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6520 
 
6521 
  def __eq__(self, other):
6522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6523 
 
6524 
  def __ne__(self, other):
6525 
    return not (self == other)
6526 
 
6527 
class getCancellableOrdersForCustomer_result:
6528 
  """
6529 
  Attributes:
6530 
   - success
6531 
   - ex
6532 
  """
6533 
 
6534 
  thrift_spec = (
6535 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6537 
  )
6538 
 
6539 
  def __init__(self, success=None, ex=None,):
6540 
    self.success = success
6541 
    self.ex = ex
6542 
 
6543 
  def read(self, iprot):
6544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6546 
      return
6547 
    iprot.readStructBegin()
6548 
    while True:
6549 
      (fname, ftype, fid) = iprot.readFieldBegin()
6550 
      if ftype == TType.STOP:
6551 
        break
6552 
      if fid == 0:
6553 
        if ftype == TType.LIST:
6554 
          self.success = []
4133 chandransh 6555 
          (_etype80, _size77) = iprot.readListBegin()
6556 
          for _i81 in xrange(_size77):
6557 
            _elem82 = iprot.readI64();
6558 
            self.success.append(_elem82)
1382 varun.gupt 6559 
          iprot.readListEnd()
6560 
        else:
6561 
          iprot.skip(ftype)
6562 
      elif fid == 1:
6563 
        if ftype == TType.STRUCT:
6564 
          self.ex = TransactionServiceException()
6565 
          self.ex.read(iprot)
6566 
        else:
6567 
          iprot.skip(ftype)
6568 
      else:
6569 
        iprot.skip(ftype)
6570 
      iprot.readFieldEnd()
6571 
    iprot.readStructEnd()
6572 
 
6573 
  def write(self, oprot):
6574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6576 
      return
6577 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6578 
    if self.success is not None:
1382 varun.gupt 6579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6580 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6581 
      for iter83 in self.success:
6582 
        oprot.writeI64(iter83)
1382 varun.gupt 6583 
      oprot.writeListEnd()
6584 
      oprot.writeFieldEnd()
3431 rajveer 6585 
    if self.ex is not None:
1382 varun.gupt 6586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6587 
      self.ex.write(oprot)
6588 
      oprot.writeFieldEnd()
6589 
    oprot.writeFieldStop()
6590 
    oprot.writeStructEnd()
6591 
 
3431 rajveer 6592 
  def validate(self):
6593 
    return
6594 
 
6595 
 
1382 varun.gupt 6596 
  def __repr__(self):
6597 
    L = ['%s=%r' % (key, value)
6598 
      for key, value in self.__dict__.iteritems()]
6599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6600 
 
6601 
  def __eq__(self, other):
6602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6603 
 
6604 
  def __ne__(self, other):
6605 
    return not (self == other)
6606 
 
483 rajveer 6607 
class changeOrderStatus_args:
94 ashish 6608 
  """
6609 
  Attributes:
483 rajveer 6610 
   - orderId
6611 
   - status
6612 
   - description
94 ashish 6613 
  """
6614 
 
6615 
  thrift_spec = (
6616 
    None, # 0
483 rajveer 6617 
    (1, TType.I64, 'orderId', None, None, ), # 1
6618 
    (2, TType.I32, 'status', None, None, ), # 2
6619 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6620 
  )
6621 
 
483 rajveer 6622 
  def __init__(self, orderId=None, status=None, description=None,):
6623 
    self.orderId = orderId
6624 
    self.status = status
6625 
    self.description = description
94 ashish 6626 
 
6627 
  def read(self, iprot):
6628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6630 
      return
6631 
    iprot.readStructBegin()
6632 
    while True:
6633 
      (fname, ftype, fid) = iprot.readFieldBegin()
6634 
      if ftype == TType.STOP:
6635 
        break
6636 
      if fid == 1:
6637 
        if ftype == TType.I64:
483 rajveer 6638 
          self.orderId = iprot.readI64();
94 ashish 6639 
        else:
6640 
          iprot.skip(ftype)
6641 
      elif fid == 2:
483 rajveer 6642 
        if ftype == TType.I32:
6643 
          self.status = iprot.readI32();
94 ashish 6644 
        else:
6645 
          iprot.skip(ftype)
483 rajveer 6646 
      elif fid == 3:
6647 
        if ftype == TType.STRING:
6648 
          self.description = iprot.readString();
6649 
        else:
6650 
          iprot.skip(ftype)
94 ashish 6651 
      else:
6652 
        iprot.skip(ftype)
6653 
      iprot.readFieldEnd()
6654 
    iprot.readStructEnd()
6655 
 
6656 
  def write(self, oprot):
6657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6659 
      return
483 rajveer 6660 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6661 
    if self.orderId is not None:
483 rajveer 6662 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6663 
      oprot.writeI64(self.orderId)
94 ashish 6664 
      oprot.writeFieldEnd()
3431 rajveer 6665 
    if self.status is not None:
483 rajveer 6666 
      oprot.writeFieldBegin('status', TType.I32, 2)
6667 
      oprot.writeI32(self.status)
94 ashish 6668 
      oprot.writeFieldEnd()
3431 rajveer 6669 
    if self.description is not None:
483 rajveer 6670 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6671 
      oprot.writeString(self.description)
6672 
      oprot.writeFieldEnd()
94 ashish 6673 
    oprot.writeFieldStop()
6674 
    oprot.writeStructEnd()
6675 
 
3431 rajveer 6676 
  def validate(self):
6677 
    return
6678 
 
6679 
 
94 ashish 6680 
  def __repr__(self):
6681 
    L = ['%s=%r' % (key, value)
6682 
      for key, value in self.__dict__.iteritems()]
6683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6684 
 
6685 
  def __eq__(self, other):
6686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6687 
 
6688 
  def __ne__(self, other):
6689 
    return not (self == other)
6690 
 
483 rajveer 6691 
class changeOrderStatus_result:
94 ashish 6692 
  """
6693 
  Attributes:
6694 
   - success
6695 
   - ex
6696 
  """
6697 
 
6698 
  thrift_spec = (
6699 
    (0, TType.BOOL, 'success', None, None, ), # 0
6700 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6701 
  )
6702 
 
6703 
  def __init__(self, success=None, ex=None,):
6704 
    self.success = success
6705 
    self.ex = ex
6706 
 
6707 
  def read(self, iprot):
6708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6710 
      return
6711 
    iprot.readStructBegin()
6712 
    while True:
6713 
      (fname, ftype, fid) = iprot.readFieldBegin()
6714 
      if ftype == TType.STOP:
6715 
        break
6716 
      if fid == 0:
6717 
        if ftype == TType.BOOL:
6718 
          self.success = iprot.readBool();
6719 
        else:
6720 
          iprot.skip(ftype)
6721 
      elif fid == 1:
6722 
        if ftype == TType.STRUCT:
6723 
          self.ex = TransactionServiceException()
6724 
          self.ex.read(iprot)
6725 
        else:
6726 
          iprot.skip(ftype)
6727 
      else:
6728 
        iprot.skip(ftype)
6729 
      iprot.readFieldEnd()
6730 
    iprot.readStructEnd()
6731 
 
6732 
  def write(self, oprot):
6733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6735 
      return
483 rajveer 6736 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6737 
    if self.success is not None:
94 ashish 6738 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6739 
      oprot.writeBool(self.success)
6740 
      oprot.writeFieldEnd()
3431 rajveer 6741 
    if self.ex is not None:
94 ashish 6742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6743 
      self.ex.write(oprot)
6744 
      oprot.writeFieldEnd()
6745 
    oprot.writeFieldStop()
6746 
    oprot.writeStructEnd()
6747 
 
3431 rajveer 6748 
  def validate(self):
6749 
    return
6750 
 
6751 
 
94 ashish 6752 
  def __repr__(self):
6753 
    L = ['%s=%r' % (key, value)
6754 
      for key, value in self.__dict__.iteritems()]
6755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6756 
 
6757 
  def __eq__(self, other):
6758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6759 
 
6760 
  def __ne__(self, other):
6761 
    return not (self == other)
6762 
 
3064 chandransh 6763 
class getOrdersForTransaction_args:
494 rajveer 6764 
  """
6765 
  Attributes:
3064 chandransh 6766 
   - transactionId
6767 
   - customerId
494 rajveer 6768 
  """
6769 
 
6770 
  thrift_spec = (
6771 
    None, # 0
3064 chandransh 6772 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6773 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6774 
  )
6775 
 
3064 chandransh 6776 
  def __init__(self, transactionId=None, customerId=None,):
6777 
    self.transactionId = transactionId
6778 
    self.customerId = customerId
494 rajveer 6779 
 
6780 
  def read(self, iprot):
6781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6783 
      return
6784 
    iprot.readStructBegin()
6785 
    while True:
6786 
      (fname, ftype, fid) = iprot.readFieldBegin()
6787 
      if ftype == TType.STOP:
6788 
        break
6789 
      if fid == 1:
6790 
        if ftype == TType.I64:
3064 chandransh 6791 
          self.transactionId = iprot.readI64();
494 rajveer 6792 
        else:
6793 
          iprot.skip(ftype)
6794 
      elif fid == 2:
3064 chandransh 6795 
        if ftype == TType.I64:
6796 
          self.customerId = iprot.readI64();
494 rajveer 6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      else:
6800 
        iprot.skip(ftype)
6801 
      iprot.readFieldEnd()
6802 
    iprot.readStructEnd()
6803 
 
6804 
  def write(self, oprot):
6805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6807 
      return
3064 chandransh 6808 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6809 
    if self.transactionId is not None:
3064 chandransh 6810 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6811 
      oprot.writeI64(self.transactionId)
494 rajveer 6812 
      oprot.writeFieldEnd()
3431 rajveer 6813 
    if self.customerId is not None:
3064 chandransh 6814 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6815 
      oprot.writeI64(self.customerId)
494 rajveer 6816 
      oprot.writeFieldEnd()
6817 
    oprot.writeFieldStop()
6818 
    oprot.writeStructEnd()
6819 
 
3431 rajveer 6820 
  def validate(self):
6821 
    return
6822 
 
6823 
 
494 rajveer 6824 
  def __repr__(self):
6825 
    L = ['%s=%r' % (key, value)
6826 
      for key, value in self.__dict__.iteritems()]
6827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6828 
 
6829 
  def __eq__(self, other):
6830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6831 
 
6832 
  def __ne__(self, other):
6833 
    return not (self == other)
6834 
 
3064 chandransh 6835 
class getOrdersForTransaction_result:
494 rajveer 6836 
  """
6837 
  Attributes:
6838 
   - success
6839 
   - ex
6840 
  """
6841 
 
6842 
  thrift_spec = (
3064 chandransh 6843 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6845 
  )
6846 
 
6847 
  def __init__(self, success=None, ex=None,):
6848 
    self.success = success
6849 
    self.ex = ex
6850 
 
6851 
  def read(self, iprot):
6852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6854 
      return
6855 
    iprot.readStructBegin()
6856 
    while True:
6857 
      (fname, ftype, fid) = iprot.readFieldBegin()
6858 
      if ftype == TType.STOP:
6859 
        break
6860 
      if fid == 0:
3064 chandransh 6861 
        if ftype == TType.LIST:
6862 
          self.success = []
4133 chandransh 6863 
          (_etype87, _size84) = iprot.readListBegin()
6864 
          for _i88 in xrange(_size84):
6865 
            _elem89 = Order()
6866 
            _elem89.read(iprot)
6867 
            self.success.append(_elem89)
3064 chandransh 6868 
          iprot.readListEnd()
494 rajveer 6869 
        else:
6870 
          iprot.skip(ftype)
6871 
      elif fid == 1:
6872 
        if ftype == TType.STRUCT:
6873 
          self.ex = TransactionServiceException()
6874 
          self.ex.read(iprot)
6875 
        else:
6876 
          iprot.skip(ftype)
6877 
      else:
6878 
        iprot.skip(ftype)
6879 
      iprot.readFieldEnd()
6880 
    iprot.readStructEnd()
6881 
 
6882 
  def write(self, oprot):
6883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6885 
      return
3064 chandransh 6886 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6887 
    if self.success is not None:
3064 chandransh 6888 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6889 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6890 
      for iter90 in self.success:
6891 
        iter90.write(oprot)
3064 chandransh 6892 
      oprot.writeListEnd()
494 rajveer 6893 
      oprot.writeFieldEnd()
3431 rajveer 6894 
    if self.ex is not None:
494 rajveer 6895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6896 
      self.ex.write(oprot)
6897 
      oprot.writeFieldEnd()
6898 
    oprot.writeFieldStop()
6899 
    oprot.writeStructEnd()
6900 
 
3431 rajveer 6901 
  def validate(self):
6902 
    return
6903 
 
6904 
 
494 rajveer 6905 
  def __repr__(self):
6906 
    L = ['%s=%r' % (key, value)
6907 
      for key, value in self.__dict__.iteritems()]
6908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6909 
 
6910 
  def __eq__(self, other):
6911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6912 
 
6913 
  def __ne__(self, other):
6914 
    return not (self == other)
6915 
 
3064 chandransh 6916 
class getOrdersForCustomer_args:
1149 chandransh 6917 
  """
6918 
  Attributes:
3064 chandransh 6919 
   - customerId
6920 
   - from_date
6921 
   - to_date
6922 
   - statuses
1149 chandransh 6923 
  """
6924 
 
6925 
  thrift_spec = (
6926 
    None, # 0
3064 chandransh 6927 
    (1, TType.I64, 'customerId', None, None, ), # 1
6928 
    (2, TType.I64, 'from_date', None, None, ), # 2
6929 
    (3, TType.I64, 'to_date', None, None, ), # 3
6930 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6931 
  )
6932 
 
3064 chandransh 6933 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6934 
    self.customerId = customerId
6935 
    self.from_date = from_date
6936 
    self.to_date = to_date
6937 
    self.statuses = statuses
1149 chandransh 6938 
 
6939 
  def read(self, iprot):
6940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6942 
      return
6943 
    iprot.readStructBegin()
6944 
    while True:
6945 
      (fname, ftype, fid) = iprot.readFieldBegin()
6946 
      if ftype == TType.STOP:
6947 
        break
6948 
      if fid == 1:
6949 
        if ftype == TType.I64:
3064 chandransh 6950 
          self.customerId = iprot.readI64();
1149 chandransh 6951 
        else:
6952 
          iprot.skip(ftype)
6953 
      elif fid == 2:
6954 
        if ftype == TType.I64:
3064 chandransh 6955 
          self.from_date = iprot.readI64();
1149 chandransh 6956 
        else:
6957 
          iprot.skip(ftype)
2783 chandransh 6958 
      elif fid == 3:
6959 
        if ftype == TType.I64:
3064 chandransh 6960 
          self.to_date = iprot.readI64();
2783 chandransh 6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      elif fid == 4:
3064 chandransh 6964 
        if ftype == TType.LIST:
6965 
          self.statuses = []
4133 chandransh 6966 
          (_etype94, _size91) = iprot.readListBegin()
6967 
          for _i95 in xrange(_size91):
6968 
            _elem96 = iprot.readI32();
6969 
            self.statuses.append(_elem96)
3064 chandransh 6970 
          iprot.readListEnd()
2783 chandransh 6971 
        else:
6972 
          iprot.skip(ftype)
1149 chandransh 6973 
      else:
6974 
        iprot.skip(ftype)
6975 
      iprot.readFieldEnd()
6976 
    iprot.readStructEnd()
6977 
 
6978 
  def write(self, oprot):
6979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6981 
      return
3064 chandransh 6982 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6983 
    if self.customerId is not None:
3064 chandransh 6984 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6985 
      oprot.writeI64(self.customerId)
1149 chandransh 6986 
      oprot.writeFieldEnd()
3431 rajveer 6987 
    if self.from_date is not None:
3064 chandransh 6988 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6989 
      oprot.writeI64(self.from_date)
1149 chandransh 6990 
      oprot.writeFieldEnd()
3431 rajveer 6991 
    if self.to_date is not None:
3064 chandransh 6992 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6993 
      oprot.writeI64(self.to_date)
2783 chandransh 6994 
      oprot.writeFieldEnd()
3431 rajveer 6995 
    if self.statuses is not None:
3064 chandransh 6996 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6997 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6998 
      for iter97 in self.statuses:
6999 
        oprot.writeI32(iter97)
3064 chandransh 7000 
      oprot.writeListEnd()
2783 chandransh 7001 
      oprot.writeFieldEnd()
1149 chandransh 7002 
    oprot.writeFieldStop()
7003 
    oprot.writeStructEnd()
7004 
 
3431 rajveer 7005 
  def validate(self):
7006 
    return
7007 
 
7008 
 
1149 chandransh 7009 
  def __repr__(self):
7010 
    L = ['%s=%r' % (key, value)
7011 
      for key, value in self.__dict__.iteritems()]
7012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7013 
 
7014 
  def __eq__(self, other):
7015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7016 
 
7017 
  def __ne__(self, other):
7018 
    return not (self == other)
7019 
 
3064 chandransh 7020 
class getOrdersForCustomer_result:
1149 chandransh 7021 
  """
7022 
  Attributes:
7023 
   - success
7024 
   - ex
7025 
  """
7026 
 
7027 
  thrift_spec = (
3064 chandransh 7028 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7029 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7030 
  )
7031 
 
7032 
  def __init__(self, success=None, ex=None,):
7033 
    self.success = success
7034 
    self.ex = ex
7035 
 
7036 
  def read(self, iprot):
7037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7039 
      return
7040 
    iprot.readStructBegin()
7041 
    while True:
7042 
      (fname, ftype, fid) = iprot.readFieldBegin()
7043 
      if ftype == TType.STOP:
7044 
        break
7045 
      if fid == 0:
3064 chandransh 7046 
        if ftype == TType.LIST:
7047 
          self.success = []
4133 chandransh 7048 
          (_etype101, _size98) = iprot.readListBegin()
7049 
          for _i102 in xrange(_size98):
7050 
            _elem103 = Order()
7051 
            _elem103.read(iprot)
7052 
            self.success.append(_elem103)
3064 chandransh 7053 
          iprot.readListEnd()
1149 chandransh 7054 
        else:
7055 
          iprot.skip(ftype)
7056 
      elif fid == 1:
7057 
        if ftype == TType.STRUCT:
7058 
          self.ex = TransactionServiceException()
7059 
          self.ex.read(iprot)
7060 
        else:
7061 
          iprot.skip(ftype)
7062 
      else:
7063 
        iprot.skip(ftype)
7064 
      iprot.readFieldEnd()
7065 
    iprot.readStructEnd()
7066 
 
7067 
  def write(self, oprot):
7068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7070 
      return
3064 chandransh 7071 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7072 
    if self.success is not None:
3064 chandransh 7073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7075 
      for iter104 in self.success:
7076 
        iter104.write(oprot)
3064 chandransh 7077 
      oprot.writeListEnd()
1149 chandransh 7078 
      oprot.writeFieldEnd()
3431 rajveer 7079 
    if self.ex is not None:
1149 chandransh 7080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7081 
      self.ex.write(oprot)
7082 
      oprot.writeFieldEnd()
7083 
    oprot.writeFieldStop()
7084 
    oprot.writeStructEnd()
7085 
 
3431 rajveer 7086 
  def validate(self):
7087 
    return
7088 
 
7089 
 
1149 chandransh 7090 
  def __repr__(self):
7091 
    L = ['%s=%r' % (key, value)
7092 
      for key, value in self.__dict__.iteritems()]
7093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7094 
 
7095 
  def __eq__(self, other):
7096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7097 
 
7098 
  def __ne__(self, other):
7099 
    return not (self == other)
7100 
 
3064 chandransh 7101 
class createOrder_args:
921 rajveer 7102 
  """
7103 
  Attributes:
3064 chandransh 7104 
   - order
921 rajveer 7105 
  """
7106 
 
7107 
  thrift_spec = (
7108 
    None, # 0
3064 chandransh 7109 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7110 
  )
7111 
 
3064 chandransh 7112 
  def __init__(self, order=None,):
7113 
    self.order = order
921 rajveer 7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      if fid == 1:
3064 chandransh 7125 
        if ftype == TType.STRUCT:
7126 
          self.order = Order()
7127 
          self.order.read(iprot)
921 rajveer 7128 
        else:
7129 
          iprot.skip(ftype)
7130 
      else:
7131 
        iprot.skip(ftype)
7132 
      iprot.readFieldEnd()
7133 
    iprot.readStructEnd()
7134 
 
7135 
  def write(self, oprot):
7136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7138 
      return
3064 chandransh 7139 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7140 
    if self.order is not None:
3064 chandransh 7141 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7142 
      self.order.write(oprot)
921 rajveer 7143 
      oprot.writeFieldEnd()
7144 
    oprot.writeFieldStop()
7145 
    oprot.writeStructEnd()
7146 
 
3431 rajveer 7147 
  def validate(self):
7148 
    return
7149 
 
7150 
 
921 rajveer 7151 
  def __repr__(self):
7152 
    L = ['%s=%r' % (key, value)
7153 
      for key, value in self.__dict__.iteritems()]
7154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7155 
 
7156 
  def __eq__(self, other):
7157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7158 
 
7159 
  def __ne__(self, other):
7160 
    return not (self == other)
7161 
 
3064 chandransh 7162 
class createOrder_result:
921 rajveer 7163 
  """
7164 
  Attributes:
7165 
   - success
7166 
   - ex
7167 
  """
7168 
 
7169 
  thrift_spec = (
3064 chandransh 7170 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7172 
  )
7173 
 
7174 
  def __init__(self, success=None, ex=None,):
7175 
    self.success = success
7176 
    self.ex = ex
7177 
 
7178 
  def read(self, iprot):
7179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7181 
      return
7182 
    iprot.readStructBegin()
7183 
    while True:
7184 
      (fname, ftype, fid) = iprot.readFieldBegin()
7185 
      if ftype == TType.STOP:
7186 
        break
7187 
      if fid == 0:
3064 chandransh 7188 
        if ftype == TType.I64:
7189 
          self.success = iprot.readI64();
921 rajveer 7190 
        else:
7191 
          iprot.skip(ftype)
7192 
      elif fid == 1:
7193 
        if ftype == TType.STRUCT:
7194 
          self.ex = TransactionServiceException()
7195 
          self.ex.read(iprot)
7196 
        else:
7197 
          iprot.skip(ftype)
7198 
      else:
7199 
        iprot.skip(ftype)
7200 
      iprot.readFieldEnd()
7201 
    iprot.readStructEnd()
7202 
 
7203 
  def write(self, oprot):
7204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7206 
      return
3064 chandransh 7207 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7208 
    if self.success is not None:
3064 chandransh 7209 
      oprot.writeFieldBegin('success', TType.I64, 0)
7210 
      oprot.writeI64(self.success)
921 rajveer 7211 
      oprot.writeFieldEnd()
3431 rajveer 7212 
    if self.ex is not None:
921 rajveer 7213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7214 
      self.ex.write(oprot)
7215 
      oprot.writeFieldEnd()
7216 
    oprot.writeFieldStop()
7217 
    oprot.writeStructEnd()
7218 
 
3431 rajveer 7219 
  def validate(self):
7220 
    return
7221 
 
7222 
 
921 rajveer 7223 
  def __repr__(self):
7224 
    L = ['%s=%r' % (key, value)
7225 
      for key, value in self.__dict__.iteritems()]
7226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7227 
 
7228 
  def __eq__(self, other):
7229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7230 
 
7231 
  def __ne__(self, other):
7232 
    return not (self == other)
7233 
 
3064 chandransh 7234 
class getOrder_args:
921 rajveer 7235 
  """
7236 
  Attributes:
3064 chandransh 7237 
   - id
921 rajveer 7238 
  """
7239 
 
7240 
  thrift_spec = (
7241 
    None, # 0
3064 chandransh 7242 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7243 
  )
7244 
 
3064 chandransh 7245 
  def __init__(self, id=None,):
7246 
    self.id = id
921 rajveer 7247 
 
7248 
  def read(self, iprot):
7249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7251 
      return
7252 
    iprot.readStructBegin()
7253 
    while True:
7254 
      (fname, ftype, fid) = iprot.readFieldBegin()
7255 
      if ftype == TType.STOP:
7256 
        break
7257 
      if fid == 1:
7258 
        if ftype == TType.I64:
3064 chandransh 7259 
          self.id = iprot.readI64();
921 rajveer 7260 
        else:
7261 
          iprot.skip(ftype)
7262 
      else:
7263 
        iprot.skip(ftype)
7264 
      iprot.readFieldEnd()
7265 
    iprot.readStructEnd()
7266 
 
7267 
  def write(self, oprot):
7268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7270 
      return
3064 chandransh 7271 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7272 
    if self.id is not None:
3064 chandransh 7273 
      oprot.writeFieldBegin('id', TType.I64, 1)
7274 
      oprot.writeI64(self.id)
921 rajveer 7275 
      oprot.writeFieldEnd()
7276 
    oprot.writeFieldStop()
7277 
    oprot.writeStructEnd()
7278 
 
3431 rajveer 7279 
  def validate(self):
7280 
    return
7281 
 
7282 
 
921 rajveer 7283 
  def __repr__(self):
7284 
    L = ['%s=%r' % (key, value)
7285 
      for key, value in self.__dict__.iteritems()]
7286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7287 
 
7288 
  def __eq__(self, other):
7289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7290 
 
7291 
  def __ne__(self, other):
7292 
    return not (self == other)
7293 
 
3064 chandransh 7294 
class getOrder_result:
921 rajveer 7295 
  """
7296 
  Attributes:
7297 
   - success
7298 
   - ex
7299 
  """
7300 
 
7301 
  thrift_spec = (
3064 chandransh 7302 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7304 
  )
7305 
 
7306 
  def __init__(self, success=None, ex=None,):
7307 
    self.success = success
7308 
    self.ex = ex
7309 
 
7310 
  def read(self, iprot):
7311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7313 
      return
7314 
    iprot.readStructBegin()
7315 
    while True:
7316 
      (fname, ftype, fid) = iprot.readFieldBegin()
7317 
      if ftype == TType.STOP:
7318 
        break
7319 
      if fid == 0:
3064 chandransh 7320 
        if ftype == TType.STRUCT:
7321 
          self.success = Order()
7322 
          self.success.read(iprot)
921 rajveer 7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      elif fid == 1:
7326 
        if ftype == TType.STRUCT:
7327 
          self.ex = TransactionServiceException()
7328 
          self.ex.read(iprot)
7329 
        else:
7330 
          iprot.skip(ftype)
7331 
      else:
7332 
        iprot.skip(ftype)
7333 
      iprot.readFieldEnd()
7334 
    iprot.readStructEnd()
7335 
 
7336 
  def write(self, oprot):
7337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7339 
      return
3064 chandransh 7340 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7341 
    if self.success is not None:
3064 chandransh 7342 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7343 
      self.success.write(oprot)
921 rajveer 7344 
      oprot.writeFieldEnd()
3431 rajveer 7345 
    if self.ex is not None:
921 rajveer 7346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7347 
      self.ex.write(oprot)
7348 
      oprot.writeFieldEnd()
7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
3431 rajveer 7352 
  def validate(self):
7353 
    return
7354 
 
7355 
 
921 rajveer 7356 
  def __repr__(self):
7357 
    L = ['%s=%r' % (key, value)
7358 
      for key, value in self.__dict__.iteritems()]
7359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7360 
 
7361 
  def __eq__(self, other):
7362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7363 
 
7364 
  def __ne__(self, other):
7365 
    return not (self == other)
7366 
 
3064 chandransh 7367 
class getLineItemsForOrder_args:
94 ashish 7368 
  """
7369 
  Attributes:
3064 chandransh 7370 
   - orderId
94 ashish 7371 
  """
7372 
 
7373 
  thrift_spec = (
7374 
    None, # 0
3064 chandransh 7375 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7376 
  )
7377 
 
3064 chandransh 7378 
  def __init__(self, orderId=None,):
7379 
    self.orderId = orderId
94 ashish 7380 
 
7381 
  def read(self, iprot):
7382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7384 
      return
7385 
    iprot.readStructBegin()
7386 
    while True:
7387 
      (fname, ftype, fid) = iprot.readFieldBegin()
7388 
      if ftype == TType.STOP:
7389 
        break
7390 
      if fid == 1:
7391 
        if ftype == TType.I64:
3064 chandransh 7392 
          self.orderId = iprot.readI64();
94 ashish 7393 
        else:
7394 
          iprot.skip(ftype)
7395 
      else:
7396 
        iprot.skip(ftype)
7397 
      iprot.readFieldEnd()
7398 
    iprot.readStructEnd()
7399 
 
7400 
  def write(self, oprot):
7401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7403 
      return
3064 chandransh 7404 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7405 
    if self.orderId is not None:
3064 chandransh 7406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7407 
      oprot.writeI64(self.orderId)
94 ashish 7408 
      oprot.writeFieldEnd()
7409 
    oprot.writeFieldStop()
7410 
    oprot.writeStructEnd()
7411 
 
3431 rajveer 7412 
  def validate(self):
7413 
    return
7414 
 
7415 
 
94 ashish 7416 
  def __repr__(self):
7417 
    L = ['%s=%r' % (key, value)
7418 
      for key, value in self.__dict__.iteritems()]
7419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7420 
 
7421 
  def __eq__(self, other):
7422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7423 
 
7424 
  def __ne__(self, other):
7425 
    return not (self == other)
7426 
 
3064 chandransh 7427 
class getLineItemsForOrder_result:
94 ashish 7428 
  """
7429 
  Attributes:
7430 
   - success
7431 
   - ex
7432 
  """
7433 
 
7434 
  thrift_spec = (
3064 chandransh 7435 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7437 
  )
7438 
 
7439 
  def __init__(self, success=None, ex=None,):
7440 
    self.success = success
7441 
    self.ex = ex
7442 
 
7443 
  def read(self, iprot):
7444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7446 
      return
7447 
    iprot.readStructBegin()
7448 
    while True:
7449 
      (fname, ftype, fid) = iprot.readFieldBegin()
7450 
      if ftype == TType.STOP:
7451 
        break
7452 
      if fid == 0:
483 rajveer 7453 
        if ftype == TType.LIST:
7454 
          self.success = []
4133 chandransh 7455 
          (_etype108, _size105) = iprot.readListBegin()
7456 
          for _i109 in xrange(_size105):
7457 
            _elem110 = LineItem()
7458 
            _elem110.read(iprot)
7459 
            self.success.append(_elem110)
483 rajveer 7460 
          iprot.readListEnd()
94 ashish 7461 
        else:
7462 
          iprot.skip(ftype)
7463 
      elif fid == 1:
7464 
        if ftype == TType.STRUCT:
7465 
          self.ex = TransactionServiceException()
7466 
          self.ex.read(iprot)
7467 
        else:
7468 
          iprot.skip(ftype)
7469 
      else:
7470 
        iprot.skip(ftype)
7471 
      iprot.readFieldEnd()
7472 
    iprot.readStructEnd()
7473 
 
7474 
  def write(self, oprot):
7475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7477 
      return
3064 chandransh 7478 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7479 
    if self.success is not None:
483 rajveer 7480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7482 
      for iter111 in self.success:
7483 
        iter111.write(oprot)
483 rajveer 7484 
      oprot.writeListEnd()
94 ashish 7485 
      oprot.writeFieldEnd()
3431 rajveer 7486 
    if self.ex is not None:
94 ashish 7487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7488 
      self.ex.write(oprot)
7489 
      oprot.writeFieldEnd()
7490 
    oprot.writeFieldStop()
7491 
    oprot.writeStructEnd()
7492 
 
3431 rajveer 7493 
  def validate(self):
7494 
    return
7495 
 
7496 
 
94 ashish 7497 
  def __repr__(self):
7498 
    L = ['%s=%r' % (key, value)
7499 
      for key, value in self.__dict__.iteritems()]
7500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7501 
 
7502 
  def __eq__(self, other):
7503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7504 
 
7505 
  def __ne__(self, other):
7506 
    return not (self == other)
7507 
 
3064 chandransh 7508 
class getOrderForCustomer_args:
94 ashish 7509 
  """
7510 
  Attributes:
3064 chandransh 7511 
   - orderId
483 rajveer 7512 
   - customerId
94 ashish 7513 
  """
7514 
 
7515 
  thrift_spec = (
7516 
    None, # 0
3064 chandransh 7517 
    (1, TType.I64, 'orderId', None, None, ), # 1
7518 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7519 
  )
7520 
 
3064 chandransh 7521 
  def __init__(self, orderId=None, customerId=None,):
7522 
    self.orderId = orderId
483 rajveer 7523 
    self.customerId = customerId
94 ashish 7524 
 
7525 
  def read(self, iprot):
7526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7528 
      return
7529 
    iprot.readStructBegin()
7530 
    while True:
7531 
      (fname, ftype, fid) = iprot.readFieldBegin()
7532 
      if ftype == TType.STOP:
7533 
        break
7534 
      if fid == 1:
7535 
        if ftype == TType.I64:
3064 chandransh 7536 
          self.orderId = iprot.readI64();
94 ashish 7537 
        else:
7538 
          iprot.skip(ftype)
7539 
      elif fid == 2:
7540 
        if ftype == TType.I64:
3064 chandransh 7541 
          self.customerId = iprot.readI64();
94 ashish 7542 
        else:
7543 
          iprot.skip(ftype)
7544 
      else:
7545 
        iprot.skip(ftype)
7546 
      iprot.readFieldEnd()
7547 
    iprot.readStructEnd()
7548 
 
7549 
  def write(self, oprot):
7550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7552 
      return
3064 chandransh 7553 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7554 
    if self.orderId is not None:
3064 chandransh 7555 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7556 
      oprot.writeI64(self.orderId)
7557 
      oprot.writeFieldEnd()
3431 rajveer 7558 
    if self.customerId is not None:
3064 chandransh 7559 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7560 
      oprot.writeI64(self.customerId)
94 ashish 7561 
      oprot.writeFieldEnd()
7562 
    oprot.writeFieldStop()
7563 
    oprot.writeStructEnd()
7564 
 
3431 rajveer 7565 
  def validate(self):
7566 
    return
7567 
 
7568 
 
94 ashish 7569 
  def __repr__(self):
7570 
    L = ['%s=%r' % (key, value)
7571 
      for key, value in self.__dict__.iteritems()]
7572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7573 
 
7574 
  def __eq__(self, other):
7575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7576 
 
7577 
  def __ne__(self, other):
7578 
    return not (self == other)
7579 
 
3064 chandransh 7580 
class getOrderForCustomer_result:
94 ashish 7581 
  """
7582 
  Attributes:
7583 
   - success
7584 
   - ex
7585 
  """
7586 
 
7587 
  thrift_spec = (
3064 chandransh 7588 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7590 
  )
7591 
 
7592 
  def __init__(self, success=None, ex=None,):
7593 
    self.success = success
7594 
    self.ex = ex
7595 
 
7596 
  def read(self, iprot):
7597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7599 
      return
7600 
    iprot.readStructBegin()
7601 
    while True:
7602 
      (fname, ftype, fid) = iprot.readFieldBegin()
7603 
      if ftype == TType.STOP:
7604 
        break
7605 
      if fid == 0:
3064 chandransh 7606 
        if ftype == TType.STRUCT:
7607 
          self.success = Order()
7608 
          self.success.read(iprot)
94 ashish 7609 
        else:
7610 
          iprot.skip(ftype)
7611 
      elif fid == 1:
7612 
        if ftype == TType.STRUCT:
7613 
          self.ex = TransactionServiceException()
7614 
          self.ex.read(iprot)
7615 
        else:
7616 
          iprot.skip(ftype)
7617 
      else:
7618 
        iprot.skip(ftype)
7619 
      iprot.readFieldEnd()
7620 
    iprot.readStructEnd()
7621 
 
7622 
  def write(self, oprot):
7623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7625 
      return
3064 chandransh 7626 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7627 
    if self.success is not None:
3064 chandransh 7628 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7629 
      self.success.write(oprot)
94 ashish 7630 
      oprot.writeFieldEnd()
3431 rajveer 7631 
    if self.ex is not None:
94 ashish 7632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7633 
      self.ex.write(oprot)
7634 
      oprot.writeFieldEnd()
7635 
    oprot.writeFieldStop()
7636 
    oprot.writeStructEnd()
7637 
 
3431 rajveer 7638 
  def validate(self):
7639 
    return
7640 
 
7641 
 
94 ashish 7642 
  def __repr__(self):
7643 
    L = ['%s=%r' % (key, value)
7644 
      for key, value in self.__dict__.iteritems()]
7645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7646 
 
7647 
  def __eq__(self, other):
7648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7649 
 
7650 
  def __ne__(self, other):
7651 
    return not (self == other)
7652 
 
3064 chandransh 7653 
class getAlerts_args:
94 ashish 7654 
  """
7655 
  Attributes:
3064 chandransh 7656 
   - orderId
7657 
   - valid
94 ashish 7658 
  """
7659 
 
7660 
  thrift_spec = (
7661 
    None, # 0
3064 chandransh 7662 
    (1, TType.I64, 'orderId', None, None, ), # 1
7663 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7664 
  )
7665 
 
3064 chandransh 7666 
  def __init__(self, orderId=None, valid=None,):
7667 
    self.orderId = orderId
7668 
    self.valid = valid
94 ashish 7669 
 
7670 
  def read(self, iprot):
7671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7673 
      return
7674 
    iprot.readStructBegin()
7675 
    while True:
7676 
      (fname, ftype, fid) = iprot.readFieldBegin()
7677 
      if ftype == TType.STOP:
7678 
        break
7679 
      if fid == 1:
3064 chandransh 7680 
        if ftype == TType.I64:
7681 
          self.orderId = iprot.readI64();
94 ashish 7682 
        else:
7683 
          iprot.skip(ftype)
3064 chandransh 7684 
      elif fid == 2:
7685 
        if ftype == TType.BOOL:
7686 
          self.valid = iprot.readBool();
7687 
        else:
7688 
          iprot.skip(ftype)
94 ashish 7689 
      else:
7690 
        iprot.skip(ftype)
7691 
      iprot.readFieldEnd()
7692 
    iprot.readStructEnd()
7693 
 
7694 
  def write(self, oprot):
7695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7697 
      return
3064 chandransh 7698 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7699 
    if self.orderId is not None:
3064 chandransh 7700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7701 
      oprot.writeI64(self.orderId)
94 ashish 7702 
      oprot.writeFieldEnd()
3431 rajveer 7703 
    if self.valid is not None:
3064 chandransh 7704 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7705 
      oprot.writeBool(self.valid)
7706 
      oprot.writeFieldEnd()
94 ashish 7707 
    oprot.writeFieldStop()
7708 
    oprot.writeStructEnd()
7709 
 
3431 rajveer 7710 
  def validate(self):
7711 
    return
7712 
 
7713 
 
94 ashish 7714 
  def __repr__(self):
7715 
    L = ['%s=%r' % (key, value)
7716 
      for key, value in self.__dict__.iteritems()]
7717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7718 
 
7719 
  def __eq__(self, other):
7720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7721 
 
7722 
  def __ne__(self, other):
7723 
    return not (self == other)
7724 
 
3064 chandransh 7725 
class getAlerts_result:
94 ashish 7726 
  """
7727 
  Attributes:
7728 
   - success
7729 
  """
7730 
 
7731 
  thrift_spec = (
3064 chandransh 7732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7733 
  )
7734 
 
3064 chandransh 7735 
  def __init__(self, success=None,):
94 ashish 7736 
    self.success = success
7737 
 
7738 
  def read(self, iprot):
7739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7741 
      return
7742 
    iprot.readStructBegin()
7743 
    while True:
7744 
      (fname, ftype, fid) = iprot.readFieldBegin()
7745 
      if ftype == TType.STOP:
7746 
        break
7747 
      if fid == 0:
3064 chandransh 7748 
        if ftype == TType.LIST:
7749 
          self.success = []
4133 chandransh 7750 
          (_etype115, _size112) = iprot.readListBegin()
7751 
          for _i116 in xrange(_size112):
7752 
            _elem117 = Alert()
7753 
            _elem117.read(iprot)
7754 
            self.success.append(_elem117)
3064 chandransh 7755 
          iprot.readListEnd()
94 ashish 7756 
        else:
7757 
          iprot.skip(ftype)
7758 
      else:
7759 
        iprot.skip(ftype)
7760 
      iprot.readFieldEnd()
7761 
    iprot.readStructEnd()
7762 
 
7763 
  def write(self, oprot):
7764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7766 
      return
3064 chandransh 7767 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7768 
    if self.success is not None:
3064 chandransh 7769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7771 
      for iter118 in self.success:
7772 
        iter118.write(oprot)
3064 chandransh 7773 
      oprot.writeListEnd()
94 ashish 7774 
      oprot.writeFieldEnd()
7775 
    oprot.writeFieldStop()
7776 
    oprot.writeStructEnd()
7777 
 
3431 rajveer 7778 
  def validate(self):
7779 
    return
7780 
 
7781 
 
94 ashish 7782 
  def __repr__(self):
7783 
    L = ['%s=%r' % (key, value)
7784 
      for key, value in self.__dict__.iteritems()]
7785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7786 
 
7787 
  def __eq__(self, other):
7788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7789 
 
7790 
  def __ne__(self, other):
7791 
    return not (self == other)
7792 
 
3064 chandransh 7793 
class setAlert_args:
94 ashish 7794 
  """
7795 
  Attributes:
3064 chandransh 7796 
   - orderId
7797 
   - unset
7798 
   - type
7799 
   - comment
94 ashish 7800 
  """
7801 
 
7802 
  thrift_spec = (
7803 
    None, # 0
3064 chandransh 7804 
    (1, TType.I64, 'orderId', None, None, ), # 1
7805 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7806 
    (3, TType.I64, 'type', None, None, ), # 3
7807 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7808 
  )
7809 
 
3064 chandransh 7810 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7811 
    self.orderId = orderId
7812 
    self.unset = unset
7813 
    self.type = type
7814 
    self.comment = comment
94 ashish 7815 
 
7816 
  def read(self, iprot):
7817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7819 
      return
7820 
    iprot.readStructBegin()
7821 
    while True:
7822 
      (fname, ftype, fid) = iprot.readFieldBegin()
7823 
      if ftype == TType.STOP:
7824 
        break
7825 
      if fid == 1:
7826 
        if ftype == TType.I64:
3064 chandransh 7827 
          self.orderId = iprot.readI64();
94 ashish 7828 
        else:
7829 
          iprot.skip(ftype)
3064 chandransh 7830 
      elif fid == 2:
7831 
        if ftype == TType.BOOL:
7832 
          self.unset = iprot.readBool();
7833 
        else:
7834 
          iprot.skip(ftype)
7835 
      elif fid == 3:
7836 
        if ftype == TType.I64:
7837 
          self.type = iprot.readI64();
7838 
        else:
7839 
          iprot.skip(ftype)
7840 
      elif fid == 4:
7841 
        if ftype == TType.STRING:
7842 
          self.comment = iprot.readString();
7843 
        else:
7844 
          iprot.skip(ftype)
94 ashish 7845 
      else:
7846 
        iprot.skip(ftype)
7847 
      iprot.readFieldEnd()
7848 
    iprot.readStructEnd()
7849 
 
7850 
  def write(self, oprot):
7851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7853 
      return
3064 chandransh 7854 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7855 
    if self.orderId is not None:
3064 chandransh 7856 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7857 
      oprot.writeI64(self.orderId)
94 ashish 7858 
      oprot.writeFieldEnd()
3431 rajveer 7859 
    if self.unset is not None:
3064 chandransh 7860 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7861 
      oprot.writeBool(self.unset)
7862 
      oprot.writeFieldEnd()
3431 rajveer 7863 
    if self.type is not None:
3064 chandransh 7864 
      oprot.writeFieldBegin('type', TType.I64, 3)
7865 
      oprot.writeI64(self.type)
7866 
      oprot.writeFieldEnd()
3431 rajveer 7867 
    if self.comment is not None:
3064 chandransh 7868 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7869 
      oprot.writeString(self.comment)
7870 
      oprot.writeFieldEnd()
94 ashish 7871 
    oprot.writeFieldStop()
7872 
    oprot.writeStructEnd()
7873 
 
3431 rajveer 7874 
  def validate(self):
7875 
    return
7876 
 
7877 
 
94 ashish 7878 
  def __repr__(self):
7879 
    L = ['%s=%r' % (key, value)
7880 
      for key, value in self.__dict__.iteritems()]
7881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7882 
 
7883 
  def __eq__(self, other):
7884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7885 
 
7886 
  def __ne__(self, other):
7887 
    return not (self == other)
7888 
 
3064 chandransh 7889 
class setAlert_result:
7890 
 
7891 
  thrift_spec = (
7892 
  )
7893 
 
7894 
  def read(self, iprot):
7895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7897 
      return
7898 
    iprot.readStructBegin()
7899 
    while True:
7900 
      (fname, ftype, fid) = iprot.readFieldBegin()
7901 
      if ftype == TType.STOP:
7902 
        break
7903 
      else:
7904 
        iprot.skip(ftype)
7905 
      iprot.readFieldEnd()
7906 
    iprot.readStructEnd()
7907 
 
7908 
  def write(self, oprot):
7909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7911 
      return
7912 
    oprot.writeStructBegin('setAlert_result')
7913 
    oprot.writeFieldStop()
7914 
    oprot.writeStructEnd()
7915 
 
3431 rajveer 7916 
  def validate(self):
7917 
    return
7918 
 
7919 
 
3064 chandransh 7920 
  def __repr__(self):
7921 
    L = ['%s=%r' % (key, value)
7922 
      for key, value in self.__dict__.iteritems()]
7923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7924 
 
7925 
  def __eq__(self, other):
7926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7927 
 
7928 
  def __ne__(self, other):
7929 
    return not (self == other)
7930 
 
7931 
class getValidOrderCount_args:
7932 
 
7933 
  thrift_spec = (
7934 
  )
7935 
 
7936 
  def read(self, iprot):
7937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7939 
      return
7940 
    iprot.readStructBegin()
7941 
    while True:
7942 
      (fname, ftype, fid) = iprot.readFieldBegin()
7943 
      if ftype == TType.STOP:
7944 
        break
7945 
      else:
7946 
        iprot.skip(ftype)
7947 
      iprot.readFieldEnd()
7948 
    iprot.readStructEnd()
7949 
 
7950 
  def write(self, oprot):
7951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7953 
      return
7954 
    oprot.writeStructBegin('getValidOrderCount_args')
7955 
    oprot.writeFieldStop()
7956 
    oprot.writeStructEnd()
7957 
 
3431 rajveer 7958 
  def validate(self):
7959 
    return
7960 
 
7961 
 
3064 chandransh 7962 
  def __repr__(self):
7963 
    L = ['%s=%r' % (key, value)
7964 
      for key, value in self.__dict__.iteritems()]
7965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7966 
 
7967 
  def __eq__(self, other):
7968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7969 
 
7970 
  def __ne__(self, other):
7971 
    return not (self == other)
7972 
 
7973 
class getValidOrderCount_result:
94 ashish 7974 
  """
7975 
  Attributes:
7976 
   - success
7977 
  """
7978 
 
7979 
  thrift_spec = (
3064 chandransh 7980 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7981 
  )
7982 
 
3064 chandransh 7983 
  def __init__(self, success=None,):
94 ashish 7984 
    self.success = success
7985 
 
7986 
  def read(self, iprot):
7987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7989 
      return
7990 
    iprot.readStructBegin()
7991 
    while True:
7992 
      (fname, ftype, fid) = iprot.readFieldBegin()
7993 
      if ftype == TType.STOP:
7994 
        break
7995 
      if fid == 0:
3064 chandransh 7996 
        if ftype == TType.I64:
7997 
          self.success = iprot.readI64();
94 ashish 7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      else:
8001 
        iprot.skip(ftype)
8002 
      iprot.readFieldEnd()
8003 
    iprot.readStructEnd()
8004 
 
8005 
  def write(self, oprot):
8006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8008 
      return
3064 chandransh 8009 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8010 
    if self.success is not None:
3064 chandransh 8011 
      oprot.writeFieldBegin('success', TType.I64, 0)
8012 
      oprot.writeI64(self.success)
94 ashish 8013 
      oprot.writeFieldEnd()
8014 
    oprot.writeFieldStop()
8015 
    oprot.writeStructEnd()
8016 
 
3431 rajveer 8017 
  def validate(self):
8018 
    return
8019 
 
8020 
 
94 ashish 8021 
  def __repr__(self):
8022 
    L = ['%s=%r' % (key, value)
8023 
      for key, value in self.__dict__.iteritems()]
8024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8025 
 
8026 
  def __eq__(self, other):
8027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8028 
 
8029 
  def __ne__(self, other):
8030 
    return not (self == other)
8031 
 
3064 chandransh 8032 
class getNoOfCustomersWithSuccessfulTransaction_args:
8033 
 
8034 
  thrift_spec = (
8035 
  )
8036 
 
8037 
  def read(self, iprot):
8038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8040 
      return
8041 
    iprot.readStructBegin()
8042 
    while True:
8043 
      (fname, ftype, fid) = iprot.readFieldBegin()
8044 
      if ftype == TType.STOP:
8045 
        break
8046 
      else:
8047 
        iprot.skip(ftype)
8048 
      iprot.readFieldEnd()
8049 
    iprot.readStructEnd()
8050 
 
8051 
  def write(self, oprot):
8052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8054 
      return
8055 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8056 
    oprot.writeFieldStop()
8057 
    oprot.writeStructEnd()
8058 
 
3431 rajveer 8059 
  def validate(self):
8060 
    return
8061 
 
8062 
 
3064 chandransh 8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
8074 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8075 
  """
8076 
  Attributes:
3064 chandransh 8077 
   - success
94 ashish 8078 
  """
8079 
 
8080 
  thrift_spec = (
3064 chandransh 8081 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8082 
  )
8083 
 
3064 chandransh 8084 
  def __init__(self, success=None,):
8085 
    self.success = success
94 ashish 8086 
 
8087 
  def read(self, iprot):
8088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8090 
      return
8091 
    iprot.readStructBegin()
8092 
    while True:
8093 
      (fname, ftype, fid) = iprot.readFieldBegin()
8094 
      if ftype == TType.STOP:
8095 
        break
3064 chandransh 8096 
      if fid == 0:
94 ashish 8097 
        if ftype == TType.I64:
3064 chandransh 8098 
          self.success = iprot.readI64();
94 ashish 8099 
        else:
8100 
          iprot.skip(ftype)
8101 
      else:
8102 
        iprot.skip(ftype)
8103 
      iprot.readFieldEnd()
8104 
    iprot.readStructEnd()
8105 
 
8106 
  def write(self, oprot):
8107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8109 
      return
3064 chandransh 8110 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8111 
    if self.success is not None:
3064 chandransh 8112 
      oprot.writeFieldBegin('success', TType.I64, 0)
8113 
      oprot.writeI64(self.success)
94 ashish 8114 
      oprot.writeFieldEnd()
8115 
    oprot.writeFieldStop()
8116 
    oprot.writeStructEnd()
8117 
 
3431 rajveer 8118 
  def validate(self):
8119 
    return
8120 
 
8121 
 
94 ashish 8122 
  def __repr__(self):
8123 
    L = ['%s=%r' % (key, value)
8124 
      for key, value in self.__dict__.iteritems()]
8125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8126 
 
8127 
  def __eq__(self, other):
8128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8129 
 
8130 
  def __ne__(self, other):
8131 
    return not (self == other)
8132 
 
3064 chandransh 8133 
class getValidOrdersAmountRange_args:
8134 
 
8135 
  thrift_spec = (
8136 
  )
8137 
 
8138 
  def read(self, iprot):
8139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8141 
      return
8142 
    iprot.readStructBegin()
8143 
    while True:
8144 
      (fname, ftype, fid) = iprot.readFieldBegin()
8145 
      if ftype == TType.STOP:
8146 
        break
8147 
      else:
8148 
        iprot.skip(ftype)
8149 
      iprot.readFieldEnd()
8150 
    iprot.readStructEnd()
8151 
 
8152 
  def write(self, oprot):
8153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8155 
      return
8156 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8157 
    oprot.writeFieldStop()
8158 
    oprot.writeStructEnd()
8159 
 
3431 rajveer 8160 
  def validate(self):
8161 
    return
8162 
 
8163 
 
3064 chandransh 8164 
  def __repr__(self):
8165 
    L = ['%s=%r' % (key, value)
8166 
      for key, value in self.__dict__.iteritems()]
8167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8168 
 
8169 
  def __eq__(self, other):
8170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8171 
 
8172 
  def __ne__(self, other):
8173 
    return not (self == other)
8174 
 
8175 
class getValidOrdersAmountRange_result:
94 ashish 8176 
  """
8177 
  Attributes:
8178 
   - success
8179 
  """
8180 
 
8181 
  thrift_spec = (
3064 chandransh 8182 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8183 
  )
8184 
 
3064 chandransh 8185 
  def __init__(self, success=None,):
94 ashish 8186 
    self.success = success
8187 
 
8188 
  def read(self, iprot):
8189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8191 
      return
8192 
    iprot.readStructBegin()
8193 
    while True:
8194 
      (fname, ftype, fid) = iprot.readFieldBegin()
8195 
      if ftype == TType.STOP:
8196 
        break
8197 
      if fid == 0:
483 rajveer 8198 
        if ftype == TType.LIST:
8199 
          self.success = []
4133 chandransh 8200 
          (_etype122, _size119) = iprot.readListBegin()
8201 
          for _i123 in xrange(_size119):
8202 
            _elem124 = iprot.readDouble();
8203 
            self.success.append(_elem124)
483 rajveer 8204 
          iprot.readListEnd()
94 ashish 8205 
        else:
8206 
          iprot.skip(ftype)
8207 
      else:
8208 
        iprot.skip(ftype)
8209 
      iprot.readFieldEnd()
8210 
    iprot.readStructEnd()
8211 
 
8212 
  def write(self, oprot):
8213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8215 
      return
3064 chandransh 8216 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8217 
    if self.success is not None:
483 rajveer 8218 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8219 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8220 
      for iter125 in self.success:
8221 
        oprot.writeDouble(iter125)
483 rajveer 8222 
      oprot.writeListEnd()
94 ashish 8223 
      oprot.writeFieldEnd()
8224 
    oprot.writeFieldStop()
8225 
    oprot.writeStructEnd()
8226 
 
3431 rajveer 8227 
  def validate(self):
8228 
    return
8229 
 
8230 
 
94 ashish 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 getValidOrders_args:
1528 ankur.sing 8243 
  """
8244 
  Attributes:
3064 chandransh 8245 
   - limit
1528 ankur.sing 8246 
  """
8247 
 
8248 
  thrift_spec = (
8249 
    None, # 0
3064 chandransh 8250 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8251 
  )
8252 
 
3064 chandransh 8253 
  def __init__(self, limit=None,):
8254 
    self.limit = limit
1528 ankur.sing 8255 
 
8256 
  def read(self, iprot):
8257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8259 
      return
8260 
    iprot.readStructBegin()
8261 
    while True:
8262 
      (fname, ftype, fid) = iprot.readFieldBegin()
8263 
      if ftype == TType.STOP:
8264 
        break
8265 
      if fid == 1:
8266 
        if ftype == TType.I64:
3064 chandransh 8267 
          self.limit = iprot.readI64();
1528 ankur.sing 8268 
        else:
8269 
          iprot.skip(ftype)
8270 
      else:
8271 
        iprot.skip(ftype)
8272 
      iprot.readFieldEnd()
8273 
    iprot.readStructEnd()
8274 
 
8275 
  def write(self, oprot):
8276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8278 
      return
3064 chandransh 8279 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8280 
    if self.limit is not None:
3064 chandransh 8281 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8282 
      oprot.writeI64(self.limit)
1528 ankur.sing 8283 
      oprot.writeFieldEnd()
8284 
    oprot.writeFieldStop()
8285 
    oprot.writeStructEnd()
8286 
 
3431 rajveer 8287 
  def validate(self):
8288 
    return
8289 
 
8290 
 
1528 ankur.sing 8291 
  def __repr__(self):
8292 
    L = ['%s=%r' % (key, value)
8293 
      for key, value in self.__dict__.iteritems()]
8294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8295 
 
8296 
  def __eq__(self, other):
8297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8298 
 
8299 
  def __ne__(self, other):
8300 
    return not (self == other)
8301 
 
3064 chandransh 8302 
class getValidOrders_result:
1528 ankur.sing 8303 
  """
8304 
  Attributes:
8305 
   - success
8306 
  """
8307 
 
8308 
  thrift_spec = (
3064 chandransh 8309 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8310 
  )
8311 
 
3064 chandransh 8312 
  def __init__(self, success=None,):
1528 ankur.sing 8313 
    self.success = success
8314 
 
8315 
  def read(self, iprot):
8316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8318 
      return
8319 
    iprot.readStructBegin()
8320 
    while True:
8321 
      (fname, ftype, fid) = iprot.readFieldBegin()
8322 
      if ftype == TType.STOP:
8323 
        break
8324 
      if fid == 0:
3064 chandransh 8325 
        if ftype == TType.LIST:
8326 
          self.success = []
4133 chandransh 8327 
          (_etype129, _size126) = iprot.readListBegin()
8328 
          for _i130 in xrange(_size126):
8329 
            _elem131 = Order()
8330 
            _elem131.read(iprot)
8331 
            self.success.append(_elem131)
3064 chandransh 8332 
          iprot.readListEnd()
1528 ankur.sing 8333 
        else:
8334 
          iprot.skip(ftype)
8335 
      else:
8336 
        iprot.skip(ftype)
8337 
      iprot.readFieldEnd()
8338 
    iprot.readStructEnd()
8339 
 
8340 
  def write(self, oprot):
8341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8343 
      return
3064 chandransh 8344 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8345 
    if self.success is not None:
3064 chandransh 8346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8348 
      for iter132 in self.success:
8349 
        iter132.write(oprot)
3064 chandransh 8350 
      oprot.writeListEnd()
1528 ankur.sing 8351 
      oprot.writeFieldEnd()
8352 
    oprot.writeFieldStop()
8353 
    oprot.writeStructEnd()
8354 
 
3431 rajveer 8355 
  def validate(self):
8356 
    return
8357 
 
8358 
 
1528 ankur.sing 8359 
  def __repr__(self):
8360 
    L = ['%s=%r' % (key, value)
8361 
      for key, value in self.__dict__.iteritems()]
8362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8363 
 
8364 
  def __eq__(self, other):
8365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8366 
 
8367 
  def __ne__(self, other):
8368 
    return not (self == other)
8369 
 
1220 chandransh 8370 
class batchOrders_args:
8371 
  """
8372 
  Attributes:
8373 
   - warehouseId
8374 
  """
8375 
 
8376 
  thrift_spec = (
8377 
    None, # 0
8378 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8379 
  )
8380 
 
8381 
  def __init__(self, warehouseId=None,):
8382 
    self.warehouseId = warehouseId
8383 
 
8384 
  def read(self, iprot):
8385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8387 
      return
8388 
    iprot.readStructBegin()
8389 
    while True:
8390 
      (fname, ftype, fid) = iprot.readFieldBegin()
8391 
      if ftype == TType.STOP:
8392 
        break
8393 
      if fid == 1:
8394 
        if ftype == TType.I64:
8395 
          self.warehouseId = iprot.readI64();
8396 
        else:
8397 
          iprot.skip(ftype)
8398 
      else:
8399 
        iprot.skip(ftype)
8400 
      iprot.readFieldEnd()
8401 
    iprot.readStructEnd()
8402 
 
8403 
  def write(self, oprot):
8404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8406 
      return
8407 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8408 
    if self.warehouseId is not None:
1220 chandransh 8409 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8410 
      oprot.writeI64(self.warehouseId)
8411 
      oprot.writeFieldEnd()
8412 
    oprot.writeFieldStop()
8413 
    oprot.writeStructEnd()
8414 
 
3431 rajveer 8415 
  def validate(self):
8416 
    return
8417 
 
8418 
 
1220 chandransh 8419 
  def __repr__(self):
8420 
    L = ['%s=%r' % (key, value)
8421 
      for key, value in self.__dict__.iteritems()]
8422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8423 
 
8424 
  def __eq__(self, other):
8425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8426 
 
8427 
  def __ne__(self, other):
8428 
    return not (self == other)
8429 
 
8430 
class batchOrders_result:
8431 
  """
8432 
  Attributes:
8433 
   - success
8434 
   - ex
8435 
  """
8436 
 
8437 
  thrift_spec = (
8438 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8439 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8440 
  )
8441 
 
8442 
  def __init__(self, success=None, ex=None,):
8443 
    self.success = success
8444 
    self.ex = ex
8445 
 
8446 
  def read(self, iprot):
8447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8449 
      return
8450 
    iprot.readStructBegin()
8451 
    while True:
8452 
      (fname, ftype, fid) = iprot.readFieldBegin()
8453 
      if ftype == TType.STOP:
8454 
        break
8455 
      if fid == 0:
8456 
        if ftype == TType.LIST:
8457 
          self.success = []
4133 chandransh 8458 
          (_etype136, _size133) = iprot.readListBegin()
8459 
          for _i137 in xrange(_size133):
8460 
            _elem138 = Order()
8461 
            _elem138.read(iprot)
8462 
            self.success.append(_elem138)
1220 chandransh 8463 
          iprot.readListEnd()
8464 
        else:
8465 
          iprot.skip(ftype)
8466 
      elif fid == 1:
8467 
        if ftype == TType.STRUCT:
8468 
          self.ex = TransactionServiceException()
8469 
          self.ex.read(iprot)
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      else:
8473 
        iprot.skip(ftype)
8474 
      iprot.readFieldEnd()
8475 
    iprot.readStructEnd()
8476 
 
8477 
  def write(self, oprot):
8478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8480 
      return
8481 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8482 
    if self.success is not None:
1220 chandransh 8483 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8484 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8485 
      for iter139 in self.success:
8486 
        iter139.write(oprot)
1220 chandransh 8487 
      oprot.writeListEnd()
8488 
      oprot.writeFieldEnd()
3431 rajveer 8489 
    if self.ex is not None:
1220 chandransh 8490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8491 
      self.ex.write(oprot)
8492 
      oprot.writeFieldEnd()
8493 
    oprot.writeFieldStop()
8494 
    oprot.writeStructEnd()
8495 
 
3431 rajveer 8496 
  def validate(self):
8497 
    return
8498 
 
8499 
 
1220 chandransh 8500 
  def __repr__(self):
8501 
    L = ['%s=%r' % (key, value)
8502 
      for key, value in self.__dict__.iteritems()]
8503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8504 
 
8505 
  def __eq__(self, other):
8506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8507 
 
8508 
  def __ne__(self, other):
8509 
    return not (self == other)
8510 
 
1208 chandransh 8511 
class markOrderAsOutOfStock_args:
8512 
  """
8513 
  Attributes:
8514 
   - orderId
8515 
  """
8516 
 
8517 
  thrift_spec = (
8518 
    None, # 0
8519 
    (1, TType.I64, 'orderId', None, None, ), # 1
8520 
  )
8521 
 
8522 
  def __init__(self, orderId=None,):
8523 
    self.orderId = orderId
8524 
 
8525 
  def read(self, iprot):
8526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8528 
      return
8529 
    iprot.readStructBegin()
8530 
    while True:
8531 
      (fname, ftype, fid) = iprot.readFieldBegin()
8532 
      if ftype == TType.STOP:
8533 
        break
8534 
      if fid == 1:
8535 
        if ftype == TType.I64:
8536 
          self.orderId = iprot.readI64();
8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      else:
8540 
        iprot.skip(ftype)
8541 
      iprot.readFieldEnd()
8542 
    iprot.readStructEnd()
8543 
 
8544 
  def write(self, oprot):
8545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8547 
      return
8548 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8549 
    if self.orderId is not None:
1208 chandransh 8550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8551 
      oprot.writeI64(self.orderId)
8552 
      oprot.writeFieldEnd()
8553 
    oprot.writeFieldStop()
8554 
    oprot.writeStructEnd()
8555 
 
3431 rajveer 8556 
  def validate(self):
8557 
    return
8558 
 
8559 
 
1208 chandransh 8560 
  def __repr__(self):
8561 
    L = ['%s=%r' % (key, value)
8562 
      for key, value in self.__dict__.iteritems()]
8563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8564 
 
8565 
  def __eq__(self, other):
8566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8567 
 
8568 
  def __ne__(self, other):
8569 
    return not (self == other)
8570 
 
8571 
class markOrderAsOutOfStock_result:
8572 
  """
8573 
  Attributes:
8574 
   - success
8575 
   - ex
8576 
  """
8577 
 
8578 
  thrift_spec = (
8579 
    (0, TType.BOOL, 'success', None, None, ), # 0
8580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8581 
  )
8582 
 
8583 
  def __init__(self, success=None, ex=None,):
8584 
    self.success = success
8585 
    self.ex = ex
8586 
 
8587 
  def read(self, iprot):
8588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8590 
      return
8591 
    iprot.readStructBegin()
8592 
    while True:
8593 
      (fname, ftype, fid) = iprot.readFieldBegin()
8594 
      if ftype == TType.STOP:
8595 
        break
8596 
      if fid == 0:
8597 
        if ftype == TType.BOOL:
8598 
          self.success = iprot.readBool();
8599 
        else:
8600 
          iprot.skip(ftype)
8601 
      elif fid == 1:
8602 
        if ftype == TType.STRUCT:
8603 
          self.ex = TransactionServiceException()
8604 
          self.ex.read(iprot)
8605 
        else:
8606 
          iprot.skip(ftype)
8607 
      else:
8608 
        iprot.skip(ftype)
8609 
      iprot.readFieldEnd()
8610 
    iprot.readStructEnd()
8611 
 
8612 
  def write(self, oprot):
8613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8615 
      return
8616 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8617 
    if self.success is not None:
1208 chandransh 8618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8619 
      oprot.writeBool(self.success)
8620 
      oprot.writeFieldEnd()
3431 rajveer 8621 
    if self.ex is not None:
1208 chandransh 8622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8623 
      self.ex.write(oprot)
8624 
      oprot.writeFieldEnd()
8625 
    oprot.writeFieldStop()
8626 
    oprot.writeStructEnd()
8627 
 
3431 rajveer 8628 
  def validate(self):
8629 
    return
8630 
 
8631 
 
1208 chandransh 8632 
  def __repr__(self):
8633 
    L = ['%s=%r' % (key, value)
8634 
      for key, value in self.__dict__.iteritems()]
8635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8636 
 
8637 
  def __eq__(self, other):
8638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8639 
 
8640 
  def __ne__(self, other):
8641 
    return not (self == other)
8642 
 
3064 chandransh 8643 
class verifyOrder_args:
759 chandransh 8644 
  """
8645 
  Attributes:
3064 chandransh 8646 
   - orderId
759 chandransh 8647 
  """
8648 
 
8649 
  thrift_spec = (
8650 
    None, # 0
3064 chandransh 8651 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8652 
  )
8653 
 
3064 chandransh 8654 
  def __init__(self, orderId=None,):
8655 
    self.orderId = orderId
759 chandransh 8656 
 
8657 
  def read(self, iprot):
8658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8660 
      return
8661 
    iprot.readStructBegin()
8662 
    while True:
8663 
      (fname, ftype, fid) = iprot.readFieldBegin()
8664 
      if ftype == TType.STOP:
8665 
        break
8666 
      if fid == 1:
8667 
        if ftype == TType.I64:
3064 chandransh 8668 
          self.orderId = iprot.readI64();
759 chandransh 8669 
        else:
8670 
          iprot.skip(ftype)
8671 
      else:
8672 
        iprot.skip(ftype)
8673 
      iprot.readFieldEnd()
8674 
    iprot.readStructEnd()
8675 
 
8676 
  def write(self, oprot):
8677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8679 
      return
3064 chandransh 8680 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8681 
    if self.orderId is not None:
3064 chandransh 8682 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8683 
      oprot.writeI64(self.orderId)
759 chandransh 8684 
      oprot.writeFieldEnd()
8685 
    oprot.writeFieldStop()
8686 
    oprot.writeStructEnd()
8687 
 
3431 rajveer 8688 
  def validate(self):
8689 
    return
8690 
 
8691 
 
759 chandransh 8692 
  def __repr__(self):
8693 
    L = ['%s=%r' % (key, value)
8694 
      for key, value in self.__dict__.iteritems()]
8695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8696 
 
8697 
  def __eq__(self, other):
8698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8699 
 
8700 
  def __ne__(self, other):
8701 
    return not (self == other)
8702 
 
3064 chandransh 8703 
class verifyOrder_result:
759 chandransh 8704 
  """
8705 
  Attributes:
8706 
   - success
8707 
   - ex
8708 
  """
8709 
 
8710 
  thrift_spec = (
8711 
    (0, TType.BOOL, 'success', None, None, ), # 0
8712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8713 
  )
8714 
 
8715 
  def __init__(self, success=None, ex=None,):
8716 
    self.success = success
8717 
    self.ex = ex
8718 
 
8719 
  def read(self, iprot):
8720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8722 
      return
8723 
    iprot.readStructBegin()
8724 
    while True:
8725 
      (fname, ftype, fid) = iprot.readFieldBegin()
8726 
      if ftype == TType.STOP:
8727 
        break
8728 
      if fid == 0:
8729 
        if ftype == TType.BOOL:
8730 
          self.success = iprot.readBool();
8731 
        else:
8732 
          iprot.skip(ftype)
8733 
      elif fid == 1:
8734 
        if ftype == TType.STRUCT:
8735 
          self.ex = TransactionServiceException()
8736 
          self.ex.read(iprot)
8737 
        else:
8738 
          iprot.skip(ftype)
8739 
      else:
8740 
        iprot.skip(ftype)
8741 
      iprot.readFieldEnd()
8742 
    iprot.readStructEnd()
8743 
 
8744 
  def write(self, oprot):
8745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8747 
      return
3064 chandransh 8748 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8749 
    if self.success is not None:
759 chandransh 8750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8751 
      oprot.writeBool(self.success)
8752 
      oprot.writeFieldEnd()
3431 rajveer 8753 
    if self.ex is not None:
759 chandransh 8754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8755 
      self.ex.write(oprot)
8756 
      oprot.writeFieldEnd()
8757 
    oprot.writeFieldStop()
8758 
    oprot.writeStructEnd()
8759 
 
3431 rajveer 8760 
  def validate(self):
8761 
    return
8762 
 
8763 
 
759 chandransh 8764 
  def __repr__(self):
8765 
    L = ['%s=%r' % (key, value)
8766 
      for key, value in self.__dict__.iteritems()]
8767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8768 
 
8769 
  def __eq__(self, other):
8770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8771 
 
8772 
  def __ne__(self, other):
8773 
    return not (self == other)
8774 
 
3064 chandransh 8775 
class acceptOrder_args:
1113 chandransh 8776 
  """
8777 
  Attributes:
3064 chandransh 8778 
   - orderId
1113 chandransh 8779 
  """
8780 
 
8781 
  thrift_spec = (
8782 
    None, # 0
3064 chandransh 8783 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8784 
  )
8785 
 
3064 chandransh 8786 
  def __init__(self, orderId=None,):
8787 
    self.orderId = orderId
1113 chandransh 8788 
 
8789 
  def read(self, iprot):
8790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8792 
      return
8793 
    iprot.readStructBegin()
8794 
    while True:
8795 
      (fname, ftype, fid) = iprot.readFieldBegin()
8796 
      if ftype == TType.STOP:
8797 
        break
8798 
      if fid == 1:
8799 
        if ftype == TType.I64:
3064 chandransh 8800 
          self.orderId = iprot.readI64();
1113 chandransh 8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      else:
8804 
        iprot.skip(ftype)
8805 
      iprot.readFieldEnd()
8806 
    iprot.readStructEnd()
8807 
 
8808 
  def write(self, oprot):
8809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8811 
      return
3064 chandransh 8812 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8813 
    if self.orderId is not None:
3064 chandransh 8814 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8815 
      oprot.writeI64(self.orderId)
1113 chandransh 8816 
      oprot.writeFieldEnd()
8817 
    oprot.writeFieldStop()
8818 
    oprot.writeStructEnd()
8819 
 
3431 rajveer 8820 
  def validate(self):
8821 
    return
8822 
 
8823 
 
1113 chandransh 8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
3064 chandransh 8835 
class acceptOrder_result:
1113 chandransh 8836 
  """
8837 
  Attributes:
8838 
   - success
8839 
   - ex
8840 
  """
8841 
 
8842 
  thrift_spec = (
3064 chandransh 8843 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8845 
  )
8846 
 
8847 
  def __init__(self, success=None, ex=None,):
8848 
    self.success = success
8849 
    self.ex = ex
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 == 0:
3064 chandransh 8861 
        if ftype == TType.BOOL:
8862 
          self.success = iprot.readBool();
1113 chandransh 8863 
        else:
8864 
          iprot.skip(ftype)
8865 
      elif fid == 1:
8866 
        if ftype == TType.STRUCT:
8867 
          self.ex = TransactionServiceException()
8868 
          self.ex.read(iprot)
8869 
        else:
8870 
          iprot.skip(ftype)
8871 
      else:
8872 
        iprot.skip(ftype)
8873 
      iprot.readFieldEnd()
8874 
    iprot.readStructEnd()
8875 
 
8876 
  def write(self, oprot):
8877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8879 
      return
3064 chandransh 8880 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8881 
    if self.success is not None:
3064 chandransh 8882 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8883 
      oprot.writeBool(self.success)
1113 chandransh 8884 
      oprot.writeFieldEnd()
3431 rajveer 8885 
    if self.ex is not None:
1113 chandransh 8886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8887 
      self.ex.write(oprot)
8888 
      oprot.writeFieldEnd()
8889 
    oprot.writeFieldStop()
8890 
    oprot.writeStructEnd()
8891 
 
3431 rajveer 8892 
  def validate(self):
8893 
    return
8894 
 
8895 
 
1113 chandransh 8896 
  def __repr__(self):
8897 
    L = ['%s=%r' % (key, value)
8898 
      for key, value in self.__dict__.iteritems()]
8899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8900 
 
8901 
  def __eq__(self, other):
8902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8903 
 
8904 
  def __ne__(self, other):
8905 
    return not (self == other)
8906 
 
3064 chandransh 8907 
class addBillingDetails_args:
1135 chandransh 8908 
  """
8909 
  Attributes:
3064 chandransh 8910 
   - orderId
8911 
   - invoice_number
4283 anupam.sin 8912 
   - imeiNumber
8913 
   - itemNumber
3064 chandransh 8914 
   - billed_by
4264 rajveer 8915 
   - jacketNumber
4283 anupam.sin 8916 
   - billingType
8917 
   - vendorId
1135 chandransh 8918 
  """
8919 
 
8920 
  thrift_spec = (
8921 
    None, # 0
3064 chandransh 8922 
    (1, TType.I64, 'orderId', None, None, ), # 1
8923 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8924 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8925 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8926 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8927 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8928 
    (7, TType.I64, 'billingType', None, None, ), # 7
8929 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8930 
  )
8931 
 
4283 anupam.sin 8932 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8933 
    self.orderId = orderId
8934 
    self.invoice_number = invoice_number
4283 anupam.sin 8935 
    self.imeiNumber = imeiNumber
8936 
    self.itemNumber = itemNumber
3064 chandransh 8937 
    self.billed_by = billed_by
4264 rajveer 8938 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8939 
    self.billingType = billingType
8940 
    self.vendorId = vendorId
1135 chandransh 8941 
 
8942 
  def read(self, iprot):
8943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8945 
      return
8946 
    iprot.readStructBegin()
8947 
    while True:
8948 
      (fname, ftype, fid) = iprot.readFieldBegin()
8949 
      if ftype == TType.STOP:
8950 
        break
8951 
      if fid == 1:
8952 
        if ftype == TType.I64:
3064 chandransh 8953 
          self.orderId = iprot.readI64();
1135 chandransh 8954 
        else:
8955 
          iprot.skip(ftype)
8956 
      elif fid == 2:
3064 chandransh 8957 
        if ftype == TType.STRING:
8958 
          self.invoice_number = iprot.readString();
1135 chandransh 8959 
        else:
8960 
          iprot.skip(ftype)
3064 chandransh 8961 
      elif fid == 3:
4264 rajveer 8962 
        if ftype == TType.I64:
3064 chandransh 8963 
          self.imeiNumber = iprot.readI64();
8964 
        else:
8965 
          iprot.skip(ftype)
8966 
      elif fid == 4:
8967 
        if ftype == TType.STRING:
8968 
          self.itemNumber = iprot.readString();
8969 
        else:
8970 
          iprot.skip(ftype)
8971 
      elif fid == 5:
8972 
        if ftype == TType.STRING:
4283 anupam.sin 8973 
          self.billed_by = iprot.readString();
3064 chandransh 8974 
        else:
8975 
          iprot.skip(ftype)
8976 
      elif fid == 6:
8977 
        if ftype == TType.I64:
4283 anupam.sin 8978 
          self.jacketNumber = iprot.readI64();
8979 
        else:
8980 
          iprot.skip(ftype)
8981 
      elif fid == 7:
8982 
        if ftype == TType.I64:
3064 chandransh 8983 
          self.billingType = iprot.readI64();
8984 
        else:
8985 
          iprot.skip(ftype)
4283 anupam.sin 8986 
      elif fid == 8:
8987 
        if ftype == TType.I64:
8988 
          self.vendorId = iprot.readI64();
8989 
        else:
8990 
          iprot.skip(ftype)
1246 chandransh 8991 
      else:
8992 
        iprot.skip(ftype)
8993 
      iprot.readFieldEnd()
8994 
    iprot.readStructEnd()
8995 
 
8996 
  def write(self, oprot):
8997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8999 
      return
4283 anupam.sin 9000 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9001 
    if self.orderId is not None:
3064 chandransh 9002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9003 
      oprot.writeI64(self.orderId)
1246 chandransh 9004 
      oprot.writeFieldEnd()
4283 anupam.sin 9005 
    if self.invoice_number is not None:
9006 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9007 
      oprot.writeString(self.invoice_number)
1246 chandransh 9008 
      oprot.writeFieldEnd()
3431 rajveer 9009 
    if self.imeiNumber is not None:
3064 chandransh 9010 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9011 
      oprot.writeI64(self.imeiNumber)
9012 
      oprot.writeFieldEnd()
3431 rajveer 9013 
    if self.itemNumber is not None:
3064 chandransh 9014 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9015 
      oprot.writeString(self.itemNumber)
9016 
      oprot.writeFieldEnd()
4283 anupam.sin 9017 
    if self.billed_by is not None:
9018 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9019 
      oprot.writeString(self.billed_by)
3064 chandransh 9020 
      oprot.writeFieldEnd()
4283 anupam.sin 9021 
    if self.jacketNumber is not None:
9022 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9023 
      oprot.writeI64(self.jacketNumber)
9024 
      oprot.writeFieldEnd()
3431 rajveer 9025 
    if self.billingType is not None:
4283 anupam.sin 9026 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9027 
      oprot.writeI64(self.billingType)
9028 
      oprot.writeFieldEnd()
4283 anupam.sin 9029 
    if self.vendorId is not None:
9030 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9031 
      oprot.writeI64(self.vendorId)
9032 
      oprot.writeFieldEnd()
1246 chandransh 9033 
    oprot.writeFieldStop()
9034 
    oprot.writeStructEnd()
9035 
 
3431 rajveer 9036 
  def validate(self):
9037 
    return
9038 
 
9039 
 
1246 chandransh 9040 
  def __repr__(self):
9041 
    L = ['%s=%r' % (key, value)
9042 
      for key, value in self.__dict__.iteritems()]
9043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9044 
 
9045 
  def __eq__(self, other):
9046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9047 
 
9048 
  def __ne__(self, other):
9049 
    return not (self == other)
9050 
 
4283 anupam.sin 9051 
class addBillingDetails_result:
1246 chandransh 9052 
  """
9053 
  Attributes:
3064 chandransh 9054 
   - success
1246 chandransh 9055 
   - ex
9056 
  """
9057 
 
9058 
  thrift_spec = (
3064 chandransh 9059 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9060 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9061 
  )
9062 
 
3064 chandransh 9063 
  def __init__(self, success=None, ex=None,):
9064 
    self.success = success
1246 chandransh 9065 
    self.ex = ex
9066 
 
9067 
  def read(self, iprot):
9068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9070 
      return
9071 
    iprot.readStructBegin()
9072 
    while True:
9073 
      (fname, ftype, fid) = iprot.readFieldBegin()
9074 
      if ftype == TType.STOP:
9075 
        break
3064 chandransh 9076 
      if fid == 0:
9077 
        if ftype == TType.BOOL:
9078 
          self.success = iprot.readBool();
9079 
        else:
9080 
          iprot.skip(ftype)
9081 
      elif fid == 1:
1246 chandransh 9082 
        if ftype == TType.STRUCT:
9083 
          self.ex = TransactionServiceException()
9084 
          self.ex.read(iprot)
9085 
        else:
9086 
          iprot.skip(ftype)
9087 
      else:
9088 
        iprot.skip(ftype)
9089 
      iprot.readFieldEnd()
9090 
    iprot.readStructEnd()
9091 
 
9092 
  def write(self, oprot):
9093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9095 
      return
4283 anupam.sin 9096 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9097 
    if self.success is not None:
3064 chandransh 9098 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9099 
      oprot.writeBool(self.success)
9100 
      oprot.writeFieldEnd()
3431 rajveer 9101 
    if self.ex is not None:
1246 chandransh 9102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9103 
      self.ex.write(oprot)
9104 
      oprot.writeFieldEnd()
9105 
    oprot.writeFieldStop()
9106 
    oprot.writeStructEnd()
9107 
 
3431 rajveer 9108 
  def validate(self):
9109 
    return
9110 
 
9111 
 
1246 chandransh 9112 
  def __repr__(self):
9113 
    L = ['%s=%r' % (key, value)
9114 
      for key, value in self.__dict__.iteritems()]
9115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9116 
 
9117 
  def __eq__(self, other):
9118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9119 
 
9120 
  def __ne__(self, other):
9121 
    return not (self == other)
9122 
 
3064 chandransh 9123 
class markOrdersAsManifested_args:
1408 ankur.sing 9124 
  """
9125 
  Attributes:
3064 chandransh 9126 
   - warehouseId
1408 ankur.sing 9127 
   - providerId
3064 chandransh 9128 
   - cod
1408 ankur.sing 9129 
  """
9130 
 
9131 
  thrift_spec = (
9132 
    None, # 0
3064 chandransh 9133 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9134 
    (2, TType.I64, 'providerId', None, None, ), # 2
9135 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9136 
  )
9137 
 
3064 chandransh 9138 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9139 
    self.warehouseId = warehouseId
1408 ankur.sing 9140 
    self.providerId = providerId
3064 chandransh 9141 
    self.cod = cod
1408 ankur.sing 9142 
 
9143 
  def read(self, iprot):
9144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9146 
      return
9147 
    iprot.readStructBegin()
9148 
    while True:
9149 
      (fname, ftype, fid) = iprot.readFieldBegin()
9150 
      if ftype == TType.STOP:
9151 
        break
9152 
      if fid == 1:
9153 
        if ftype == TType.I64:
3064 chandransh 9154 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      elif fid == 2:
9158 
        if ftype == TType.I64:
3064 chandransh 9159 
          self.providerId = iprot.readI64();
1408 ankur.sing 9160 
        else:
9161 
          iprot.skip(ftype)
3064 chandransh 9162 
      elif fid == 3:
9163 
        if ftype == TType.BOOL:
9164 
          self.cod = iprot.readBool();
9165 
        else:
9166 
          iprot.skip(ftype)
1408 ankur.sing 9167 
      else:
9168 
        iprot.skip(ftype)
9169 
      iprot.readFieldEnd()
9170 
    iprot.readStructEnd()
9171 
 
9172 
  def write(self, oprot):
9173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9175 
      return
3064 chandransh 9176 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9177 
    if self.warehouseId is not None:
3064 chandransh 9178 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9179 
      oprot.writeI64(self.warehouseId)
9180 
      oprot.writeFieldEnd()
3431 rajveer 9181 
    if self.providerId is not None:
3064 chandransh 9182 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9183 
      oprot.writeI64(self.providerId)
9184 
      oprot.writeFieldEnd()
3431 rajveer 9185 
    if self.cod is not None:
3064 chandransh 9186 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9187 
      oprot.writeBool(self.cod)
1408 ankur.sing 9188 
      oprot.writeFieldEnd()
9189 
    oprot.writeFieldStop()
9190 
    oprot.writeStructEnd()
9191 
 
3431 rajveer 9192 
  def validate(self):
9193 
    return
9194 
 
9195 
 
1408 ankur.sing 9196 
  def __repr__(self):
9197 
    L = ['%s=%r' % (key, value)
9198 
      for key, value in self.__dict__.iteritems()]
9199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9200 
 
9201 
  def __eq__(self, other):
9202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9203 
 
9204 
  def __ne__(self, other):
9205 
    return not (self == other)
9206 
 
3064 chandransh 9207 
class markOrdersAsManifested_result:
1408 ankur.sing 9208 
  """
9209 
  Attributes:
9210 
   - success
3064 chandransh 9211 
   - ex
1408 ankur.sing 9212 
  """
9213 
 
9214 
  thrift_spec = (
3064 chandransh 9215 
    (0, TType.BOOL, 'success', None, None, ), # 0
9216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9217 
  )
9218 
 
3064 chandransh 9219 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9220 
    self.success = success
3064 chandransh 9221 
    self.ex = ex
1408 ankur.sing 9222 
 
9223 
  def read(self, iprot):
9224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9226 
      return
9227 
    iprot.readStructBegin()
9228 
    while True:
9229 
      (fname, ftype, fid) = iprot.readFieldBegin()
9230 
      if ftype == TType.STOP:
9231 
        break
9232 
      if fid == 0:
3064 chandransh 9233 
        if ftype == TType.BOOL:
9234 
          self.success = iprot.readBool();
1408 ankur.sing 9235 
        else:
9236 
          iprot.skip(ftype)
3064 chandransh 9237 
      elif fid == 1:
9238 
        if ftype == TType.STRUCT:
9239 
          self.ex = TransactionServiceException()
9240 
          self.ex.read(iprot)
9241 
        else:
9242 
          iprot.skip(ftype)
1408 ankur.sing 9243 
      else:
9244 
        iprot.skip(ftype)
9245 
      iprot.readFieldEnd()
9246 
    iprot.readStructEnd()
9247 
 
9248 
  def write(self, oprot):
9249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9251 
      return
3064 chandransh 9252 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9253 
    if self.success is not None:
3064 chandransh 9254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9255 
      oprot.writeBool(self.success)
1408 ankur.sing 9256 
      oprot.writeFieldEnd()
3431 rajveer 9257 
    if self.ex is not None:
3064 chandransh 9258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9259 
      self.ex.write(oprot)
9260 
      oprot.writeFieldEnd()
1408 ankur.sing 9261 
    oprot.writeFieldStop()
9262 
    oprot.writeStructEnd()
9263 
 
3431 rajveer 9264 
  def validate(self):
9265 
    return
9266 
 
9267 
 
1408 ankur.sing 9268 
  def __repr__(self):
9269 
    L = ['%s=%r' % (key, value)
9270 
      for key, value in self.__dict__.iteritems()]
9271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9272 
 
9273 
  def __eq__(self, other):
9274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9275 
 
9276 
  def __ne__(self, other):
9277 
    return not (self == other)
9278 
 
3064 chandransh 9279 
class markOrdersAsPickedUp_args:
304 ashish 9280 
  """
9281 
  Attributes:
3064 chandransh 9282 
   - providerId
9283 
   - pickupDetails
304 ashish 9284 
  """
94 ashish 9285 
 
304 ashish 9286 
  thrift_spec = (
9287 
    None, # 0
3064 chandransh 9288 
    (1, TType.I64, 'providerId', None, None, ), # 1
9289 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9290 
  )
9291 
 
3064 chandransh 9292 
  def __init__(self, providerId=None, pickupDetails=None,):
9293 
    self.providerId = providerId
9294 
    self.pickupDetails = pickupDetails
304 ashish 9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 1:
9306 
        if ftype == TType.I64:
3064 chandransh 9307 
          self.providerId = iprot.readI64();
304 ashish 9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 2:
3064 chandransh 9311 
        if ftype == TType.MAP:
9312 
          self.pickupDetails = {}
4133 chandransh 9313 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9314 
          for _i144 in xrange(_size140):
9315 
            _key145 = iprot.readString();
9316 
            _val146 = iprot.readString();
9317 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9318 
          iprot.readMapEnd()
304 ashish 9319 
        else:
9320 
          iprot.skip(ftype)
9321 
      else:
9322 
        iprot.skip(ftype)
9323 
      iprot.readFieldEnd()
9324 
    iprot.readStructEnd()
9325 
 
9326 
  def write(self, oprot):
9327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9329 
      return
3064 chandransh 9330 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9331 
    if self.providerId is not None:
3064 chandransh 9332 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9333 
      oprot.writeI64(self.providerId)
304 ashish 9334 
      oprot.writeFieldEnd()
3431 rajveer 9335 
    if self.pickupDetails is not None:
3064 chandransh 9336 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9337 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9338 
      for kiter147,viter148 in self.pickupDetails.items():
9339 
        oprot.writeString(kiter147)
9340 
        oprot.writeString(viter148)
3064 chandransh 9341 
      oprot.writeMapEnd()
304 ashish 9342 
      oprot.writeFieldEnd()
9343 
    oprot.writeFieldStop()
9344 
    oprot.writeStructEnd()
9345 
 
3431 rajveer 9346 
  def validate(self):
9347 
    return
9348 
 
9349 
 
304 ashish 9350 
  def __repr__(self):
9351 
    L = ['%s=%r' % (key, value)
9352 
      for key, value in self.__dict__.iteritems()]
9353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9354 
 
9355 
  def __eq__(self, other):
9356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9357 
 
9358 
  def __ne__(self, other):
9359 
    return not (self == other)
9360 
 
3064 chandransh 9361 
class markOrdersAsPickedUp_result:
304 ashish 9362 
  """
9363 
  Attributes:
9364 
   - success
3064 chandransh 9365 
   - ex
304 ashish 9366 
  """
9367 
 
9368 
  thrift_spec = (
3064 chandransh 9369 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9371 
  )
9372 
 
3064 chandransh 9373 
  def __init__(self, success=None, ex=None,):
304 ashish 9374 
    self.success = success
3064 chandransh 9375 
    self.ex = ex
304 ashish 9376 
 
9377 
  def read(self, iprot):
9378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9380 
      return
9381 
    iprot.readStructBegin()
9382 
    while True:
9383 
      (fname, ftype, fid) = iprot.readFieldBegin()
9384 
      if ftype == TType.STOP:
9385 
        break
9386 
      if fid == 0:
9387 
        if ftype == TType.LIST:
9388 
          self.success = []
4133 chandransh 9389 
          (_etype152, _size149) = iprot.readListBegin()
9390 
          for _i153 in xrange(_size149):
9391 
            _elem154 = Order()
9392 
            _elem154.read(iprot)
9393 
            self.success.append(_elem154)
304 ashish 9394 
          iprot.readListEnd()
9395 
        else:
9396 
          iprot.skip(ftype)
3064 chandransh 9397 
      elif fid == 1:
9398 
        if ftype == TType.STRUCT:
9399 
          self.ex = TransactionServiceException()
9400 
          self.ex.read(iprot)
9401 
        else:
9402 
          iprot.skip(ftype)
304 ashish 9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
3064 chandransh 9412 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9413 
    if self.success is not None:
304 ashish 9414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9416 
      for iter155 in self.success:
9417 
        iter155.write(oprot)
304 ashish 9418 
      oprot.writeListEnd()
9419 
      oprot.writeFieldEnd()
3431 rajveer 9420 
    if self.ex is not None:
3064 chandransh 9421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9422 
      self.ex.write(oprot)
9423 
      oprot.writeFieldEnd()
304 ashish 9424 
    oprot.writeFieldStop()
9425 
    oprot.writeStructEnd()
9426 
 
3431 rajveer 9427 
  def validate(self):
9428 
    return
9429 
 
9430 
 
304 ashish 9431 
  def __repr__(self):
9432 
    L = ['%s=%r' % (key, value)
9433 
      for key, value in self.__dict__.iteritems()]
9434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9435 
 
9436 
  def __eq__(self, other):
9437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9438 
 
9439 
  def __ne__(self, other):
9440 
    return not (self == other)
9441 
 
3064 chandransh 9442 
class markOrdersAsDelivered_args:
304 ashish 9443 
  """
9444 
  Attributes:
3064 chandransh 9445 
   - providerId
9446 
   - deliveredOrders
304 ashish 9447 
  """
9448 
 
9449 
  thrift_spec = (
9450 
    None, # 0
3064 chandransh 9451 
    (1, TType.I64, 'providerId', None, None, ), # 1
9452 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9453 
  )
9454 
 
3064 chandransh 9455 
  def __init__(self, providerId=None, deliveredOrders=None,):
9456 
    self.providerId = providerId
9457 
    self.deliveredOrders = deliveredOrders
304 ashish 9458 
 
9459 
  def read(self, iprot):
9460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9462 
      return
9463 
    iprot.readStructBegin()
9464 
    while True:
9465 
      (fname, ftype, fid) = iprot.readFieldBegin()
9466 
      if ftype == TType.STOP:
9467 
        break
9468 
      if fid == 1:
9469 
        if ftype == TType.I64:
3064 chandransh 9470 
          self.providerId = iprot.readI64();
304 ashish 9471 
        else:
9472 
          iprot.skip(ftype)
9473 
      elif fid == 2:
3064 chandransh 9474 
        if ftype == TType.MAP:
9475 
          self.deliveredOrders = {}
4133 chandransh 9476 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9477 
          for _i160 in xrange(_size156):
9478 
            _key161 = iprot.readString();
9479 
            _val162 = iprot.readString();
9480 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9481 
          iprot.readMapEnd()
304 ashish 9482 
        else:
9483 
          iprot.skip(ftype)
9484 
      else:
9485 
        iprot.skip(ftype)
9486 
      iprot.readFieldEnd()
9487 
    iprot.readStructEnd()
9488 
 
9489 
  def write(self, oprot):
9490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9492 
      return
3064 chandransh 9493 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9494 
    if self.providerId is not None:
3064 chandransh 9495 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9496 
      oprot.writeI64(self.providerId)
304 ashish 9497 
      oprot.writeFieldEnd()
3431 rajveer 9498 
    if self.deliveredOrders is not None:
3064 chandransh 9499 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9500 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9501 
      for kiter163,viter164 in self.deliveredOrders.items():
9502 
        oprot.writeString(kiter163)
9503 
        oprot.writeString(viter164)
3064 chandransh 9504 
      oprot.writeMapEnd()
304 ashish 9505 
      oprot.writeFieldEnd()
9506 
    oprot.writeFieldStop()
9507 
    oprot.writeStructEnd()
9508 
 
3431 rajveer 9509 
  def validate(self):
9510 
    return
9511 
 
9512 
 
304 ashish 9513 
  def __repr__(self):
9514 
    L = ['%s=%r' % (key, value)
9515 
      for key, value in self.__dict__.iteritems()]
9516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9517 
 
9518 
  def __eq__(self, other):
9519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9520 
 
9521 
  def __ne__(self, other):
9522 
    return not (self == other)
9523 
 
3064 chandransh 9524 
class markOrdersAsDelivered_result:
9525 
  """
9526 
  Attributes:
9527 
   - ex
9528 
  """
304 ashish 9529 
 
9530 
  thrift_spec = (
3064 chandransh 9531 
    None, # 0
9532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9533 
  )
9534 
 
3064 chandransh 9535 
  def __init__(self, ex=None,):
9536 
    self.ex = ex
304 ashish 9537 
 
1596 ankur.sing 9538 
  def read(self, iprot):
9539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9541 
      return
9542 
    iprot.readStructBegin()
9543 
    while True:
9544 
      (fname, ftype, fid) = iprot.readFieldBegin()
9545 
      if ftype == TType.STOP:
9546 
        break
3064 chandransh 9547 
      if fid == 1:
9548 
        if ftype == TType.STRUCT:
9549 
          self.ex = TransactionServiceException()
9550 
          self.ex.read(iprot)
9551 
        else:
9552 
          iprot.skip(ftype)
1596 ankur.sing 9553 
      else:
9554 
        iprot.skip(ftype)
9555 
      iprot.readFieldEnd()
9556 
    iprot.readStructEnd()
9557 
 
9558 
  def write(self, oprot):
9559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9561 
      return
3064 chandransh 9562 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9563 
    if self.ex is not None:
3064 chandransh 9564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9565 
      self.ex.write(oprot)
9566 
      oprot.writeFieldEnd()
1596 ankur.sing 9567 
    oprot.writeFieldStop()
9568 
    oprot.writeStructEnd()
9569 
 
3431 rajveer 9570 
  def validate(self):
9571 
    return
9572 
 
9573 
 
1596 ankur.sing 9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
3064 chandransh 9585 
class markOrdersAsFailed_args:
1596 ankur.sing 9586 
  """
9587 
  Attributes:
3064 chandransh 9588 
   - providerId
9589 
   - returnedOrders
1596 ankur.sing 9590 
  """
9591 
 
9592 
  thrift_spec = (
3064 chandransh 9593 
    None, # 0
9594 
    (1, TType.I64, 'providerId', None, None, ), # 1
9595 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9596 
  )
9597 
 
3064 chandransh 9598 
  def __init__(self, providerId=None, returnedOrders=None,):
9599 
    self.providerId = providerId
9600 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9601 
 
9602 
  def read(self, iprot):
9603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9605 
      return
9606 
    iprot.readStructBegin()
9607 
    while True:
9608 
      (fname, ftype, fid) = iprot.readFieldBegin()
9609 
      if ftype == TType.STOP:
9610 
        break
3064 chandransh 9611 
      if fid == 1:
1596 ankur.sing 9612 
        if ftype == TType.I64:
3064 chandransh 9613 
          self.providerId = iprot.readI64();
1596 ankur.sing 9614 
        else:
9615 
          iprot.skip(ftype)
3064 chandransh 9616 
      elif fid == 2:
9617 
        if ftype == TType.MAP:
9618 
          self.returnedOrders = {}
4133 chandransh 9619 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9620 
          for _i169 in xrange(_size165):
9621 
            _key170 = iprot.readString();
9622 
            _val171 = iprot.readString();
9623 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9624 
          iprot.readMapEnd()
9625 
        else:
9626 
          iprot.skip(ftype)
1596 ankur.sing 9627 
      else:
9628 
        iprot.skip(ftype)
9629 
      iprot.readFieldEnd()
9630 
    iprot.readStructEnd()
9631 
 
9632 
  def write(self, oprot):
9633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9635 
      return
3064 chandransh 9636 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9637 
    if self.providerId is not None:
3064 chandransh 9638 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9639 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9640 
      oprot.writeFieldEnd()
3431 rajveer 9641 
    if self.returnedOrders is not None:
3064 chandransh 9642 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9643 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9644 
      for kiter172,viter173 in self.returnedOrders.items():
9645 
        oprot.writeString(kiter172)
9646 
        oprot.writeString(viter173)
3064 chandransh 9647 
      oprot.writeMapEnd()
9648 
      oprot.writeFieldEnd()
1596 ankur.sing 9649 
    oprot.writeFieldStop()
9650 
    oprot.writeStructEnd()
9651 
 
3431 rajveer 9652 
  def validate(self):
9653 
    return
9654 
 
9655 
 
1596 ankur.sing 9656 
  def __repr__(self):
9657 
    L = ['%s=%r' % (key, value)
9658 
      for key, value in self.__dict__.iteritems()]
9659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9660 
 
9661 
  def __eq__(self, other):
9662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9663 
 
9664 
  def __ne__(self, other):
9665 
    return not (self == other)
9666 
 
3064 chandransh 9667 
class markOrdersAsFailed_result:
9668 
  """
9669 
  Attributes:
9670 
   - ex
9671 
  """
1596 ankur.sing 9672 
 
1627 ankur.sing 9673 
  thrift_spec = (
3064 chandransh 9674 
    None, # 0
9675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9676 
  )
9677 
 
3064 chandransh 9678 
  def __init__(self, ex=None,):
9679 
    self.ex = ex
9680 
 
1627 ankur.sing 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
3064 chandransh 9690 
      if fid == 1:
9691 
        if ftype == TType.STRUCT:
9692 
          self.ex = TransactionServiceException()
9693 
          self.ex.read(iprot)
9694 
        else:
9695 
          iprot.skip(ftype)
1627 ankur.sing 9696 
      else:
9697 
        iprot.skip(ftype)
9698 
      iprot.readFieldEnd()
9699 
    iprot.readStructEnd()
9700 
 
9701 
  def write(self, oprot):
9702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9704 
      return
3064 chandransh 9705 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9706 
    if self.ex is not None:
3064 chandransh 9707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9708 
      self.ex.write(oprot)
9709 
      oprot.writeFieldEnd()
1627 ankur.sing 9710 
    oprot.writeFieldStop()
9711 
    oprot.writeStructEnd()
9712 
 
3431 rajveer 9713 
  def validate(self):
9714 
    return
9715 
 
9716 
 
1627 ankur.sing 9717 
  def __repr__(self):
9718 
    L = ['%s=%r' % (key, value)
9719 
      for key, value in self.__dict__.iteritems()]
9720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9721 
 
9722 
  def __eq__(self, other):
9723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9724 
 
9725 
  def __ne__(self, other):
9726 
    return not (self == other)
9727 
 
3064 chandransh 9728 
class updateNonDeliveryReason_args:
1627 ankur.sing 9729 
  """
9730 
  Attributes:
3064 chandransh 9731 
   - providerId
9732 
   - undeliveredOrders
1627 ankur.sing 9733 
  """
9734 
 
9735 
  thrift_spec = (
3064 chandransh 9736 
    None, # 0
9737 
    (1, TType.I64, 'providerId', None, None, ), # 1
9738 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9739 
  )
9740 
 
3064 chandransh 9741 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9742 
    self.providerId = providerId
9743 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9744 
 
9745 
  def read(self, iprot):
9746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9748 
      return
9749 
    iprot.readStructBegin()
9750 
    while True:
9751 
      (fname, ftype, fid) = iprot.readFieldBegin()
9752 
      if ftype == TType.STOP:
9753 
        break
3064 chandransh 9754 
      if fid == 1:
1627 ankur.sing 9755 
        if ftype == TType.I64:
3064 chandransh 9756 
          self.providerId = iprot.readI64();
1627 ankur.sing 9757 
        else:
9758 
          iprot.skip(ftype)
3064 chandransh 9759 
      elif fid == 2:
9760 
        if ftype == TType.MAP:
9761 
          self.undeliveredOrders = {}
4133 chandransh 9762 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9763 
          for _i178 in xrange(_size174):
9764 
            _key179 = iprot.readString();
9765 
            _val180 = iprot.readString();
9766 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9767 
          iprot.readMapEnd()
9768 
        else:
9769 
          iprot.skip(ftype)
1627 ankur.sing 9770 
      else:
9771 
        iprot.skip(ftype)
9772 
      iprot.readFieldEnd()
9773 
    iprot.readStructEnd()
9774 
 
9775 
  def write(self, oprot):
9776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9778 
      return
3064 chandransh 9779 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9780 
    if self.providerId is not None:
3064 chandransh 9781 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9782 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9783 
      oprot.writeFieldEnd()
3431 rajveer 9784 
    if self.undeliveredOrders is not None:
3064 chandransh 9785 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9786 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9787 
      for kiter181,viter182 in self.undeliveredOrders.items():
9788 
        oprot.writeString(kiter181)
9789 
        oprot.writeString(viter182)
3064 chandransh 9790 
      oprot.writeMapEnd()
9791 
      oprot.writeFieldEnd()
1627 ankur.sing 9792 
    oprot.writeFieldStop()
9793 
    oprot.writeStructEnd()
9794 
 
3431 rajveer 9795 
  def validate(self):
9796 
    return
9797 
 
9798 
 
1627 ankur.sing 9799 
  def __repr__(self):
9800 
    L = ['%s=%r' % (key, value)
9801 
      for key, value in self.__dict__.iteritems()]
9802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9803 
 
9804 
  def __eq__(self, other):
9805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9806 
 
9807 
  def __ne__(self, other):
9808 
    return not (self == other)
9809 
 
3064 chandransh 9810 
class updateNonDeliveryReason_result:
1627 ankur.sing 9811 
  """
9812 
  Attributes:
3064 chandransh 9813 
   - ex
1627 ankur.sing 9814 
  """
9815 
 
9816 
  thrift_spec = (
3064 chandransh 9817 
    None, # 0
9818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9819 
  )
9820 
 
3064 chandransh 9821 
  def __init__(self, ex=None,):
9822 
    self.ex = ex
1627 ankur.sing 9823 
 
9824 
  def read(self, iprot):
9825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9827 
      return
9828 
    iprot.readStructBegin()
9829 
    while True:
9830 
      (fname, ftype, fid) = iprot.readFieldBegin()
9831 
      if ftype == TType.STOP:
9832 
        break
3064 chandransh 9833 
      if fid == 1:
9834 
        if ftype == TType.STRUCT:
9835 
          self.ex = TransactionServiceException()
9836 
          self.ex.read(iprot)
1627 ankur.sing 9837 
        else:
9838 
          iprot.skip(ftype)
9839 
      else:
9840 
        iprot.skip(ftype)
9841 
      iprot.readFieldEnd()
9842 
    iprot.readStructEnd()
9843 
 
9844 
  def write(self, oprot):
9845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9847 
      return
3064 chandransh 9848 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9849 
    if self.ex is not None:
3064 chandransh 9850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9851 
      self.ex.write(oprot)
1627 ankur.sing 9852 
      oprot.writeFieldEnd()
9853 
    oprot.writeFieldStop()
9854 
    oprot.writeStructEnd()
9855 
 
3431 rajveer 9856 
  def validate(self):
9857 
    return
9858 
 
9859 
 
1627 ankur.sing 9860 
  def __repr__(self):
9861 
    L = ['%s=%r' % (key, value)
9862 
      for key, value in self.__dict__.iteritems()]
9863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9864 
 
9865 
  def __eq__(self, other):
9866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9867 
 
9868 
  def __ne__(self, other):
9869 
    return not (self == other)
9870 
 
3064 chandransh 9871 
class getUndeliveredOrders_args:
1886 ankur.sing 9872 
  """
9873 
  Attributes:
3064 chandransh 9874 
   - providerId
9875 
   - warehouseId
1886 ankur.sing 9876 
  """
1627 ankur.sing 9877 
 
1886 ankur.sing 9878 
  thrift_spec = (
9879 
    None, # 0
3064 chandransh 9880 
    (1, TType.I64, 'providerId', None, None, ), # 1
9881 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9882 
  )
9883 
 
3064 chandransh 9884 
  def __init__(self, providerId=None, warehouseId=None,):
9885 
    self.providerId = providerId
9886 
    self.warehouseId = warehouseId
1886 ankur.sing 9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 1:
9898 
        if ftype == TType.I64:
3064 chandransh 9899 
          self.providerId = iprot.readI64();
1886 ankur.sing 9900 
        else:
9901 
          iprot.skip(ftype)
3064 chandransh 9902 
      elif fid == 2:
9903 
        if ftype == TType.I64:
9904 
          self.warehouseId = iprot.readI64();
9905 
        else:
9906 
          iprot.skip(ftype)
1886 ankur.sing 9907 
      else:
9908 
        iprot.skip(ftype)
9909 
      iprot.readFieldEnd()
9910 
    iprot.readStructEnd()
9911 
 
9912 
  def write(self, oprot):
9913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9915 
      return
3064 chandransh 9916 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9917 
    if self.providerId is not None:
3064 chandransh 9918 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9919 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9920 
      oprot.writeFieldEnd()
3431 rajveer 9921 
    if self.warehouseId is not None:
3064 chandransh 9922 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9923 
      oprot.writeI64(self.warehouseId)
9924 
      oprot.writeFieldEnd()
1886 ankur.sing 9925 
    oprot.writeFieldStop()
9926 
    oprot.writeStructEnd()
9927 
 
3431 rajveer 9928 
  def validate(self):
9929 
    return
9930 
 
9931 
 
1886 ankur.sing 9932 
  def __repr__(self):
9933 
    L = ['%s=%r' % (key, value)
9934 
      for key, value in self.__dict__.iteritems()]
9935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9936 
 
9937 
  def __eq__(self, other):
9938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9939 
 
9940 
  def __ne__(self, other):
9941 
    return not (self == other)
9942 
 
3064 chandransh 9943 
class getUndeliveredOrders_result:
1886 ankur.sing 9944 
  """
9945 
  Attributes:
9946 
   - success
9947 
  """
9948 
 
9949 
  thrift_spec = (
9950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9951 
  )
9952 
 
9953 
  def __init__(self, success=None,):
9954 
    self.success = success
9955 
 
9956 
  def read(self, iprot):
9957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9959 
      return
9960 
    iprot.readStructBegin()
9961 
    while True:
9962 
      (fname, ftype, fid) = iprot.readFieldBegin()
9963 
      if ftype == TType.STOP:
9964 
        break
9965 
      if fid == 0:
9966 
        if ftype == TType.LIST:
9967 
          self.success = []
4133 chandransh 9968 
          (_etype186, _size183) = iprot.readListBegin()
9969 
          for _i187 in xrange(_size183):
9970 
            _elem188 = Order()
9971 
            _elem188.read(iprot)
9972 
            self.success.append(_elem188)
1886 ankur.sing 9973 
          iprot.readListEnd()
9974 
        else:
9975 
          iprot.skip(ftype)
9976 
      else:
9977 
        iprot.skip(ftype)
9978 
      iprot.readFieldEnd()
9979 
    iprot.readStructEnd()
9980 
 
9981 
  def write(self, oprot):
9982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9984 
      return
3064 chandransh 9985 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9986 
    if self.success is not None:
1886 ankur.sing 9987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9989 
      for iter189 in self.success:
9990 
        iter189.write(oprot)
1886 ankur.sing 9991 
      oprot.writeListEnd()
9992 
      oprot.writeFieldEnd()
9993 
    oprot.writeFieldStop()
9994 
    oprot.writeStructEnd()
9995 
 
3431 rajveer 9996 
  def validate(self):
9997 
    return
9998 
 
9999 
 
1886 ankur.sing 10000 
  def __repr__(self):
10001 
    L = ['%s=%r' % (key, value)
10002 
      for key, value in self.__dict__.iteritems()]
10003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10004 
 
10005 
  def __eq__(self, other):
10006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10007 
 
10008 
  def __ne__(self, other):
10009 
    return not (self == other)
10010 
 
2536 chandransh 10011 
class toggleDOAFlag_args:
10012 
  """
10013 
  Attributes:
10014 
   - orderId
10015 
  """
1886 ankur.sing 10016 
 
2536 chandransh 10017 
  thrift_spec = (
10018 
    None, # 0
10019 
    (1, TType.I64, 'orderId', None, None, ), # 1
10020 
  )
10021 
 
10022 
  def __init__(self, orderId=None,):
10023 
    self.orderId = orderId
10024 
 
10025 
  def read(self, iprot):
10026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10028 
      return
10029 
    iprot.readStructBegin()
10030 
    while True:
10031 
      (fname, ftype, fid) = iprot.readFieldBegin()
10032 
      if ftype == TType.STOP:
10033 
        break
10034 
      if fid == 1:
10035 
        if ftype == TType.I64:
10036 
          self.orderId = iprot.readI64();
10037 
        else:
10038 
          iprot.skip(ftype)
10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10049 
    if self.orderId is not None:
2536 chandransh 10050 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10051 
      oprot.writeI64(self.orderId)
10052 
      oprot.writeFieldEnd()
10053 
    oprot.writeFieldStop()
10054 
    oprot.writeStructEnd()
10055 
 
3431 rajveer 10056 
  def validate(self):
10057 
    return
10058 
 
10059 
 
2536 chandransh 10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
10071 
class toggleDOAFlag_result:
10072 
  """
10073 
  Attributes:
10074 
   - success
10075 
   - ex
10076 
  """
10077 
 
10078 
  thrift_spec = (
10079 
    (0, TType.BOOL, 'success', None, None, ), # 0
10080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10081 
  )
10082 
 
10083 
  def __init__(self, success=None, ex=None,):
10084 
    self.success = success
10085 
    self.ex = ex
10086 
 
10087 
  def read(self, iprot):
10088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10090 
      return
10091 
    iprot.readStructBegin()
10092 
    while True:
10093 
      (fname, ftype, fid) = iprot.readFieldBegin()
10094 
      if ftype == TType.STOP:
10095 
        break
10096 
      if fid == 0:
10097 
        if ftype == TType.BOOL:
10098 
          self.success = iprot.readBool();
10099 
        else:
10100 
          iprot.skip(ftype)
10101 
      elif fid == 1:
10102 
        if ftype == TType.STRUCT:
10103 
          self.ex = TransactionServiceException()
10104 
          self.ex.read(iprot)
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
10116 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10117 
    if self.success is not None:
2536 chandransh 10118 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10119 
      oprot.writeBool(self.success)
10120 
      oprot.writeFieldEnd()
3431 rajveer 10121 
    if self.ex is not None:
2536 chandransh 10122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10123 
      self.ex.write(oprot)
10124 
      oprot.writeFieldEnd()
10125 
    oprot.writeFieldStop()
10126 
    oprot.writeStructEnd()
10127 
 
3431 rajveer 10128 
  def validate(self):
10129 
    return
10130 
 
10131 
 
2536 chandransh 10132 
  def __repr__(self):
10133 
    L = ['%s=%r' % (key, value)
10134 
      for key, value in self.__dict__.iteritems()]
10135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10136 
 
10137 
  def __eq__(self, other):
10138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10139 
 
10140 
  def __ne__(self, other):
10141 
    return not (self == other)
10142 
 
10143 
class requestPickupNumber_args:
10144 
  """
10145 
  Attributes:
10146 
   - orderId
10147 
  """
10148 
 
10149 
  thrift_spec = (
10150 
    None, # 0
10151 
    (1, TType.I64, 'orderId', None, None, ), # 1
10152 
  )
10153 
 
10154 
  def __init__(self, orderId=None,):
10155 
    self.orderId = orderId
10156 
 
10157 
  def read(self, iprot):
10158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10160 
      return
10161 
    iprot.readStructBegin()
10162 
    while True:
10163 
      (fname, ftype, fid) = iprot.readFieldBegin()
10164 
      if ftype == TType.STOP:
10165 
        break
10166 
      if fid == 1:
10167 
        if ftype == TType.I64:
10168 
          self.orderId = iprot.readI64();
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      else:
10172 
        iprot.skip(ftype)
10173 
      iprot.readFieldEnd()
10174 
    iprot.readStructEnd()
10175 
 
10176 
  def write(self, oprot):
10177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10179 
      return
10180 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10181 
    if self.orderId is not None:
2536 chandransh 10182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10183 
      oprot.writeI64(self.orderId)
10184 
      oprot.writeFieldEnd()
10185 
    oprot.writeFieldStop()
10186 
    oprot.writeStructEnd()
10187 
 
3431 rajveer 10188 
  def validate(self):
10189 
    return
10190 
 
10191 
 
2536 chandransh 10192 
  def __repr__(self):
10193 
    L = ['%s=%r' % (key, value)
10194 
      for key, value in self.__dict__.iteritems()]
10195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10196 
 
10197 
  def __eq__(self, other):
10198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10199 
 
10200 
  def __ne__(self, other):
10201 
    return not (self == other)
10202 
 
10203 
class requestPickupNumber_result:
10204 
  """
10205 
  Attributes:
10206 
   - success
10207 
   - ex
10208 
  """
10209 
 
10210 
  thrift_spec = (
10211 
    (0, TType.BOOL, 'success', None, None, ), # 0
10212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10213 
  )
10214 
 
10215 
  def __init__(self, success=None, ex=None,):
10216 
    self.success = success
10217 
    self.ex = ex
10218 
 
10219 
  def read(self, iprot):
10220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10222 
      return
10223 
    iprot.readStructBegin()
10224 
    while True:
10225 
      (fname, ftype, fid) = iprot.readFieldBegin()
10226 
      if ftype == TType.STOP:
10227 
        break
10228 
      if fid == 0:
10229 
        if ftype == TType.BOOL:
10230 
          self.success = iprot.readBool();
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      elif fid == 1:
10234 
        if ftype == TType.STRUCT:
10235 
          self.ex = TransactionServiceException()
10236 
          self.ex.read(iprot)
10237 
        else:
10238 
          iprot.skip(ftype)
10239 
      else:
10240 
        iprot.skip(ftype)
10241 
      iprot.readFieldEnd()
10242 
    iprot.readStructEnd()
10243 
 
10244 
  def write(self, oprot):
10245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10247 
      return
10248 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10249 
    if self.success is not None:
2536 chandransh 10250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10251 
      oprot.writeBool(self.success)
10252 
      oprot.writeFieldEnd()
3431 rajveer 10253 
    if self.ex is not None:
2536 chandransh 10254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10255 
      self.ex.write(oprot)
10256 
      oprot.writeFieldEnd()
10257 
    oprot.writeFieldStop()
10258 
    oprot.writeStructEnd()
10259 
 
3431 rajveer 10260 
  def validate(self):
10261 
    return
10262 
 
10263 
 
2536 chandransh 10264 
  def __repr__(self):
10265 
    L = ['%s=%r' % (key, value)
10266 
      for key, value in self.__dict__.iteritems()]
10267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10268 
 
10269 
  def __eq__(self, other):
10270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10271 
 
10272 
  def __ne__(self, other):
10273 
    return not (self == other)
10274 
 
10275 
class authorizePickup_args:
10276 
  """
10277 
  Attributes:
10278 
   - orderId
10279 
   - pickupNumber
10280 
  """
10281 
 
10282 
  thrift_spec = (
10283 
    None, # 0
10284 
    (1, TType.I64, 'orderId', None, None, ), # 1
10285 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10286 
  )
10287 
 
10288 
  def __init__(self, orderId=None, pickupNumber=None,):
10289 
    self.orderId = orderId
10290 
    self.pickupNumber = pickupNumber
10291 
 
10292 
  def read(self, iprot):
10293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10295 
      return
10296 
    iprot.readStructBegin()
10297 
    while True:
10298 
      (fname, ftype, fid) = iprot.readFieldBegin()
10299 
      if ftype == TType.STOP:
10300 
        break
10301 
      if fid == 1:
10302 
        if ftype == TType.I64:
10303 
          self.orderId = iprot.readI64();
10304 
        else:
10305 
          iprot.skip(ftype)
10306 
      elif fid == 2:
10307 
        if ftype == TType.STRING:
10308 
          self.pickupNumber = iprot.readString();
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
10320 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10321 
    if self.orderId is not None:
2536 chandransh 10322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10323 
      oprot.writeI64(self.orderId)
10324 
      oprot.writeFieldEnd()
3431 rajveer 10325 
    if self.pickupNumber is not None:
2536 chandransh 10326 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10327 
      oprot.writeString(self.pickupNumber)
10328 
      oprot.writeFieldEnd()
10329 
    oprot.writeFieldStop()
10330 
    oprot.writeStructEnd()
10331 
 
3431 rajveer 10332 
  def validate(self):
10333 
    return
10334 
 
10335 
 
2536 chandransh 10336 
  def __repr__(self):
10337 
    L = ['%s=%r' % (key, value)
10338 
      for key, value in self.__dict__.iteritems()]
10339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10340 
 
10341 
  def __eq__(self, other):
10342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10343 
 
10344 
  def __ne__(self, other):
10345 
    return not (self == other)
10346 
 
10347 
class authorizePickup_result:
10348 
  """
10349 
  Attributes:
10350 
   - success
10351 
   - ex
10352 
  """
10353 
 
10354 
  thrift_spec = (
10355 
    (0, TType.BOOL, 'success', None, None, ), # 0
10356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10357 
  )
10358 
 
10359 
  def __init__(self, success=None, ex=None,):
10360 
    self.success = success
10361 
    self.ex = ex
10362 
 
10363 
  def read(self, iprot):
10364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10366 
      return
10367 
    iprot.readStructBegin()
10368 
    while True:
10369 
      (fname, ftype, fid) = iprot.readFieldBegin()
10370 
      if ftype == TType.STOP:
10371 
        break
10372 
      if fid == 0:
10373 
        if ftype == TType.BOOL:
10374 
          self.success = iprot.readBool();
10375 
        else:
10376 
          iprot.skip(ftype)
10377 
      elif fid == 1:
10378 
        if ftype == TType.STRUCT:
10379 
          self.ex = TransactionServiceException()
10380 
          self.ex.read(iprot)
10381 
        else:
10382 
          iprot.skip(ftype)
10383 
      else:
10384 
        iprot.skip(ftype)
10385 
      iprot.readFieldEnd()
10386 
    iprot.readStructEnd()
10387 
 
10388 
  def write(self, oprot):
10389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10391 
      return
10392 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10393 
    if self.success is not None:
2536 chandransh 10394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10395 
      oprot.writeBool(self.success)
10396 
      oprot.writeFieldEnd()
3431 rajveer 10397 
    if self.ex is not None:
2536 chandransh 10398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10399 
      self.ex.write(oprot)
10400 
      oprot.writeFieldEnd()
10401 
    oprot.writeFieldStop()
10402 
    oprot.writeStructEnd()
10403 
 
3431 rajveer 10404 
  def validate(self):
10405 
    return
10406 
 
10407 
 
2536 chandransh 10408 
  def __repr__(self):
10409 
    L = ['%s=%r' % (key, value)
10410 
      for key, value in self.__dict__.iteritems()]
10411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10412 
 
10413 
  def __eq__(self, other):
10414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10415 
 
10416 
  def __ne__(self, other):
10417 
    return not (self == other)
10418 
 
2764 chandransh 10419 
class markDoasAsPickedUp_args:
10420 
  """
10421 
  Attributes:
10422 
   - providerId
10423 
   - pickupDetails
10424 
  """
10425 
 
10426 
  thrift_spec = (
10427 
    None, # 0
10428 
    (1, TType.I64, 'providerId', None, None, ), # 1
10429 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10430 
  )
10431 
 
10432 
  def __init__(self, providerId=None, pickupDetails=None,):
10433 
    self.providerId = providerId
10434 
    self.pickupDetails = pickupDetails
10435 
 
10436 
  def read(self, iprot):
10437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10439 
      return
10440 
    iprot.readStructBegin()
10441 
    while True:
10442 
      (fname, ftype, fid) = iprot.readFieldBegin()
10443 
      if ftype == TType.STOP:
10444 
        break
10445 
      if fid == 1:
10446 
        if ftype == TType.I64:
10447 
          self.providerId = iprot.readI64();
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      elif fid == 2:
10451 
        if ftype == TType.MAP:
10452 
          self.pickupDetails = {}
4133 chandransh 10453 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10454 
          for _i194 in xrange(_size190):
10455 
            _key195 = iprot.readString();
10456 
            _val196 = iprot.readString();
10457 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10458 
          iprot.readMapEnd()
10459 
        else:
10460 
          iprot.skip(ftype)
10461 
      else:
10462 
        iprot.skip(ftype)
10463 
      iprot.readFieldEnd()
10464 
    iprot.readStructEnd()
10465 
 
10466 
  def write(self, oprot):
10467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10469 
      return
10470 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10471 
    if self.providerId is not None:
2764 chandransh 10472 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10473 
      oprot.writeI64(self.providerId)
10474 
      oprot.writeFieldEnd()
3431 rajveer 10475 
    if self.pickupDetails is not None:
2764 chandransh 10476 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10477 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10478 
      for kiter197,viter198 in self.pickupDetails.items():
10479 
        oprot.writeString(kiter197)
10480 
        oprot.writeString(viter198)
2764 chandransh 10481 
      oprot.writeMapEnd()
10482 
      oprot.writeFieldEnd()
10483 
    oprot.writeFieldStop()
10484 
    oprot.writeStructEnd()
10485 
 
3431 rajveer 10486 
  def validate(self):
10487 
    return
10488 
 
10489 
 
2764 chandransh 10490 
  def __repr__(self):
10491 
    L = ['%s=%r' % (key, value)
10492 
      for key, value in self.__dict__.iteritems()]
10493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10494 
 
10495 
  def __eq__(self, other):
10496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10497 
 
10498 
  def __ne__(self, other):
10499 
    return not (self == other)
10500 
 
10501 
class markDoasAsPickedUp_result:
10502 
  """
10503 
  Attributes:
10504 
   - success
10505 
  """
10506 
 
10507 
  thrift_spec = (
10508 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10509 
  )
10510 
 
10511 
  def __init__(self, success=None,):
10512 
    self.success = success
10513 
 
10514 
  def read(self, iprot):
10515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10517 
      return
10518 
    iprot.readStructBegin()
10519 
    while True:
10520 
      (fname, ftype, fid) = iprot.readFieldBegin()
10521 
      if ftype == TType.STOP:
10522 
        break
10523 
      if fid == 0:
10524 
        if ftype == TType.LIST:
10525 
          self.success = []
4133 chandransh 10526 
          (_etype202, _size199) = iprot.readListBegin()
10527 
          for _i203 in xrange(_size199):
10528 
            _elem204 = Order()
10529 
            _elem204.read(iprot)
10530 
            self.success.append(_elem204)
2764 chandransh 10531 
          iprot.readListEnd()
10532 
        else:
10533 
          iprot.skip(ftype)
10534 
      else:
10535 
        iprot.skip(ftype)
10536 
      iprot.readFieldEnd()
10537 
    iprot.readStructEnd()
10538 
 
10539 
  def write(self, oprot):
10540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10542 
      return
10543 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10544 
    if self.success is not None:
2764 chandransh 10545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10546 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10547 
      for iter205 in self.success:
10548 
        iter205.write(oprot)
2764 chandransh 10549 
      oprot.writeListEnd()
10550 
      oprot.writeFieldEnd()
10551 
    oprot.writeFieldStop()
10552 
    oprot.writeStructEnd()
10553 
 
3431 rajveer 10554 
  def validate(self):
10555 
    return
10556 
 
10557 
 
2764 chandransh 10558 
  def __repr__(self):
10559 
    L = ['%s=%r' % (key, value)
10560 
      for key, value in self.__dict__.iteritems()]
10561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10562 
 
10563 
  def __eq__(self, other):
10564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10565 
 
10566 
  def __ne__(self, other):
10567 
    return not (self == other)
10568 
 
2616 chandransh 10569 
class receiveReturn_args:
2591 chandransh 10570 
  """
10571 
  Attributes:
10572 
   - orderId
10573 
  """
2536 chandransh 10574 
 
2591 chandransh 10575 
  thrift_spec = (
10576 
    None, # 0
10577 
    (1, TType.I64, 'orderId', None, None, ), # 1
10578 
  )
10579 
 
10580 
  def __init__(self, orderId=None,):
10581 
    self.orderId = orderId
10582 
 
10583 
  def read(self, iprot):
10584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10586 
      return
10587 
    iprot.readStructBegin()
10588 
    while True:
10589 
      (fname, ftype, fid) = iprot.readFieldBegin()
10590 
      if ftype == TType.STOP:
10591 
        break
10592 
      if fid == 1:
10593 
        if ftype == TType.I64:
10594 
          self.orderId = iprot.readI64();
10595 
        else:
10596 
          iprot.skip(ftype)
10597 
      else:
10598 
        iprot.skip(ftype)
10599 
      iprot.readFieldEnd()
10600 
    iprot.readStructEnd()
10601 
 
10602 
  def write(self, oprot):
10603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10605 
      return
2616 chandransh 10606 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10607 
    if self.orderId is not None:
2591 chandransh 10608 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10609 
      oprot.writeI64(self.orderId)
10610 
      oprot.writeFieldEnd()
10611 
    oprot.writeFieldStop()
10612 
    oprot.writeStructEnd()
10613 
 
3431 rajveer 10614 
  def validate(self):
10615 
    return
10616 
 
10617 
 
2591 chandransh 10618 
  def __repr__(self):
10619 
    L = ['%s=%r' % (key, value)
10620 
      for key, value in self.__dict__.iteritems()]
10621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10622 
 
10623 
  def __eq__(self, other):
10624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10625 
 
10626 
  def __ne__(self, other):
10627 
    return not (self == other)
10628 
 
2616 chandransh 10629 
class receiveReturn_result:
2591 chandransh 10630 
  """
10631 
  Attributes:
10632 
   - success
10633 
   - ex
10634 
  """
10635 
 
10636 
  thrift_spec = (
10637 
    (0, TType.BOOL, 'success', None, None, ), # 0
10638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10639 
  )
10640 
 
10641 
  def __init__(self, success=None, ex=None,):
10642 
    self.success = success
10643 
    self.ex = ex
10644 
 
10645 
  def read(self, iprot):
10646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10648 
      return
10649 
    iprot.readStructBegin()
10650 
    while True:
10651 
      (fname, ftype, fid) = iprot.readFieldBegin()
10652 
      if ftype == TType.STOP:
10653 
        break
10654 
      if fid == 0:
10655 
        if ftype == TType.BOOL:
10656 
          self.success = iprot.readBool();
10657 
        else:
10658 
          iprot.skip(ftype)
10659 
      elif fid == 1:
10660 
        if ftype == TType.STRUCT:
10661 
          self.ex = TransactionServiceException()
10662 
          self.ex.read(iprot)
10663 
        else:
10664 
          iprot.skip(ftype)
10665 
      else:
10666 
        iprot.skip(ftype)
10667 
      iprot.readFieldEnd()
10668 
    iprot.readStructEnd()
10669 
 
10670 
  def write(self, oprot):
10671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10673 
      return
2616 chandransh 10674 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10675 
    if self.success is not None:
2591 chandransh 10676 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10677 
      oprot.writeBool(self.success)
10678 
      oprot.writeFieldEnd()
3431 rajveer 10679 
    if self.ex is not None:
2591 chandransh 10680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10681 
      self.ex.write(oprot)
10682 
      oprot.writeFieldEnd()
10683 
    oprot.writeFieldStop()
10684 
    oprot.writeStructEnd()
10685 
 
3431 rajveer 10686 
  def validate(self):
10687 
    return
10688 
 
10689 
 
2591 chandransh 10690 
  def __repr__(self):
10691 
    L = ['%s=%r' % (key, value)
10692 
      for key, value in self.__dict__.iteritems()]
10693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10694 
 
10695 
  def __eq__(self, other):
10696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10697 
 
10698 
  def __ne__(self, other):
10699 
    return not (self == other)
10700 
 
10701 
class validateDoa_args:
10702 
  """
10703 
  Attributes:
10704 
   - orderId
10705 
   - isValid
10706 
  """
10707 
 
10708 
  thrift_spec = (
10709 
    None, # 0
10710 
    (1, TType.I64, 'orderId', None, None, ), # 1
10711 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10712 
  )
10713 
 
10714 
  def __init__(self, orderId=None, isValid=None,):
10715 
    self.orderId = orderId
10716 
    self.isValid = isValid
10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 1:
10728 
        if ftype == TType.I64:
10729 
          self.orderId = iprot.readI64();
10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      elif fid == 2:
10733 
        if ftype == TType.BOOL:
10734 
          self.isValid = iprot.readBool();
10735 
        else:
10736 
          iprot.skip(ftype)
10737 
      else:
10738 
        iprot.skip(ftype)
10739 
      iprot.readFieldEnd()
10740 
    iprot.readStructEnd()
10741 
 
10742 
  def write(self, oprot):
10743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10745 
      return
10746 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10747 
    if self.orderId is not None:
2591 chandransh 10748 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10749 
      oprot.writeI64(self.orderId)
10750 
      oprot.writeFieldEnd()
3431 rajveer 10751 
    if self.isValid is not None:
2591 chandransh 10752 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10753 
      oprot.writeBool(self.isValid)
10754 
      oprot.writeFieldEnd()
10755 
    oprot.writeFieldStop()
10756 
    oprot.writeStructEnd()
10757 
 
3431 rajveer 10758 
  def validate(self):
10759 
    return
10760 
 
10761 
 
2591 chandransh 10762 
  def __repr__(self):
10763 
    L = ['%s=%r' % (key, value)
10764 
      for key, value in self.__dict__.iteritems()]
10765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10766 
 
10767 
  def __eq__(self, other):
10768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10769 
 
10770 
  def __ne__(self, other):
10771 
    return not (self == other)
10772 
 
10773 
class validateDoa_result:
10774 
  """
10775 
  Attributes:
10776 
   - success
10777 
   - ex
10778 
  """
10779 
 
10780 
  thrift_spec = (
10781 
    (0, TType.BOOL, 'success', None, None, ), # 0
10782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10783 
  )
10784 
 
10785 
  def __init__(self, success=None, ex=None,):
10786 
    self.success = success
10787 
    self.ex = ex
10788 
 
10789 
  def read(self, iprot):
10790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10792 
      return
10793 
    iprot.readStructBegin()
10794 
    while True:
10795 
      (fname, ftype, fid) = iprot.readFieldBegin()
10796 
      if ftype == TType.STOP:
10797 
        break
10798 
      if fid == 0:
10799 
        if ftype == TType.BOOL:
10800 
          self.success = iprot.readBool();
10801 
        else:
10802 
          iprot.skip(ftype)
10803 
      elif fid == 1:
10804 
        if ftype == TType.STRUCT:
10805 
          self.ex = TransactionServiceException()
10806 
          self.ex.read(iprot)
10807 
        else:
10808 
          iprot.skip(ftype)
10809 
      else:
10810 
        iprot.skip(ftype)
10811 
      iprot.readFieldEnd()
10812 
    iprot.readStructEnd()
10813 
 
10814 
  def write(self, oprot):
10815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10817 
      return
10818 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10819 
    if self.success is not None:
2591 chandransh 10820 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10821 
      oprot.writeBool(self.success)
10822 
      oprot.writeFieldEnd()
3431 rajveer 10823 
    if self.ex is not None:
2591 chandransh 10824 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10825 
      self.ex.write(oprot)
10826 
      oprot.writeFieldEnd()
10827 
    oprot.writeFieldStop()
10828 
    oprot.writeStructEnd()
10829 
 
3431 rajveer 10830 
  def validate(self):
10831 
    return
10832 
 
10833 
 
2591 chandransh 10834 
  def __repr__(self):
10835 
    L = ['%s=%r' % (key, value)
10836 
      for key, value in self.__dict__.iteritems()]
10837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10838 
 
10839 
  def __eq__(self, other):
10840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10841 
 
10842 
  def __ne__(self, other):
10843 
    return not (self == other)
10844 
 
2616 chandransh 10845 
class reshipOrder_args:
10846 
  """
10847 
  Attributes:
10848 
   - orderId
10849 
  """
2591 chandransh 10850 
 
2616 chandransh 10851 
  thrift_spec = (
10852 
    None, # 0
10853 
    (1, TType.I64, 'orderId', None, None, ), # 1
10854 
  )
10855 
 
10856 
  def __init__(self, orderId=None,):
10857 
    self.orderId = orderId
10858 
 
10859 
  def read(self, iprot):
10860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10862 
      return
10863 
    iprot.readStructBegin()
10864 
    while True:
10865 
      (fname, ftype, fid) = iprot.readFieldBegin()
10866 
      if ftype == TType.STOP:
10867 
        break
10868 
      if fid == 1:
10869 
        if ftype == TType.I64:
10870 
          self.orderId = iprot.readI64();
10871 
        else:
10872 
          iprot.skip(ftype)
10873 
      else:
10874 
        iprot.skip(ftype)
10875 
      iprot.readFieldEnd()
10876 
    iprot.readStructEnd()
10877 
 
10878 
  def write(self, oprot):
10879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10881 
      return
10882 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10883 
    if self.orderId is not None:
2616 chandransh 10884 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10885 
      oprot.writeI64(self.orderId)
10886 
      oprot.writeFieldEnd()
10887 
    oprot.writeFieldStop()
10888 
    oprot.writeStructEnd()
10889 
 
3431 rajveer 10890 
  def validate(self):
10891 
    return
10892 
 
10893 
 
2616 chandransh 10894 
  def __repr__(self):
10895 
    L = ['%s=%r' % (key, value)
10896 
      for key, value in self.__dict__.iteritems()]
10897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10898 
 
10899 
  def __eq__(self, other):
10900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10901 
 
10902 
  def __ne__(self, other):
10903 
    return not (self == other)
10904 
 
10905 
class reshipOrder_result:
10906 
  """
10907 
  Attributes:
10908 
   - success
10909 
   - ex
10910 
  """
10911 
 
10912 
  thrift_spec = (
10913 
    (0, TType.I64, 'success', None, None, ), # 0
10914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10915 
  )
10916 
 
10917 
  def __init__(self, success=None, ex=None,):
10918 
    self.success = success
10919 
    self.ex = ex
10920 
 
10921 
  def read(self, iprot):
10922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10924 
      return
10925 
    iprot.readStructBegin()
10926 
    while True:
10927 
      (fname, ftype, fid) = iprot.readFieldBegin()
10928 
      if ftype == TType.STOP:
10929 
        break
10930 
      if fid == 0:
10931 
        if ftype == TType.I64:
10932 
          self.success = iprot.readI64();
10933 
        else:
10934 
          iprot.skip(ftype)
10935 
      elif fid == 1:
10936 
        if ftype == TType.STRUCT:
10937 
          self.ex = TransactionServiceException()
10938 
          self.ex.read(iprot)
10939 
        else:
10940 
          iprot.skip(ftype)
10941 
      else:
10942 
        iprot.skip(ftype)
10943 
      iprot.readFieldEnd()
10944 
    iprot.readStructEnd()
10945 
 
10946 
  def write(self, oprot):
10947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10949 
      return
10950 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10951 
    if self.success is not None:
2616 chandransh 10952 
      oprot.writeFieldBegin('success', TType.I64, 0)
10953 
      oprot.writeI64(self.success)
10954 
      oprot.writeFieldEnd()
3431 rajveer 10955 
    if self.ex is not None:
2616 chandransh 10956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10957 
      self.ex.write(oprot)
10958 
      oprot.writeFieldEnd()
10959 
    oprot.writeFieldStop()
10960 
    oprot.writeStructEnd()
10961 
 
3431 rajveer 10962 
  def validate(self):
10963 
    return
10964 
 
10965 
 
2616 chandransh 10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
10977 
class refundOrder_args:
10978 
  """
10979 
  Attributes:
10980 
   - orderId
3226 chandransh 10981 
   - refundedBy
10982 
   - reason
2616 chandransh 10983 
  """
10984 
 
10985 
  thrift_spec = (
10986 
    None, # 0
10987 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10988 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10989 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10990 
  )
10991 
 
3226 chandransh 10992 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10993 
    self.orderId = orderId
3226 chandransh 10994 
    self.refundedBy = refundedBy
10995 
    self.reason = reason
2616 chandransh 10996 
 
10997 
  def read(self, iprot):
10998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11000 
      return
11001 
    iprot.readStructBegin()
11002 
    while True:
11003 
      (fname, ftype, fid) = iprot.readFieldBegin()
11004 
      if ftype == TType.STOP:
11005 
        break
11006 
      if fid == 1:
11007 
        if ftype == TType.I64:
11008 
          self.orderId = iprot.readI64();
11009 
        else:
11010 
          iprot.skip(ftype)
3226 chandransh 11011 
      elif fid == 2:
11012 
        if ftype == TType.STRING:
11013 
          self.refundedBy = iprot.readString();
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      elif fid == 3:
11017 
        if ftype == TType.STRING:
11018 
          self.reason = iprot.readString();
11019 
        else:
11020 
          iprot.skip(ftype)
2616 chandransh 11021 
      else:
11022 
        iprot.skip(ftype)
11023 
      iprot.readFieldEnd()
11024 
    iprot.readStructEnd()
11025 
 
11026 
  def write(self, oprot):
11027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11029 
      return
11030 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 11031 
    if self.orderId is not None:
2616 chandransh 11032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11033 
      oprot.writeI64(self.orderId)
11034 
      oprot.writeFieldEnd()
3431 rajveer 11035 
    if self.refundedBy is not None:
3226 chandransh 11036 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11037 
      oprot.writeString(self.refundedBy)
11038 
      oprot.writeFieldEnd()
3431 rajveer 11039 
    if self.reason is not None:
3226 chandransh 11040 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11041 
      oprot.writeString(self.reason)
11042 
      oprot.writeFieldEnd()
2616 chandransh 11043 
    oprot.writeFieldStop()
11044 
    oprot.writeStructEnd()
11045 
 
3431 rajveer 11046 
  def validate(self):
11047 
    return
11048 
 
11049 
 
2616 chandransh 11050 
  def __repr__(self):
11051 
    L = ['%s=%r' % (key, value)
11052 
      for key, value in self.__dict__.iteritems()]
11053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11054 
 
11055 
  def __eq__(self, other):
11056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11057 
 
11058 
  def __ne__(self, other):
11059 
    return not (self == other)
11060 
 
11061 
class refundOrder_result:
11062 
  """
11063 
  Attributes:
11064 
   - success
11065 
   - ex
11066 
  """
11067 
 
11068 
  thrift_spec = (
11069 
    (0, TType.BOOL, 'success', None, None, ), # 0
11070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11071 
  )
11072 
 
11073 
  def __init__(self, success=None, ex=None,):
11074 
    self.success = success
11075 
    self.ex = ex
11076 
 
11077 
  def read(self, iprot):
11078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11080 
      return
11081 
    iprot.readStructBegin()
11082 
    while True:
11083 
      (fname, ftype, fid) = iprot.readFieldBegin()
11084 
      if ftype == TType.STOP:
11085 
        break
11086 
      if fid == 0:
11087 
        if ftype == TType.BOOL:
11088 
          self.success = iprot.readBool();
11089 
        else:
11090 
          iprot.skip(ftype)
11091 
      elif fid == 1:
11092 
        if ftype == TType.STRUCT:
11093 
          self.ex = TransactionServiceException()
11094 
          self.ex.read(iprot)
11095 
        else:
11096 
          iprot.skip(ftype)
11097 
      else:
11098 
        iprot.skip(ftype)
11099 
      iprot.readFieldEnd()
11100 
    iprot.readStructEnd()
11101 
 
11102 
  def write(self, oprot):
11103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11105 
      return
11106 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11107 
    if self.success is not None:
2616 chandransh 11108 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11109 
      oprot.writeBool(self.success)
11110 
      oprot.writeFieldEnd()
3431 rajveer 11111 
    if self.ex is not None:
2616 chandransh 11112 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11113 
      self.ex.write(oprot)
11114 
      oprot.writeFieldEnd()
11115 
    oprot.writeFieldStop()
11116 
    oprot.writeStructEnd()
11117 
 
3431 rajveer 11118 
  def validate(self):
11119 
    return
11120 
 
11121 
 
2616 chandransh 11122 
  def __repr__(self):
11123 
    L = ['%s=%r' % (key, value)
11124 
      for key, value in self.__dict__.iteritems()]
11125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11126 
 
11127 
  def __eq__(self, other):
11128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11129 
 
11130 
  def __ne__(self, other):
11131 
    return not (self == other)
11132 
 
2690 chandransh 11133 
class getReturnOrders_args:
11134 
  """
11135 
  Attributes:
11136 
   - warehouseId
11137 
   - fromDate
11138 
   - toDate
11139 
  """
2616 chandransh 11140 
 
2690 chandransh 11141 
  thrift_spec = (
11142 
    None, # 0
11143 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11144 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11145 
    (3, TType.I64, 'toDate', None, None, ), # 3
11146 
  )
11147 
 
11148 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11149 
    self.warehouseId = warehouseId
11150 
    self.fromDate = fromDate
11151 
    self.toDate = toDate
11152 
 
11153 
  def read(self, iprot):
11154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11156 
      return
11157 
    iprot.readStructBegin()
11158 
    while True:
11159 
      (fname, ftype, fid) = iprot.readFieldBegin()
11160 
      if ftype == TType.STOP:
11161 
        break
11162 
      if fid == 1:
11163 
        if ftype == TType.I64:
11164 
          self.warehouseId = iprot.readI64();
11165 
        else:
11166 
          iprot.skip(ftype)
11167 
      elif fid == 2:
11168 
        if ftype == TType.I64:
11169 
          self.fromDate = iprot.readI64();
11170 
        else:
11171 
          iprot.skip(ftype)
11172 
      elif fid == 3:
11173 
        if ftype == TType.I64:
11174 
          self.toDate = iprot.readI64();
11175 
        else:
11176 
          iprot.skip(ftype)
11177 
      else:
11178 
        iprot.skip(ftype)
11179 
      iprot.readFieldEnd()
11180 
    iprot.readStructEnd()
11181 
 
11182 
  def write(self, oprot):
11183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11185 
      return
11186 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11187 
    if self.warehouseId is not None:
2690 chandransh 11188 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11189 
      oprot.writeI64(self.warehouseId)
11190 
      oprot.writeFieldEnd()
3431 rajveer 11191 
    if self.fromDate is not None:
2690 chandransh 11192 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11193 
      oprot.writeI64(self.fromDate)
11194 
      oprot.writeFieldEnd()
3431 rajveer 11195 
    if self.toDate is not None:
2690 chandransh 11196 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11197 
      oprot.writeI64(self.toDate)
11198 
      oprot.writeFieldEnd()
11199 
    oprot.writeFieldStop()
11200 
    oprot.writeStructEnd()
11201 
 
3431 rajveer 11202 
  def validate(self):
11203 
    return
11204 
 
11205 
 
2690 chandransh 11206 
  def __repr__(self):
11207 
    L = ['%s=%r' % (key, value)
11208 
      for key, value in self.__dict__.iteritems()]
11209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11210 
 
11211 
  def __eq__(self, other):
11212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11213 
 
11214 
  def __ne__(self, other):
11215 
    return not (self == other)
11216 
 
11217 
class getReturnOrders_result:
11218 
  """
11219 
  Attributes:
11220 
   - success
11221 
  """
11222 
 
11223 
  thrift_spec = (
11224 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11225 
  )
11226 
 
11227 
  def __init__(self, success=None,):
11228 
    self.success = success
11229 
 
11230 
  def read(self, iprot):
11231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11233 
      return
11234 
    iprot.readStructBegin()
11235 
    while True:
11236 
      (fname, ftype, fid) = iprot.readFieldBegin()
11237 
      if ftype == TType.STOP:
11238 
        break
11239 
      if fid == 0:
11240 
        if ftype == TType.LIST:
11241 
          self.success = []
4133 chandransh 11242 
          (_etype209, _size206) = iprot.readListBegin()
11243 
          for _i210 in xrange(_size206):
11244 
            _elem211 = ReturnOrder()
11245 
            _elem211.read(iprot)
11246 
            self.success.append(_elem211)
2690 chandransh 11247 
          iprot.readListEnd()
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      else:
11251 
        iprot.skip(ftype)
11252 
      iprot.readFieldEnd()
11253 
    iprot.readStructEnd()
11254 
 
11255 
  def write(self, oprot):
11256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11258 
      return
11259 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11260 
    if self.success is not None:
2690 chandransh 11261 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11262 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11263 
      for iter212 in self.success:
11264 
        iter212.write(oprot)
2690 chandransh 11265 
      oprot.writeListEnd()
11266 
      oprot.writeFieldEnd()
11267 
    oprot.writeFieldStop()
11268 
    oprot.writeStructEnd()
11269 
 
3431 rajveer 11270 
  def validate(self):
11271 
    return
11272 
 
11273 
 
2690 chandransh 11274 
  def __repr__(self):
11275 
    L = ['%s=%r' % (key, value)
11276 
      for key, value in self.__dict__.iteritems()]
11277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11278 
 
11279 
  def __eq__(self, other):
11280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11281 
 
11282 
  def __ne__(self, other):
11283 
    return not (self == other)
11284 
 
2700 chandransh 11285 
class getReturnOrder_args:
11286 
  """
11287 
  Attributes:
11288 
   - id
11289 
  """
11290 
 
11291 
  thrift_spec = (
11292 
    None, # 0
11293 
    (1, TType.I64, 'id', None, None, ), # 1
11294 
  )
11295 
 
11296 
  def __init__(self, id=None,):
11297 
    self.id = id
11298 
 
11299 
  def read(self, iprot):
11300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11302 
      return
11303 
    iprot.readStructBegin()
11304 
    while True:
11305 
      (fname, ftype, fid) = iprot.readFieldBegin()
11306 
      if ftype == TType.STOP:
11307 
        break
11308 
      if fid == 1:
11309 
        if ftype == TType.I64:
11310 
          self.id = iprot.readI64();
11311 
        else:
11312 
          iprot.skip(ftype)
11313 
      else:
11314 
        iprot.skip(ftype)
11315 
      iprot.readFieldEnd()
11316 
    iprot.readStructEnd()
11317 
 
11318 
  def write(self, oprot):
11319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11321 
      return
11322 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11323 
    if self.id is not None:
2700 chandransh 11324 
      oprot.writeFieldBegin('id', TType.I64, 1)
11325 
      oprot.writeI64(self.id)
11326 
      oprot.writeFieldEnd()
11327 
    oprot.writeFieldStop()
11328 
    oprot.writeStructEnd()
11329 
 
3431 rajveer 11330 
  def validate(self):
11331 
    return
11332 
 
11333 
 
2700 chandransh 11334 
  def __repr__(self):
11335 
    L = ['%s=%r' % (key, value)
11336 
      for key, value in self.__dict__.iteritems()]
11337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11338 
 
11339 
  def __eq__(self, other):
11340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11341 
 
11342 
  def __ne__(self, other):
11343 
    return not (self == other)
11344 
 
11345 
class getReturnOrder_result:
11346 
  """
11347 
  Attributes:
11348 
   - success
11349 
   - ex
11350 
  """
11351 
 
11352 
  thrift_spec = (
11353 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11355 
  )
11356 
 
11357 
  def __init__(self, success=None, ex=None,):
11358 
    self.success = success
11359 
    self.ex = ex
11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 0:
11371 
        if ftype == TType.STRUCT:
11372 
          self.success = ReturnOrder()
11373 
          self.success.read(iprot)
11374 
        else:
11375 
          iprot.skip(ftype)
11376 
      elif fid == 1:
11377 
        if ftype == TType.STRUCT:
11378 
          self.ex = TransactionServiceException()
11379 
          self.ex.read(iprot)
11380 
        else:
11381 
          iprot.skip(ftype)
11382 
      else:
11383 
        iprot.skip(ftype)
11384 
      iprot.readFieldEnd()
11385 
    iprot.readStructEnd()
11386 
 
11387 
  def write(self, oprot):
11388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11390 
      return
11391 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11392 
    if self.success is not None:
2700 chandransh 11393 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11394 
      self.success.write(oprot)
11395 
      oprot.writeFieldEnd()
3431 rajveer 11396 
    if self.ex is not None:
2700 chandransh 11397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11398 
      self.ex.write(oprot)
11399 
      oprot.writeFieldEnd()
11400 
    oprot.writeFieldStop()
11401 
    oprot.writeStructEnd()
11402 
 
3431 rajveer 11403 
  def validate(self):
11404 
    return
11405 
 
11406 
 
2700 chandransh 11407 
  def __repr__(self):
11408 
    L = ['%s=%r' % (key, value)
11409 
      for key, value in self.__dict__.iteritems()]
11410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11411 
 
11412 
  def __eq__(self, other):
11413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11414 
 
11415 
  def __ne__(self, other):
11416 
    return not (self == other)
11417 
 
2690 chandransh 11418 
class processReturn_args:
11419 
  """
11420 
  Attributes:
11421 
   - returnOrderId
11422 
  """
11423 
 
11424 
  thrift_spec = (
11425 
    None, # 0
11426 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11427 
  )
11428 
 
11429 
  def __init__(self, returnOrderId=None,):
11430 
    self.returnOrderId = returnOrderId
11431 
 
11432 
  def read(self, iprot):
11433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11435 
      return
11436 
    iprot.readStructBegin()
11437 
    while True:
11438 
      (fname, ftype, fid) = iprot.readFieldBegin()
11439 
      if ftype == TType.STOP:
11440 
        break
11441 
      if fid == 1:
11442 
        if ftype == TType.I64:
11443 
          self.returnOrderId = iprot.readI64();
11444 
        else:
11445 
          iprot.skip(ftype)
11446 
      else:
11447 
        iprot.skip(ftype)
11448 
      iprot.readFieldEnd()
11449 
    iprot.readStructEnd()
11450 
 
11451 
  def write(self, oprot):
11452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11454 
      return
11455 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11456 
    if self.returnOrderId is not None:
2690 chandransh 11457 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11458 
      oprot.writeI64(self.returnOrderId)
11459 
      oprot.writeFieldEnd()
11460 
    oprot.writeFieldStop()
11461 
    oprot.writeStructEnd()
11462 
 
3431 rajveer 11463 
  def validate(self):
11464 
    return
11465 
 
11466 
 
2690 chandransh 11467 
  def __repr__(self):
11468 
    L = ['%s=%r' % (key, value)
11469 
      for key, value in self.__dict__.iteritems()]
11470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11471 
 
11472 
  def __eq__(self, other):
11473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11474 
 
11475 
  def __ne__(self, other):
11476 
    return not (self == other)
11477 
 
11478 
class processReturn_result:
11479 
  """
11480 
  Attributes:
11481 
   - ex
11482 
  """
11483 
 
11484 
  thrift_spec = (
11485 
    None, # 0
11486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11487 
  )
11488 
 
11489 
  def __init__(self, ex=None,):
11490 
    self.ex = ex
11491 
 
11492 
  def read(self, iprot):
11493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11495 
      return
11496 
    iprot.readStructBegin()
11497 
    while True:
11498 
      (fname, ftype, fid) = iprot.readFieldBegin()
11499 
      if ftype == TType.STOP:
11500 
        break
11501 
      if fid == 1:
11502 
        if ftype == TType.STRUCT:
11503 
          self.ex = TransactionServiceException()
11504 
          self.ex.read(iprot)
11505 
        else:
11506 
          iprot.skip(ftype)
11507 
      else:
11508 
        iprot.skip(ftype)
11509 
      iprot.readFieldEnd()
11510 
    iprot.readStructEnd()
11511 
 
11512 
  def write(self, oprot):
11513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11515 
      return
11516 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11517 
    if self.ex is not None:
2690 chandransh 11518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11519 
      self.ex.write(oprot)
11520 
      oprot.writeFieldEnd()
11521 
    oprot.writeFieldStop()
11522 
    oprot.writeStructEnd()
11523 
 
3431 rajveer 11524 
  def validate(self):
11525 
    return
11526 
 
11527 
 
2690 chandransh 11528 
  def __repr__(self):
11529 
    L = ['%s=%r' % (key, value)
11530 
      for key, value in self.__dict__.iteritems()]
11531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11532 
 
11533 
  def __eq__(self, other):
11534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11535 
 
11536 
  def __ne__(self, other):
11537 
    return not (self == other)
11538 
 
2819 chandransh 11539 
class createPurchaseOrder_args:
11540 
  """
11541 
  Attributes:
11542 
   - warehouseId
11543 
  """
2690 chandransh 11544 
 
2819 chandransh 11545 
  thrift_spec = (
11546 
    None, # 0
11547 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11548 
  )
11549 
 
11550 
  def __init__(self, warehouseId=None,):
11551 
    self.warehouseId = warehouseId
11552 
 
11553 
  def read(self, iprot):
11554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11556 
      return
11557 
    iprot.readStructBegin()
11558 
    while True:
11559 
      (fname, ftype, fid) = iprot.readFieldBegin()
11560 
      if ftype == TType.STOP:
11561 
        break
11562 
      if fid == 1:
11563 
        if ftype == TType.I64:
11564 
          self.warehouseId = iprot.readI64();
11565 
        else:
11566 
          iprot.skip(ftype)
11567 
      else:
11568 
        iprot.skip(ftype)
11569 
      iprot.readFieldEnd()
11570 
    iprot.readStructEnd()
11571 
 
11572 
  def write(self, oprot):
11573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11575 
      return
11576 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11577 
    if self.warehouseId is not None:
2819 chandransh 11578 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11579 
      oprot.writeI64(self.warehouseId)
11580 
      oprot.writeFieldEnd()
11581 
    oprot.writeFieldStop()
11582 
    oprot.writeStructEnd()
11583 
 
3431 rajveer 11584 
  def validate(self):
11585 
    return
11586 
 
11587 
 
2819 chandransh 11588 
  def __repr__(self):
11589 
    L = ['%s=%r' % (key, value)
11590 
      for key, value in self.__dict__.iteritems()]
11591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11592 
 
11593 
  def __eq__(self, other):
11594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11595 
 
11596 
  def __ne__(self, other):
11597 
    return not (self == other)
11598 
 
11599 
class createPurchaseOrder_result:
11600 
  """
11601 
  Attributes:
11602 
   - success
11603 
   - ex
11604 
  """
11605 
 
11606 
  thrift_spec = (
11607 
    (0, TType.I64, 'success', None, None, ), # 0
11608 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11609 
  )
11610 
 
11611 
  def __init__(self, success=None, ex=None,):
11612 
    self.success = success
11613 
    self.ex = ex
11614 
 
11615 
  def read(self, iprot):
11616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11618 
      return
11619 
    iprot.readStructBegin()
11620 
    while True:
11621 
      (fname, ftype, fid) = iprot.readFieldBegin()
11622 
      if ftype == TType.STOP:
11623 
        break
11624 
      if fid == 0:
11625 
        if ftype == TType.I64:
11626 
          self.success = iprot.readI64();
11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      elif fid == 1:
11630 
        if ftype == TType.STRUCT:
11631 
          self.ex = TransactionServiceException()
11632 
          self.ex.read(iprot)
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      else:
11636 
        iprot.skip(ftype)
11637 
      iprot.readFieldEnd()
11638 
    iprot.readStructEnd()
11639 
 
11640 
  def write(self, oprot):
11641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11643 
      return
11644 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11645 
    if self.success is not None:
2819 chandransh 11646 
      oprot.writeFieldBegin('success', TType.I64, 0)
11647 
      oprot.writeI64(self.success)
11648 
      oprot.writeFieldEnd()
3431 rajveer 11649 
    if self.ex is not None:
2819 chandransh 11650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11651 
      self.ex.write(oprot)
11652 
      oprot.writeFieldEnd()
11653 
    oprot.writeFieldStop()
11654 
    oprot.writeStructEnd()
11655 
 
3431 rajveer 11656 
  def validate(self):
11657 
    return
11658 
 
11659 
 
2819 chandransh 11660 
  def __repr__(self):
11661 
    L = ['%s=%r' % (key, value)
11662 
      for key, value in self.__dict__.iteritems()]
11663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11664 
 
11665 
  def __eq__(self, other):
11666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11667 
 
11668 
  def __ne__(self, other):
11669 
    return not (self == other)
3451 chandransh 11670 
 
11671 
class updateWeight_args:
11672 
  """
11673 
  Attributes:
11674 
   - orderId
11675 
   - weight
11676 
  """
11677 
 
11678 
  thrift_spec = (
11679 
    None, # 0
11680 
    (1, TType.I64, 'orderId', None, None, ), # 1
11681 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11682 
  )
11683 
 
11684 
  def __init__(self, orderId=None, weight=None,):
11685 
    self.orderId = orderId
11686 
    self.weight = weight
11687 
 
11688 
  def read(self, iprot):
11689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11691 
      return
11692 
    iprot.readStructBegin()
11693 
    while True:
11694 
      (fname, ftype, fid) = iprot.readFieldBegin()
11695 
      if ftype == TType.STOP:
11696 
        break
11697 
      if fid == 1:
11698 
        if ftype == TType.I64:
11699 
          self.orderId = iprot.readI64();
11700 
        else:
11701 
          iprot.skip(ftype)
11702 
      elif fid == 2:
11703 
        if ftype == TType.DOUBLE:
11704 
          self.weight = iprot.readDouble();
11705 
        else:
11706 
          iprot.skip(ftype)
11707 
      else:
11708 
        iprot.skip(ftype)
11709 
      iprot.readFieldEnd()
11710 
    iprot.readStructEnd()
11711 
 
11712 
  def write(self, oprot):
11713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11715 
      return
11716 
    oprot.writeStructBegin('updateWeight_args')
11717 
    if self.orderId is not None:
11718 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11719 
      oprot.writeI64(self.orderId)
11720 
      oprot.writeFieldEnd()
11721 
    if self.weight is not None:
11722 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11723 
      oprot.writeDouble(self.weight)
11724 
      oprot.writeFieldEnd()
11725 
    oprot.writeFieldStop()
11726 
    oprot.writeStructEnd()
11727 
 
11728 
  def validate(self):
11729 
    return
11730 
 
11731 
 
11732 
  def __repr__(self):
11733 
    L = ['%s=%r' % (key, value)
11734 
      for key, value in self.__dict__.iteritems()]
11735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11736 
 
11737 
  def __eq__(self, other):
11738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11739 
 
11740 
  def __ne__(self, other):
11741 
    return not (self == other)
11742 
 
11743 
class updateWeight_result:
11744 
  """
11745 
  Attributes:
11746 
   - success
11747 
   - ex
11748 
  """
11749 
 
11750 
  thrift_spec = (
11751 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11753 
  )
11754 
 
11755 
  def __init__(self, success=None, ex=None,):
11756 
    self.success = success
11757 
    self.ex = ex
11758 
 
11759 
  def read(self, iprot):
11760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11762 
      return
11763 
    iprot.readStructBegin()
11764 
    while True:
11765 
      (fname, ftype, fid) = iprot.readFieldBegin()
11766 
      if ftype == TType.STOP:
11767 
        break
11768 
      if fid == 0:
11769 
        if ftype == TType.STRUCT:
11770 
          self.success = Order()
11771 
          self.success.read(iprot)
11772 
        else:
11773 
          iprot.skip(ftype)
11774 
      elif fid == 1:
11775 
        if ftype == TType.STRUCT:
11776 
          self.ex = TransactionServiceException()
11777 
          self.ex.read(iprot)
11778 
        else:
11779 
          iprot.skip(ftype)
11780 
      else:
11781 
        iprot.skip(ftype)
11782 
      iprot.readFieldEnd()
11783 
    iprot.readStructEnd()
11784 
 
11785 
  def write(self, oprot):
11786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11788 
      return
11789 
    oprot.writeStructBegin('updateWeight_result')
11790 
    if self.success is not None:
11791 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11792 
      self.success.write(oprot)
11793 
      oprot.writeFieldEnd()
11794 
    if self.ex is not None:
11795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11796 
      self.ex.write(oprot)
11797 
      oprot.writeFieldEnd()
11798 
    oprot.writeFieldStop()
11799 
    oprot.writeStructEnd()
11800 
 
11801 
  def validate(self):
11802 
    return
11803 
 
11804 
 
11805 
  def __repr__(self):
11806 
    L = ['%s=%r' % (key, value)
11807 
      for key, value in self.__dict__.iteritems()]
11808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11809 
 
11810 
  def __eq__(self, other):
11811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11812 
 
11813 
  def __ne__(self, other):
11814 
    return not (self == other)
3469 chandransh 11815 
 
11816 
class changeItem_args:
11817 
  """
11818 
  Attributes:
11819 
   - orderId
11820 
   - itemId
11821 
  """
11822 
 
11823 
  thrift_spec = (
11824 
    None, # 0
11825 
    (1, TType.I64, 'orderId', None, None, ), # 1
11826 
    (2, TType.I64, 'itemId', None, None, ), # 2
11827 
  )
11828 
 
11829 
  def __init__(self, orderId=None, itemId=None,):
11830 
    self.orderId = orderId
11831 
    self.itemId = itemId
11832 
 
11833 
  def read(self, iprot):
11834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11836 
      return
11837 
    iprot.readStructBegin()
11838 
    while True:
11839 
      (fname, ftype, fid) = iprot.readFieldBegin()
11840 
      if ftype == TType.STOP:
11841 
        break
11842 
      if fid == 1:
11843 
        if ftype == TType.I64:
11844 
          self.orderId = iprot.readI64();
11845 
        else:
11846 
          iprot.skip(ftype)
11847 
      elif fid == 2:
11848 
        if ftype == TType.I64:
11849 
          self.itemId = iprot.readI64();
11850 
        else:
11851 
          iprot.skip(ftype)
11852 
      else:
11853 
        iprot.skip(ftype)
11854 
      iprot.readFieldEnd()
11855 
    iprot.readStructEnd()
11856 
 
11857 
  def write(self, oprot):
11858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11860 
      return
11861 
    oprot.writeStructBegin('changeItem_args')
11862 
    if self.orderId is not None:
11863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11864 
      oprot.writeI64(self.orderId)
11865 
      oprot.writeFieldEnd()
11866 
    if self.itemId is not None:
11867 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11868 
      oprot.writeI64(self.itemId)
11869 
      oprot.writeFieldEnd()
11870 
    oprot.writeFieldStop()
11871 
    oprot.writeStructEnd()
11872 
 
11873 
  def validate(self):
11874 
    return
11875 
 
11876 
 
11877 
  def __repr__(self):
11878 
    L = ['%s=%r' % (key, value)
11879 
      for key, value in self.__dict__.iteritems()]
11880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11881 
 
11882 
  def __eq__(self, other):
11883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11884 
 
11885 
  def __ne__(self, other):
11886 
    return not (self == other)
11887 
 
11888 
class changeItem_result:
11889 
  """
11890 
  Attributes:
11891 
   - success
11892 
   - ex
11893 
  """
11894 
 
11895 
  thrift_spec = (
11896 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11898 
  )
11899 
 
11900 
  def __init__(self, success=None, ex=None,):
11901 
    self.success = success
11902 
    self.ex = ex
11903 
 
11904 
  def read(self, iprot):
11905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11907 
      return
11908 
    iprot.readStructBegin()
11909 
    while True:
11910 
      (fname, ftype, fid) = iprot.readFieldBegin()
11911 
      if ftype == TType.STOP:
11912 
        break
11913 
      if fid == 0:
11914 
        if ftype == TType.STRUCT:
11915 
          self.success = Order()
11916 
          self.success.read(iprot)
11917 
        else:
11918 
          iprot.skip(ftype)
11919 
      elif fid == 1:
11920 
        if ftype == TType.STRUCT:
11921 
          self.ex = TransactionServiceException()
11922 
          self.ex.read(iprot)
11923 
        else:
11924 
          iprot.skip(ftype)
11925 
      else:
11926 
        iprot.skip(ftype)
11927 
      iprot.readFieldEnd()
11928 
    iprot.readStructEnd()
11929 
 
11930 
  def write(self, oprot):
11931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11933 
      return
11934 
    oprot.writeStructBegin('changeItem_result')
11935 
    if self.success is not None:
11936 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11937 
      self.success.write(oprot)
11938 
      oprot.writeFieldEnd()
11939 
    if self.ex is not None:
11940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11941 
      self.ex.write(oprot)
11942 
      oprot.writeFieldEnd()
11943 
    oprot.writeFieldStop()
11944 
    oprot.writeStructEnd()
11945 
 
11946 
  def validate(self):
11947 
    return
11948 
 
11949 
 
11950 
  def __repr__(self):
11951 
    L = ['%s=%r' % (key, value)
11952 
      for key, value in self.__dict__.iteritems()]
11953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11954 
 
11955 
  def __eq__(self, other):
11956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11957 
 
11958 
  def __ne__(self, other):
11959 
    return not (self == other)
11960 
 
11961 
class shiftToWarehouse_args:
11962 
  """
11963 
  Attributes:
11964 
   - orderId
11965 
   - warehouseId
11966 
  """
11967 
 
11968 
  thrift_spec = (
11969 
    None, # 0
11970 
    (1, TType.I64, 'orderId', None, None, ), # 1
11971 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11972 
  )
11973 
 
11974 
  def __init__(self, orderId=None, warehouseId=None,):
11975 
    self.orderId = orderId
11976 
    self.warehouseId = warehouseId
11977 
 
11978 
  def read(self, iprot):
11979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11981 
      return
11982 
    iprot.readStructBegin()
11983 
    while True:
11984 
      (fname, ftype, fid) = iprot.readFieldBegin()
11985 
      if ftype == TType.STOP:
11986 
        break
11987 
      if fid == 1:
11988 
        if ftype == TType.I64:
11989 
          self.orderId = iprot.readI64();
11990 
        else:
11991 
          iprot.skip(ftype)
11992 
      elif fid == 2:
11993 
        if ftype == TType.I64:
11994 
          self.warehouseId = iprot.readI64();
11995 
        else:
11996 
          iprot.skip(ftype)
11997 
      else:
11998 
        iprot.skip(ftype)
11999 
      iprot.readFieldEnd()
12000 
    iprot.readStructEnd()
12001 
 
12002 
  def write(self, oprot):
12003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12005 
      return
12006 
    oprot.writeStructBegin('shiftToWarehouse_args')
12007 
    if self.orderId is not None:
12008 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12009 
      oprot.writeI64(self.orderId)
12010 
      oprot.writeFieldEnd()
12011 
    if self.warehouseId is not None:
12012 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12013 
      oprot.writeI64(self.warehouseId)
12014 
      oprot.writeFieldEnd()
12015 
    oprot.writeFieldStop()
12016 
    oprot.writeStructEnd()
12017 
 
12018 
  def validate(self):
12019 
    return
12020 
 
12021 
 
12022 
  def __repr__(self):
12023 
    L = ['%s=%r' % (key, value)
12024 
      for key, value in self.__dict__.iteritems()]
12025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12026 
 
12027 
  def __eq__(self, other):
12028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12029 
 
12030 
  def __ne__(self, other):
12031 
    return not (self == other)
12032 
 
12033 
class shiftToWarehouse_result:
12034 
  """
12035 
  Attributes:
12036 
   - success
12037 
   - ex
12038 
  """
12039 
 
12040 
  thrift_spec = (
12041 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12043 
  )
12044 
 
12045 
  def __init__(self, success=None, ex=None,):
12046 
    self.success = success
12047 
    self.ex = ex
12048 
 
12049 
  def read(self, iprot):
12050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12052 
      return
12053 
    iprot.readStructBegin()
12054 
    while True:
12055 
      (fname, ftype, fid) = iprot.readFieldBegin()
12056 
      if ftype == TType.STOP:
12057 
        break
12058 
      if fid == 0:
12059 
        if ftype == TType.STRUCT:
12060 
          self.success = Order()
12061 
          self.success.read(iprot)
12062 
        else:
12063 
          iprot.skip(ftype)
12064 
      elif fid == 1:
12065 
        if ftype == TType.STRUCT:
12066 
          self.ex = TransactionServiceException()
12067 
          self.ex.read(iprot)
12068 
        else:
12069 
          iprot.skip(ftype)
12070 
      else:
12071 
        iprot.skip(ftype)
12072 
      iprot.readFieldEnd()
12073 
    iprot.readStructEnd()
12074 
 
12075 
  def write(self, oprot):
12076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12078 
      return
12079 
    oprot.writeStructBegin('shiftToWarehouse_result')
12080 
    if self.success is not None:
12081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12082 
      self.success.write(oprot)
12083 
      oprot.writeFieldEnd()
12084 
    if self.ex is not None:
12085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12086 
      self.ex.write(oprot)
12087 
      oprot.writeFieldEnd()
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
12091 
  def validate(self):
12092 
    return
12093 
 
12094 
 
12095 
  def __repr__(self):
12096 
    L = ['%s=%r' % (key, value)
12097 
      for key, value in self.__dict__.iteritems()]
12098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12099 
 
12100 
  def __eq__(self, other):
12101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12102 
 
12103 
  def __ne__(self, other):
12104 
    return not (self == other)
3553 chandransh 12105 
 
12106 
class addDelayReason_args:
12107 
  """
12108 
  Attributes:
12109 
   - orderId
12110 
   - delayReason
3986 chandransh 12111 
   - furtherDelay
3553 chandransh 12112 
  """
12113 
 
12114 
  thrift_spec = (
12115 
    None, # 0
12116 
    (1, TType.I64, 'orderId', None, None, ), # 1
12117 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12118 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12119 
  )
12120 
 
3986 chandransh 12121 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12122 
    self.orderId = orderId
12123 
    self.delayReason = delayReason
3986 chandransh 12124 
    self.furtherDelay = furtherDelay
3553 chandransh 12125 
 
12126 
  def read(self, iprot):
12127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12129 
      return
12130 
    iprot.readStructBegin()
12131 
    while True:
12132 
      (fname, ftype, fid) = iprot.readFieldBegin()
12133 
      if ftype == TType.STOP:
12134 
        break
12135 
      if fid == 1:
12136 
        if ftype == TType.I64:
12137 
          self.orderId = iprot.readI64();
12138 
        else:
12139 
          iprot.skip(ftype)
12140 
      elif fid == 2:
12141 
        if ftype == TType.I32:
12142 
          self.delayReason = iprot.readI32();
12143 
        else:
12144 
          iprot.skip(ftype)
3986 chandransh 12145 
      elif fid == 3:
12146 
        if ftype == TType.I64:
12147 
          self.furtherDelay = iprot.readI64();
12148 
        else:
12149 
          iprot.skip(ftype)
3553 chandransh 12150 
      else:
12151 
        iprot.skip(ftype)
12152 
      iprot.readFieldEnd()
12153 
    iprot.readStructEnd()
12154 
 
12155 
  def write(self, oprot):
12156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12158 
      return
12159 
    oprot.writeStructBegin('addDelayReason_args')
12160 
    if self.orderId is not None:
12161 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12162 
      oprot.writeI64(self.orderId)
12163 
      oprot.writeFieldEnd()
12164 
    if self.delayReason is not None:
12165 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12166 
      oprot.writeI32(self.delayReason)
12167 
      oprot.writeFieldEnd()
3986 chandransh 12168 
    if self.furtherDelay is not None:
12169 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12170 
      oprot.writeI64(self.furtherDelay)
12171 
      oprot.writeFieldEnd()
3553 chandransh 12172 
    oprot.writeFieldStop()
12173 
    oprot.writeStructEnd()
12174 
 
12175 
  def validate(self):
12176 
    return
12177 
 
12178 
 
12179 
  def __repr__(self):
12180 
    L = ['%s=%r' % (key, value)
12181 
      for key, value in self.__dict__.iteritems()]
12182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12183 
 
12184 
  def __eq__(self, other):
12185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12186 
 
12187 
  def __ne__(self, other):
12188 
    return not (self == other)
12189 
 
12190 
class addDelayReason_result:
12191 
  """
12192 
  Attributes:
12193 
   - success
12194 
   - ex
12195 
  """
12196 
 
12197 
  thrift_spec = (
12198 
    (0, TType.BOOL, 'success', None, None, ), # 0
12199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12200 
  )
12201 
 
12202 
  def __init__(self, success=None, ex=None,):
12203 
    self.success = success
12204 
    self.ex = ex
12205 
 
12206 
  def read(self, iprot):
12207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12209 
      return
12210 
    iprot.readStructBegin()
12211 
    while True:
12212 
      (fname, ftype, fid) = iprot.readFieldBegin()
12213 
      if ftype == TType.STOP:
12214 
        break
12215 
      if fid == 0:
12216 
        if ftype == TType.BOOL:
12217 
          self.success = iprot.readBool();
12218 
        else:
12219 
          iprot.skip(ftype)
12220 
      elif fid == 1:
12221 
        if ftype == TType.STRUCT:
12222 
          self.ex = TransactionServiceException()
12223 
          self.ex.read(iprot)
12224 
        else:
12225 
          iprot.skip(ftype)
12226 
      else:
12227 
        iprot.skip(ftype)
12228 
      iprot.readFieldEnd()
12229 
    iprot.readStructEnd()
12230 
 
12231 
  def write(self, oprot):
12232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12234 
      return
12235 
    oprot.writeStructBegin('addDelayReason_result')
12236 
    if self.success is not None:
12237 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12238 
      oprot.writeBool(self.success)
12239 
      oprot.writeFieldEnd()
12240 
    if self.ex is not None:
12241 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12242 
      self.ex.write(oprot)
12243 
      oprot.writeFieldEnd()
12244 
    oprot.writeFieldStop()
12245 
    oprot.writeStructEnd()
12246 
 
12247 
  def validate(self):
12248 
    return
12249 
 
12250 
 
12251 
  def __repr__(self):
12252 
    L = ['%s=%r' % (key, value)
12253 
      for key, value in self.__dict__.iteritems()]
12254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12255 
 
12256 
  def __eq__(self, other):
12257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12258 
 
12259 
  def __ne__(self, other):
12260 
    return not (self == other)
3956 chandransh 12261 
 
12262 
class reconcileCodCollection_args:
12263 
  """
12264 
  Attributes:
12265 
   - collectedAmountMap
12266 
   - xferBy
12267 
   - xferTxnId
12268 
   - xferDate
12269 
  """
12270 
 
12271 
  thrift_spec = (
12272 
    None, # 0
12273 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12274 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12275 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12276 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12277 
  )
12278 
 
12279 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12280 
    self.collectedAmountMap = collectedAmountMap
12281 
    self.xferBy = xferBy
12282 
    self.xferTxnId = xferTxnId
12283 
    self.xferDate = xferDate
12284 
 
12285 
  def read(self, iprot):
12286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12288 
      return
12289 
    iprot.readStructBegin()
12290 
    while True:
12291 
      (fname, ftype, fid) = iprot.readFieldBegin()
12292 
      if ftype == TType.STOP:
12293 
        break
12294 
      if fid == 1:
12295 
        if ftype == TType.MAP:
12296 
          self.collectedAmountMap = {}
4133 chandransh 12297 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12298 
          for _i217 in xrange(_size213):
12299 
            _key218 = iprot.readString();
12300 
            _val219 = iprot.readDouble();
12301 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12302 
          iprot.readMapEnd()
12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      elif fid == 2:
12306 
        if ftype == TType.STRING:
12307 
          self.xferBy = iprot.readString();
12308 
        else:
12309 
          iprot.skip(ftype)
12310 
      elif fid == 3:
12311 
        if ftype == TType.STRING:
12312 
          self.xferTxnId = iprot.readString();
12313 
        else:
12314 
          iprot.skip(ftype)
12315 
      elif fid == 4:
12316 
        if ftype == TType.I64:
12317 
          self.xferDate = iprot.readI64();
12318 
        else:
12319 
          iprot.skip(ftype)
12320 
      else:
12321 
        iprot.skip(ftype)
12322 
      iprot.readFieldEnd()
12323 
    iprot.readStructEnd()
12324 
 
12325 
  def write(self, oprot):
12326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12328 
      return
12329 
    oprot.writeStructBegin('reconcileCodCollection_args')
12330 
    if self.collectedAmountMap is not None:
12331 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12332 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12333 
      for kiter220,viter221 in self.collectedAmountMap.items():
12334 
        oprot.writeString(kiter220)
12335 
        oprot.writeDouble(viter221)
3956 chandransh 12336 
      oprot.writeMapEnd()
12337 
      oprot.writeFieldEnd()
12338 
    if self.xferBy is not None:
12339 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12340 
      oprot.writeString(self.xferBy)
12341 
      oprot.writeFieldEnd()
12342 
    if self.xferTxnId is not None:
12343 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12344 
      oprot.writeString(self.xferTxnId)
12345 
      oprot.writeFieldEnd()
12346 
    if self.xferDate is not None:
12347 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12348 
      oprot.writeI64(self.xferDate)
12349 
      oprot.writeFieldEnd()
12350 
    oprot.writeFieldStop()
12351 
    oprot.writeStructEnd()
12352 
 
12353 
  def validate(self):
12354 
    return
12355 
 
12356 
 
12357 
  def __repr__(self):
12358 
    L = ['%s=%r' % (key, value)
12359 
      for key, value in self.__dict__.iteritems()]
12360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12361 
 
12362 
  def __eq__(self, other):
12363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12364 
 
12365 
  def __ne__(self, other):
12366 
    return not (self == other)
12367 
 
12368 
class reconcileCodCollection_result:
12369 
  """
12370 
  Attributes:
12371 
   - success
12372 
   - ex
12373 
  """
12374 
 
12375 
  thrift_spec = (
12376 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12378 
  )
12379 
 
12380 
  def __init__(self, success=None, ex=None,):
12381 
    self.success = success
12382 
    self.ex = ex
12383 
 
12384 
  def read(self, iprot):
12385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12387 
      return
12388 
    iprot.readStructBegin()
12389 
    while True:
12390 
      (fname, ftype, fid) = iprot.readFieldBegin()
12391 
      if ftype == TType.STOP:
12392 
        break
12393 
      if fid == 0:
12394 
        if ftype == TType.MAP:
12395 
          self.success = {}
4133 chandransh 12396 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12397 
          for _i226 in xrange(_size222):
12398 
            _key227 = iprot.readString();
12399 
            _val228 = iprot.readString();
12400 
            self.success[_key227] = _val228
3956 chandransh 12401 
          iprot.readMapEnd()
12402 
        else:
12403 
          iprot.skip(ftype)
12404 
      elif fid == 1:
12405 
        if ftype == TType.STRUCT:
12406 
          self.ex = TransactionServiceException()
12407 
          self.ex.read(iprot)
12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
12419 
    oprot.writeStructBegin('reconcileCodCollection_result')
12420 
    if self.success is not None:
12421 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12422 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12423 
      for kiter229,viter230 in self.success.items():
12424 
        oprot.writeString(kiter229)
12425 
        oprot.writeString(viter230)
3956 chandransh 12426 
      oprot.writeMapEnd()
12427 
      oprot.writeFieldEnd()
12428 
    if self.ex is not None:
12429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12430 
      self.ex.write(oprot)
12431 
      oprot.writeFieldEnd()
12432 
    oprot.writeFieldStop()
12433 
    oprot.writeStructEnd()
12434 
 
12435 
  def validate(self):
12436 
    return
12437 
 
12438 
 
12439 
  def __repr__(self):
12440 
    L = ['%s=%r' % (key, value)
12441 
      for key, value in self.__dict__.iteritems()]
12442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12443 
 
12444 
  def __eq__(self, other):
12445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12446 
 
12447 
  def __ne__(self, other):
12448 
    return not (self == other)
4008 mandeep.dh 12449 
 
12450 
class getTransactionsRequiringExtraProcessing_args:
12451 
  """
12452 
  Attributes:
12453 
   - category
12454 
  """
12455 
 
12456 
  thrift_spec = (
12457 
    None, # 0
12458 
    (1, TType.I32, 'category', None, None, ), # 1
12459 
  )
12460 
 
12461 
  def __init__(self, category=None,):
12462 
    self.category = category
12463 
 
12464 
  def read(self, iprot):
12465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12467 
      return
12468 
    iprot.readStructBegin()
12469 
    while True:
12470 
      (fname, ftype, fid) = iprot.readFieldBegin()
12471 
      if ftype == TType.STOP:
12472 
        break
12473 
      if fid == 1:
12474 
        if ftype == TType.I32:
12475 
          self.category = iprot.readI32();
12476 
        else:
12477 
          iprot.skip(ftype)
12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
12487 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12488 
    if self.category is not None:
12489 
      oprot.writeFieldBegin('category', TType.I32, 1)
12490 
      oprot.writeI32(self.category)
12491 
      oprot.writeFieldEnd()
12492 
    oprot.writeFieldStop()
12493 
    oprot.writeStructEnd()
12494 
 
12495 
  def validate(self):
12496 
    return
12497 
 
12498 
 
12499 
  def __repr__(self):
12500 
    L = ['%s=%r' % (key, value)
12501 
      for key, value in self.__dict__.iteritems()]
12502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12503 
 
12504 
  def __eq__(self, other):
12505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12506 
 
12507 
  def __ne__(self, other):
12508 
    return not (self == other)
12509 
 
12510 
class getTransactionsRequiringExtraProcessing_result:
12511 
  """
12512 
  Attributes:
12513 
   - success
12514 
  """
12515 
 
12516 
  thrift_spec = (
12517 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12518 
  )
12519 
 
12520 
  def __init__(self, success=None,):
12521 
    self.success = success
12522 
 
12523 
  def read(self, iprot):
12524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12526 
      return
12527 
    iprot.readStructBegin()
12528 
    while True:
12529 
      (fname, ftype, fid) = iprot.readFieldBegin()
12530 
      if ftype == TType.STOP:
12531 
        break
12532 
      if fid == 0:
12533 
        if ftype == TType.LIST:
12534 
          self.success = []
4133 chandransh 12535 
          (_etype234, _size231) = iprot.readListBegin()
12536 
          for _i235 in xrange(_size231):
12537 
            _elem236 = iprot.readI64();
12538 
            self.success.append(_elem236)
4008 mandeep.dh 12539 
          iprot.readListEnd()
12540 
        else:
12541 
          iprot.skip(ftype)
12542 
      else:
12543 
        iprot.skip(ftype)
12544 
      iprot.readFieldEnd()
12545 
    iprot.readStructEnd()
12546 
 
12547 
  def write(self, oprot):
12548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12550 
      return
12551 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12552 
    if self.success is not None:
12553 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12554 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12555 
      for iter237 in self.success:
12556 
        oprot.writeI64(iter237)
4008 mandeep.dh 12557 
      oprot.writeListEnd()
12558 
      oprot.writeFieldEnd()
12559 
    oprot.writeFieldStop()
12560 
    oprot.writeStructEnd()
12561 
 
12562 
  def validate(self):
12563 
    return
12564 
 
12565 
 
12566 
  def __repr__(self):
12567 
    L = ['%s=%r' % (key, value)
12568 
      for key, value in self.__dict__.iteritems()]
12569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12570 
 
12571 
  def __eq__(self, other):
12572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12573 
 
12574 
  def __ne__(self, other):
12575 
    return not (self == other)
12576 
 
12577 
class markTransactionAsProcessed_args:
12578 
  """
12579 
  Attributes:
12580 
   - transactionId
12581 
   - category
12582 
  """
12583 
 
12584 
  thrift_spec = (
12585 
    None, # 0
12586 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12587 
    (2, TType.I32, 'category', None, None, ), # 2
12588 
  )
12589 
 
12590 
  def __init__(self, transactionId=None, category=None,):
12591 
    self.transactionId = transactionId
12592 
    self.category = category
12593 
 
12594 
  def read(self, iprot):
12595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12597 
      return
12598 
    iprot.readStructBegin()
12599 
    while True:
12600 
      (fname, ftype, fid) = iprot.readFieldBegin()
12601 
      if ftype == TType.STOP:
12602 
        break
12603 
      if fid == 1:
12604 
        if ftype == TType.I64:
12605 
          self.transactionId = iprot.readI64();
12606 
        else:
12607 
          iprot.skip(ftype)
12608 
      elif fid == 2:
12609 
        if ftype == TType.I32:
12610 
          self.category = iprot.readI32();
12611 
        else:
12612 
          iprot.skip(ftype)
12613 
      else:
12614 
        iprot.skip(ftype)
12615 
      iprot.readFieldEnd()
12616 
    iprot.readStructEnd()
12617 
 
12618 
  def write(self, oprot):
12619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12621 
      return
12622 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12623 
    if self.transactionId is not None:
12624 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12625 
      oprot.writeI64(self.transactionId)
12626 
      oprot.writeFieldEnd()
12627 
    if self.category is not None:
12628 
      oprot.writeFieldBegin('category', TType.I32, 2)
12629 
      oprot.writeI32(self.category)
12630 
      oprot.writeFieldEnd()
12631 
    oprot.writeFieldStop()
12632 
    oprot.writeStructEnd()
12633 
 
12634 
  def validate(self):
12635 
    return
12636 
 
12637 
 
12638 
  def __repr__(self):
12639 
    L = ['%s=%r' % (key, value)
12640 
      for key, value in self.__dict__.iteritems()]
12641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12642 
 
12643 
  def __eq__(self, other):
12644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12645 
 
12646 
  def __ne__(self, other):
12647 
    return not (self == other)
12648 
 
12649 
class markTransactionAsProcessed_result:
12650 
 
12651 
  thrift_spec = (
12652 
  )
12653 
 
12654 
  def read(self, iprot):
12655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12657 
      return
12658 
    iprot.readStructBegin()
12659 
    while True:
12660 
      (fname, ftype, fid) = iprot.readFieldBegin()
12661 
      if ftype == TType.STOP:
12662 
        break
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
12672 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
4018 chandransh 12690 
 
12691 
class getItemWiseRiskyOrdersCount_args:
12692 
 
12693 
  thrift_spec = (
12694 
  )
12695 
 
12696 
  def read(self, iprot):
12697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12699 
      return
12700 
    iprot.readStructBegin()
12701 
    while True:
12702 
      (fname, ftype, fid) = iprot.readFieldBegin()
12703 
      if ftype == TType.STOP:
12704 
        break
12705 
      else:
12706 
        iprot.skip(ftype)
12707 
      iprot.readFieldEnd()
12708 
    iprot.readStructEnd()
12709 
 
12710 
  def write(self, oprot):
12711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12713 
      return
12714 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12715 
    oprot.writeFieldStop()
12716 
    oprot.writeStructEnd()
12717 
 
12718 
  def validate(self):
12719 
    return
12720 
 
12721 
 
12722 
  def __repr__(self):
12723 
    L = ['%s=%r' % (key, value)
12724 
      for key, value in self.__dict__.iteritems()]
12725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12726 
 
12727 
  def __eq__(self, other):
12728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12729 
 
12730 
  def __ne__(self, other):
12731 
    return not (self == other)
12732 
 
12733 
class getItemWiseRiskyOrdersCount_result:
12734 
  """
12735 
  Attributes:
12736 
   - success
12737 
  """
12738 
 
12739 
  thrift_spec = (
12740 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12741 
  )
12742 
 
12743 
  def __init__(self, success=None,):
12744 
    self.success = success
12745 
 
12746 
  def read(self, iprot):
12747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12749 
      return
12750 
    iprot.readStructBegin()
12751 
    while True:
12752 
      (fname, ftype, fid) = iprot.readFieldBegin()
12753 
      if ftype == TType.STOP:
12754 
        break
12755 
      if fid == 0:
12756 
        if ftype == TType.MAP:
12757 
          self.success = {}
4133 chandransh 12758 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12759 
          for _i242 in xrange(_size238):
12760 
            _key243 = iprot.readI64();
12761 
            _val244 = iprot.readI64();
12762 
            self.success[_key243] = _val244
4018 chandransh 12763 
          iprot.readMapEnd()
12764 
        else:
12765 
          iprot.skip(ftype)
12766 
      else:
12767 
        iprot.skip(ftype)
12768 
      iprot.readFieldEnd()
12769 
    iprot.readStructEnd()
12770 
 
12771 
  def write(self, oprot):
12772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12774 
      return
12775 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12776 
    if self.success is not None:
12777 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12778 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12779 
      for kiter245,viter246 in self.success.items():
12780 
        oprot.writeI64(kiter245)
12781 
        oprot.writeI64(viter246)
4018 chandransh 12782 
      oprot.writeMapEnd()
12783 
      oprot.writeFieldEnd()
12784 
    oprot.writeFieldStop()
12785 
    oprot.writeStructEnd()
12786 
 
12787 
  def validate(self):
12788 
    return
12789 
 
12790 
 
12791 
  def __repr__(self):
12792 
    L = ['%s=%r' % (key, value)
12793 
      for key, value in self.__dict__.iteritems()]
12794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12795 
 
12796 
  def __eq__(self, other):
12797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12798 
 
12799 
  def __ne__(self, other):
12800 
    return not (self == other)
4247 rajveer 12801 
 
4295 varun.gupt 12802 
class getOrdersForItemIds_args:
12803 
  """
12804 
  Attributes:
12805 
   - itemIds
12806 
  """
12807 
 
12808 
  thrift_spec = (
12809 
    None, # 0
12810 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12811 
  )
12812 
 
12813 
  def __init__(self, itemIds=None,):
12814 
    self.itemIds = itemIds
12815 
 
12816 
  def read(self, iprot):
12817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12819 
      return
12820 
    iprot.readStructBegin()
12821 
    while True:
12822 
      (fname, ftype, fid) = iprot.readFieldBegin()
12823 
      if ftype == TType.STOP:
12824 
        break
12825 
      if fid == 1:
12826 
        if ftype == TType.LIST:
12827 
          self.itemIds = []
12828 
          (_etype250, _size247) = iprot.readListBegin()
12829 
          for _i251 in xrange(_size247):
12830 
            _elem252 = iprot.readI64();
12831 
            self.itemIds.append(_elem252)
12832 
          iprot.readListEnd()
12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      else:
12836 
        iprot.skip(ftype)
12837 
      iprot.readFieldEnd()
12838 
    iprot.readStructEnd()
12839 
 
12840 
  def write(self, oprot):
12841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12843 
      return
12844 
    oprot.writeStructBegin('getOrdersForItemIds_args')
12845 
    if self.itemIds is not None:
12846 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12847 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12848 
      for iter253 in self.itemIds:
12849 
        oprot.writeI64(iter253)
12850 
      oprot.writeListEnd()
12851 
      oprot.writeFieldEnd()
12852 
    oprot.writeFieldStop()
12853 
    oprot.writeStructEnd()
12854 
 
12855 
  def validate(self):
12856 
    return
12857 
 
12858 
 
12859 
  def __repr__(self):
12860 
    L = ['%s=%r' % (key, value)
12861 
      for key, value in self.__dict__.iteritems()]
12862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12863 
 
12864 
  def __eq__(self, other):
12865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12866 
 
12867 
  def __ne__(self, other):
12868 
    return not (self == other)
12869 
 
12870 
class getOrdersForItemIds_result:
12871 
  """
12872 
  Attributes:
12873 
   - success
12874 
  """
12875 
 
12876 
  thrift_spec = (
12877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12878 
  )
12879 
 
12880 
  def __init__(self, success=None,):
12881 
    self.success = success
12882 
 
12883 
  def read(self, iprot):
12884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12886 
      return
12887 
    iprot.readStructBegin()
12888 
    while True:
12889 
      (fname, ftype, fid) = iprot.readFieldBegin()
12890 
      if ftype == TType.STOP:
12891 
        break
12892 
      if fid == 0:
12893 
        if ftype == TType.LIST:
12894 
          self.success = []
12895 
          (_etype257, _size254) = iprot.readListBegin()
12896 
          for _i258 in xrange(_size254):
12897 
            _elem259 = Order()
12898 
            _elem259.read(iprot)
12899 
            self.success.append(_elem259)
12900 
          iprot.readListEnd()
12901 
        else:
12902 
          iprot.skip(ftype)
12903 
      else:
12904 
        iprot.skip(ftype)
12905 
      iprot.readFieldEnd()
12906 
    iprot.readStructEnd()
12907 
 
12908 
  def write(self, oprot):
12909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12911 
      return
12912 
    oprot.writeStructBegin('getOrdersForItemIds_result')
12913 
    if self.success is not None:
12914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12916 
      for iter260 in self.success:
12917 
        iter260.write(oprot)
12918 
      oprot.writeListEnd()
12919 
      oprot.writeFieldEnd()
12920 
    oprot.writeFieldStop()
12921 
    oprot.writeStructEnd()
12922 
 
12923 
  def validate(self):
12924 
    return
12925 
 
12926 
 
12927 
  def __repr__(self):
12928 
    L = ['%s=%r' % (key, value)
12929 
      for key, value in self.__dict__.iteritems()]
12930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12931 
 
12932 
  def __eq__(self, other):
12933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12934 
 
12935 
  def __ne__(self, other):
12936 
    return not (self == other)
12937 
 
4247 rajveer 12938 
class markOrderCancellationRequestReceived_args:
12939 
  """
12940 
  Attributes:
12941 
   - orderId
12942 
  """
12943 
 
12944 
  thrift_spec = (
12945 
    None, # 0
12946 
    (1, TType.I64, 'orderId', None, None, ), # 1
12947 
  )
12948 
 
12949 
  def __init__(self, orderId=None,):
12950 
    self.orderId = orderId
12951 
 
12952 
  def read(self, iprot):
12953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12955 
      return
12956 
    iprot.readStructBegin()
12957 
    while True:
12958 
      (fname, ftype, fid) = iprot.readFieldBegin()
12959 
      if ftype == TType.STOP:
12960 
        break
12961 
      if fid == 1:
12962 
        if ftype == TType.I64:
12963 
          self.orderId = iprot.readI64();
12964 
        else:
12965 
          iprot.skip(ftype)
12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
12975 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12976 
    if self.orderId is not None:
12977 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12978 
      oprot.writeI64(self.orderId)
12979 
      oprot.writeFieldEnd()
12980 
    oprot.writeFieldStop()
12981 
    oprot.writeStructEnd()
12982 
 
12983 
  def validate(self):
12984 
    return
12985 
 
12986 
 
12987 
  def __repr__(self):
12988 
    L = ['%s=%r' % (key, value)
12989 
      for key, value in self.__dict__.iteritems()]
12990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12991 
 
12992 
  def __eq__(self, other):
12993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12994 
 
12995 
  def __ne__(self, other):
12996 
    return not (self == other)
12997 
 
12998 
class markOrderCancellationRequestReceived_result:
12999 
  """
13000 
  Attributes:
13001 
   - ex
13002 
  """
13003 
 
13004 
  thrift_spec = (
13005 
    None, # 0
13006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13007 
  )
13008 
 
13009 
  def __init__(self, ex=None,):
13010 
    self.ex = ex
13011 
 
13012 
  def read(self, iprot):
13013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13015 
      return
13016 
    iprot.readStructBegin()
13017 
    while True:
13018 
      (fname, ftype, fid) = iprot.readFieldBegin()
13019 
      if ftype == TType.STOP:
13020 
        break
13021 
      if fid == 1:
13022 
        if ftype == TType.STRUCT:
13023 
          self.ex = TransactionServiceException()
13024 
          self.ex.read(iprot)
13025 
        else:
13026 
          iprot.skip(ftype)
13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
13036 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13037 
    if self.ex is not None:
13038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13039 
      self.ex.write(oprot)
13040 
      oprot.writeFieldEnd()
13041 
    oprot.writeFieldStop()
13042 
    oprot.writeStructEnd()
13043 
 
13044 
  def validate(self):
13045 
    return
13046 
 
13047 
 
13048 
  def __repr__(self):
13049 
    L = ['%s=%r' % (key, value)
13050 
      for key, value in self.__dict__.iteritems()]
13051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13052 
 
13053 
  def __eq__(self, other):
13054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13055 
 
13056 
  def __ne__(self, other):
13057 
    return not (self == other)
13058 
 
13059 
class markOrderCancellationRequestConfirmed_args:
13060 
  """
13061 
  Attributes:
13062 
   - orderId
13063 
  """
13064 
 
13065 
  thrift_spec = (
13066 
    None, # 0
13067 
    (1, TType.I64, 'orderId', None, None, ), # 1
13068 
  )
13069 
 
13070 
  def __init__(self, orderId=None,):
13071 
    self.orderId = orderId
13072 
 
13073 
  def read(self, iprot):
13074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13076 
      return
13077 
    iprot.readStructBegin()
13078 
    while True:
13079 
      (fname, ftype, fid) = iprot.readFieldBegin()
13080 
      if ftype == TType.STOP:
13081 
        break
13082 
      if fid == 1:
13083 
        if ftype == TType.I64:
13084 
          self.orderId = iprot.readI64();
13085 
        else:
13086 
          iprot.skip(ftype)
13087 
      else:
13088 
        iprot.skip(ftype)
13089 
      iprot.readFieldEnd()
13090 
    iprot.readStructEnd()
13091 
 
13092 
  def write(self, oprot):
13093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13095 
      return
13096 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13097 
    if self.orderId is not None:
13098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13099 
      oprot.writeI64(self.orderId)
13100 
      oprot.writeFieldEnd()
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
13119 
class markOrderCancellationRequestConfirmed_result:
13120 
  """
13121 
  Attributes:
13122 
   - ex
13123 
  """
13124 
 
13125 
  thrift_spec = (
13126 
    None, # 0
13127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13128 
  )
13129 
 
13130 
  def __init__(self, ex=None,):
13131 
    self.ex = ex
13132 
 
13133 
  def read(self, iprot):
13134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13136 
      return
13137 
    iprot.readStructBegin()
13138 
    while True:
13139 
      (fname, ftype, fid) = iprot.readFieldBegin()
13140 
      if ftype == TType.STOP:
13141 
        break
13142 
      if fid == 1:
13143 
        if ftype == TType.STRUCT:
13144 
          self.ex = TransactionServiceException()
13145 
          self.ex.read(iprot)
13146 
        else:
13147 
          iprot.skip(ftype)
13148 
      else:
13149 
        iprot.skip(ftype)
13150 
      iprot.readFieldEnd()
13151 
    iprot.readStructEnd()
13152 
 
13153 
  def write(self, oprot):
13154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13156 
      return
13157 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13158 
    if self.ex is not None:
13159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13160 
      self.ex.write(oprot)
13161 
      oprot.writeFieldEnd()
13162 
    oprot.writeFieldStop()
13163 
    oprot.writeStructEnd()
13164 
 
13165 
  def validate(self):
13166 
    return
13167 
 
13168 
 
13169 
  def __repr__(self):
13170 
    L = ['%s=%r' % (key, value)
13171 
      for key, value in self.__dict__.iteritems()]
13172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13173 
 
13174 
  def __eq__(self, other):
13175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13176 
 
13177 
  def __ne__(self, other):
13178 
    return not (self == other)
13179 
 
13180 
class markOrderCancellationRequestDenied_args:
13181 
  """
13182 
  Attributes:
13183 
   - orderId
13184 
  """
13185 
 
13186 
  thrift_spec = (
13187 
    None, # 0
13188 
    (1, TType.I64, 'orderId', None, None, ), # 1
13189 
  )
13190 
 
13191 
  def __init__(self, orderId=None,):
13192 
    self.orderId = orderId
13193 
 
13194 
  def read(self, iprot):
13195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13197 
      return
13198 
    iprot.readStructBegin()
13199 
    while True:
13200 
      (fname, ftype, fid) = iprot.readFieldBegin()
13201 
      if ftype == TType.STOP:
13202 
        break
13203 
      if fid == 1:
13204 
        if ftype == TType.I64:
13205 
          self.orderId = iprot.readI64();
13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      else:
13209 
        iprot.skip(ftype)
13210 
      iprot.readFieldEnd()
13211 
    iprot.readStructEnd()
13212 
 
13213 
  def write(self, oprot):
13214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13216 
      return
13217 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13218 
    if self.orderId is not None:
13219 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13220 
      oprot.writeI64(self.orderId)
13221 
      oprot.writeFieldEnd()
13222 
    oprot.writeFieldStop()
13223 
    oprot.writeStructEnd()
13224 
 
13225 
  def validate(self):
13226 
    return
13227 
 
13228 
 
13229 
  def __repr__(self):
13230 
    L = ['%s=%r' % (key, value)
13231 
      for key, value in self.__dict__.iteritems()]
13232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13233 
 
13234 
  def __eq__(self, other):
13235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13236 
 
13237 
  def __ne__(self, other):
13238 
    return not (self == other)
13239 
 
13240 
class markOrderCancellationRequestDenied_result:
13241 
  """
13242 
  Attributes:
13243 
   - ex
13244 
  """
13245 
 
13246 
  thrift_spec = (
13247 
    None, # 0
13248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13249 
  )
13250 
 
13251 
  def __init__(self, ex=None,):
13252 
    self.ex = ex
13253 
 
13254 
  def read(self, iprot):
13255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13257 
      return
13258 
    iprot.readStructBegin()
13259 
    while True:
13260 
      (fname, ftype, fid) = iprot.readFieldBegin()
13261 
      if ftype == TType.STOP:
13262 
        break
13263 
      if fid == 1:
13264 
        if ftype == TType.STRUCT:
13265 
          self.ex = TransactionServiceException()
13266 
          self.ex.read(iprot)
13267 
        else:
13268 
          iprot.skip(ftype)
13269 
      else:
13270 
        iprot.skip(ftype)
13271 
      iprot.readFieldEnd()
13272 
    iprot.readStructEnd()
13273 
 
13274 
  def write(self, oprot):
13275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13277 
      return
13278 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13279 
    if self.ex is not None:
13280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13281 
      self.ex.write(oprot)
13282 
      oprot.writeFieldEnd()
13283 
    oprot.writeFieldStop()
13284 
    oprot.writeStructEnd()
13285 
 
13286 
  def validate(self):
13287 
    return
13288 
 
13289 
 
13290 
  def __repr__(self):
13291 
    L = ['%s=%r' % (key, value)
13292 
      for key, value in self.__dict__.iteritems()]
13293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13294 
 
13295 
  def __eq__(self, other):
13296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13297 
 
13298 
  def __ne__(self, other):
13299 
    return not (self == other)
13300 
 
4258 rajveer 13301 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13302 
  """
13303 
  Attributes:
4258 rajveer 13304 
   - transactionId
4247 rajveer 13305 
  """
13306 
 
13307 
  thrift_spec = (
13308 
    None, # 0
4258 rajveer 13309 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13310 
  )
13311 
 
4258 rajveer 13312 
  def __init__(self, transactionId=None,):
13313 
    self.transactionId = transactionId
4247 rajveer 13314 
 
13315 
  def read(self, iprot):
13316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13318 
      return
13319 
    iprot.readStructBegin()
13320 
    while True:
13321 
      (fname, ftype, fid) = iprot.readFieldBegin()
13322 
      if ftype == TType.STOP:
13323 
        break
13324 
      if fid == 1:
13325 
        if ftype == TType.I64:
4258 rajveer 13326 
          self.transactionId = iprot.readI64();
4247 rajveer 13327 
        else:
13328 
          iprot.skip(ftype)
13329 
      else:
13330 
        iprot.skip(ftype)
13331 
      iprot.readFieldEnd()
13332 
    iprot.readStructEnd()
13333 
 
13334 
  def write(self, oprot):
13335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13337 
      return
4258 rajveer 13338 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13339 
    if self.transactionId is not None:
13340 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13341 
      oprot.writeI64(self.transactionId)
4247 rajveer 13342 
      oprot.writeFieldEnd()
13343 
    oprot.writeFieldStop()
13344 
    oprot.writeStructEnd()
13345 
 
13346 
  def validate(self):
13347 
    return
13348 
 
13349 
 
13350 
  def __repr__(self):
13351 
    L = ['%s=%r' % (key, value)
13352 
      for key, value in self.__dict__.iteritems()]
13353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13354 
 
13355 
  def __eq__(self, other):
13356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13357 
 
13358 
  def __ne__(self, other):
13359 
    return not (self == other)
13360 
 
4258 rajveer 13361 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13362 
  """
13363 
  Attributes:
13364 
   - ex
13365 
  """
13366 
 
13367 
  thrift_spec = (
13368 
    None, # 0
13369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13370 
  )
13371 
 
13372 
  def __init__(self, ex=None,):
13373 
    self.ex = ex
13374 
 
13375 
  def read(self, iprot):
13376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13378 
      return
13379 
    iprot.readStructBegin()
13380 
    while True:
13381 
      (fname, ftype, fid) = iprot.readFieldBegin()
13382 
      if ftype == TType.STOP:
13383 
        break
13384 
      if fid == 1:
13385 
        if ftype == TType.STRUCT:
13386 
          self.ex = TransactionServiceException()
13387 
          self.ex.read(iprot)
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
4258 rajveer 13399 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13400 
    if self.ex is not None:
13401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13402 
      self.ex.write(oprot)
13403 
      oprot.writeFieldEnd()
13404 
    oprot.writeFieldStop()
13405 
    oprot.writeStructEnd()
13406 
 
13407 
  def validate(self):
13408 
    return
13409 
 
13410 
 
13411 
  def __repr__(self):
13412 
    L = ['%s=%r' % (key, value)
13413 
      for key, value in self.__dict__.iteritems()]
13414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13415 
 
13416 
  def __eq__(self, other):
13417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13418 
 
13419 
  def __ne__(self, other):
13420 
    return not (self == other)
4259 anupam.sin 13421 
 
13422 
class refundTransaction_args:
13423 
  """
13424 
  Attributes:
13425 
   - transactionId
13426 
   - refundedBy
13427 
   - reason
13428 
  """
13429 
 
13430 
  thrift_spec = (
13431 
    None, # 0
13432 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13433 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13434 
    (3, TType.STRING, 'reason', None, None, ), # 3
13435 
  )
13436 
 
13437 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13438 
    self.transactionId = transactionId
13439 
    self.refundedBy = refundedBy
13440 
    self.reason = reason
13441 
 
13442 
  def read(self, iprot):
13443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13445 
      return
13446 
    iprot.readStructBegin()
13447 
    while True:
13448 
      (fname, ftype, fid) = iprot.readFieldBegin()
13449 
      if ftype == TType.STOP:
13450 
        break
13451 
      if fid == 1:
13452 
        if ftype == TType.I64:
13453 
          self.transactionId = iprot.readI64();
13454 
        else:
13455 
          iprot.skip(ftype)
13456 
      elif fid == 2:
13457 
        if ftype == TType.STRING:
13458 
          self.refundedBy = iprot.readString();
13459 
        else:
13460 
          iprot.skip(ftype)
13461 
      elif fid == 3:
13462 
        if ftype == TType.STRING:
13463 
          self.reason = iprot.readString();
13464 
        else:
13465 
          iprot.skip(ftype)
13466 
      else:
13467 
        iprot.skip(ftype)
13468 
      iprot.readFieldEnd()
13469 
    iprot.readStructEnd()
13470 
 
13471 
  def write(self, oprot):
13472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13474 
      return
13475 
    oprot.writeStructBegin('refundTransaction_args')
13476 
    if self.transactionId is not None:
13477 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13478 
      oprot.writeI64(self.transactionId)
13479 
      oprot.writeFieldEnd()
13480 
    if self.refundedBy is not None:
13481 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13482 
      oprot.writeString(self.refundedBy)
13483 
      oprot.writeFieldEnd()
13484 
    if self.reason is not None:
13485 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13486 
      oprot.writeString(self.reason)
13487 
      oprot.writeFieldEnd()
13488 
    oprot.writeFieldStop()
13489 
    oprot.writeStructEnd()
13490 
 
13491 
  def validate(self):
13492 
    return
13493 
 
13494 
 
13495 
  def __repr__(self):
13496 
    L = ['%s=%r' % (key, value)
13497 
      for key, value in self.__dict__.iteritems()]
13498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13499 
 
13500 
  def __eq__(self, other):
13501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13502 
 
13503 
  def __ne__(self, other):
13504 
    return not (self == other)
13505 
 
13506 
class refundTransaction_result:
13507 
  """
13508 
  Attributes:
13509 
   - ex
13510 
  """
13511 
 
13512 
  thrift_spec = (
13513 
    None, # 0
13514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13515 
  )
13516 
 
13517 
  def __init__(self, ex=None,):
13518 
    self.ex = ex
13519 
 
13520 
  def read(self, iprot):
13521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13523 
      return
13524 
    iprot.readStructBegin()
13525 
    while True:
13526 
      (fname, ftype, fid) = iprot.readFieldBegin()
13527 
      if ftype == TType.STOP:
13528 
        break
13529 
      if fid == 1:
13530 
        if ftype == TType.STRUCT:
13531 
          self.ex = TransactionServiceException()
13532 
          self.ex.read(iprot)
13533 
        else:
13534 
          iprot.skip(ftype)
13535 
      else:
13536 
        iprot.skip(ftype)
13537 
      iprot.readFieldEnd()
13538 
    iprot.readStructEnd()
13539 
 
13540 
  def write(self, oprot):
13541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13543 
      return
13544 
    oprot.writeStructBegin('refundTransaction_result')
13545 
    if self.ex is not None:
13546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13547 
      self.ex.write(oprot)
13548 
      oprot.writeFieldEnd()
13549 
    oprot.writeFieldStop()
13550 
    oprot.writeStructEnd()
13551 
 
13552 
  def validate(self):
13553 
    return
13554 
 
13555 
 
13556 
  def __repr__(self):
13557 
    L = ['%s=%r' % (key, value)
13558 
      for key, value in self.__dict__.iteritems()]
13559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13560 
 
13561 
  def __eq__(self, other):
13562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13563 
 
13564 
  def __ne__(self, other):
13565 
    return not (self == other)
4285 rajveer 13566 
 
4324 mandeep.dh 13567 
class updateShipmentAddress_args:
13568 
  """
13569 
  Attributes:
13570 
   - orderId
13571 
   - addressId
13572 
  """
13573 
 
13574 
  thrift_spec = (
13575 
    None, # 0
13576 
    (1, TType.I64, 'orderId', None, None, ), # 1
13577 
    (2, TType.I64, 'addressId', None, None, ), # 2
13578 
  )
13579 
 
13580 
  def __init__(self, orderId=None, addressId=None,):
13581 
    self.orderId = orderId
13582 
    self.addressId = addressId
13583 
 
13584 
  def read(self, iprot):
13585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13587 
      return
13588 
    iprot.readStructBegin()
13589 
    while True:
13590 
      (fname, ftype, fid) = iprot.readFieldBegin()
13591 
      if ftype == TType.STOP:
13592 
        break
13593 
      if fid == 1:
13594 
        if ftype == TType.I64:
13595 
          self.orderId = iprot.readI64();
13596 
        else:
13597 
          iprot.skip(ftype)
13598 
      elif fid == 2:
13599 
        if ftype == TType.I64:
13600 
          self.addressId = iprot.readI64();
13601 
        else:
13602 
          iprot.skip(ftype)
13603 
      else:
13604 
        iprot.skip(ftype)
13605 
      iprot.readFieldEnd()
13606 
    iprot.readStructEnd()
13607 
 
13608 
  def write(self, oprot):
13609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13611 
      return
13612 
    oprot.writeStructBegin('updateShipmentAddress_args')
13613 
    if self.orderId is not None:
13614 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13615 
      oprot.writeI64(self.orderId)
13616 
      oprot.writeFieldEnd()
13617 
    if self.addressId is not None:
13618 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
13619 
      oprot.writeI64(self.addressId)
13620 
      oprot.writeFieldEnd()
13621 
    oprot.writeFieldStop()
13622 
    oprot.writeStructEnd()
13623 
 
13624 
  def validate(self):
13625 
    return
13626 
 
13627 
 
13628 
  def __repr__(self):
13629 
    L = ['%s=%r' % (key, value)
13630 
      for key, value in self.__dict__.iteritems()]
13631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13632 
 
13633 
  def __eq__(self, other):
13634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13635 
 
13636 
  def __ne__(self, other):
13637 
    return not (self == other)
13638 
 
13639 
class updateShipmentAddress_result:
13640 
  """
13641 
  Attributes:
13642 
   - ex
13643 
  """
13644 
 
13645 
  thrift_spec = (
13646 
    None, # 0
13647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13648 
  )
13649 
 
13650 
  def __init__(self, ex=None,):
13651 
    self.ex = ex
13652 
 
13653 
  def read(self, iprot):
13654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13656 
      return
13657 
    iprot.readStructBegin()
13658 
    while True:
13659 
      (fname, ftype, fid) = iprot.readFieldBegin()
13660 
      if ftype == TType.STOP:
13661 
        break
13662 
      if fid == 1:
13663 
        if ftype == TType.STRUCT:
13664 
          self.ex = TransactionServiceException()
13665 
          self.ex.read(iprot)
13666 
        else:
13667 
          iprot.skip(ftype)
13668 
      else:
13669 
        iprot.skip(ftype)
13670 
      iprot.readFieldEnd()
13671 
    iprot.readStructEnd()
13672 
 
13673 
  def write(self, oprot):
13674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13676 
      return
13677 
    oprot.writeStructBegin('updateShipmentAddress_result')
13678 
    if self.ex is not None:
13679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13680 
      self.ex.write(oprot)
13681 
      oprot.writeFieldEnd()
13682 
    oprot.writeFieldStop()
13683 
    oprot.writeStructEnd()
13684 
 
13685 
  def validate(self):
13686 
    return
13687 
 
13688 
 
13689 
  def __repr__(self):
13690 
    L = ['%s=%r' % (key, value)
13691 
      for key, value in self.__dict__.iteritems()]
13692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13693 
 
13694 
  def __eq__(self, other):
13695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13696 
 
13697 
  def __ne__(self, other):
13698 
    return not (self == other)
13699 
 
4285 rajveer 13700 
class acceptOrdersForItemId_args:
13701 
  """
13702 
  Attributes:
13703 
   - itemId
13704 
   - inventory
13705 
  """
13706 
 
13707 
  thrift_spec = (
13708 
    None, # 0
13709 
    (1, TType.I64, 'itemId', None, None, ), # 1
13710 
    (2, TType.I64, 'inventory', None, None, ), # 2
13711 
  )
13712 
 
13713 
  def __init__(self, itemId=None, inventory=None,):
13714 
    self.itemId = itemId
13715 
    self.inventory = inventory
13716 
 
13717 
  def read(self, iprot):
13718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13720 
      return
13721 
    iprot.readStructBegin()
13722 
    while True:
13723 
      (fname, ftype, fid) = iprot.readFieldBegin()
13724 
      if ftype == TType.STOP:
13725 
        break
13726 
      if fid == 1:
13727 
        if ftype == TType.I64:
13728 
          self.itemId = iprot.readI64();
13729 
        else:
13730 
          iprot.skip(ftype)
13731 
      elif fid == 2:
13732 
        if ftype == TType.I64:
13733 
          self.inventory = iprot.readI64();
13734 
        else:
13735 
          iprot.skip(ftype)
13736 
      else:
13737 
        iprot.skip(ftype)
13738 
      iprot.readFieldEnd()
13739 
    iprot.readStructEnd()
13740 
 
13741 
  def write(self, oprot):
13742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13744 
      return
13745 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13746 
    if self.itemId is not None:
13747 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13748 
      oprot.writeI64(self.itemId)
13749 
      oprot.writeFieldEnd()
13750 
    if self.inventory is not None:
13751 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13752 
      oprot.writeI64(self.inventory)
13753 
      oprot.writeFieldEnd()
13754 
    oprot.writeFieldStop()
13755 
    oprot.writeStructEnd()
13756 
 
13757 
  def validate(self):
13758 
    return
13759 
 
13760 
 
13761 
  def __repr__(self):
13762 
    L = ['%s=%r' % (key, value)
13763 
      for key, value in self.__dict__.iteritems()]
13764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13765 
 
13766 
  def __eq__(self, other):
13767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13768 
 
13769 
  def __ne__(self, other):
13770 
    return not (self == other)
13771 
 
13772 
class acceptOrdersForItemId_result:
13773 
  """
13774 
  Attributes:
13775 
   - success
13776 
   - ex
13777 
  """
13778 
 
13779 
  thrift_spec = (
13780 
    (0, TType.BOOL, 'success', None, None, ), # 0
13781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13782 
  )
13783 
 
13784 
  def __init__(self, success=None, ex=None,):
13785 
    self.success = success
13786 
    self.ex = ex
13787 
 
13788 
  def read(self, iprot):
13789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13791 
      return
13792 
    iprot.readStructBegin()
13793 
    while True:
13794 
      (fname, ftype, fid) = iprot.readFieldBegin()
13795 
      if ftype == TType.STOP:
13796 
        break
13797 
      if fid == 0:
13798 
        if ftype == TType.BOOL:
13799 
          self.success = iprot.readBool();
13800 
        else:
13801 
          iprot.skip(ftype)
13802 
      elif fid == 1:
13803 
        if ftype == TType.STRUCT:
13804 
          self.ex = TransactionServiceException()
13805 
          self.ex.read(iprot)
13806 
        else:
13807 
          iprot.skip(ftype)
13808 
      else:
13809 
        iprot.skip(ftype)
13810 
      iprot.readFieldEnd()
13811 
    iprot.readStructEnd()
13812 
 
13813 
  def write(self, oprot):
13814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13816 
      return
13817 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13818 
    if self.success is not None:
13819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13820 
      oprot.writeBool(self.success)
13821 
      oprot.writeFieldEnd()
13822 
    if self.ex is not None:
13823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13824 
      self.ex.write(oprot)
13825 
      oprot.writeFieldEnd()
13826 
    oprot.writeFieldStop()
13827 
    oprot.writeStructEnd()
13828 
 
13829 
  def validate(self):
13830 
    return
13831 
 
13832 
 
13833 
  def __repr__(self):
13834 
    L = ['%s=%r' % (key, value)
13835 
      for key, value in self.__dict__.iteritems()]
13836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13837 
 
13838 
  def __eq__(self, other):
13839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13840 
 
13841 
  def __ne__(self, other):
13842 
    return not (self == other)
4303 rajveer 13843 
 
13844 
class markOrdersAsPORaised_args:
13845 
  """
13846 
  Attributes:
13847 
   - vendorId
13848 
   - itemId
13849 
   - quantity
13850 
   - estimate
4369 rajveer 13851 
   - isReminder
4303 rajveer 13852 
  """
13853 
 
13854 
  thrift_spec = (
13855 
    None, # 0
13856 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13857 
    (2, TType.I64, 'itemId', None, None, ), # 2
13858 
    (3, TType.I64, 'quantity', None, None, ), # 3
13859 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 13860 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 13861 
  )
13862 
 
4369 rajveer 13863 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 13864 
    self.vendorId = vendorId
13865 
    self.itemId = itemId
13866 
    self.quantity = quantity
13867 
    self.estimate = estimate
4369 rajveer 13868 
    self.isReminder = isReminder
4303 rajveer 13869 
 
13870 
  def read(self, iprot):
13871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13873 
      return
13874 
    iprot.readStructBegin()
13875 
    while True:
13876 
      (fname, ftype, fid) = iprot.readFieldBegin()
13877 
      if ftype == TType.STOP:
13878 
        break
13879 
      if fid == 1:
13880 
        if ftype == TType.I64:
13881 
          self.vendorId = iprot.readI64();
13882 
        else:
13883 
          iprot.skip(ftype)
13884 
      elif fid == 2:
13885 
        if ftype == TType.I64:
13886 
          self.itemId = iprot.readI64();
13887 
        else:
13888 
          iprot.skip(ftype)
13889 
      elif fid == 3:
13890 
        if ftype == TType.I64:
13891 
          self.quantity = iprot.readI64();
13892 
        else:
13893 
          iprot.skip(ftype)
13894 
      elif fid == 4:
13895 
        if ftype == TType.I64:
13896 
          self.estimate = iprot.readI64();
13897 
        else:
13898 
          iprot.skip(ftype)
4369 rajveer 13899 
      elif fid == 5:
13900 
        if ftype == TType.BOOL:
13901 
          self.isReminder = iprot.readBool();
13902 
        else:
13903 
          iprot.skip(ftype)
4303 rajveer 13904 
      else:
13905 
        iprot.skip(ftype)
13906 
      iprot.readFieldEnd()
13907 
    iprot.readStructEnd()
13908 
 
13909 
  def write(self, oprot):
13910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13912 
      return
13913 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
13914 
    if self.vendorId is not None:
13915 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13916 
      oprot.writeI64(self.vendorId)
13917 
      oprot.writeFieldEnd()
13918 
    if self.itemId is not None:
13919 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13920 
      oprot.writeI64(self.itemId)
13921 
      oprot.writeFieldEnd()
13922 
    if self.quantity is not None:
13923 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13924 
      oprot.writeI64(self.quantity)
13925 
      oprot.writeFieldEnd()
13926 
    if self.estimate is not None:
13927 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13928 
      oprot.writeI64(self.estimate)
13929 
      oprot.writeFieldEnd()
4369 rajveer 13930 
    if self.isReminder is not None:
13931 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
13932 
      oprot.writeBool(self.isReminder)
13933 
      oprot.writeFieldEnd()
4303 rajveer 13934 
    oprot.writeFieldStop()
13935 
    oprot.writeStructEnd()
13936 
 
13937 
  def validate(self):
13938 
    return
13939 
 
13940 
 
13941 
  def __repr__(self):
13942 
    L = ['%s=%r' % (key, value)
13943 
      for key, value in self.__dict__.iteritems()]
13944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13945 
 
13946 
  def __eq__(self, other):
13947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13948 
 
13949 
  def __ne__(self, other):
13950 
    return not (self == other)
13951 
 
13952 
class markOrdersAsPORaised_result:
13953 
  """
13954 
  Attributes:
13955 
   - ex
13956 
  """
13957 
 
13958 
  thrift_spec = (
13959 
    None, # 0
13960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13961 
  )
13962 
 
13963 
  def __init__(self, ex=None,):
13964 
    self.ex = ex
13965 
 
13966 
  def read(self, iprot):
13967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13969 
      return
13970 
    iprot.readStructBegin()
13971 
    while True:
13972 
      (fname, ftype, fid) = iprot.readFieldBegin()
13973 
      if ftype == TType.STOP:
13974 
        break
13975 
      if fid == 1:
13976 
        if ftype == TType.STRUCT:
13977 
          self.ex = TransactionServiceException()
13978 
          self.ex.read(iprot)
13979 
        else:
13980 
          iprot.skip(ftype)
13981 
      else:
13982 
        iprot.skip(ftype)
13983 
      iprot.readFieldEnd()
13984 
    iprot.readStructEnd()
13985 
 
13986 
  def write(self, oprot):
13987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13989 
      return
13990 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
13991 
    if self.ex is not None:
13992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13993 
      self.ex.write(oprot)
13994 
      oprot.writeFieldEnd()
13995 
    oprot.writeFieldStop()
13996 
    oprot.writeStructEnd()
13997 
 
13998 
  def validate(self):
13999 
    return
14000 
 
14001 
 
14002 
  def __repr__(self):
14003 
    L = ['%s=%r' % (key, value)
14004 
      for key, value in self.__dict__.iteritems()]
14005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14006 
 
14007 
  def __eq__(self, other):
14008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14009 
 
14010 
  def __ne__(self, other):
14011 
    return not (self == other)
14012 
 
14013 
class markOrdersAsReversalInitiated_args:
14014 
  """
14015 
  Attributes:
14016 
   - vendorId
14017 
   - itemId
14018 
   - quantity
14019 
   - estimate
4369 rajveer 14020 
   - isReminder
4303 rajveer 14021 
  """
14022 
 
14023 
  thrift_spec = (
14024 
    None, # 0
14025 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14026 
    (2, TType.I64, 'itemId', None, None, ), # 2
14027 
    (3, TType.I64, 'quantity', None, None, ), # 3
14028 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14029 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14030 
  )
14031 
 
4369 rajveer 14032 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14033 
    self.vendorId = vendorId
14034 
    self.itemId = itemId
14035 
    self.quantity = quantity
14036 
    self.estimate = estimate
4369 rajveer 14037 
    self.isReminder = isReminder
4303 rajveer 14038 
 
14039 
  def read(self, iprot):
14040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14042 
      return
14043 
    iprot.readStructBegin()
14044 
    while True:
14045 
      (fname, ftype, fid) = iprot.readFieldBegin()
14046 
      if ftype == TType.STOP:
14047 
        break
14048 
      if fid == 1:
14049 
        if ftype == TType.I64:
14050 
          self.vendorId = iprot.readI64();
14051 
        else:
14052 
          iprot.skip(ftype)
14053 
      elif fid == 2:
14054 
        if ftype == TType.I64:
14055 
          self.itemId = iprot.readI64();
14056 
        else:
14057 
          iprot.skip(ftype)
14058 
      elif fid == 3:
14059 
        if ftype == TType.I64:
14060 
          self.quantity = iprot.readI64();
14061 
        else:
14062 
          iprot.skip(ftype)
14063 
      elif fid == 4:
14064 
        if ftype == TType.I64:
14065 
          self.estimate = iprot.readI64();
14066 
        else:
14067 
          iprot.skip(ftype)
4369 rajveer 14068 
      elif fid == 5:
14069 
        if ftype == TType.BOOL:
14070 
          self.isReminder = iprot.readBool();
14071 
        else:
14072 
          iprot.skip(ftype)
4303 rajveer 14073 
      else:
14074 
        iprot.skip(ftype)
14075 
      iprot.readFieldEnd()
14076 
    iprot.readStructEnd()
14077 
 
14078 
  def write(self, oprot):
14079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14081 
      return
14082 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14083 
    if self.vendorId is not None:
14084 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14085 
      oprot.writeI64(self.vendorId)
14086 
      oprot.writeFieldEnd()
14087 
    if self.itemId is not None:
14088 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14089 
      oprot.writeI64(self.itemId)
14090 
      oprot.writeFieldEnd()
14091 
    if self.quantity is not None:
14092 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14093 
      oprot.writeI64(self.quantity)
14094 
      oprot.writeFieldEnd()
14095 
    if self.estimate is not None:
14096 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14097 
      oprot.writeI64(self.estimate)
14098 
      oprot.writeFieldEnd()
4369 rajveer 14099 
    if self.isReminder is not None:
14100 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14101 
      oprot.writeBool(self.isReminder)
14102 
      oprot.writeFieldEnd()
4303 rajveer 14103 
    oprot.writeFieldStop()
14104 
    oprot.writeStructEnd()
14105 
 
14106 
  def validate(self):
14107 
    return
14108 
 
14109 
 
14110 
  def __repr__(self):
14111 
    L = ['%s=%r' % (key, value)
14112 
      for key, value in self.__dict__.iteritems()]
14113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14114 
 
14115 
  def __eq__(self, other):
14116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14117 
 
14118 
  def __ne__(self, other):
14119 
    return not (self == other)
14120 
 
14121 
class markOrdersAsReversalInitiated_result:
14122 
  """
14123 
  Attributes:
14124 
   - ex
14125 
  """
14126 
 
14127 
  thrift_spec = (
14128 
    None, # 0
14129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14130 
  )
14131 
 
14132 
  def __init__(self, ex=None,):
14133 
    self.ex = ex
14134 
 
14135 
  def read(self, iprot):
14136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14138 
      return
14139 
    iprot.readStructBegin()
14140 
    while True:
14141 
      (fname, ftype, fid) = iprot.readFieldBegin()
14142 
      if ftype == TType.STOP:
14143 
        break
14144 
      if fid == 1:
14145 
        if ftype == TType.STRUCT:
14146 
          self.ex = TransactionServiceException()
14147 
          self.ex.read(iprot)
14148 
        else:
14149 
          iprot.skip(ftype)
14150 
      else:
14151 
        iprot.skip(ftype)
14152 
      iprot.readFieldEnd()
14153 
    iprot.readStructEnd()
14154 
 
14155 
  def write(self, oprot):
14156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14158 
      return
14159 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14160 
    if self.ex is not None:
14161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14162 
      self.ex.write(oprot)
14163 
      oprot.writeFieldEnd()
14164 
    oprot.writeFieldStop()
14165 
    oprot.writeStructEnd()
14166 
 
14167 
  def validate(self):
14168 
    return
14169 
 
14170 
 
14171 
  def __repr__(self):
14172 
    L = ['%s=%r' % (key, value)
14173 
      for key, value in self.__dict__.iteritems()]
14174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14175 
 
14176 
  def __eq__(self, other):
14177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14178 
 
14179 
  def __ne__(self, other):
14180 
    return not (self == other)
14181 
 
14182 
class markOrdersAsNotAvailabke_args:
14183 
  """
14184 
  Attributes:
14185 
   - vendorId
14186 
   - itemId
14187 
   - quantity
14188 
   - estimate
4369 rajveer 14189 
   - isReminder
4303 rajveer 14190 
  """
14191 
 
14192 
  thrift_spec = (
14193 
    None, # 0
14194 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14195 
    (2, TType.I64, 'itemId', None, None, ), # 2
14196 
    (3, TType.I64, 'quantity', None, None, ), # 3
14197 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14198 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14199 
  )
14200 
 
4369 rajveer 14201 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14202 
    self.vendorId = vendorId
14203 
    self.itemId = itemId
14204 
    self.quantity = quantity
14205 
    self.estimate = estimate
4369 rajveer 14206 
    self.isReminder = isReminder
4303 rajveer 14207 
 
14208 
  def read(self, iprot):
14209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14211 
      return
14212 
    iprot.readStructBegin()
14213 
    while True:
14214 
      (fname, ftype, fid) = iprot.readFieldBegin()
14215 
      if ftype == TType.STOP:
14216 
        break
14217 
      if fid == 1:
14218 
        if ftype == TType.I64:
14219 
          self.vendorId = iprot.readI64();
14220 
        else:
14221 
          iprot.skip(ftype)
14222 
      elif fid == 2:
14223 
        if ftype == TType.I64:
14224 
          self.itemId = iprot.readI64();
14225 
        else:
14226 
          iprot.skip(ftype)
14227 
      elif fid == 3:
14228 
        if ftype == TType.I64:
14229 
          self.quantity = iprot.readI64();
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      elif fid == 4:
14233 
        if ftype == TType.I64:
14234 
          self.estimate = iprot.readI64();
14235 
        else:
14236 
          iprot.skip(ftype)
4369 rajveer 14237 
      elif fid == 5:
14238 
        if ftype == TType.BOOL:
14239 
          self.isReminder = iprot.readBool();
14240 
        else:
14241 
          iprot.skip(ftype)
4303 rajveer 14242 
      else:
14243 
        iprot.skip(ftype)
14244 
      iprot.readFieldEnd()
14245 
    iprot.readStructEnd()
14246 
 
14247 
  def write(self, oprot):
14248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14250 
      return
14251 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14252 
    if self.vendorId is not None:
14253 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14254 
      oprot.writeI64(self.vendorId)
14255 
      oprot.writeFieldEnd()
14256 
    if self.itemId is not None:
14257 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14258 
      oprot.writeI64(self.itemId)
14259 
      oprot.writeFieldEnd()
14260 
    if self.quantity is not None:
14261 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14262 
      oprot.writeI64(self.quantity)
14263 
      oprot.writeFieldEnd()
14264 
    if self.estimate is not None:
14265 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14266 
      oprot.writeI64(self.estimate)
14267 
      oprot.writeFieldEnd()
4369 rajveer 14268 
    if self.isReminder is not None:
14269 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14270 
      oprot.writeBool(self.isReminder)
14271 
      oprot.writeFieldEnd()
4303 rajveer 14272 
    oprot.writeFieldStop()
14273 
    oprot.writeStructEnd()
14274 
 
14275 
  def validate(self):
14276 
    return
14277 
 
14278 
 
14279 
  def __repr__(self):
14280 
    L = ['%s=%r' % (key, value)
14281 
      for key, value in self.__dict__.iteritems()]
14282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14283 
 
14284 
  def __eq__(self, other):
14285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14286 
 
14287 
  def __ne__(self, other):
14288 
    return not (self == other)
14289 
 
14290 
class markOrdersAsNotAvailabke_result:
14291 
  """
14292 
  Attributes:
14293 
   - ex
14294 
  """
14295 
 
14296 
  thrift_spec = (
14297 
    None, # 0
14298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14299 
  )
14300 
 
14301 
  def __init__(self, ex=None,):
14302 
    self.ex = ex
14303 
 
14304 
  def read(self, iprot):
14305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14307 
      return
14308 
    iprot.readStructBegin()
14309 
    while True:
14310 
      (fname, ftype, fid) = iprot.readFieldBegin()
14311 
      if ftype == TType.STOP:
14312 
        break
14313 
      if fid == 1:
14314 
        if ftype == TType.STRUCT:
14315 
          self.ex = TransactionServiceException()
14316 
          self.ex.read(iprot)
14317 
        else:
14318 
          iprot.skip(ftype)
14319 
      else:
14320 
        iprot.skip(ftype)
14321 
      iprot.readFieldEnd()
14322 
    iprot.readStructEnd()
14323 
 
14324 
  def write(self, oprot):
14325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14327 
      return
14328 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14329 
    if self.ex is not None:
14330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14331 
      self.ex.write(oprot)
14332 
      oprot.writeFieldEnd()
14333 
    oprot.writeFieldStop()
14334 
    oprot.writeStructEnd()
14335 
 
14336 
  def validate(self):
14337 
    return
14338 
 
14339 
 
14340 
  def __repr__(self):
14341 
    L = ['%s=%r' % (key, value)
14342 
      for key, value in self.__dict__.iteritems()]
14343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14344 
 
14345 
  def __eq__(self, other):
14346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14347 
 
14348 
  def __ne__(self, other):
14349 
    return not (self == other)
4369 rajveer 14350 
 
14351 
class markOrdersAsTimeout_args:
14352 
  """
14353 
  Attributes:
14354 
   - vendorId
14355 
  """
14356 
 
14357 
  thrift_spec = (
14358 
    None, # 0
14359 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14360 
  )
14361 
 
14362 
  def __init__(self, vendorId=None,):
14363 
    self.vendorId = vendorId
14364 
 
14365 
  def read(self, iprot):
14366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14368 
      return
14369 
    iprot.readStructBegin()
14370 
    while True:
14371 
      (fname, ftype, fid) = iprot.readFieldBegin()
14372 
      if ftype == TType.STOP:
14373 
        break
14374 
      if fid == 1:
14375 
        if ftype == TType.I64:
14376 
          self.vendorId = iprot.readI64();
14377 
        else:
14378 
          iprot.skip(ftype)
14379 
      else:
14380 
        iprot.skip(ftype)
14381 
      iprot.readFieldEnd()
14382 
    iprot.readStructEnd()
14383 
 
14384 
  def write(self, oprot):
14385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14387 
      return
14388 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
14389 
    if self.vendorId is not None:
14390 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14391 
      oprot.writeI64(self.vendorId)
14392 
      oprot.writeFieldEnd()
14393 
    oprot.writeFieldStop()
14394 
    oprot.writeStructEnd()
14395 
 
14396 
  def validate(self):
14397 
    return
14398 
 
14399 
 
14400 
  def __repr__(self):
14401 
    L = ['%s=%r' % (key, value)
14402 
      for key, value in self.__dict__.iteritems()]
14403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14404 
 
14405 
  def __eq__(self, other):
14406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14407 
 
14408 
  def __ne__(self, other):
14409 
    return not (self == other)
14410 
 
14411 
class markOrdersAsTimeout_result:
14412 
  """
14413 
  Attributes:
14414 
   - success
14415 
   - ex
14416 
  """
14417 
 
14418 
  thrift_spec = (
14419 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
14420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14421 
  )
14422 
 
14423 
  def __init__(self, success=None, ex=None,):
14424 
    self.success = success
14425 
    self.ex = ex
14426 
 
14427 
  def read(self, iprot):
14428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14430 
      return
14431 
    iprot.readStructBegin()
14432 
    while True:
14433 
      (fname, ftype, fid) = iprot.readFieldBegin()
14434 
      if ftype == TType.STOP:
14435 
        break
14436 
      if fid == 0:
14437 
        if ftype == TType.MAP:
14438 
          self.success = {}
14439 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
14440 
          for _i265 in xrange(_size261):
14441 
            _key266 = iprot.readI32();
14442 
            _val267 = TimeoutSummary()
14443 
            _val267.read(iprot)
14444 
            self.success[_key266] = _val267
14445 
          iprot.readMapEnd()
14446 
        else:
14447 
          iprot.skip(ftype)
14448 
      elif fid == 1:
14449 
        if ftype == TType.STRUCT:
14450 
          self.ex = TransactionServiceException()
14451 
          self.ex.read(iprot)
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      else:
14455 
        iprot.skip(ftype)
14456 
      iprot.readFieldEnd()
14457 
    iprot.readStructEnd()
14458 
 
14459 
  def write(self, oprot):
14460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14462 
      return
14463 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
14464 
    if self.success is not None:
14465 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14466 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
14467 
      for kiter268,viter269 in self.success.items():
14468 
        oprot.writeI32(kiter268)
14469 
        viter269.write(oprot)
14470 
      oprot.writeMapEnd()
14471 
      oprot.writeFieldEnd()
14472 
    if self.ex is not None:
14473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14474 
      self.ex.write(oprot)
14475 
      oprot.writeFieldEnd()
14476 
    oprot.writeFieldStop()
14477 
    oprot.writeStructEnd()
14478 
 
14479 
  def validate(self):
14480 
    return
14481 
 
14482 
 
14483 
  def __repr__(self):
14484 
    L = ['%s=%r' % (key, value)
14485 
      for key, value in self.__dict__.iteritems()]
14486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14487 
 
14488 
  def __eq__(self, other):
14489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14490 
 
14491 
  def __ne__(self, other):
14492 
    return not (self == other)
4386 anupam.sin 14493 
 
14494 
class getOrderForAwb_args:
14495 
  """
14496 
  Attributes:
14497 
   - awb
14498 
  """
14499 
 
14500 
  thrift_spec = (
14501 
    None, # 0
14502 
    (1, TType.STRING, 'awb', None, None, ), # 1
14503 
  )
14504 
 
14505 
  def __init__(self, awb=None,):
14506 
    self.awb = awb
14507 
 
14508 
  def read(self, iprot):
14509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14511 
      return
14512 
    iprot.readStructBegin()
14513 
    while True:
14514 
      (fname, ftype, fid) = iprot.readFieldBegin()
14515 
      if ftype == TType.STOP:
14516 
        break
14517 
      if fid == 1:
14518 
        if ftype == TType.STRING:
14519 
          self.awb = iprot.readString();
14520 
        else:
14521 
          iprot.skip(ftype)
14522 
      else:
14523 
        iprot.skip(ftype)
14524 
      iprot.readFieldEnd()
14525 
    iprot.readStructEnd()
14526 
 
14527 
  def write(self, oprot):
14528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14530 
      return
14531 
    oprot.writeStructBegin('getOrderForAwb_args')
14532 
    if self.awb is not None:
14533 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
14534 
      oprot.writeString(self.awb)
14535 
      oprot.writeFieldEnd()
14536 
    oprot.writeFieldStop()
14537 
    oprot.writeStructEnd()
14538 
 
14539 
  def validate(self):
14540 
    return
14541 
 
14542 
 
14543 
  def __repr__(self):
14544 
    L = ['%s=%r' % (key, value)
14545 
      for key, value in self.__dict__.iteritems()]
14546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14547 
 
14548 
  def __eq__(self, other):
14549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14550 
 
14551 
  def __ne__(self, other):
14552 
    return not (self == other)
14553 
 
14554 
class getOrderForAwb_result:
14555 
  """
14556 
  Attributes:
14557 
   - success
14558 
   - ex
14559 
  """
14560 
 
14561 
  thrift_spec = (
14562 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14564 
  )
14565 
 
14566 
  def __init__(self, success=None, ex=None,):
14567 
    self.success = success
14568 
    self.ex = ex
14569 
 
14570 
  def read(self, iprot):
14571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14573 
      return
14574 
    iprot.readStructBegin()
14575 
    while True:
14576 
      (fname, ftype, fid) = iprot.readFieldBegin()
14577 
      if ftype == TType.STOP:
14578 
        break
14579 
      if fid == 0:
14580 
        if ftype == TType.STRUCT:
14581 
          self.success = Order()
14582 
          self.success.read(iprot)
14583 
        else:
14584 
          iprot.skip(ftype)
14585 
      elif fid == 1:
14586 
        if ftype == TType.STRUCT:
14587 
          self.ex = TransactionServiceException()
14588 
          self.ex.read(iprot)
14589 
        else:
14590 
          iprot.skip(ftype)
14591 
      else:
14592 
        iprot.skip(ftype)
14593 
      iprot.readFieldEnd()
14594 
    iprot.readStructEnd()
14595 
 
14596 
  def write(self, oprot):
14597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14599 
      return
14600 
    oprot.writeStructBegin('getOrderForAwb_result')
14601 
    if self.success is not None:
14602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14603 
      self.success.write(oprot)
14604 
      oprot.writeFieldEnd()
14605 
    if self.ex is not None:
14606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14607 
      self.ex.write(oprot)
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)