Subversion Repositories SmartDukaan

Rev

Rev 4386 | Rev 4410 | 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 
 
4394 rajveer 219 
  def getAlerts(self, type, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
223 
     - status
224 
     - timestamp
3064 chandransh 225 
    """
226 
    pass
227 
 
4394 rajveer 228 
  def addAlert(self, type, description):
3064 chandransh 229 
    """
230 
    Parameters:
231 
     - type
4394 rajveer 232 
     - description
3064 chandransh 233 
    """
234 
    pass
235 
 
236 
  def getValidOrderCount(self, ):
237 
    """
238 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
239 
    """
240 
    pass
241 
 
242 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
243 
    """
244 
    Returns the number of distinct customers who have done successful transactions
245 
    """
246 
    pass
247 
 
248 
  def getValidOrdersAmountRange(self, ):
249 
    """
250 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
251 
    List contains two values, first minimum amount and second maximum amount.
252 
    """
253 
    pass
254 
 
255 
  def getValidOrders(self, limit):
256 
    """
257 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
258 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 259 
 
3064 chandransh 260 
    Parameters:
261 
     - limit
262 
    """
263 
    pass
264 
 
1220 chandransh 265 
  def batchOrders(self, warehouseId):
266 
    """
267 
    Create a batch of all the pending orders for the given warehouse.
268 
    The returned list is orderd by created_timestamp.
269 
    If there are no pending orders, an empty list is returned.
3431 rajveer 270 
 
1220 chandransh 271 
    Parameters:
272 
     - warehouseId
273 
    """
274 
    pass
275 
 
1208 chandransh 276 
  def markOrderAsOutOfStock(self, orderId):
277 
    """
278 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 279 
 
1208 chandransh 280 
    Parameters:
281 
     - orderId
282 
    """
283 
    pass
284 
 
3064 chandransh 285 
  def verifyOrder(self, orderId):
759 chandransh 286 
    """
3064 chandransh 287 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
288 
    timestamp. It is intended to be used for COD orders but can be harmlessly
289 
    used for all other orders as well.
290 
    Throws an exception if no such order exists.
3431 rajveer 291 
 
759 chandransh 292 
    Parameters:
3064 chandransh 293 
     - orderId
294 
    """
295 
    pass
296 
 
297 
  def acceptOrder(self, orderId):
298 
    """
299 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
300 
    given order is not a COD order, it also captures the payment if the same has
301 
    not been captured.
302 
    Throws an exception if no such order exists.
3431 rajveer 303 
 
3064 chandransh 304 
    Parameters:
305 
     - orderId
306 
    """
307 
    pass
308 
 
4283 anupam.sin 309 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 310 
    """
311 
    Add billing details such as the bill number and the biller to the Order.
312 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
313 
    the IMEI no. if a -1 is supplied.
314 
    Also, it generates an invoice number for the order, marks the order as
315 
    BILLED and sets the billing timestamp.
316 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 317 
 
3064 chandransh 318 
    Parameters:
319 
     - orderId
4283 anupam.sin 320 
     - invoice_number
3064 chandransh 321 
     - imeiNumber
322 
     - itemNumber
4283 anupam.sin 323 
     - billed_by
324 
     - jacketNumber
3064 chandransh 325 
     - billingType
4283 anupam.sin 326 
     - vendorId
3064 chandransh 327 
    """
328 
    pass
329 
 
330 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
331 
    """
332 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
333 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 334 
 
3064 chandransh 335 
    Parameters:
759 chandransh 336 
     - warehouseId
337 
     - providerId
3064 chandransh 338 
     - cod
759 chandransh 339 
    """
340 
    pass
341 
 
1113 chandransh 342 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
343 
    """
344 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
345 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
346 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 347 
 
1113 chandransh 348 
    Parameters:
349 
     - providerId
350 
     - pickupDetails
351 
    """
352 
    pass
353 
 
1132 chandransh 354 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
355 
    """
356 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
357 
    the name of the receiver.
358 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 359 
 
1132 chandransh 360 
    Parameters:
361 
     - providerId
362 
     - deliveredOrders
363 
    """
364 
    pass
365 
 
1135 chandransh 366 
  def markOrdersAsFailed(self, providerId, returnedOrders):
367 
    """
368 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
369 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 370 
 
1135 chandransh 371 
    Parameters:
372 
     - providerId
373 
     - returnedOrders
374 
    """
375 
    pass
376 
 
1246 chandransh 377 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
378 
    """
379 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 380 
 
1246 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - undeliveredOrders
384 
    """
385 
    pass
386 
 
1408 ankur.sing 387 
  def getUndeliveredOrders(self, providerId, warehouseId):
388 
    """
389 
    Returns the list of orders whose delivery time has passed but have not been
390 
    delivered yet for the given provider and warehouse. To get a complete list of
391 
    undelivered orders, pass them as -1.
392 
    Returns an empty list if no such orders exist.
3431 rajveer 393 
 
1408 ankur.sing 394 
    Parameters:
395 
     - providerId
396 
     - warehouseId
397 
    """
398 
    pass
399 
 
2536 chandransh 400 
  def toggleDOAFlag(self, orderId):
401 
    """
402 
    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.
403 
    Returns the final flag status.
404 
    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 405 
 
2536 chandransh 406 
    Parameters:
407 
     - orderId
408 
    """
409 
    pass
1886 ankur.sing 410 
 
2536 chandransh 411 
  def requestPickupNumber(self, orderId):
412 
    """
413 
    Sends out an email to the account manager of the original courier provider used to ship the order.
414 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
415 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
416 
    For any other status, it returns false.
417 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 418 
 
2536 chandransh 419 
    Parameters:
420 
     - orderId
421 
    """
422 
    pass
423 
 
424 
  def authorizePickup(self, orderId, pickupNumber):
425 
    """
426 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
427 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
428 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
429 
    	3. Returns true
2591 chandransh 430 
    If the order is in any other status, it returns false.
2536 chandransh 431 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 432 
 
2536 chandransh 433 
    Parameters:
434 
     - orderId
435 
     - pickupNumber
436 
    """
437 
    pass
438 
 
2764 chandransh 439 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
440 
    """
441 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
442 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 443 
 
2764 chandransh 444 
    Parameters:
445 
     - providerId
446 
     - pickupDetails
447 
    """
448 
    pass
449 
 
2616 chandransh 450 
  def receiveReturn(self, orderId):
2591 chandransh 451 
    """
2599 chandransh 452 
    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 453 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 454 
    If the order is in any other state, it returns false.
455 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 456 
 
2591 chandransh 457 
    Parameters:
458 
     - orderId
459 
    """
460 
    pass
2536 chandransh 461 
 
2591 chandransh 462 
  def validateDoa(self, orderId, isValid):
463 
    """
2599 chandransh 464 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 465 
    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 466 
    If the order is in any other state, it returns false.
467 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 468 
 
2591 chandransh 469 
    Parameters:
470 
     - orderId
471 
     - isValid
472 
    """
473 
    pass
474 
 
2616 chandransh 475 
  def reshipOrder(self, orderId):
476 
    """
477 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
478 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
479 
    	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.
480 
 
481 
    If the order is in DOA_CERT_VALID state, it does the following:
482 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
483 
    	2. Creates a return order for the warehouse executive to return the DOA material.
484 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 485 
 
2616 chandransh 486 
    Returns the id of the newly created order.
3431 rajveer 487 
 
2616 chandransh 488 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 489 
 
2616 chandransh 490 
    Parameters:
491 
     - orderId
492 
    """
493 
    pass
2591 chandransh 494 
 
3226 chandransh 495 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 496 
    """
497 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
498 
    	1. Creates a refund request for batch processing.
499 
    	2. Creates a return order for the warehouse executive to return the shipped material.
500 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 501 
 
2616 chandransh 502 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
503 
    	1. Creates a refund request for batch processing.
3226 chandransh 504 
    	2. Cancels the reservation of the item in the warehouse.
505 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 506 
 
3226 chandransh 507 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
508 
    	1. Cancels the reservation of the item in the warehouse.
509 
    	2. Marks the current order as CANCELED.
510 
 
511 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
512 
 
2616 chandransh 513 
    Returns True if it is successful, False otherwise.
3431 rajveer 514 
 
2616 chandransh 515 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 516 
 
2616 chandransh 517 
    Parameters:
518 
     - orderId
3226 chandransh 519 
     - refundedBy
520 
     - reason
2616 chandransh 521 
    """
522 
    pass
523 
 
2690 chandransh 524 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
525 
    """
526 
    Get all return orders created between the from and to dates for the given warehouse.
527 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 528 
 
2690 chandransh 529 
    Parameters:
530 
     - warehouseId
531 
     - fromDate
532 
     - toDate
533 
    """
534 
    pass
2616 chandransh 535 
 
2700 chandransh 536 
  def getReturnOrder(self, id):
537 
    """
538 
    Returns the ReturnOrder corresponding to the given id.
539 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 540 
 
2700 chandransh 541 
    Parameters:
542 
     - id
543 
    """
544 
    pass
545 
 
2690 chandransh 546 
  def processReturn(self, returnOrderId):
547 
    """
548 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 549 
 
2690 chandransh 550 
    Parameters:
551 
     - returnOrderId
552 
    """
553 
    pass
554 
 
2819 chandransh 555 
  def createPurchaseOrder(self, warehouseId):
556 
    """
557 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 558 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 559 
 
2819 chandransh 560 
    Parameters:
561 
     - warehouseId
562 
    """
563 
    pass
2690 chandransh 564 
 
3451 chandransh 565 
  def updateWeight(self, orderId, weight):
566 
    """
567 
    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 568 
 
3451 chandransh 569 
    Parameters:
570 
     - orderId
571 
     - weight
572 
    """
573 
    pass
574 
 
3469 chandransh 575 
  def changeItem(self, orderId, itemId):
576 
    """
577 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
578 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 579 
 
3469 chandransh 580 
    Parameters:
581 
     - orderId
582 
     - itemId
583 
    """
584 
    pass
585 
 
586 
  def shiftToWarehouse(self, orderId, warehouseId):
587 
    """
588 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
589 
 
590 
    Parameters:
591 
     - orderId
592 
     - warehouseId
593 
    """
594 
    pass
595 
 
3986 chandransh 596 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 597 
    """
598 
    Adds the given delay reason to the given order.
3986 chandransh 599 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 600 
    Raises an exception if no order with the given id can be found.
3469 chandransh 601 
 
3553 chandransh 602 
    Parameters:
603 
     - orderId
604 
     - delayReason
3986 chandransh 605 
     - furtherDelay
3553 chandransh 606 
    """
607 
    pass
608 
 
3956 chandransh 609 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
610 
    """
611 
    Marks the COD orders with given AWB nos. as having been processed.
612 
    Updates the captured amount for the corresponding payment.
3553 chandransh 613 
 
3956 chandransh 614 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
615 
    1. There is no order corresponding to an AWB number.
616 
    2. The captured amount for a payment exceeds the total payment.
617 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
618 
 
619 
    Parameters:
620 
     - collectedAmountMap
621 
     - xferBy
622 
     - xferTxnId
623 
     - xferDate
624 
    """
625 
    pass
626 
 
4008 mandeep.dh 627 
  def getTransactionsRequiringExtraProcessing(self, category):
628 
    """
4065 mandeep.dh 629 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 630 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 631 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 632 
 
4008 mandeep.dh 633 
    Parameters:
634 
     - category
635 
    """
636 
    pass
637 
 
638 
  def markTransactionAsProcessed(self, transactionId, category):
639 
    """
640 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 641 
    It essentially deletes the transaction id record for a particular
642 
    processing type category (if present) from DB.
643 
    This is currently used by CRM application.
4008 mandeep.dh 644 
 
645 
    Parameters:
646 
     - transactionId
647 
     - category
648 
    """
649 
    pass
650 
 
4018 chandransh 651 
  def getItemWiseRiskyOrdersCount(self, ):
652 
    """
653 
    Returns a map containing the number of risky orders keyed by item id. A risky order
654 
    is defined as one whose shipping date is about to expire.
655 
    """
656 
    pass
4008 mandeep.dh 657 
 
4295 varun.gupt 658 
  def getOrdersForItemIds(self, itemIds):
659 
    """
660 
    Returns a list of all orders which have items with given id
661 
 
662 
    Parameters:
663 
     - itemIds
664 
    """
665 
    pass
666 
 
4247 rajveer 667 
  def markOrderCancellationRequestReceived(self, orderId):
668 
    """
669 
    Mark order as cancellation request received. If customer sends request of cancellation of
670 
    a particular order, this method will be called. It will just change status of the order
671 
    depending on its current status. It also records the previous status, so that we can move
672 
    back to that status if cancellation request is denied.
4018 chandransh 673 
 
4247 rajveer 674 
    Parameters:
675 
     - orderId
676 
    """
677 
    pass
678 
 
679 
  def markOrderCancellationRequestConfirmed(self, orderId):
680 
    """
681 
    If we decide to to cancel order, CRM will call this method to move the status of order to
682 
    cancellation request confirmed. After this OM will be able to cancel the order.
683 
 
684 
    Parameters:
685 
     - orderId
686 
    """
687 
    pass
688 
 
689 
  def markOrderCancellationRequestDenied(self, orderId):
690 
    """
691 
    If we decide to not to cancel order, we will move the order ro previous status.
692 
 
693 
    Parameters:
694 
     - orderId
695 
    """
696 
    pass
697 
 
4258 rajveer 698 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 699 
    """
4258 rajveer 700 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
701 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 702 
 
703 
    Parameters:
4258 rajveer 704 
     - transactionId
4247 rajveer 705 
    """
706 
    pass
707 
 
4259 anupam.sin 708 
  def refundTransaction(self, transactionId, refundedBy, reason):
709 
    """
710 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
711 
    need to be cancelled
4247 rajveer 712 
 
4259 anupam.sin 713 
    Parameters:
714 
     - transactionId
715 
     - refundedBy
716 
     - reason
717 
    """
718 
    pass
719 
 
4324 mandeep.dh 720 
  def updateShipmentAddress(self, orderId, addressId):
721 
    """
722 
    Updates shipment address of an order. Delivery and shipping date estimates
723 
    etc. are also updated here.
724 
 
725 
    Throws TransactionServiceException in case address change is not
726 
    possible due to certain reasons such as new pincode in address is
727 
    not serviceable etc.
728 
 
729 
    Parameters:
730 
     - orderId
731 
     - addressId
732 
    """
733 
    pass
734 
 
4285 rajveer 735 
  def acceptOrdersForItemId(self, itemId, inventory):
736 
    """
737 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
738 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 739 
 
4285 rajveer 740 
    Parameters:
741 
     - itemId
742 
     - inventory
743 
    """
744 
    pass
745 
 
4369 rajveer 746 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 747 
    """
748 
    Parameters:
749 
     - vendorId
750 
     - itemId
751 
     - quantity
752 
     - estimate
4369 rajveer 753 
     - isReminder
4303 rajveer 754 
    """
755 
    pass
4285 rajveer 756 
 
4369 rajveer 757 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 758 
    """
759 
    Parameters:
760 
     - vendorId
761 
     - itemId
762 
     - quantity
763 
     - estimate
4369 rajveer 764 
     - isReminder
4303 rajveer 765 
    """
766 
    pass
767 
 
4369 rajveer 768 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 769 
    """
770 
    Parameters:
771 
     - vendorId
772 
     - itemId
773 
     - quantity
774 
     - estimate
4369 rajveer 775 
     - isReminder
4303 rajveer 776 
    """
777 
    pass
778 
 
4369 rajveer 779 
  def markOrdersAsTimeout(self, vendorId):
780 
    """
781 
    Parameters:
782 
     - vendorId
783 
    """
784 
    pass
4303 rajveer 785 
 
4386 anupam.sin 786 
  def getOrderForAwb(self, awb):
787 
    """
788 
    Returns the order corresponding to an AWB number
4369 rajveer 789 
 
4386 anupam.sin 790 
    Parameters:
791 
     - awb
792 
    """
793 
    pass
794 
 
795 
 
3376 rajveer 796 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 797 
  def __init__(self, iprot, oprot=None):
3376 rajveer 798 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 799 
 
800 
  def createTransaction(self, transaction):
801 
    """
802 
    Parameters:
803 
     - transaction
804 
    """
805 
    self.send_createTransaction(transaction)
132 ashish 806 
    return self.recv_createTransaction()
94 ashish 807 
 
808 
  def send_createTransaction(self, transaction):
809 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
810 
    args = createTransaction_args()
811 
    args.transaction = transaction
812 
    args.write(self._oprot)
813 
    self._oprot.writeMessageEnd()
814 
    self._oprot.trans.flush()
815 
 
816 
  def recv_createTransaction(self, ):
817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
818 
    if mtype == TMessageType.EXCEPTION:
819 
      x = TApplicationException()
820 
      x.read(self._iprot)
821 
      self._iprot.readMessageEnd()
822 
      raise x
823 
    result = createTransaction_result()
824 
    result.read(self._iprot)
825 
    self._iprot.readMessageEnd()
3431 rajveer 826 
    if result.success is not None:
132 ashish 827 
      return result.success
3431 rajveer 828 
    if result.ex is not None:
94 ashish 829 
      raise result.ex
132 ashish 830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 831 
 
832 
  def getTransaction(self, id):
833 
    """
834 
    Parameters:
835 
     - id
836 
    """
837 
    self.send_getTransaction(id)
838 
    return self.recv_getTransaction()
839 
 
840 
  def send_getTransaction(self, id):
841 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
842 
    args = getTransaction_args()
843 
    args.id = id
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_getTransaction(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = getTransaction_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
3431 rajveer 858 
    if result.success is not None:
94 ashish 859 
      return result.success
3431 rajveer 860 
    if result.ex is not None:
94 ashish 861 
      raise result.ex
862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
863 
 
864 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
865 
    """
866 
    Parameters:
867 
     - customerId
868 
     - from_date
869 
     - to_date
870 
     - status
871 
    """
872 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
873 
    return self.recv_getTransactionsForCustomer()
874 
 
875 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
876 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
877 
    args = getTransactionsForCustomer_args()
878 
    args.customerId = customerId
879 
    args.from_date = from_date
880 
    args.to_date = to_date
881 
    args.status = status
882 
    args.write(self._oprot)
883 
    self._oprot.writeMessageEnd()
884 
    self._oprot.trans.flush()
885 
 
886 
  def recv_getTransactionsForCustomer(self, ):
887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
888 
    if mtype == TMessageType.EXCEPTION:
889 
      x = TApplicationException()
890 
      x.read(self._iprot)
891 
      self._iprot.readMessageEnd()
892 
      raise x
893 
    result = getTransactionsForCustomer_result()
894 
    result.read(self._iprot)
895 
    self._iprot.readMessageEnd()
3431 rajveer 896 
    if result.success is not None:
94 ashish 897 
      return result.success
3431 rajveer 898 
    if result.ex is not None:
94 ashish 899 
      raise result.ex
900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
901 
 
132 ashish 902 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
903 
    """
904 
    Parameters:
905 
     - shoppingCartId
906 
    """
907 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
908 
    return self.recv_getTransactionsForShoppingCartId()
909 
 
910 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
911 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
912 
    args = getTransactionsForShoppingCartId_args()
913 
    args.shoppingCartId = shoppingCartId
914 
    args.write(self._oprot)
915 
    self._oprot.writeMessageEnd()
916 
    self._oprot.trans.flush()
917 
 
918 
  def recv_getTransactionsForShoppingCartId(self, ):
919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
920 
    if mtype == TMessageType.EXCEPTION:
921 
      x = TApplicationException()
922 
      x.read(self._iprot)
923 
      self._iprot.readMessageEnd()
924 
      raise x
925 
    result = getTransactionsForShoppingCartId_result()
926 
    result.read(self._iprot)
927 
    self._iprot.readMessageEnd()
3431 rajveer 928 
    if result.success is not None:
132 ashish 929 
      return result.success
3431 rajveer 930 
    if result.ex is not None:
132 ashish 931 
      raise result.ex
932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
933 
 
94 ashish 934 
  def getTransactionStatus(self, transactionId):
935 
    """
936 
    Parameters:
937 
     - transactionId
938 
    """
939 
    self.send_getTransactionStatus(transactionId)
940 
    return self.recv_getTransactionStatus()
941 
 
942 
  def send_getTransactionStatus(self, transactionId):
943 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
944 
    args = getTransactionStatus_args()
945 
    args.transactionId = transactionId
946 
    args.write(self._oprot)
947 
    self._oprot.writeMessageEnd()
948 
    self._oprot.trans.flush()
949 
 
950 
  def recv_getTransactionStatus(self, ):
951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
952 
    if mtype == TMessageType.EXCEPTION:
953 
      x = TApplicationException()
954 
      x.read(self._iprot)
955 
      self._iprot.readMessageEnd()
956 
      raise x
957 
    result = getTransactionStatus_result()
958 
    result.read(self._iprot)
959 
    self._iprot.readMessageEnd()
3431 rajveer 960 
    if result.success is not None:
94 ashish 961 
      return result.success
3431 rajveer 962 
    if result.ex is not None:
94 ashish 963 
      raise result.ex
964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
965 
 
966 
  def changeTransactionStatus(self, transactionId, status, description):
967 
    """
968 
    Parameters:
969 
     - transactionId
970 
     - status
971 
     - description
972 
    """
973 
    self.send_changeTransactionStatus(transactionId, status, description)
974 
    return self.recv_changeTransactionStatus()
975 
 
976 
  def send_changeTransactionStatus(self, transactionId, status, description):
977 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
978 
    args = changeTransactionStatus_args()
979 
    args.transactionId = transactionId
980 
    args.status = status
981 
    args.description = description
982 
    args.write(self._oprot)
983 
    self._oprot.writeMessageEnd()
984 
    self._oprot.trans.flush()
985 
 
986 
  def recv_changeTransactionStatus(self, ):
987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
988 
    if mtype == TMessageType.EXCEPTION:
989 
      x = TApplicationException()
990 
      x.read(self._iprot)
991 
      self._iprot.readMessageEnd()
992 
      raise x
993 
    result = changeTransactionStatus_result()
994 
    result.read(self._iprot)
995 
    self._iprot.readMessageEnd()
3431 rajveer 996 
    if result.success is not None:
94 ashish 997 
      return result.success
3431 rajveer 998 
    if result.ex is not None:
94 ashish 999 
      raise result.ex
1000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1001 
 
1398 varun.gupt 1002 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1003 
    """
1004 
    Parameters:
1005 
     - transactionId
1006 
    """
1398 varun.gupt 1007 
    self.send_enqueueTransactionInfoEmail(transactionId)
1008 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1009 
 
1398 varun.gupt 1010 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1011 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1012 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1013 
    args.transactionId = transactionId
1014 
    args.write(self._oprot)
1015 
    self._oprot.writeMessageEnd()
1016 
    self._oprot.trans.flush()
1017 
 
1398 varun.gupt 1018 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1020 
    if mtype == TMessageType.EXCEPTION:
1021 
      x = TApplicationException()
1022 
      x.read(self._iprot)
1023 
      self._iprot.readMessageEnd()
1024 
      raise x
1398 varun.gupt 1025 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1026 
    result.read(self._iprot)
1027 
    self._iprot.readMessageEnd()
3431 rajveer 1028 
    if result.success is not None:
1382 varun.gupt 1029 
      return result.success
3431 rajveer 1030 
    if result.ex is not None:
1382 varun.gupt 1031 
      raise result.ex
1398 varun.gupt 1032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1033 
 
483 rajveer 1034 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1035 
    """
1036 
    Parameters:
483 rajveer 1037 
     - status
1038 
     - from_date
1039 
     - to_date
1040 
     - warehouse_id
94 ashish 1041 
    """
483 rajveer 1042 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1043 
    return self.recv_getAllOrders()
94 ashish 1044 
 
483 rajveer 1045 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1046 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1047 
    args = getAllOrders_args()
1048 
    args.status = status
1049 
    args.from_date = from_date
1050 
    args.to_date = to_date
1051 
    args.warehouse_id = warehouse_id
94 ashish 1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
483 rajveer 1056 
  def recv_getAllOrders(self, ):
94 ashish 1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
483 rajveer 1063 
    result = getAllOrders_result()
94 ashish 1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
3431 rajveer 1066 
    if result.success is not None:
94 ashish 1067 
      return result.success
3431 rajveer 1068 
    if result.ex is not None:
94 ashish 1069 
      raise result.ex
483 rajveer 1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1071 
 
4133 chandransh 1072 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1073 
    """
1074 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1075 
    Pass the status as null and the limit as 0 to ignore them.
1076 
 
1077 
    Parameters:
1078 
     - statuses
1079 
     - offset
1080 
     - limit
1081 
     - warehouse_id
1082 
    """
1083 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1084 
    return self.recv_getOrdersInBatch()
1085 
 
1086 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1087 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1088 
    args = getOrdersInBatch_args()
1089 
    args.statuses = statuses
1090 
    args.offset = offset
1091 
    args.limit = limit
1092 
    args.warehouse_id = warehouse_id
1093 
    args.write(self._oprot)
1094 
    self._oprot.writeMessageEnd()
1095 
    self._oprot.trans.flush()
1096 
 
1097 
  def recv_getOrdersInBatch(self, ):
1098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1099 
    if mtype == TMessageType.EXCEPTION:
1100 
      x = TApplicationException()
1101 
      x.read(self._iprot)
1102 
      self._iprot.readMessageEnd()
1103 
      raise x
1104 
    result = getOrdersInBatch_result()
1105 
    result.read(self._iprot)
1106 
    self._iprot.readMessageEnd()
1107 
    if result.success is not None:
1108 
      return result.success
1109 
    if result.ex is not None:
1110 
      raise result.ex
1111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1112 
 
1113 
  def getOrderCount(self, statuses, warehouseId):
1114 
    """
1115 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1116 
 
1117 
    Parameters:
1118 
     - statuses
1119 
     - warehouseId
1120 
    """
1121 
    self.send_getOrderCount(statuses, warehouseId)
1122 
    return self.recv_getOrderCount()
1123 
 
1124 
  def send_getOrderCount(self, statuses, warehouseId):
1125 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1126 
    args = getOrderCount_args()
1127 
    args.statuses = statuses
1128 
    args.warehouseId = warehouseId
1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_getOrderCount(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = getOrderCount_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
1143 
    if result.success is not None:
1144 
      return result.success
1145 
    if result.ex is not None:
1146 
      raise result.ex
1147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1148 
 
999 varun.gupt 1149 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1150 
    """
1132 chandransh 1151 
    Returns orders within a range of their billing dates
3431 rajveer 1152 
 
999 varun.gupt 1153 
    Parameters:
1154 
     - status
1155 
     - start_billing_date
1156 
     - end_billing_date
1157 
     - warehouse_id
1158 
    """
1159 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1160 
    return self.recv_getOrdersByBillingDate()
1161 
 
1162 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1163 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1164 
    args = getOrdersByBillingDate_args()
1165 
    args.status = status
1166 
    args.start_billing_date = start_billing_date
1167 
    args.end_billing_date = end_billing_date
1168 
    args.warehouse_id = warehouse_id
1169 
    args.write(self._oprot)
1170 
    self._oprot.writeMessageEnd()
1171 
    self._oprot.trans.flush()
1172 
 
1173 
  def recv_getOrdersByBillingDate(self, ):
1174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1175 
    if mtype == TMessageType.EXCEPTION:
1176 
      x = TApplicationException()
1177 
      x.read(self._iprot)
1178 
      self._iprot.readMessageEnd()
1179 
      raise x
1180 
    result = getOrdersByBillingDate_result()
1181 
    result.read(self._iprot)
1182 
    self._iprot.readMessageEnd()
3431 rajveer 1183 
    if result.success is not None:
999 varun.gupt 1184 
      return result.success
3431 rajveer 1185 
    if result.ex is not None:
999 varun.gupt 1186 
      raise result.ex
1187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1188 
 
3451 chandransh 1189 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1190 
    """
1191 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1192 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1193 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1194 
 
3427 chandransh 1195 
    Parameters:
1196 
     - fromShippingDate
1197 
     - toShippingDate
1198 
     - providerId
1199 
     - warehouseId
3451 chandransh 1200 
     - cod
3427 chandransh 1201 
    """
3451 chandransh 1202 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1203 
    return self.recv_getOrdersByShippingDate()
1204 
 
3451 chandransh 1205 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1206 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1207 
    args = getOrdersByShippingDate_args()
1208 
    args.fromShippingDate = fromShippingDate
1209 
    args.toShippingDate = toShippingDate
1210 
    args.providerId = providerId
1211 
    args.warehouseId = warehouseId
3451 chandransh 1212 
    args.cod = cod
3427 chandransh 1213 
    args.write(self._oprot)
1214 
    self._oprot.writeMessageEnd()
1215 
    self._oprot.trans.flush()
1216 
 
1217 
  def recv_getOrdersByShippingDate(self, ):
1218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1219 
    if mtype == TMessageType.EXCEPTION:
1220 
      x = TApplicationException()
1221 
      x.read(self._iprot)
1222 
      self._iprot.readMessageEnd()
1223 
      raise x
1224 
    result = getOrdersByShippingDate_result()
1225 
    result.read(self._iprot)
1226 
    self._iprot.readMessageEnd()
3431 rajveer 1227 
    if result.success is not None:
3427 chandransh 1228 
      return result.success
3431 rajveer 1229 
    if result.ex is not None:
3427 chandransh 1230 
      raise result.ex
1231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1232 
 
1382 varun.gupt 1233 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1234 
    """
1235 
    Returns order ids for orders which can be returned
3431 rajveer 1236 
 
1382 varun.gupt 1237 
    Parameters:
1238 
     - customer_id
1239 
     - limit
1240 
    """
1241 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1242 
    return self.recv_getReturnableOrdersForCustomer()
1243 
 
1244 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1245 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1246 
    args = getReturnableOrdersForCustomer_args()
1247 
    args.customer_id = customer_id
1248 
    args.limit = limit
1249 
    args.write(self._oprot)
1250 
    self._oprot.writeMessageEnd()
1251 
    self._oprot.trans.flush()
1252 
 
1253 
  def recv_getReturnableOrdersForCustomer(self, ):
1254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1255 
    if mtype == TMessageType.EXCEPTION:
1256 
      x = TApplicationException()
1257 
      x.read(self._iprot)
1258 
      self._iprot.readMessageEnd()
1259 
      raise x
1260 
    result = getReturnableOrdersForCustomer_result()
1261 
    result.read(self._iprot)
1262 
    self._iprot.readMessageEnd()
3431 rajveer 1263 
    if result.success is not None:
1382 varun.gupt 1264 
      return result.success
3431 rajveer 1265 
    if result.ex is not None:
1382 varun.gupt 1266 
      raise result.ex
1267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1268 
 
1269 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1270 
    """
1271 
    Returns order ids for orders which can be cancelled
3431 rajveer 1272 
 
1382 varun.gupt 1273 
    Parameters:
1274 
     - customer_id
1275 
     - limit
1276 
    """
1277 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1278 
    return self.recv_getCancellableOrdersForCustomer()
1279 
 
1280 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1281 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1282 
    args = getCancellableOrdersForCustomer_args()
1283 
    args.customer_id = customer_id
1284 
    args.limit = limit
1285 
    args.write(self._oprot)
1286 
    self._oprot.writeMessageEnd()
1287 
    self._oprot.trans.flush()
1288 
 
1289 
  def recv_getCancellableOrdersForCustomer(self, ):
1290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1291 
    if mtype == TMessageType.EXCEPTION:
1292 
      x = TApplicationException()
1293 
      x.read(self._iprot)
1294 
      self._iprot.readMessageEnd()
1295 
      raise x
1296 
    result = getCancellableOrdersForCustomer_result()
1297 
    result.read(self._iprot)
1298 
    self._iprot.readMessageEnd()
3431 rajveer 1299 
    if result.success is not None:
1382 varun.gupt 1300 
      return result.success
3431 rajveer 1301 
    if result.ex is not None:
1382 varun.gupt 1302 
      raise result.ex
1303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1304 
 
483 rajveer 1305 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1306 
    """
1307 
    Parameters:
483 rajveer 1308 
     - orderId
1309 
     - status
1310 
     - description
94 ashish 1311 
    """
483 rajveer 1312 
    self.send_changeOrderStatus(orderId, status, description)
1313 
    return self.recv_changeOrderStatus()
94 ashish 1314 
 
483 rajveer 1315 
  def send_changeOrderStatus(self, orderId, status, description):
1316 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1317 
    args = changeOrderStatus_args()
1318 
    args.orderId = orderId
1319 
    args.status = status
1320 
    args.description = description
94 ashish 1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
483 rajveer 1325 
  def recv_changeOrderStatus(self, ):
94 ashish 1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
483 rajveer 1332 
    result = changeOrderStatus_result()
94 ashish 1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
3431 rajveer 1335 
    if result.success is not None:
94 ashish 1336 
      return result.success
3431 rajveer 1337 
    if result.ex is not None:
94 ashish 1338 
      raise result.ex
483 rajveer 1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1340 
 
1528 ankur.sing 1341 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1342 
    """
1528 ankur.sing 1343 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1344 
    only user who owns the transaction can view its order details.
3431 rajveer 1345 
 
94 ashish 1346 
    Parameters:
1347 
     - transactionId
1528 ankur.sing 1348 
     - customerId
94 ashish 1349 
    """
1528 ankur.sing 1350 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1351 
    return self.recv_getOrdersForTransaction()
94 ashish 1352 
 
1528 ankur.sing 1353 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1354 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1355 
    args = getOrdersForTransaction_args()
94 ashish 1356 
    args.transactionId = transactionId
1528 ankur.sing 1357 
    args.customerId = customerId
94 ashish 1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
483 rajveer 1362 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
483 rajveer 1369 
    result = getOrdersForTransaction_result()
94 ashish 1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
3431 rajveer 1372 
    if result.success is not None:
94 ashish 1373 
      return result.success
3431 rajveer 1374 
    if result.ex is not None:
94 ashish 1375 
      raise result.ex
483 rajveer 1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1377 
 
3014 chandransh 1378 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1379 
    """
3014 chandransh 1380 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1381 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1382 
 
94 ashish 1383 
    Parameters:
483 rajveer 1384 
     - customerId
1385 
     - from_date
1386 
     - to_date
3014 chandransh 1387 
     - statuses
94 ashish 1388 
    """
3014 chandransh 1389 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1390 
    return self.recv_getOrdersForCustomer()
94 ashish 1391 
 
3014 chandransh 1392 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1393 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1394 
    args = getOrdersForCustomer_args()
1395 
    args.customerId = customerId
1396 
    args.from_date = from_date
1397 
    args.to_date = to_date
3014 chandransh 1398 
    args.statuses = statuses
94 ashish 1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
483 rajveer 1403 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
483 rajveer 1410 
    result = getOrdersForCustomer_result()
94 ashish 1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
94 ashish 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
94 ashish 1416 
      raise result.ex
483 rajveer 1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1418 
 
483 rajveer 1419 
  def createOrder(self, order):
94 ashish 1420 
    """
1421 
    Parameters:
483 rajveer 1422 
     - order
94 ashish 1423 
    """
483 rajveer 1424 
    self.send_createOrder(order)
1425 
    return self.recv_createOrder()
94 ashish 1426 
 
483 rajveer 1427 
  def send_createOrder(self, order):
1428 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1429 
    args = createOrder_args()
1430 
    args.order = order
94 ashish 1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
483 rajveer 1435 
  def recv_createOrder(self, ):
94 ashish 1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
483 rajveer 1442 
    result = createOrder_result()
94 ashish 1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
3431 rajveer 1445 
    if result.success is not None:
94 ashish 1446 
      return result.success
3431 rajveer 1447 
    if result.ex is not None:
94 ashish 1448 
      raise result.ex
483 rajveer 1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1450 
 
483 rajveer 1451 
  def getOrder(self, id):
94 ashish 1452 
    """
1453 
    Parameters:
483 rajveer 1454 
     - id
94 ashish 1455 
    """
483 rajveer 1456 
    self.send_getOrder(id)
1457 
    return self.recv_getOrder()
94 ashish 1458 
 
483 rajveer 1459 
  def send_getOrder(self, id):
1460 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1461 
    args = getOrder_args()
1462 
    args.id = id
94 ashish 1463 
    args.write(self._oprot)
1464 
    self._oprot.writeMessageEnd()
1465 
    self._oprot.trans.flush()
1466 
 
483 rajveer 1467 
  def recv_getOrder(self, ):
94 ashish 1468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1469 
    if mtype == TMessageType.EXCEPTION:
1470 
      x = TApplicationException()
1471 
      x.read(self._iprot)
1472 
      self._iprot.readMessageEnd()
1473 
      raise x
483 rajveer 1474 
    result = getOrder_result()
94 ashish 1475 
    result.read(self._iprot)
1476 
    self._iprot.readMessageEnd()
3431 rajveer 1477 
    if result.success is not None:
94 ashish 1478 
      return result.success
3431 rajveer 1479 
    if result.ex is not None:
94 ashish 1480 
      raise result.ex
483 rajveer 1481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1482 
 
483 rajveer 1483 
  def getLineItemsForOrder(self, orderId):
94 ashish 1484 
    """
1485 
    Parameters:
483 rajveer 1486 
     - orderId
94 ashish 1487 
    """
483 rajveer 1488 
    self.send_getLineItemsForOrder(orderId)
1489 
    return self.recv_getLineItemsForOrder()
94 ashish 1490 
 
483 rajveer 1491 
  def send_getLineItemsForOrder(self, orderId):
1492 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1493 
    args = getLineItemsForOrder_args()
1494 
    args.orderId = orderId
94 ashish 1495 
    args.write(self._oprot)
1496 
    self._oprot.writeMessageEnd()
1497 
    self._oprot.trans.flush()
1498 
 
483 rajveer 1499 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1501 
    if mtype == TMessageType.EXCEPTION:
1502 
      x = TApplicationException()
1503 
      x.read(self._iprot)
1504 
      self._iprot.readMessageEnd()
1505 
      raise x
483 rajveer 1506 
    result = getLineItemsForOrder_result()
94 ashish 1507 
    result.read(self._iprot)
1508 
    self._iprot.readMessageEnd()
3431 rajveer 1509 
    if result.success is not None:
94 ashish 1510 
      return result.success
3431 rajveer 1511 
    if result.ex is not None:
94 ashish 1512 
      raise result.ex
483 rajveer 1513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1514 
 
1528 ankur.sing 1515 
  def getOrderForCustomer(self, orderId, customerId):
1516 
    """
1517 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1518 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1519 
 
1528 ankur.sing 1520 
    Parameters:
1521 
     - orderId
1522 
     - customerId
1523 
    """
1524 
    self.send_getOrderForCustomer(orderId, customerId)
1525 
    return self.recv_getOrderForCustomer()
1526 
 
1527 
  def send_getOrderForCustomer(self, orderId, customerId):
1528 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1529 
    args = getOrderForCustomer_args()
1530 
    args.orderId = orderId
1531 
    args.customerId = customerId
1532 
    args.write(self._oprot)
1533 
    self._oprot.writeMessageEnd()
1534 
    self._oprot.trans.flush()
1535 
 
1536 
  def recv_getOrderForCustomer(self, ):
1537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1538 
    if mtype == TMessageType.EXCEPTION:
1539 
      x = TApplicationException()
1540 
      x.read(self._iprot)
1541 
      self._iprot.readMessageEnd()
1542 
      raise x
1543 
    result = getOrderForCustomer_result()
1544 
    result.read(self._iprot)
1545 
    self._iprot.readMessageEnd()
3431 rajveer 1546 
    if result.success is not None:
1528 ankur.sing 1547 
      return result.success
3431 rajveer 1548 
    if result.ex is not None:
1528 ankur.sing 1549 
      raise result.ex
1550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1551 
 
4394 rajveer 1552 
  def getAlerts(self, type, status, timestamp):
3064 chandransh 1553 
    """
1554 
    Parameters:
4394 rajveer 1555 
     - type
1556 
     - status
1557 
     - timestamp
3064 chandransh 1558 
    """
4394 rajveer 1559 
    self.send_getAlerts(type, status, timestamp)
3064 chandransh 1560 
    return self.recv_getAlerts()
1561 
 
4394 rajveer 1562 
  def send_getAlerts(self, type, status, timestamp):
3064 chandransh 1563 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1564 
    args = getAlerts_args()
4394 rajveer 1565 
    args.type = type
1566 
    args.status = status
1567 
    args.timestamp = timestamp
3064 chandransh 1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getAlerts(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getAlerts_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
3431 rajveer 1582 
    if result.success is not None:
3064 chandransh 1583 
      return result.success
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1585 
 
4394 rajveer 1586 
  def addAlert(self, type, description):
3064 chandransh 1587 
    """
1588 
    Parameters:
1589 
     - type
4394 rajveer 1590 
     - description
3064 chandransh 1591 
    """
4394 rajveer 1592 
    self.send_addAlert(type, description)
1593 
    self.recv_addAlert()
3064 chandransh 1594 
 
4394 rajveer 1595 
  def send_addAlert(self, type, description):
1596 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1597 
    args = addAlert_args()
3064 chandransh 1598 
    args.type = type
4394 rajveer 1599 
    args.description = description
3064 chandransh 1600 
    args.write(self._oprot)
1601 
    self._oprot.writeMessageEnd()
1602 
    self._oprot.trans.flush()
1603 
 
4394 rajveer 1604 
  def recv_addAlert(self, ):
3064 chandransh 1605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1606 
    if mtype == TMessageType.EXCEPTION:
1607 
      x = TApplicationException()
1608 
      x.read(self._iprot)
1609 
      self._iprot.readMessageEnd()
1610 
      raise x
4394 rajveer 1611 
    result = addAlert_result()
3064 chandransh 1612 
    result.read(self._iprot)
1613 
    self._iprot.readMessageEnd()
1614 
    return
1615 
 
1616 
  def getValidOrderCount(self, ):
1617 
    """
1618 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1619 
    """
1620 
    self.send_getValidOrderCount()
1621 
    return self.recv_getValidOrderCount()
1622 
 
1623 
  def send_getValidOrderCount(self, ):
1624 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1625 
    args = getValidOrderCount_args()
1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getValidOrderCount(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getValidOrderCount_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
3431 rajveer 1640 
    if result.success is not None:
3064 chandransh 1641 
      return result.success
1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1643 
 
1644 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1645 
    """
1646 
    Returns the number of distinct customers who have done successful transactions
1647 
    """
1648 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1649 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1650 
 
1651 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1652 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1653 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
3064 chandransh 1669 
      return result.success
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1671 
 
1672 
  def getValidOrdersAmountRange(self, ):
1673 
    """
1674 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1675 
    List contains two values, first minimum amount and second maximum amount.
1676 
    """
1677 
    self.send_getValidOrdersAmountRange()
1678 
    return self.recv_getValidOrdersAmountRange()
1679 
 
1680 
  def send_getValidOrdersAmountRange(self, ):
1681 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1682 
    args = getValidOrdersAmountRange_args()
1683 
    args.write(self._oprot)
1684 
    self._oprot.writeMessageEnd()
1685 
    self._oprot.trans.flush()
1686 
 
1687 
  def recv_getValidOrdersAmountRange(self, ):
1688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1689 
    if mtype == TMessageType.EXCEPTION:
1690 
      x = TApplicationException()
1691 
      x.read(self._iprot)
1692 
      self._iprot.readMessageEnd()
1693 
      raise x
1694 
    result = getValidOrdersAmountRange_result()
1695 
    result.read(self._iprot)
1696 
    self._iprot.readMessageEnd()
3431 rajveer 1697 
    if result.success is not None:
3064 chandransh 1698 
      return result.success
1699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1700 
 
1701 
  def getValidOrders(self, limit):
1702 
    """
1703 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1704 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1705 
 
3064 chandransh 1706 
    Parameters:
1707 
     - limit
1708 
    """
1709 
    self.send_getValidOrders(limit)
1710 
    return self.recv_getValidOrders()
1711 
 
1712 
  def send_getValidOrders(self, limit):
1713 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1714 
    args = getValidOrders_args()
1715 
    args.limit = limit
1716 
    args.write(self._oprot)
1717 
    self._oprot.writeMessageEnd()
1718 
    self._oprot.trans.flush()
1719 
 
1720 
  def recv_getValidOrders(self, ):
1721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1722 
    if mtype == TMessageType.EXCEPTION:
1723 
      x = TApplicationException()
1724 
      x.read(self._iprot)
1725 
      self._iprot.readMessageEnd()
1726 
      raise x
1727 
    result = getValidOrders_result()
1728 
    result.read(self._iprot)
1729 
    self._iprot.readMessageEnd()
3431 rajveer 1730 
    if result.success is not None:
3064 chandransh 1731 
      return result.success
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1733 
 
1220 chandransh 1734 
  def batchOrders(self, warehouseId):
1735 
    """
1736 
    Create a batch of all the pending orders for the given warehouse.
1737 
    The returned list is orderd by created_timestamp.
1738 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1739 
 
1220 chandransh 1740 
    Parameters:
1741 
     - warehouseId
1742 
    """
1743 
    self.send_batchOrders(warehouseId)
1744 
    return self.recv_batchOrders()
1745 
 
1746 
  def send_batchOrders(self, warehouseId):
1747 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1748 
    args = batchOrders_args()
1749 
    args.warehouseId = warehouseId
1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1754 
  def recv_batchOrders(self, ):
1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1761 
    result = batchOrders_result()
1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
1220 chandransh 1765 
      return result.success
3431 rajveer 1766 
    if result.ex is not None:
1220 chandransh 1767 
      raise result.ex
1768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1769 
 
1208 chandransh 1770 
  def markOrderAsOutOfStock(self, orderId):
1771 
    """
1772 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1773 
 
1208 chandransh 1774 
    Parameters:
1775 
     - orderId
1776 
    """
1777 
    self.send_markOrderAsOutOfStock(orderId)
1778 
    return self.recv_markOrderAsOutOfStock()
1779 
 
1780 
  def send_markOrderAsOutOfStock(self, orderId):
1781 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1782 
    args = markOrderAsOutOfStock_args()
1783 
    args.orderId = orderId
1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1788 
  def recv_markOrderAsOutOfStock(self, ):
1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1795 
    result = markOrderAsOutOfStock_result()
1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
3431 rajveer 1798 
    if result.success is not None:
1208 chandransh 1799 
      return result.success
3431 rajveer 1800 
    if result.ex is not None:
1208 chandransh 1801 
      raise result.ex
1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1803 
 
3064 chandransh 1804 
  def verifyOrder(self, orderId):
759 chandransh 1805 
    """
3064 chandransh 1806 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1807 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1808 
    used for all other orders as well.
1809 
    Throws an exception if no such order exists.
3431 rajveer 1810 
 
759 chandransh 1811 
    Parameters:
3064 chandransh 1812 
     - orderId
759 chandransh 1813 
    """
3064 chandransh 1814 
    self.send_verifyOrder(orderId)
1815 
    return self.recv_verifyOrder()
759 chandransh 1816 
 
3064 chandransh 1817 
  def send_verifyOrder(self, orderId):
1818 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1819 
    args = verifyOrder_args()
1820 
    args.orderId = orderId
759 chandransh 1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
3064 chandransh 1825 
  def recv_verifyOrder(self, ):
759 chandransh 1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
3064 chandransh 1832 
    result = verifyOrder_result()
759 chandransh 1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
3431 rajveer 1835 
    if result.success is not None:
759 chandransh 1836 
      return result.success
3431 rajveer 1837 
    if result.ex is not None:
759 chandransh 1838 
      raise result.ex
3064 chandransh 1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1840 
 
3064 chandransh 1841 
  def acceptOrder(self, orderId):
1113 chandransh 1842 
    """
3064 chandransh 1843 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1844 
    given order is not a COD order, it also captures the payment if the same has
1845 
    not been captured.
1846 
    Throws an exception if no such order exists.
3431 rajveer 1847 
 
1113 chandransh 1848 
    Parameters:
3064 chandransh 1849 
     - orderId
1113 chandransh 1850 
    """
3064 chandransh 1851 
    self.send_acceptOrder(orderId)
1852 
    return self.recv_acceptOrder()
1113 chandransh 1853 
 
3064 chandransh 1854 
  def send_acceptOrder(self, orderId):
1855 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1856 
    args = acceptOrder_args()
1857 
    args.orderId = orderId
1113 chandransh 1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
3064 chandransh 1862 
  def recv_acceptOrder(self, ):
1113 chandransh 1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
3064 chandransh 1869 
    result = acceptOrder_result()
1113 chandransh 1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
3431 rajveer 1872 
    if result.success is not None:
1113 chandransh 1873 
      return result.success
3431 rajveer 1874 
    if result.ex is not None:
1113 chandransh 1875 
      raise result.ex
3064 chandransh 1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1877 
 
4283 anupam.sin 1878 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1879 
    """
3064 chandransh 1880 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1881 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1882 
    the IMEI no. if a -1 is supplied.
1883 
    Also, it generates an invoice number for the order, marks the order as
1884 
    BILLED and sets the billing timestamp.
1885 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1886 
 
1135 chandransh 1887 
    Parameters:
3064 chandransh 1888 
     - orderId
1889 
     - invoice_number
4283 anupam.sin 1890 
     - imeiNumber
1891 
     - itemNumber
3064 chandransh 1892 
     - billed_by
4264 rajveer 1893 
     - jacketNumber
4283 anupam.sin 1894 
     - billingType
1895 
     - vendorId
1135 chandransh 1896 
    """
4283 anupam.sin 1897 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1898 
    return self.recv_addBillingDetails()
1135 chandransh 1899 
 
4283 anupam.sin 1900 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1901 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1902 
    args = addBillingDetails_args()
1903 
    args.orderId = orderId
1904 
    args.invoice_number = invoice_number
4283 anupam.sin 1905 
    args.imeiNumber = imeiNumber
1906 
    args.itemNumber = itemNumber
3064 chandransh 1907 
    args.billed_by = billed_by
4264 rajveer 1908 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1909 
    args.billingType = billingType
1910 
    args.vendorId = vendorId
1135 chandransh 1911 
    args.write(self._oprot)
1912 
    self._oprot.writeMessageEnd()
1913 
    self._oprot.trans.flush()
1914 
 
3064 chandransh 1915 
  def recv_addBillingDetails(self, ):
1135 chandransh 1916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1917 
    if mtype == TMessageType.EXCEPTION:
1918 
      x = TApplicationException()
1919 
      x.read(self._iprot)
1920 
      self._iprot.readMessageEnd()
1921 
      raise x
3064 chandransh 1922 
    result = addBillingDetails_result()
1135 chandransh 1923 
    result.read(self._iprot)
1924 
    self._iprot.readMessageEnd()
3431 rajveer 1925 
    if result.success is not None:
3064 chandransh 1926 
      return result.success
3431 rajveer 1927 
    if result.ex is not None:
1135 chandransh 1928 
      raise result.ex
3064 chandransh 1929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1930 
 
3064 chandransh 1931 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1932 
    """
3064 chandransh 1933 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1934 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1935 
 
1408 ankur.sing 1936 
    Parameters:
3064 chandransh 1937 
     - warehouseId
1408 ankur.sing 1938 
     - providerId
3064 chandransh 1939 
     - cod
1408 ankur.sing 1940 
    """
3064 chandransh 1941 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1942 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1943 
 
3064 chandransh 1944 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1945 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1946 
    args = markOrdersAsManifested_args()
1947 
    args.warehouseId = warehouseId
1408 ankur.sing 1948 
    args.providerId = providerId
3064 chandransh 1949 
    args.cod = cod
1408 ankur.sing 1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
3064 chandransh 1954 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
3064 chandransh 1961 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
3431 rajveer 1964 
    if result.success is not None:
1408 ankur.sing 1965 
      return result.success
3431 rajveer 1966 
    if result.ex is not None:
3064 chandransh 1967 
      raise result.ex
1968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1969 
 
3064 chandransh 1970 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1971 
    """
3064 chandransh 1972 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1973 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1974 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1975 
 
94 ashish 1976 
    Parameters:
3064 chandransh 1977 
     - providerId
1978 
     - pickupDetails
304 ashish 1979 
    """
3064 chandransh 1980 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1981 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1982 
 
3064 chandransh 1983 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1984 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1985 
    args = markOrdersAsPickedUp_args()
1986 
    args.providerId = providerId
1987 
    args.pickupDetails = pickupDetails
304 ashish 1988 
    args.write(self._oprot)
1989 
    self._oprot.writeMessageEnd()
1990 
    self._oprot.trans.flush()
1991 
 
3064 chandransh 1992 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1994 
    if mtype == TMessageType.EXCEPTION:
1995 
      x = TApplicationException()
1996 
      x.read(self._iprot)
1997 
      self._iprot.readMessageEnd()
1998 
      raise x
3064 chandransh 1999 
    result = markOrdersAsPickedUp_result()
304 ashish 2000 
    result.read(self._iprot)
2001 
    self._iprot.readMessageEnd()
3431 rajveer 2002 
    if result.success is not None:
304 ashish 2003 
      return result.success
3431 rajveer 2004 
    if result.ex is not None:
3064 chandransh 2005 
      raise result.ex
2006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2007 
 
3064 chandransh 2008 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2009 
    """
3064 chandransh 2010 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2011 
    the name of the receiver.
2012 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2013 
 
304 ashish 2014 
    Parameters:
3064 chandransh 2015 
     - providerId
2016 
     - deliveredOrders
304 ashish 2017 
    """
3064 chandransh 2018 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2019 
    self.recv_markOrdersAsDelivered()
304 ashish 2020 
 
3064 chandransh 2021 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2022 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2023 
    args = markOrdersAsDelivered_args()
2024 
    args.providerId = providerId
2025 
    args.deliveredOrders = deliveredOrders
304 ashish 2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
3064 chandransh 2030 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
3064 chandransh 2037 
    result = markOrdersAsDelivered_result()
304 ashish 2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
3431 rajveer 2040 
    if result.ex is not None:
3064 chandransh 2041 
      raise result.ex
304 ashish 2042 
    return
2043 
 
3064 chandransh 2044 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2045 
    """
3064 chandransh 2046 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2047 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2048 
 
3064 chandransh 2049 
    Parameters:
2050 
     - providerId
2051 
     - returnedOrders
1596 ankur.sing 2052 
    """
3064 chandransh 2053 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2054 
    self.recv_markOrdersAsFailed()
304 ashish 2055 
 
3064 chandransh 2056 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2057 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2058 
    args = markOrdersAsFailed_args()
2059 
    args.providerId = providerId
2060 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
3064 chandransh 2065 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
3064 chandransh 2072 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
3431 rajveer 2075 
    if result.ex is not None:
3064 chandransh 2076 
      raise result.ex
2077 
    return
1596 ankur.sing 2078 
 
3064 chandransh 2079 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2080 
    """
3064 chandransh 2081 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2082 
 
3064 chandransh 2083 
    Parameters:
2084 
     - providerId
2085 
     - undeliveredOrders
1627 ankur.sing 2086 
    """
3064 chandransh 2087 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2088 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2089 
 
3064 chandransh 2090 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2091 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2092 
    args = updateNonDeliveryReason_args()
2093 
    args.providerId = providerId
2094 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
3064 chandransh 2099 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
3064 chandransh 2106 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
3431 rajveer 2109 
    if result.ex is not None:
3064 chandransh 2110 
      raise result.ex
2111 
    return
1627 ankur.sing 2112 
 
3064 chandransh 2113 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2114 
    """
3064 chandransh 2115 
    Returns the list of orders whose delivery time has passed but have not been
2116 
    delivered yet for the given provider and warehouse. To get a complete list of
2117 
    undelivered orders, pass them as -1.
2118 
    Returns an empty list if no such orders exist.
3431 rajveer 2119 
 
1886 ankur.sing 2120 
    Parameters:
3064 chandransh 2121 
     - providerId
2122 
     - warehouseId
1886 ankur.sing 2123 
    """
3064 chandransh 2124 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2125 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2126 
 
3064 chandransh 2127 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2128 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2129 
    args = getUndeliveredOrders_args()
2130 
    args.providerId = providerId
2131 
    args.warehouseId = warehouseId
1886 ankur.sing 2132 
    args.write(self._oprot)
2133 
    self._oprot.writeMessageEnd()
2134 
    self._oprot.trans.flush()
2135 
 
3064 chandransh 2136 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2138 
    if mtype == TMessageType.EXCEPTION:
2139 
      x = TApplicationException()
2140 
      x.read(self._iprot)
2141 
      self._iprot.readMessageEnd()
2142 
      raise x
3064 chandransh 2143 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2144 
    result.read(self._iprot)
2145 
    self._iprot.readMessageEnd()
3431 rajveer 2146 
    if result.success is not None:
1886 ankur.sing 2147 
      return result.success
3064 chandransh 2148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2149 
 
2536 chandransh 2150 
  def toggleDOAFlag(self, orderId):
2151 
    """
2152 
    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.
2153 
    Returns the final flag status.
2154 
    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 2155 
 
2536 chandransh 2156 
    Parameters:
2157 
     - orderId
2158 
    """
2159 
    self.send_toggleDOAFlag(orderId)
2160 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2161 
 
2536 chandransh 2162 
  def send_toggleDOAFlag(self, orderId):
2163 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2164 
    args = toggleDOAFlag_args()
2165 
    args.orderId = orderId
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_toggleDOAFlag(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = toggleDOAFlag_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
2536 chandransh 2181 
      return result.success
3431 rajveer 2182 
    if result.ex is not None:
2536 chandransh 2183 
      raise result.ex
2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2185 
 
2186 
  def requestPickupNumber(self, orderId):
2187 
    """
2188 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2189 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2190 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2191 
    For any other status, it returns false.
2192 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2193 
 
2536 chandransh 2194 
    Parameters:
2195 
     - orderId
2196 
    """
2197 
    self.send_requestPickupNumber(orderId)
2198 
    return self.recv_requestPickupNumber()
2199 
 
2200 
  def send_requestPickupNumber(self, orderId):
2201 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2202 
    args = requestPickupNumber_args()
2203 
    args.orderId = orderId
2204 
    args.write(self._oprot)
2205 
    self._oprot.writeMessageEnd()
2206 
    self._oprot.trans.flush()
2207 
 
2208 
  def recv_requestPickupNumber(self, ):
2209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2210 
    if mtype == TMessageType.EXCEPTION:
2211 
      x = TApplicationException()
2212 
      x.read(self._iprot)
2213 
      self._iprot.readMessageEnd()
2214 
      raise x
2215 
    result = requestPickupNumber_result()
2216 
    result.read(self._iprot)
2217 
    self._iprot.readMessageEnd()
3431 rajveer 2218 
    if result.success is not None:
2536 chandransh 2219 
      return result.success
3431 rajveer 2220 
    if result.ex is not None:
2536 chandransh 2221 
      raise result.ex
2222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2223 
 
2224 
  def authorizePickup(self, orderId, pickupNumber):
2225 
    """
2226 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2227 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2228 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2229 
    	3. Returns true
2591 chandransh 2230 
    If the order is in any other status, it returns false.
2536 chandransh 2231 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2232 
 
2536 chandransh 2233 
    Parameters:
2234 
     - orderId
2235 
     - pickupNumber
2236 
    """
2237 
    self.send_authorizePickup(orderId, pickupNumber)
2238 
    return self.recv_authorizePickup()
2239 
 
2240 
  def send_authorizePickup(self, orderId, pickupNumber):
2241 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2242 
    args = authorizePickup_args()
2243 
    args.orderId = orderId
2244 
    args.pickupNumber = pickupNumber
2245 
    args.write(self._oprot)
2246 
    self._oprot.writeMessageEnd()
2247 
    self._oprot.trans.flush()
2248 
 
2249 
  def recv_authorizePickup(self, ):
2250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2251 
    if mtype == TMessageType.EXCEPTION:
2252 
      x = TApplicationException()
2253 
      x.read(self._iprot)
2254 
      self._iprot.readMessageEnd()
2255 
      raise x
2256 
    result = authorizePickup_result()
2257 
    result.read(self._iprot)
2258 
    self._iprot.readMessageEnd()
3431 rajveer 2259 
    if result.success is not None:
2536 chandransh 2260 
      return result.success
3431 rajveer 2261 
    if result.ex is not None:
2536 chandransh 2262 
      raise result.ex
2263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2264 
 
2764 chandransh 2265 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2266 
    """
2267 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2268 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2269 
 
2764 chandransh 2270 
    Parameters:
2271 
     - providerId
2272 
     - pickupDetails
2273 
    """
2274 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2275 
    return self.recv_markDoasAsPickedUp()
2276 
 
2277 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2278 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2279 
    args = markDoasAsPickedUp_args()
2280 
    args.providerId = providerId
2281 
    args.pickupDetails = pickupDetails
2282 
    args.write(self._oprot)
2283 
    self._oprot.writeMessageEnd()
2284 
    self._oprot.trans.flush()
2285 
 
2286 
  def recv_markDoasAsPickedUp(self, ):
2287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2288 
    if mtype == TMessageType.EXCEPTION:
2289 
      x = TApplicationException()
2290 
      x.read(self._iprot)
2291 
      self._iprot.readMessageEnd()
2292 
      raise x
2293 
    result = markDoasAsPickedUp_result()
2294 
    result.read(self._iprot)
2295 
    self._iprot.readMessageEnd()
3431 rajveer 2296 
    if result.success is not None:
2764 chandransh 2297 
      return result.success
2298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2299 
 
2616 chandransh 2300 
  def receiveReturn(self, orderId):
2591 chandransh 2301 
    """
2599 chandransh 2302 
    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 2303 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2304 
    If the order is in any other state, it returns false.
2305 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2306 
 
2591 chandransh 2307 
    Parameters:
2308 
     - orderId
2309 
    """
2616 chandransh 2310 
    self.send_receiveReturn(orderId)
2311 
    return self.recv_receiveReturn()
2536 chandransh 2312 
 
2616 chandransh 2313 
  def send_receiveReturn(self, orderId):
2314 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2315 
    args = receiveReturn_args()
2591 chandransh 2316 
    args.orderId = orderId
2317 
    args.write(self._oprot)
2318 
    self._oprot.writeMessageEnd()
2319 
    self._oprot.trans.flush()
2320 
 
2616 chandransh 2321 
  def recv_receiveReturn(self, ):
2591 chandransh 2322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2323 
    if mtype == TMessageType.EXCEPTION:
2324 
      x = TApplicationException()
2325 
      x.read(self._iprot)
2326 
      self._iprot.readMessageEnd()
2327 
      raise x
2616 chandransh 2328 
    result = receiveReturn_result()
2591 chandransh 2329 
    result.read(self._iprot)
2330 
    self._iprot.readMessageEnd()
3431 rajveer 2331 
    if result.success is not None:
2591 chandransh 2332 
      return result.success
3431 rajveer 2333 
    if result.ex is not None:
2591 chandransh 2334 
      raise result.ex
2616 chandransh 2335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2336 
 
2337 
  def validateDoa(self, orderId, isValid):
2338 
    """
2599 chandransh 2339 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2340 
    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 2341 
    If the order is in any other state, it returns false.
2342 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2343 
 
2591 chandransh 2344 
    Parameters:
2345 
     - orderId
2346 
     - isValid
2347 
    """
2348 
    self.send_validateDoa(orderId, isValid)
2349 
    return self.recv_validateDoa()
2350 
 
2351 
  def send_validateDoa(self, orderId, isValid):
2352 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2353 
    args = validateDoa_args()
2354 
    args.orderId = orderId
2355 
    args.isValid = isValid
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
2360 
  def recv_validateDoa(self, ):
2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
2367 
    result = validateDoa_result()
2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
3431 rajveer 2370 
    if result.success is not None:
2591 chandransh 2371 
      return result.success
3431 rajveer 2372 
    if result.ex is not None:
2591 chandransh 2373 
      raise result.ex
2374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2375 
 
2616 chandransh 2376 
  def reshipOrder(self, orderId):
2377 
    """
2378 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2379 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2380 
    	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.
2381 
 
2382 
    If the order is in DOA_CERT_VALID state, it does the following:
2383 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2384 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2385 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2386 
 
2616 chandransh 2387 
    Returns the id of the newly created order.
3431 rajveer 2388 
 
2616 chandransh 2389 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2390 
 
2616 chandransh 2391 
    Parameters:
2392 
     - orderId
2393 
    """
2394 
    self.send_reshipOrder(orderId)
2395 
    return self.recv_reshipOrder()
2591 chandransh 2396 
 
2616 chandransh 2397 
  def send_reshipOrder(self, orderId):
2398 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2399 
    args = reshipOrder_args()
2400 
    args.orderId = orderId
2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_reshipOrder(self, ):
2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
2412 
    result = reshipOrder_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
3431 rajveer 2415 
    if result.success is not None:
2616 chandransh 2416 
      return result.success
3431 rajveer 2417 
    if result.ex is not None:
2616 chandransh 2418 
      raise result.ex
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2420 
 
3226 chandransh 2421 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2422 
    """
2423 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2424 
    	1. Creates a refund request for batch processing.
2425 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2426 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2427 
 
2616 chandransh 2428 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2429 
    	1. Creates a refund request for batch processing.
3226 chandransh 2430 
    	2. Cancels the reservation of the item in the warehouse.
2431 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2432 
 
3226 chandransh 2433 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2434 
    	1. Cancels the reservation of the item in the warehouse.
2435 
    	2. Marks the current order as CANCELED.
2436 
 
2437 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2438 
 
2616 chandransh 2439 
    Returns True if it is successful, False otherwise.
3431 rajveer 2440 
 
2616 chandransh 2441 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2442 
 
2616 chandransh 2443 
    Parameters:
2444 
     - orderId
3226 chandransh 2445 
     - refundedBy
2446 
     - reason
2616 chandransh 2447 
    """
3226 chandransh 2448 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2449 
    return self.recv_refundOrder()
2450 
 
3226 chandransh 2451 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2452 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2453 
    args = refundOrder_args()
2454 
    args.orderId = orderId
3226 chandransh 2455 
    args.refundedBy = refundedBy
2456 
    args.reason = reason
2616 chandransh 2457 
    args.write(self._oprot)
2458 
    self._oprot.writeMessageEnd()
2459 
    self._oprot.trans.flush()
2460 
 
2461 
  def recv_refundOrder(self, ):
2462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2463 
    if mtype == TMessageType.EXCEPTION:
2464 
      x = TApplicationException()
2465 
      x.read(self._iprot)
2466 
      self._iprot.readMessageEnd()
2467 
      raise x
2468 
    result = refundOrder_result()
2469 
    result.read(self._iprot)
2470 
    self._iprot.readMessageEnd()
3431 rajveer 2471 
    if result.success is not None:
2616 chandransh 2472 
      return result.success
3431 rajveer 2473 
    if result.ex is not None:
2616 chandransh 2474 
      raise result.ex
2475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2476 
 
2690 chandransh 2477 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2478 
    """
2479 
    Get all return orders created between the from and to dates for the given warehouse.
2480 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2481 
 
2690 chandransh 2482 
    Parameters:
2483 
     - warehouseId
2484 
     - fromDate
2485 
     - toDate
2486 
    """
2487 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2488 
    return self.recv_getReturnOrders()
2616 chandransh 2489 
 
2690 chandransh 2490 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2491 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2492 
    args = getReturnOrders_args()
2493 
    args.warehouseId = warehouseId
2494 
    args.fromDate = fromDate
2495 
    args.toDate = toDate
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_getReturnOrders(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = getReturnOrders_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
3431 rajveer 2510 
    if result.success is not None:
2690 chandransh 2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2513 
 
2700 chandransh 2514 
  def getReturnOrder(self, id):
2515 
    """
2516 
    Returns the ReturnOrder corresponding to the given id.
2517 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2518 
 
2700 chandransh 2519 
    Parameters:
2520 
     - id
2521 
    """
2522 
    self.send_getReturnOrder(id)
2523 
    return self.recv_getReturnOrder()
2524 
 
2525 
  def send_getReturnOrder(self, id):
2526 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2527 
    args = getReturnOrder_args()
2528 
    args.id = id
2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
2533 
  def recv_getReturnOrder(self, ):
2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
2540 
    result = getReturnOrder_result()
2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
3431 rajveer 2543 
    if result.success is not None:
2700 chandransh 2544 
      return result.success
3431 rajveer 2545 
    if result.ex is not None:
2700 chandransh 2546 
      raise result.ex
2547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2548 
 
2690 chandransh 2549 
  def processReturn(self, returnOrderId):
2550 
    """
2551 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2552 
 
2690 chandransh 2553 
    Parameters:
2554 
     - returnOrderId
2555 
    """
2556 
    self.send_processReturn(returnOrderId)
2557 
    self.recv_processReturn()
2558 
 
2559 
  def send_processReturn(self, returnOrderId):
2560 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2561 
    args = processReturn_args()
2562 
    args.returnOrderId = returnOrderId
2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
2567 
  def recv_processReturn(self, ):
2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
2574 
    result = processReturn_result()
2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
3431 rajveer 2577 
    if result.ex is not None:
2690 chandransh 2578 
      raise result.ex
2579 
    return
2580 
 
2819 chandransh 2581 
  def createPurchaseOrder(self, warehouseId):
2582 
    """
2583 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2584 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2585 
 
2819 chandransh 2586 
    Parameters:
2587 
     - warehouseId
2588 
    """
2589 
    self.send_createPurchaseOrder(warehouseId)
2590 
    return self.recv_createPurchaseOrder()
2690 chandransh 2591 
 
2819 chandransh 2592 
  def send_createPurchaseOrder(self, warehouseId):
2593 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2594 
    args = createPurchaseOrder_args()
2595 
    args.warehouseId = warehouseId
2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_createPurchaseOrder(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = createPurchaseOrder_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
3431 rajveer 2610 
    if result.success is not None:
2819 chandransh 2611 
      return result.success
3431 rajveer 2612 
    if result.ex is not None:
2819 chandransh 2613 
      raise result.ex
2614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2615 
 
3451 chandransh 2616 
  def updateWeight(self, orderId, weight):
2617 
    """
2618 
    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 2619 
 
3451 chandransh 2620 
    Parameters:
2621 
     - orderId
2622 
     - weight
2623 
    """
2624 
    self.send_updateWeight(orderId, weight)
2625 
    return self.recv_updateWeight()
2626 
 
2627 
  def send_updateWeight(self, orderId, weight):
2628 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2629 
    args = updateWeight_args()
2630 
    args.orderId = orderId
2631 
    args.weight = weight
2632 
    args.write(self._oprot)
2633 
    self._oprot.writeMessageEnd()
2634 
    self._oprot.trans.flush()
2635 
 
2636 
  def recv_updateWeight(self, ):
2637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2638 
    if mtype == TMessageType.EXCEPTION:
2639 
      x = TApplicationException()
2640 
      x.read(self._iprot)
2641 
      self._iprot.readMessageEnd()
2642 
      raise x
2643 
    result = updateWeight_result()
2644 
    result.read(self._iprot)
2645 
    self._iprot.readMessageEnd()
2646 
    if result.success is not None:
2647 
      return result.success
2648 
    if result.ex is not None:
2649 
      raise result.ex
2650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2651 
 
3469 chandransh 2652 
  def changeItem(self, orderId, itemId):
2653 
    """
2654 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2655 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2656 
 
3469 chandransh 2657 
    Parameters:
2658 
     - orderId
2659 
     - itemId
2660 
    """
2661 
    self.send_changeItem(orderId, itemId)
2662 
    return self.recv_changeItem()
2663 
 
2664 
  def send_changeItem(self, orderId, itemId):
2665 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2666 
    args = changeItem_args()
2667 
    args.orderId = orderId
2668 
    args.itemId = itemId
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_changeItem(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = changeItem_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    if result.success is not None:
2684 
      return result.success
2685 
    if result.ex is not None:
2686 
      raise result.ex
2687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2688 
 
2689 
  def shiftToWarehouse(self, orderId, warehouseId):
2690 
    """
2691 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2692 
 
2693 
    Parameters:
2694 
     - orderId
2695 
     - warehouseId
2696 
    """
2697 
    self.send_shiftToWarehouse(orderId, warehouseId)
2698 
    return self.recv_shiftToWarehouse()
2699 
 
2700 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2701 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2702 
    args = shiftToWarehouse_args()
2703 
    args.orderId = orderId
2704 
    args.warehouseId = warehouseId
2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2709 
  def recv_shiftToWarehouse(self, ):
2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2716 
    result = shiftToWarehouse_result()
2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
2719 
    if result.success is not None:
2720 
      return result.success
2721 
    if result.ex is not None:
2722 
      raise result.ex
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2724 
 
3986 chandransh 2725 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2726 
    """
2727 
    Adds the given delay reason to the given order.
3986 chandransh 2728 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2729 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2730 
 
3553 chandransh 2731 
    Parameters:
2732 
     - orderId
2733 
     - delayReason
3986 chandransh 2734 
     - furtherDelay
3553 chandransh 2735 
    """
3986 chandransh 2736 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2737 
    return self.recv_addDelayReason()
2738 
 
3986 chandransh 2739 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2740 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2741 
    args = addDelayReason_args()
2742 
    args.orderId = orderId
2743 
    args.delayReason = delayReason
3986 chandransh 2744 
    args.furtherDelay = furtherDelay
3553 chandransh 2745 
    args.write(self._oprot)
2746 
    self._oprot.writeMessageEnd()
2747 
    self._oprot.trans.flush()
2748 
 
2749 
  def recv_addDelayReason(self, ):
2750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2751 
    if mtype == TMessageType.EXCEPTION:
2752 
      x = TApplicationException()
2753 
      x.read(self._iprot)
2754 
      self._iprot.readMessageEnd()
2755 
      raise x
2756 
    result = addDelayReason_result()
2757 
    result.read(self._iprot)
2758 
    self._iprot.readMessageEnd()
2759 
    if result.success is not None:
2760 
      return result.success
2761 
    if result.ex is not None:
2762 
      raise result.ex
2763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2764 
 
3956 chandransh 2765 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2766 
    """
2767 
    Marks the COD orders with given AWB nos. as having been processed.
2768 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2769 
 
3956 chandransh 2770 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2771 
    1. There is no order corresponding to an AWB number.
2772 
    2. The captured amount for a payment exceeds the total payment.
2773 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2774 
 
2775 
    Parameters:
2776 
     - collectedAmountMap
2777 
     - xferBy
2778 
     - xferTxnId
2779 
     - xferDate
2780 
    """
2781 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2782 
    return self.recv_reconcileCodCollection()
2783 
 
2784 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2785 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2786 
    args = reconcileCodCollection_args()
2787 
    args.collectedAmountMap = collectedAmountMap
2788 
    args.xferBy = xferBy
2789 
    args.xferTxnId = xferTxnId
2790 
    args.xferDate = xferDate
2791 
    args.write(self._oprot)
2792 
    self._oprot.writeMessageEnd()
2793 
    self._oprot.trans.flush()
2794 
 
2795 
  def recv_reconcileCodCollection(self, ):
2796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2797 
    if mtype == TMessageType.EXCEPTION:
2798 
      x = TApplicationException()
2799 
      x.read(self._iprot)
2800 
      self._iprot.readMessageEnd()
2801 
      raise x
2802 
    result = reconcileCodCollection_result()
2803 
    result.read(self._iprot)
2804 
    self._iprot.readMessageEnd()
2805 
    if result.success is not None:
2806 
      return result.success
2807 
    if result.ex is not None:
2808 
      raise result.ex
2809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2810 
 
4008 mandeep.dh 2811 
  def getTransactionsRequiringExtraProcessing(self, category):
2812 
    """
4065 mandeep.dh 2813 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2814 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2815 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2816 
 
4008 mandeep.dh 2817 
    Parameters:
2818 
     - category
2819 
    """
2820 
    self.send_getTransactionsRequiringExtraProcessing(category)
2821 
    return self.recv_getTransactionsRequiringExtraProcessing()
2822 
 
2823 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2824 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2825 
    args = getTransactionsRequiringExtraProcessing_args()
2826 
    args.category = category
2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
2831 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
2838 
    result = getTransactionsRequiringExtraProcessing_result()
2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.success is not None:
2842 
      return result.success
2843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2844 
 
2845 
  def markTransactionAsProcessed(self, transactionId, category):
2846 
    """
2847 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2848 
    It essentially deletes the transaction id record for a particular
2849 
    processing type category (if present) from DB.
2850 
    This is currently used by CRM application.
4008 mandeep.dh 2851 
 
2852 
    Parameters:
2853 
     - transactionId
2854 
     - category
2855 
    """
2856 
    self.send_markTransactionAsProcessed(transactionId, category)
2857 
    self.recv_markTransactionAsProcessed()
2858 
 
2859 
  def send_markTransactionAsProcessed(self, transactionId, category):
2860 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2861 
    args = markTransactionAsProcessed_args()
2862 
    args.transactionId = transactionId
2863 
    args.category = category
2864 
    args.write(self._oprot)
2865 
    self._oprot.writeMessageEnd()
2866 
    self._oprot.trans.flush()
2867 
 
2868 
  def recv_markTransactionAsProcessed(self, ):
2869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2870 
    if mtype == TMessageType.EXCEPTION:
2871 
      x = TApplicationException()
2872 
      x.read(self._iprot)
2873 
      self._iprot.readMessageEnd()
2874 
      raise x
2875 
    result = markTransactionAsProcessed_result()
2876 
    result.read(self._iprot)
2877 
    self._iprot.readMessageEnd()
2878 
    return
2879 
 
4018 chandransh 2880 
  def getItemWiseRiskyOrdersCount(self, ):
2881 
    """
2882 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2883 
    is defined as one whose shipping date is about to expire.
2884 
    """
2885 
    self.send_getItemWiseRiskyOrdersCount()
2886 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2887 
 
4018 chandransh 2888 
  def send_getItemWiseRiskyOrdersCount(self, ):
2889 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2890 
    args = getItemWiseRiskyOrdersCount_args()
2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = getItemWiseRiskyOrdersCount_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2908 
 
4295 varun.gupt 2909 
  def getOrdersForItemIds(self, itemIds):
2910 
    """
2911 
    Returns a list of all orders which have items with given id
2912 
 
2913 
    Parameters:
2914 
     - itemIds
2915 
    """
2916 
    self.send_getOrdersForItemIds(itemIds)
2917 
    return self.recv_getOrdersForItemIds()
2918 
 
2919 
  def send_getOrdersForItemIds(self, itemIds):
2920 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2921 
    args = getOrdersForItemIds_args()
2922 
    args.itemIds = itemIds
2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
2926 
 
2927 
  def recv_getOrdersForItemIds(self, ):
2928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2929 
    if mtype == TMessageType.EXCEPTION:
2930 
      x = TApplicationException()
2931 
      x.read(self._iprot)
2932 
      self._iprot.readMessageEnd()
2933 
      raise x
2934 
    result = getOrdersForItemIds_result()
2935 
    result.read(self._iprot)
2936 
    self._iprot.readMessageEnd()
2937 
    if result.success is not None:
2938 
      return result.success
2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2940 
 
4247 rajveer 2941 
  def markOrderCancellationRequestReceived(self, orderId):
2942 
    """
2943 
    Mark order as cancellation request received. If customer sends request of cancellation of
2944 
    a particular order, this method will be called. It will just change status of the order
2945 
    depending on its current status. It also records the previous status, so that we can move
2946 
    back to that status if cancellation request is denied.
4018 chandransh 2947 
 
4247 rajveer 2948 
    Parameters:
2949 
     - orderId
2950 
    """
2951 
    self.send_markOrderCancellationRequestReceived(orderId)
2952 
    self.recv_markOrderCancellationRequestReceived()
2953 
 
2954 
  def send_markOrderCancellationRequestReceived(self, orderId):
2955 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2956 
    args = markOrderCancellationRequestReceived_args()
2957 
    args.orderId = orderId
2958 
    args.write(self._oprot)
2959 
    self._oprot.writeMessageEnd()
2960 
    self._oprot.trans.flush()
2961 
 
2962 
  def recv_markOrderCancellationRequestReceived(self, ):
2963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2964 
    if mtype == TMessageType.EXCEPTION:
2965 
      x = TApplicationException()
2966 
      x.read(self._iprot)
2967 
      self._iprot.readMessageEnd()
2968 
      raise x
2969 
    result = markOrderCancellationRequestReceived_result()
2970 
    result.read(self._iprot)
2971 
    self._iprot.readMessageEnd()
2972 
    if result.ex is not None:
2973 
      raise result.ex
2974 
    return
2975 
 
2976 
  def markOrderCancellationRequestConfirmed(self, orderId):
2977 
    """
2978 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2979 
    cancellation request confirmed. After this OM will be able to cancel the order.
2980 
 
2981 
    Parameters:
2982 
     - orderId
2983 
    """
2984 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2985 
    self.recv_markOrderCancellationRequestConfirmed()
2986 
 
2987 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2988 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2989 
    args = markOrderCancellationRequestConfirmed_args()
2990 
    args.orderId = orderId
2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
2995 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
3002 
    result = markOrderCancellationRequestConfirmed_result()
3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3005 
    if result.ex is not None:
3006 
      raise result.ex
3007 
    return
3008 
 
3009 
  def markOrderCancellationRequestDenied(self, orderId):
3010 
    """
3011 
    If we decide to not to cancel order, we will move the order ro previous status.
3012 
 
3013 
    Parameters:
3014 
     - orderId
3015 
    """
3016 
    self.send_markOrderCancellationRequestDenied(orderId)
3017 
    self.recv_markOrderCancellationRequestDenied()
3018 
 
3019 
  def send_markOrderCancellationRequestDenied(self, orderId):
3020 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3021 
    args = markOrderCancellationRequestDenied_args()
3022 
    args.orderId = orderId
3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3027 
  def recv_markOrderCancellationRequestDenied(self, ):
3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3034 
    result = markOrderCancellationRequestDenied_result()
3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
3037 
    if result.ex is not None:
3038 
      raise result.ex
3039 
    return
3040 
 
4258 rajveer 3041 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3042 
    """
4258 rajveer 3043 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3044 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3045 
 
3046 
    Parameters:
4258 rajveer 3047 
     - transactionId
4247 rajveer 3048 
    """
4258 rajveer 3049 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3050 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3051 
 
4258 rajveer 3052 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3053 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3054 
    args = markTransactionAsPaymentFlagRemoved_args()
3055 
    args.transactionId = transactionId
4247 rajveer 3056 
    args.write(self._oprot)
3057 
    self._oprot.writeMessageEnd()
3058 
    self._oprot.trans.flush()
3059 
 
4258 rajveer 3060 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3062 
    if mtype == TMessageType.EXCEPTION:
3063 
      x = TApplicationException()
3064 
      x.read(self._iprot)
3065 
      self._iprot.readMessageEnd()
3066 
      raise x
4258 rajveer 3067 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3068 
    result.read(self._iprot)
3069 
    self._iprot.readMessageEnd()
3070 
    if result.ex is not None:
3071 
      raise result.ex
3072 
    return
3073 
 
4259 anupam.sin 3074 
  def refundTransaction(self, transactionId, refundedBy, reason):
3075 
    """
3076 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3077 
    need to be cancelled
4247 rajveer 3078 
 
4259 anupam.sin 3079 
    Parameters:
3080 
     - transactionId
3081 
     - refundedBy
3082 
     - reason
3083 
    """
3084 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3085 
    self.recv_refundTransaction()
3086 
 
3087 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3088 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3089 
    args = refundTransaction_args()
3090 
    args.transactionId = transactionId
3091 
    args.refundedBy = refundedBy
3092 
    args.reason = reason
3093 
    args.write(self._oprot)
3094 
    self._oprot.writeMessageEnd()
3095 
    self._oprot.trans.flush()
3096 
 
3097 
  def recv_refundTransaction(self, ):
3098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3099 
    if mtype == TMessageType.EXCEPTION:
3100 
      x = TApplicationException()
3101 
      x.read(self._iprot)
3102 
      self._iprot.readMessageEnd()
3103 
      raise x
3104 
    result = refundTransaction_result()
3105 
    result.read(self._iprot)
3106 
    self._iprot.readMessageEnd()
3107 
    if result.ex is not None:
3108 
      raise result.ex
3109 
    return
3110 
 
4324 mandeep.dh 3111 
  def updateShipmentAddress(self, orderId, addressId):
3112 
    """
3113 
    Updates shipment address of an order. Delivery and shipping date estimates
3114 
    etc. are also updated here.
3115 
 
3116 
    Throws TransactionServiceException in case address change is not
3117 
    possible due to certain reasons such as new pincode in address is
3118 
    not serviceable etc.
3119 
 
3120 
    Parameters:
3121 
     - orderId
3122 
     - addressId
3123 
    """
3124 
    self.send_updateShipmentAddress(orderId, addressId)
3125 
    self.recv_updateShipmentAddress()
3126 
 
3127 
  def send_updateShipmentAddress(self, orderId, addressId):
3128 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3129 
    args = updateShipmentAddress_args()
3130 
    args.orderId = orderId
3131 
    args.addressId = addressId
3132 
    args.write(self._oprot)
3133 
    self._oprot.writeMessageEnd()
3134 
    self._oprot.trans.flush()
3135 
 
3136 
  def recv_updateShipmentAddress(self, ):
3137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3138 
    if mtype == TMessageType.EXCEPTION:
3139 
      x = TApplicationException()
3140 
      x.read(self._iprot)
3141 
      self._iprot.readMessageEnd()
3142 
      raise x
3143 
    result = updateShipmentAddress_result()
3144 
    result.read(self._iprot)
3145 
    self._iprot.readMessageEnd()
3146 
    if result.ex is not None:
3147 
      raise result.ex
3148 
    return
3149 
 
4285 rajveer 3150 
  def acceptOrdersForItemId(self, itemId, inventory):
3151 
    """
3152 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3153 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3154 
 
4285 rajveer 3155 
    Parameters:
3156 
     - itemId
3157 
     - inventory
3158 
    """
3159 
    self.send_acceptOrdersForItemId(itemId, inventory)
3160 
    return self.recv_acceptOrdersForItemId()
3161 
 
3162 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3163 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3164 
    args = acceptOrdersForItemId_args()
3165 
    args.itemId = itemId
3166 
    args.inventory = inventory
3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3171 
  def recv_acceptOrdersForItemId(self, ):
3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3178 
    result = acceptOrdersForItemId_result()
3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3181 
    if result.success is not None:
3182 
      return result.success
3183 
    if result.ex is not None:
3184 
      raise result.ex
3185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3186 
 
4369 rajveer 3187 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3188 
    """
3189 
    Parameters:
3190 
     - vendorId
3191 
     - itemId
3192 
     - quantity
3193 
     - estimate
4369 rajveer 3194 
     - isReminder
4303 rajveer 3195 
    """
4369 rajveer 3196 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3197 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3198 
 
4369 rajveer 3199 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3200 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3201 
    args = markOrdersAsPORaised_args()
3202 
    args.vendorId = vendorId
3203 
    args.itemId = itemId
3204 
    args.quantity = quantity
3205 
    args.estimate = estimate
4369 rajveer 3206 
    args.isReminder = isReminder
4303 rajveer 3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_markOrdersAsPORaised(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = markOrdersAsPORaised_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.ex is not None:
3222 
      raise result.ex
3223 
    return
3224 
 
4369 rajveer 3225 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3226 
    """
3227 
    Parameters:
3228 
     - vendorId
3229 
     - itemId
3230 
     - quantity
3231 
     - estimate
4369 rajveer 3232 
     - isReminder
4303 rajveer 3233 
    """
4369 rajveer 3234 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3235 
    self.recv_markOrdersAsReversalInitiated()
3236 
 
4369 rajveer 3237 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3238 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3239 
    args = markOrdersAsReversalInitiated_args()
3240 
    args.vendorId = vendorId
3241 
    args.itemId = itemId
3242 
    args.quantity = quantity
3243 
    args.estimate = estimate
4369 rajveer 3244 
    args.isReminder = isReminder
4303 rajveer 3245 
    args.write(self._oprot)
3246 
    self._oprot.writeMessageEnd()
3247 
    self._oprot.trans.flush()
3248 
 
3249 
  def recv_markOrdersAsReversalInitiated(self, ):
3250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3251 
    if mtype == TMessageType.EXCEPTION:
3252 
      x = TApplicationException()
3253 
      x.read(self._iprot)
3254 
      self._iprot.readMessageEnd()
3255 
      raise x
3256 
    result = markOrdersAsReversalInitiated_result()
3257 
    result.read(self._iprot)
3258 
    self._iprot.readMessageEnd()
3259 
    if result.ex is not None:
3260 
      raise result.ex
3261 
    return
3262 
 
4369 rajveer 3263 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3264 
    """
3265 
    Parameters:
3266 
     - vendorId
3267 
     - itemId
3268 
     - quantity
3269 
     - estimate
4369 rajveer 3270 
     - isReminder
4303 rajveer 3271 
    """
4369 rajveer 3272 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3273 
    self.recv_markOrdersAsNotAvailabke()
3274 
 
4369 rajveer 3275 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3276 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3277 
    args = markOrdersAsNotAvailabke_args()
3278 
    args.vendorId = vendorId
3279 
    args.itemId = itemId
3280 
    args.quantity = quantity
3281 
    args.estimate = estimate
4369 rajveer 3282 
    args.isReminder = isReminder
4303 rajveer 3283 
    args.write(self._oprot)
3284 
    self._oprot.writeMessageEnd()
3285 
    self._oprot.trans.flush()
3286 
 
3287 
  def recv_markOrdersAsNotAvailabke(self, ):
3288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3289 
    if mtype == TMessageType.EXCEPTION:
3290 
      x = TApplicationException()
3291 
      x.read(self._iprot)
3292 
      self._iprot.readMessageEnd()
3293 
      raise x
3294 
    result = markOrdersAsNotAvailabke_result()
3295 
    result.read(self._iprot)
3296 
    self._iprot.readMessageEnd()
3297 
    if result.ex is not None:
3298 
      raise result.ex
3299 
    return
3300 
 
4369 rajveer 3301 
  def markOrdersAsTimeout(self, vendorId):
3302 
    """
3303 
    Parameters:
3304 
     - vendorId
3305 
    """
3306 
    self.send_markOrdersAsTimeout(vendorId)
3307 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3308 
 
4369 rajveer 3309 
  def send_markOrdersAsTimeout(self, vendorId):
3310 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3311 
    args = markOrdersAsTimeout_args()
3312 
    args.vendorId = vendorId
3313 
    args.write(self._oprot)
3314 
    self._oprot.writeMessageEnd()
3315 
    self._oprot.trans.flush()
3316 
 
3317 
  def recv_markOrdersAsTimeout(self, ):
3318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3319 
    if mtype == TMessageType.EXCEPTION:
3320 
      x = TApplicationException()
3321 
      x.read(self._iprot)
3322 
      self._iprot.readMessageEnd()
3323 
      raise x
3324 
    result = markOrdersAsTimeout_result()
3325 
    result.read(self._iprot)
3326 
    self._iprot.readMessageEnd()
3327 
    if result.success is not None:
3328 
      return result.success
3329 
    if result.ex is not None:
3330 
      raise result.ex
3331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3332 
 
4386 anupam.sin 3333 
  def getOrderForAwb(self, awb):
3334 
    """
3335 
    Returns the order corresponding to an AWB number
4369 rajveer 3336 
 
4386 anupam.sin 3337 
    Parameters:
3338 
     - awb
3339 
    """
3340 
    self.send_getOrderForAwb(awb)
3341 
    return self.recv_getOrderForAwb()
3342 
 
3343 
  def send_getOrderForAwb(self, awb):
3344 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3345 
    args = getOrderForAwb_args()
3346 
    args.awb = awb
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_getOrderForAwb(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = getOrderForAwb_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3361 
    if result.success is not None:
3362 
      return result.success
3363 
    if result.ex is not None:
3364 
      raise result.ex
3365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3366 
 
3367 
 
3376 rajveer 3368 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3369 
  def __init__(self, handler):
3376 rajveer 3370 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3371 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3372 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3373 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3374 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3375 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3376 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3377 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3378 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3379 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3380 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3381 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3382 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3383 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3384 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3385 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3386 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3387 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3388 
    self._processMap["createOrder"] = Processor.process_createOrder
3389 
    self._processMap["getOrder"] = Processor.process_getOrder
3390 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3391 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3392 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3393 
    self._processMap["addAlert"] = Processor.process_addAlert
3064 chandransh 3394 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3395 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3396 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3397 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3398 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3399 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3400 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3401 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3402 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3403 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3404 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3405 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3406 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3407 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3408 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3409 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3410 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3411 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3412 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3413 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3414 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3415 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3416 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3417 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3418 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3419 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3420 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3421 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3422 
    self._processMap["changeItem"] = Processor.process_changeItem
3423 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3424 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3425 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3426 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3427 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3428 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3429 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3430 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3431 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3432 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3433 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3434 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3435 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3436 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3437 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3438 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3439 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3440 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3441 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3442 
 
3443 
  def process(self, iprot, oprot):
3444 
    (name, type, seqid) = iprot.readMessageBegin()
3445 
    if name not in self._processMap:
3446 
      iprot.skip(TType.STRUCT)
3447 
      iprot.readMessageEnd()
3448 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3449 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3450 
      x.write(oprot)
3451 
      oprot.writeMessageEnd()
3452 
      oprot.trans.flush()
3453 
      return
3454 
    else:
3455 
      self._processMap[name](self, seqid, iprot, oprot)
3456 
    return True
3457 
 
3458 
  def process_createTransaction(self, seqid, iprot, oprot):
3459 
    args = createTransaction_args()
3460 
    args.read(iprot)
3461 
    iprot.readMessageEnd()
3462 
    result = createTransaction_result()
3463 
    try:
132 ashish 3464 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3465 
    except TransactionServiceException, ex:
3466 
      result.ex = ex
3467 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3468 
    result.write(oprot)
3469 
    oprot.writeMessageEnd()
3470 
    oprot.trans.flush()
3471 
 
3472 
  def process_getTransaction(self, seqid, iprot, oprot):
3473 
    args = getTransaction_args()
3474 
    args.read(iprot)
3475 
    iprot.readMessageEnd()
3476 
    result = getTransaction_result()
3477 
    try:
3478 
      result.success = self._handler.getTransaction(args.id)
3479 
    except TransactionServiceException, ex:
3480 
      result.ex = ex
3481 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3482 
    result.write(oprot)
3483 
    oprot.writeMessageEnd()
3484 
    oprot.trans.flush()
3485 
 
3486 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3487 
    args = getTransactionsForCustomer_args()
3488 
    args.read(iprot)
3489 
    iprot.readMessageEnd()
3490 
    result = getTransactionsForCustomer_result()
3491 
    try:
3492 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3493 
    except TransactionServiceException, ex:
3494 
      result.ex = ex
3495 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3496 
    result.write(oprot)
3497 
    oprot.writeMessageEnd()
3498 
    oprot.trans.flush()
3499 
 
132 ashish 3500 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3501 
    args = getTransactionsForShoppingCartId_args()
3502 
    args.read(iprot)
3503 
    iprot.readMessageEnd()
3504 
    result = getTransactionsForShoppingCartId_result()
3505 
    try:
3506 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3507 
    except TransactionServiceException, ex:
3508 
      result.ex = ex
3509 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3510 
    result.write(oprot)
3511 
    oprot.writeMessageEnd()
3512 
    oprot.trans.flush()
3513 
 
94 ashish 3514 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3515 
    args = getTransactionStatus_args()
3516 
    args.read(iprot)
3517 
    iprot.readMessageEnd()
3518 
    result = getTransactionStatus_result()
3519 
    try:
3520 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3521 
    except TransactionServiceException, ex:
3522 
      result.ex = ex
3523 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3524 
    result.write(oprot)
3525 
    oprot.writeMessageEnd()
3526 
    oprot.trans.flush()
3527 
 
3528 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3529 
    args = changeTransactionStatus_args()
3530 
    args.read(iprot)
3531 
    iprot.readMessageEnd()
3532 
    result = changeTransactionStatus_result()
3533 
    try:
3534 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3535 
    except TransactionServiceException, ex:
3536 
      result.ex = ex
3537 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3538 
    result.write(oprot)
3539 
    oprot.writeMessageEnd()
3540 
    oprot.trans.flush()
3541 
 
1398 varun.gupt 3542 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3543 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3544 
    args.read(iprot)
3545 
    iprot.readMessageEnd()
1398 varun.gupt 3546 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3547 
    try:
1398 varun.gupt 3548 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3549 
    except TransactionServiceException, ex:
3550 
      result.ex = ex
1398 varun.gupt 3551 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3552 
    result.write(oprot)
3553 
    oprot.writeMessageEnd()
3554 
    oprot.trans.flush()
3555 
 
483 rajveer 3556 
  def process_getAllOrders(self, seqid, iprot, oprot):
3557 
    args = getAllOrders_args()
94 ashish 3558 
    args.read(iprot)
3559 
    iprot.readMessageEnd()
483 rajveer 3560 
    result = getAllOrders_result()
94 ashish 3561 
    try:
483 rajveer 3562 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3563 
    except TransactionServiceException, ex:
3564 
      result.ex = ex
483 rajveer 3565 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3566 
    result.write(oprot)
3567 
    oprot.writeMessageEnd()
3568 
    oprot.trans.flush()
3569 
 
4133 chandransh 3570 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3571 
    args = getOrdersInBatch_args()
3572 
    args.read(iprot)
3573 
    iprot.readMessageEnd()
3574 
    result = getOrdersInBatch_result()
3575 
    try:
3576 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3577 
    except TransactionServiceException, ex:
3578 
      result.ex = ex
3579 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3580 
    result.write(oprot)
3581 
    oprot.writeMessageEnd()
3582 
    oprot.trans.flush()
3583 
 
3584 
  def process_getOrderCount(self, seqid, iprot, oprot):
3585 
    args = getOrderCount_args()
3586 
    args.read(iprot)
3587 
    iprot.readMessageEnd()
3588 
    result = getOrderCount_result()
3589 
    try:
3590 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3591 
    except TransactionServiceException, ex:
3592 
      result.ex = ex
3593 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3594 
    result.write(oprot)
3595 
    oprot.writeMessageEnd()
3596 
    oprot.trans.flush()
3597 
 
999 varun.gupt 3598 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3599 
    args = getOrdersByBillingDate_args()
3600 
    args.read(iprot)
3601 
    iprot.readMessageEnd()
3602 
    result = getOrdersByBillingDate_result()
3603 
    try:
3604 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3605 
    except TransactionServiceException, ex:
3606 
      result.ex = ex
3607 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3608 
    result.write(oprot)
3609 
    oprot.writeMessageEnd()
3610 
    oprot.trans.flush()
3611 
 
3427 chandransh 3612 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3613 
    args = getOrdersByShippingDate_args()
3614 
    args.read(iprot)
3615 
    iprot.readMessageEnd()
3616 
    result = getOrdersByShippingDate_result()
3617 
    try:
3451 chandransh 3618 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3619 
    except TransactionServiceException, ex:
3620 
      result.ex = ex
3621 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3622 
    result.write(oprot)
3623 
    oprot.writeMessageEnd()
3624 
    oprot.trans.flush()
3625 
 
1382 varun.gupt 3626 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3627 
    args = getReturnableOrdersForCustomer_args()
3628 
    args.read(iprot)
3629 
    iprot.readMessageEnd()
3630 
    result = getReturnableOrdersForCustomer_result()
3631 
    try:
3632 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3633 
    except TransactionServiceException, ex:
3634 
      result.ex = ex
3635 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3636 
    result.write(oprot)
3637 
    oprot.writeMessageEnd()
3638 
    oprot.trans.flush()
3639 
 
3640 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3641 
    args = getCancellableOrdersForCustomer_args()
3642 
    args.read(iprot)
3643 
    iprot.readMessageEnd()
3644 
    result = getCancellableOrdersForCustomer_result()
3645 
    try:
3646 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3647 
    except TransactionServiceException, ex:
3648 
      result.ex = ex
3649 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3650 
    result.write(oprot)
3651 
    oprot.writeMessageEnd()
3652 
    oprot.trans.flush()
3653 
 
483 rajveer 3654 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3655 
    args = changeOrderStatus_args()
94 ashish 3656 
    args.read(iprot)
3657 
    iprot.readMessageEnd()
483 rajveer 3658 
    result = changeOrderStatus_result()
94 ashish 3659 
    try:
483 rajveer 3660 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3661 
    except TransactionServiceException, ex:
3662 
      result.ex = ex
483 rajveer 3663 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3664 
    result.write(oprot)
3665 
    oprot.writeMessageEnd()
3666 
    oprot.trans.flush()
3667 
 
483 rajveer 3668 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3669 
    args = getOrdersForTransaction_args()
94 ashish 3670 
    args.read(iprot)
3671 
    iprot.readMessageEnd()
483 rajveer 3672 
    result = getOrdersForTransaction_result()
94 ashish 3673 
    try:
1528 ankur.sing 3674 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3675 
    except TransactionServiceException, ex:
3676 
      result.ex = ex
483 rajveer 3677 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3678 
    result.write(oprot)
3679 
    oprot.writeMessageEnd()
3680 
    oprot.trans.flush()
3681 
 
483 rajveer 3682 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3683 
    args = getOrdersForCustomer_args()
94 ashish 3684 
    args.read(iprot)
3685 
    iprot.readMessageEnd()
483 rajveer 3686 
    result = getOrdersForCustomer_result()
94 ashish 3687 
    try:
3014 chandransh 3688 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3689 
    except TransactionServiceException, ex:
3690 
      result.ex = ex
483 rajveer 3691 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3692 
    result.write(oprot)
3693 
    oprot.writeMessageEnd()
3694 
    oprot.trans.flush()
3695 
 
483 rajveer 3696 
  def process_createOrder(self, seqid, iprot, oprot):
3697 
    args = createOrder_args()
94 ashish 3698 
    args.read(iprot)
3699 
    iprot.readMessageEnd()
483 rajveer 3700 
    result = createOrder_result()
94 ashish 3701 
    try:
483 rajveer 3702 
      result.success = self._handler.createOrder(args.order)
94 ashish 3703 
    except TransactionServiceException, ex:
3704 
      result.ex = ex
483 rajveer 3705 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3706 
    result.write(oprot)
3707 
    oprot.writeMessageEnd()
3708 
    oprot.trans.flush()
3709 
 
483 rajveer 3710 
  def process_getOrder(self, seqid, iprot, oprot):
3711 
    args = getOrder_args()
94 ashish 3712 
    args.read(iprot)
3713 
    iprot.readMessageEnd()
483 rajveer 3714 
    result = getOrder_result()
94 ashish 3715 
    try:
483 rajveer 3716 
      result.success = self._handler.getOrder(args.id)
94 ashish 3717 
    except TransactionServiceException, ex:
3718 
      result.ex = ex
483 rajveer 3719 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3720 
    result.write(oprot)
3721 
    oprot.writeMessageEnd()
3722 
    oprot.trans.flush()
3723 
 
483 rajveer 3724 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3725 
    args = getLineItemsForOrder_args()
94 ashish 3726 
    args.read(iprot)
3727 
    iprot.readMessageEnd()
483 rajveer 3728 
    result = getLineItemsForOrder_result()
94 ashish 3729 
    try:
483 rajveer 3730 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3731 
    except TransactionServiceException, ex:
3732 
      result.ex = ex
483 rajveer 3733 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3734 
    result.write(oprot)
3735 
    oprot.writeMessageEnd()
3736 
    oprot.trans.flush()
3737 
 
1528 ankur.sing 3738 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3739 
    args = getOrderForCustomer_args()
3740 
    args.read(iprot)
3741 
    iprot.readMessageEnd()
3742 
    result = getOrderForCustomer_result()
3743 
    try:
3744 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3745 
    except TransactionServiceException, ex:
3746 
      result.ex = ex
3747 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3748 
    result.write(oprot)
3749 
    oprot.writeMessageEnd()
3750 
    oprot.trans.flush()
3751 
 
3064 chandransh 3752 
  def process_getAlerts(self, seqid, iprot, oprot):
3753 
    args = getAlerts_args()
3754 
    args.read(iprot)
3755 
    iprot.readMessageEnd()
3756 
    result = getAlerts_result()
4394 rajveer 3757 
    result.success = self._handler.getAlerts(args.type, args.status, args.timestamp)
3064 chandransh 3758 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3759 
    result.write(oprot)
3760 
    oprot.writeMessageEnd()
3761 
    oprot.trans.flush()
3762 
 
4394 rajveer 3763 
  def process_addAlert(self, seqid, iprot, oprot):
3764 
    args = addAlert_args()
3064 chandransh 3765 
    args.read(iprot)
3766 
    iprot.readMessageEnd()
4394 rajveer 3767 
    result = addAlert_result()
3768 
    self._handler.addAlert(args.type, args.description)
3769 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 3770 
    result.write(oprot)
3771 
    oprot.writeMessageEnd()
3772 
    oprot.trans.flush()
3773 
 
3774 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3775 
    args = getValidOrderCount_args()
3776 
    args.read(iprot)
3777 
    iprot.readMessageEnd()
3778 
    result = getValidOrderCount_result()
3779 
    result.success = self._handler.getValidOrderCount()
3780 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3781 
    result.write(oprot)
3782 
    oprot.writeMessageEnd()
3783 
    oprot.trans.flush()
3784 
 
3785 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3786 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3787 
    args.read(iprot)
3788 
    iprot.readMessageEnd()
3789 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3790 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3791 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3792 
    result.write(oprot)
3793 
    oprot.writeMessageEnd()
3794 
    oprot.trans.flush()
3795 
 
3796 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3797 
    args = getValidOrdersAmountRange_args()
3798 
    args.read(iprot)
3799 
    iprot.readMessageEnd()
3800 
    result = getValidOrdersAmountRange_result()
3801 
    result.success = self._handler.getValidOrdersAmountRange()
3802 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3803 
    result.write(oprot)
3804 
    oprot.writeMessageEnd()
3805 
    oprot.trans.flush()
3806 
 
3807 
  def process_getValidOrders(self, seqid, iprot, oprot):
3808 
    args = getValidOrders_args()
3809 
    args.read(iprot)
3810 
    iprot.readMessageEnd()
3811 
    result = getValidOrders_result()
3812 
    result.success = self._handler.getValidOrders(args.limit)
3813 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3814 
    result.write(oprot)
3815 
    oprot.writeMessageEnd()
3816 
    oprot.trans.flush()
3817 
 
1220 chandransh 3818 
  def process_batchOrders(self, seqid, iprot, oprot):
3819 
    args = batchOrders_args()
3820 
    args.read(iprot)
3821 
    iprot.readMessageEnd()
3822 
    result = batchOrders_result()
3823 
    try:
3824 
      result.success = self._handler.batchOrders(args.warehouseId)
3825 
    except TransactionServiceException, ex:
3826 
      result.ex = ex
3827 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
3831 
 
1208 chandransh 3832 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3833 
    args = markOrderAsOutOfStock_args()
3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
3836 
    result = markOrderAsOutOfStock_result()
3837 
    try:
3838 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3839 
    except TransactionServiceException, ex:
3840 
      result.ex = ex
3841 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
3845 
 
3064 chandransh 3846 
  def process_verifyOrder(self, seqid, iprot, oprot):
3847 
    args = verifyOrder_args()
759 chandransh 3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
3064 chandransh 3850 
    result = verifyOrder_result()
759 chandransh 3851 
    try:
3064 chandransh 3852 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3853 
    except TransactionServiceException, ex:
3854 
      result.ex = ex
3064 chandransh 3855 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3856 
    result.write(oprot)
3857 
    oprot.writeMessageEnd()
3858 
    oprot.trans.flush()
3859 
 
3064 chandransh 3860 
  def process_acceptOrder(self, seqid, iprot, oprot):
3861 
    args = acceptOrder_args()
1113 chandransh 3862 
    args.read(iprot)
3863 
    iprot.readMessageEnd()
3064 chandransh 3864 
    result = acceptOrder_result()
1113 chandransh 3865 
    try:
3064 chandransh 3866 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3867 
    except TransactionServiceException, ex:
3868 
      result.ex = ex
3064 chandransh 3869 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3870 
    result.write(oprot)
3871 
    oprot.writeMessageEnd()
3872 
    oprot.trans.flush()
3873 
 
3064 chandransh 3874 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3875 
    args = addBillingDetails_args()
1135 chandransh 3876 
    args.read(iprot)
3877 
    iprot.readMessageEnd()
3064 chandransh 3878 
    result = addBillingDetails_result()
1135 chandransh 3879 
    try:
4283 anupam.sin 3880 
      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 3881 
    except TransactionServiceException, ex:
3882 
      result.ex = ex
3064 chandransh 3883 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3884 
    result.write(oprot)
3885 
    oprot.writeMessageEnd()
3886 
    oprot.trans.flush()
3887 
 
3064 chandransh 3888 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3889 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3890 
    args.read(iprot)
3891 
    iprot.readMessageEnd()
3064 chandransh 3892 
    result = markOrdersAsManifested_result()
3893 
    try:
3894 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3895 
    except TransactionServiceException, ex:
3896 
      result.ex = ex
3897 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3898 
    result.write(oprot)
3899 
    oprot.writeMessageEnd()
3900 
    oprot.trans.flush()
3901 
 
3064 chandransh 3902 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3903 
    args = markOrdersAsPickedUp_args()
304 ashish 3904 
    args.read(iprot)
3905 
    iprot.readMessageEnd()
3064 chandransh 3906 
    result = markOrdersAsPickedUp_result()
3907 
    try:
3908 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3909 
    except TransactionServiceException, ex:
3910 
      result.ex = ex
3911 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3912 
    result.write(oprot)
3913 
    oprot.writeMessageEnd()
3914 
    oprot.trans.flush()
94 ashish 3915 
 
3064 chandransh 3916 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3917 
    args = markOrdersAsDelivered_args()
304 ashish 3918 
    args.read(iprot)
3919 
    iprot.readMessageEnd()
3064 chandransh 3920 
    result = markOrdersAsDelivered_result()
3921 
    try:
3922 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3923 
    except TransactionServiceException, ex:
3924 
      result.ex = ex
3925 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3926 
    result.write(oprot)
3927 
    oprot.writeMessageEnd()
3928 
    oprot.trans.flush()
3929 
 
3064 chandransh 3930 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3931 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3932 
    args.read(iprot)
3933 
    iprot.readMessageEnd()
3064 chandransh 3934 
    result = markOrdersAsFailed_result()
3935 
    try:
3936 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3937 
    except TransactionServiceException, ex:
3938 
      result.ex = ex
3939 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3940 
    result.write(oprot)
3941 
    oprot.writeMessageEnd()
3942 
    oprot.trans.flush()
304 ashish 3943 
 
3064 chandransh 3944 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3945 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3946 
    args.read(iprot)
3947 
    iprot.readMessageEnd()
3064 chandransh 3948 
    result = updateNonDeliveryReason_result()
3949 
    try:
3950 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3951 
    except TransactionServiceException, ex:
3952 
      result.ex = ex
3953 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3954 
    result.write(oprot)
3955 
    oprot.writeMessageEnd()
3956 
    oprot.trans.flush()
1596 ankur.sing 3957 
 
3064 chandransh 3958 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3959 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3960 
    args.read(iprot)
3961 
    iprot.readMessageEnd()
3064 chandransh 3962 
    result = getUndeliveredOrders_result()
3963 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3964 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3965 
    result.write(oprot)
3966 
    oprot.writeMessageEnd()
3967 
    oprot.trans.flush()
3968 
 
2536 chandransh 3969 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3970 
    args = toggleDOAFlag_args()
3971 
    args.read(iprot)
3972 
    iprot.readMessageEnd()
3973 
    result = toggleDOAFlag_result()
3974 
    try:
3975 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3976 
    except TransactionServiceException, ex:
3977 
      result.ex = ex
3978 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
1886 ankur.sing 3982 
 
2536 chandransh 3983 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3984 
    args = requestPickupNumber_args()
3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
3987 
    result = requestPickupNumber_result()
3988 
    try:
3989 
      result.success = self._handler.requestPickupNumber(args.orderId)
3990 
    except TransactionServiceException, ex:
3991 
      result.ex = ex
3992 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
3997 
  def process_authorizePickup(self, seqid, iprot, oprot):
3998 
    args = authorizePickup_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = authorizePickup_result()
4002 
    try:
4003 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4004 
    except TransactionServiceException, ex:
4005 
      result.ex = ex
4006 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
2764 chandransh 4011 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4012 
    args = markDoasAsPickedUp_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = markDoasAsPickedUp_result()
4016 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4017 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4018 
    result.write(oprot)
4019 
    oprot.writeMessageEnd()
4020 
    oprot.trans.flush()
4021 
 
2616 chandransh 4022 
  def process_receiveReturn(self, seqid, iprot, oprot):
4023 
    args = receiveReturn_args()
2591 chandransh 4024 
    args.read(iprot)
4025 
    iprot.readMessageEnd()
2616 chandransh 4026 
    result = receiveReturn_result()
2591 chandransh 4027 
    try:
2616 chandransh 4028 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 4029 
    except TransactionServiceException, ex:
4030 
      result.ex = ex
2616 chandransh 4031 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4032 
    result.write(oprot)
4033 
    oprot.writeMessageEnd()
4034 
    oprot.trans.flush()
2536 chandransh 4035 
 
2591 chandransh 4036 
  def process_validateDoa(self, seqid, iprot, oprot):
4037 
    args = validateDoa_args()
4038 
    args.read(iprot)
4039 
    iprot.readMessageEnd()
4040 
    result = validateDoa_result()
4041 
    try:
4042 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4043 
    except TransactionServiceException, ex:
4044 
      result.ex = ex
4045 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4046 
    result.write(oprot)
4047 
    oprot.writeMessageEnd()
4048 
    oprot.trans.flush()
4049 
 
2616 chandransh 4050 
  def process_reshipOrder(self, seqid, iprot, oprot):
4051 
    args = reshipOrder_args()
4052 
    args.read(iprot)
4053 
    iprot.readMessageEnd()
4054 
    result = reshipOrder_result()
4055 
    try:
4056 
      result.success = self._handler.reshipOrder(args.orderId)
4057 
    except TransactionServiceException, ex:
4058 
      result.ex = ex
4059 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4060 
    result.write(oprot)
4061 
    oprot.writeMessageEnd()
4062 
    oprot.trans.flush()
2591 chandransh 4063 
 
2616 chandransh 4064 
  def process_refundOrder(self, seqid, iprot, oprot):
4065 
    args = refundOrder_args()
4066 
    args.read(iprot)
4067 
    iprot.readMessageEnd()
4068 
    result = refundOrder_result()
4069 
    try:
3226 chandransh 4070 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4071 
    except TransactionServiceException, ex:
4072 
      result.ex = ex
4073 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4074 
    result.write(oprot)
4075 
    oprot.writeMessageEnd()
4076 
    oprot.trans.flush()
4077 
 
2690 chandransh 4078 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4079 
    args = getReturnOrders_args()
4080 
    args.read(iprot)
4081 
    iprot.readMessageEnd()
4082 
    result = getReturnOrders_result()
4083 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4084 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
2616 chandransh 4088 
 
2700 chandransh 4089 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4090 
    args = getReturnOrder_args()
4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4093 
    result = getReturnOrder_result()
4094 
    try:
4095 
      result.success = self._handler.getReturnOrder(args.id)
4096 
    except TransactionServiceException, ex:
4097 
      result.ex = ex
4098 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4099 
    result.write(oprot)
4100 
    oprot.writeMessageEnd()
4101 
    oprot.trans.flush()
4102 
 
2690 chandransh 4103 
  def process_processReturn(self, seqid, iprot, oprot):
4104 
    args = processReturn_args()
4105 
    args.read(iprot)
4106 
    iprot.readMessageEnd()
4107 
    result = processReturn_result()
4108 
    try:
4109 
      self._handler.processReturn(args.returnOrderId)
4110 
    except TransactionServiceException, ex:
4111 
      result.ex = ex
4112 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4113 
    result.write(oprot)
4114 
    oprot.writeMessageEnd()
4115 
    oprot.trans.flush()
4116 
 
2819 chandransh 4117 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4118 
    args = createPurchaseOrder_args()
4119 
    args.read(iprot)
4120 
    iprot.readMessageEnd()
4121 
    result = createPurchaseOrder_result()
4122 
    try:
4123 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4124 
    except TransactionServiceException, ex:
4125 
      result.ex = ex
4126 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4127 
    result.write(oprot)
4128 
    oprot.writeMessageEnd()
4129 
    oprot.trans.flush()
2690 chandransh 4130 
 
3451 chandransh 4131 
  def process_updateWeight(self, seqid, iprot, oprot):
4132 
    args = updateWeight_args()
4133 
    args.read(iprot)
4134 
    iprot.readMessageEnd()
4135 
    result = updateWeight_result()
4136 
    try:
4137 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4138 
    except TransactionServiceException, ex:
4139 
      result.ex = ex
4140 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4141 
    result.write(oprot)
4142 
    oprot.writeMessageEnd()
4143 
    oprot.trans.flush()
2819 chandransh 4144 
 
3469 chandransh 4145 
  def process_changeItem(self, seqid, iprot, oprot):
4146 
    args = changeItem_args()
4147 
    args.read(iprot)
4148 
    iprot.readMessageEnd()
4149 
    result = changeItem_result()
4150 
    try:
4151 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4152 
    except TransactionServiceException, ex:
4153 
      result.ex = ex
4154 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
3451 chandransh 4158 
 
3469 chandransh 4159 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4160 
    args = shiftToWarehouse_args()
4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
4163 
    result = shiftToWarehouse_result()
4164 
    try:
4165 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4166 
    except TransactionServiceException, ex:
4167 
      result.ex = ex
4168 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
4172 
 
3553 chandransh 4173 
  def process_addDelayReason(self, seqid, iprot, oprot):
4174 
    args = addDelayReason_args()
4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
4177 
    result = addDelayReason_result()
4178 
    try:
3986 chandransh 4179 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4180 
    except TransactionServiceException, ex:
4181 
      result.ex = ex
4182 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4183 
    result.write(oprot)
4184 
    oprot.writeMessageEnd()
4185 
    oprot.trans.flush()
3469 chandransh 4186 
 
3956 chandransh 4187 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4188 
    args = reconcileCodCollection_args()
4189 
    args.read(iprot)
4190 
    iprot.readMessageEnd()
4191 
    result = reconcileCodCollection_result()
4192 
    try:
4193 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4194 
    except TransactionServiceException, ex:
4195 
      result.ex = ex
4196 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
3553 chandransh 4200 
 
4008 mandeep.dh 4201 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4202 
    args = getTransactionsRequiringExtraProcessing_args()
4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
4205 
    result = getTransactionsRequiringExtraProcessing_result()
4206 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4207 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
3956 chandransh 4211 
 
4008 mandeep.dh 4212 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4213 
    args = markTransactionAsProcessed_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = markTransactionAsProcessed_result()
4217 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4218 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
4018 chandransh 4223 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4224 
    args = getItemWiseRiskyOrdersCount_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = getItemWiseRiskyOrdersCount_result()
4228 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4229 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4008 mandeep.dh 4233 
 
4295 varun.gupt 4234 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4235 
    args = getOrdersForItemIds_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getOrdersForItemIds_result()
4239 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4240 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
4247 rajveer 4245 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4246 
    args = markOrderCancellationRequestReceived_args()
4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
4249 
    result = markOrderCancellationRequestReceived_result()
4250 
    try:
4251 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4252 
    except TransactionServiceException, ex:
4253 
      result.ex = ex
4254 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4255 
    result.write(oprot)
4256 
    oprot.writeMessageEnd()
4257 
    oprot.trans.flush()
4018 chandransh 4258 
 
4247 rajveer 4259 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4260 
    args = markOrderCancellationRequestConfirmed_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = markOrderCancellationRequestConfirmed_result()
4264 
    try:
4265 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4266 
    except TransactionServiceException, ex:
4267 
      result.ex = ex
4268 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4274 
    args = markOrderCancellationRequestDenied_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = markOrderCancellationRequestDenied_result()
4278 
    try:
4279 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4280 
    except TransactionServiceException, ex:
4281 
      result.ex = ex
4282 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
4258 rajveer 4287 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4288 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4258 rajveer 4291 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4292 
    try:
4258 rajveer 4293 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4294 
    except TransactionServiceException, ex:
4295 
      result.ex = ex
4258 rajveer 4296 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
4259 anupam.sin 4301 
  def process_refundTransaction(self, seqid, iprot, oprot):
4302 
    args = refundTransaction_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = refundTransaction_result()
4306 
    try:
4307 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4308 
    except TransactionServiceException, ex:
4309 
      result.ex = ex
4310 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4247 rajveer 4314 
 
4324 mandeep.dh 4315 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4316 
    args = updateShipmentAddress_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = updateShipmentAddress_result()
4320 
    try:
4321 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4322 
    except TransactionServiceException, ex:
4323 
      result.ex = ex
4324 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
4328 
 
4285 rajveer 4329 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4330 
    args = acceptOrdersForItemId_args()
4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
4333 
    result = acceptOrdersForItemId_result()
4334 
    try:
4335 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4336 
    except TransactionServiceException, ex:
4337 
      result.ex = ex
4338 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4259 anupam.sin 4342 
 
4303 rajveer 4343 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4344 
    args = markOrdersAsPORaised_args()
4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
4347 
    result = markOrdersAsPORaised_result()
4348 
    try:
4369 rajveer 4349 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4350 
    except TransactionServiceException, ex:
4351 
      result.ex = ex
4352 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4285 rajveer 4356 
 
4303 rajveer 4357 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4358 
    args = markOrdersAsReversalInitiated_args()
4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
4361 
    result = markOrdersAsReversalInitiated_result()
4362 
    try:
4369 rajveer 4363 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4364 
    except TransactionServiceException, ex:
4365 
      result.ex = ex
4366 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
4370 
 
4371 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4372 
    args = markOrdersAsNotAvailabke_args()
4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
4375 
    result = markOrdersAsNotAvailabke_result()
4376 
    try:
4369 rajveer 4377 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4378 
    except TransactionServiceException, ex:
4379 
      result.ex = ex
4380 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4369 rajveer 4385 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4386 
    args = markOrdersAsTimeout_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = markOrdersAsTimeout_result()
4390 
    try:
4391 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4392 
    except TransactionServiceException, ex:
4393 
      result.ex = ex
4394 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
4303 rajveer 4398 
 
4386 anupam.sin 4399 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4400 
    args = getOrderForAwb_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = getOrderForAwb_result()
4404 
    try:
4405 
      result.success = self._handler.getOrderForAwb(args.awb)
4406 
    except TransactionServiceException, ex:
4407 
      result.ex = ex
4408 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4369 rajveer 4412 
 
4386 anupam.sin 4413 
 
94 ashish 4414 
# HELPER FUNCTIONS AND STRUCTURES
4415 
 
4416 
class createTransaction_args:
4417 
  """
4418 
  Attributes:
4419 
   - transaction
4420 
  """
4421 
 
4422 
  thrift_spec = (
4423 
    None, # 0
4424 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4425 
  )
4426 
 
4427 
  def __init__(self, transaction=None,):
4428 
    self.transaction = transaction
4429 
 
4430 
  def read(self, iprot):
4431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4433 
      return
4434 
    iprot.readStructBegin()
4435 
    while True:
4436 
      (fname, ftype, fid) = iprot.readFieldBegin()
4437 
      if ftype == TType.STOP:
4438 
        break
4439 
      if fid == 1:
4440 
        if ftype == TType.STRUCT:
4441 
          self.transaction = Transaction()
4442 
          self.transaction.read(iprot)
4443 
        else:
4444 
          iprot.skip(ftype)
4445 
      else:
4446 
        iprot.skip(ftype)
4447 
      iprot.readFieldEnd()
4448 
    iprot.readStructEnd()
4449 
 
4450 
  def write(self, oprot):
4451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4453 
      return
4454 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4455 
    if self.transaction is not None:
94 ashish 4456 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4457 
      self.transaction.write(oprot)
4458 
      oprot.writeFieldEnd()
4459 
    oprot.writeFieldStop()
4460 
    oprot.writeStructEnd()
4461 
 
3431 rajveer 4462 
  def validate(self):
4463 
    return
4464 
 
4465 
 
94 ashish 4466 
  def __repr__(self):
4467 
    L = ['%s=%r' % (key, value)
4468 
      for key, value in self.__dict__.iteritems()]
4469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4470 
 
4471 
  def __eq__(self, other):
4472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4473 
 
4474 
  def __ne__(self, other):
4475 
    return not (self == other)
4476 
 
4477 
class createTransaction_result:
4478 
  """
4479 
  Attributes:
132 ashish 4480 
   - success
94 ashish 4481 
   - ex
4482 
  """
4483 
 
4484 
  thrift_spec = (
132 ashish 4485 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4487 
  )
4488 
 
132 ashish 4489 
  def __init__(self, success=None, ex=None,):
4490 
    self.success = success
94 ashish 4491 
    self.ex = ex
4492 
 
4493 
  def read(self, iprot):
4494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4496 
      return
4497 
    iprot.readStructBegin()
4498 
    while True:
4499 
      (fname, ftype, fid) = iprot.readFieldBegin()
4500 
      if ftype == TType.STOP:
4501 
        break
132 ashish 4502 
      if fid == 0:
4503 
        if ftype == TType.I64:
4504 
          self.success = iprot.readI64();
4505 
        else:
4506 
          iprot.skip(ftype)
4507 
      elif fid == 1:
94 ashish 4508 
        if ftype == TType.STRUCT:
4509 
          self.ex = TransactionServiceException()
4510 
          self.ex.read(iprot)
4511 
        else:
4512 
          iprot.skip(ftype)
4513 
      else:
4514 
        iprot.skip(ftype)
4515 
      iprot.readFieldEnd()
4516 
    iprot.readStructEnd()
4517 
 
4518 
  def write(self, oprot):
4519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4521 
      return
4522 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4523 
    if self.success is not None:
132 ashish 4524 
      oprot.writeFieldBegin('success', TType.I64, 0)
4525 
      oprot.writeI64(self.success)
4526 
      oprot.writeFieldEnd()
3431 rajveer 4527 
    if self.ex is not None:
94 ashish 4528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4529 
      self.ex.write(oprot)
4530 
      oprot.writeFieldEnd()
4531 
    oprot.writeFieldStop()
4532 
    oprot.writeStructEnd()
4533 
 
3431 rajveer 4534 
  def validate(self):
4535 
    return
4536 
 
4537 
 
94 ashish 4538 
  def __repr__(self):
4539 
    L = ['%s=%r' % (key, value)
4540 
      for key, value in self.__dict__.iteritems()]
4541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4542 
 
4543 
  def __eq__(self, other):
4544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4545 
 
4546 
  def __ne__(self, other):
4547 
    return not (self == other)
4548 
 
4549 
class getTransaction_args:
4550 
  """
4551 
  Attributes:
4552 
   - id
4553 
  """
4554 
 
4555 
  thrift_spec = (
4556 
    None, # 0
4557 
    (1, TType.I64, 'id', None, None, ), # 1
4558 
  )
4559 
 
4560 
  def __init__(self, id=None,):
4561 
    self.id = id
4562 
 
4563 
  def read(self, iprot):
4564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4566 
      return
4567 
    iprot.readStructBegin()
4568 
    while True:
4569 
      (fname, ftype, fid) = iprot.readFieldBegin()
4570 
      if ftype == TType.STOP:
4571 
        break
4572 
      if fid == 1:
4573 
        if ftype == TType.I64:
4574 
          self.id = iprot.readI64();
4575 
        else:
4576 
          iprot.skip(ftype)
4577 
      else:
4578 
        iprot.skip(ftype)
4579 
      iprot.readFieldEnd()
4580 
    iprot.readStructEnd()
4581 
 
4582 
  def write(self, oprot):
4583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4585 
      return
4586 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4587 
    if self.id is not None:
94 ashish 4588 
      oprot.writeFieldBegin('id', TType.I64, 1)
4589 
      oprot.writeI64(self.id)
4590 
      oprot.writeFieldEnd()
4591 
    oprot.writeFieldStop()
4592 
    oprot.writeStructEnd()
4593 
 
3431 rajveer 4594 
  def validate(self):
4595 
    return
4596 
 
4597 
 
94 ashish 4598 
  def __repr__(self):
4599 
    L = ['%s=%r' % (key, value)
4600 
      for key, value in self.__dict__.iteritems()]
4601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4602 
 
4603 
  def __eq__(self, other):
4604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4605 
 
4606 
  def __ne__(self, other):
4607 
    return not (self == other)
4608 
 
4609 
class getTransaction_result:
4610 
  """
4611 
  Attributes:
4612 
   - success
4613 
   - ex
4614 
  """
4615 
 
4616 
  thrift_spec = (
4617 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4619 
  )
4620 
 
4621 
  def __init__(self, success=None, ex=None,):
4622 
    self.success = success
4623 
    self.ex = ex
4624 
 
4625 
  def read(self, iprot):
4626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4628 
      return
4629 
    iprot.readStructBegin()
4630 
    while True:
4631 
      (fname, ftype, fid) = iprot.readFieldBegin()
4632 
      if ftype == TType.STOP:
4633 
        break
4634 
      if fid == 0:
4635 
        if ftype == TType.STRUCT:
4636 
          self.success = Transaction()
4637 
          self.success.read(iprot)
4638 
        else:
4639 
          iprot.skip(ftype)
4640 
      elif fid == 1:
4641 
        if ftype == TType.STRUCT:
4642 
          self.ex = TransactionServiceException()
4643 
          self.ex.read(iprot)
4644 
        else:
4645 
          iprot.skip(ftype)
4646 
      else:
4647 
        iprot.skip(ftype)
4648 
      iprot.readFieldEnd()
4649 
    iprot.readStructEnd()
4650 
 
4651 
  def write(self, oprot):
4652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4654 
      return
4655 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4656 
    if self.success is not None:
94 ashish 4657 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4658 
      self.success.write(oprot)
4659 
      oprot.writeFieldEnd()
3431 rajveer 4660 
    if self.ex is not None:
94 ashish 4661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4662 
      self.ex.write(oprot)
4663 
      oprot.writeFieldEnd()
4664 
    oprot.writeFieldStop()
4665 
    oprot.writeStructEnd()
4666 
 
3431 rajveer 4667 
  def validate(self):
4668 
    return
4669 
 
4670 
 
94 ashish 4671 
  def __repr__(self):
4672 
    L = ['%s=%r' % (key, value)
4673 
      for key, value in self.__dict__.iteritems()]
4674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4675 
 
4676 
  def __eq__(self, other):
4677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4678 
 
4679 
  def __ne__(self, other):
4680 
    return not (self == other)
4681 
 
4682 
class getTransactionsForCustomer_args:
4683 
  """
4684 
  Attributes:
4685 
   - customerId
4686 
   - from_date
4687 
   - to_date
4688 
   - status
4689 
  """
4690 
 
4691 
  thrift_spec = (
4692 
    None, # 0
4693 
    (1, TType.I64, 'customerId', None, None, ), # 1
4694 
    (2, TType.I64, 'from_date', None, None, ), # 2
4695 
    (3, TType.I64, 'to_date', None, None, ), # 3
4696 
    (4, TType.I32, 'status', None, None, ), # 4
4697 
  )
4698 
 
4699 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4700 
    self.customerId = customerId
4701 
    self.from_date = from_date
4702 
    self.to_date = to_date
4703 
    self.status = status
4704 
 
4705 
  def read(self, iprot):
4706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4708 
      return
4709 
    iprot.readStructBegin()
4710 
    while True:
4711 
      (fname, ftype, fid) = iprot.readFieldBegin()
4712 
      if ftype == TType.STOP:
4713 
        break
4714 
      if fid == 1:
4715 
        if ftype == TType.I64:
4716 
          self.customerId = iprot.readI64();
4717 
        else:
4718 
          iprot.skip(ftype)
4719 
      elif fid == 2:
4720 
        if ftype == TType.I64:
4721 
          self.from_date = iprot.readI64();
4722 
        else:
4723 
          iprot.skip(ftype)
4724 
      elif fid == 3:
4725 
        if ftype == TType.I64:
4726 
          self.to_date = iprot.readI64();
4727 
        else:
4728 
          iprot.skip(ftype)
4729 
      elif fid == 4:
4730 
        if ftype == TType.I32:
4731 
          self.status = iprot.readI32();
4732 
        else:
4733 
          iprot.skip(ftype)
4734 
      else:
4735 
        iprot.skip(ftype)
4736 
      iprot.readFieldEnd()
4737 
    iprot.readStructEnd()
4738 
 
4739 
  def write(self, oprot):
4740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4742 
      return
4743 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4744 
    if self.customerId is not None:
94 ashish 4745 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4746 
      oprot.writeI64(self.customerId)
4747 
      oprot.writeFieldEnd()
3431 rajveer 4748 
    if self.from_date is not None:
94 ashish 4749 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4750 
      oprot.writeI64(self.from_date)
4751 
      oprot.writeFieldEnd()
3431 rajveer 4752 
    if self.to_date is not None:
94 ashish 4753 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4754 
      oprot.writeI64(self.to_date)
4755 
      oprot.writeFieldEnd()
3431 rajveer 4756 
    if self.status is not None:
94 ashish 4757 
      oprot.writeFieldBegin('status', TType.I32, 4)
4758 
      oprot.writeI32(self.status)
4759 
      oprot.writeFieldEnd()
4760 
    oprot.writeFieldStop()
4761 
    oprot.writeStructEnd()
4762 
 
3431 rajveer 4763 
  def validate(self):
4764 
    return
4765 
 
4766 
 
94 ashish 4767 
  def __repr__(self):
4768 
    L = ['%s=%r' % (key, value)
4769 
      for key, value in self.__dict__.iteritems()]
4770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4771 
 
4772 
  def __eq__(self, other):
4773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4774 
 
4775 
  def __ne__(self, other):
4776 
    return not (self == other)
4777 
 
4778 
class getTransactionsForCustomer_result:
4779 
  """
4780 
  Attributes:
4781 
   - success
4782 
   - ex
4783 
  """
4784 
 
4785 
  thrift_spec = (
4786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4787 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4788 
  )
4789 
 
4790 
  def __init__(self, success=None, ex=None,):
4791 
    self.success = success
4792 
    self.ex = ex
4793 
 
4794 
  def read(self, iprot):
4795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4797 
      return
4798 
    iprot.readStructBegin()
4799 
    while True:
4800 
      (fname, ftype, fid) = iprot.readFieldBegin()
4801 
      if ftype == TType.STOP:
4802 
        break
4803 
      if fid == 0:
4804 
        if ftype == TType.LIST:
4805 
          self.success = []
685 chandransh 4806 
          (_etype17, _size14) = iprot.readListBegin()
4807 
          for _i18 in xrange(_size14):
4808 
            _elem19 = Transaction()
4809 
            _elem19.read(iprot)
4810 
            self.success.append(_elem19)
94 ashish 4811 
          iprot.readListEnd()
4812 
        else:
4813 
          iprot.skip(ftype)
4814 
      elif fid == 1:
4815 
        if ftype == TType.STRUCT:
4816 
          self.ex = TransactionServiceException()
4817 
          self.ex.read(iprot)
4818 
        else:
4819 
          iprot.skip(ftype)
4820 
      else:
4821 
        iprot.skip(ftype)
4822 
      iprot.readFieldEnd()
4823 
    iprot.readStructEnd()
4824 
 
4825 
  def write(self, oprot):
4826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4828 
      return
4829 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4830 
    if self.success is not None:
94 ashish 4831 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4832 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4833 
      for iter20 in self.success:
4834 
        iter20.write(oprot)
94 ashish 4835 
      oprot.writeListEnd()
4836 
      oprot.writeFieldEnd()
3431 rajveer 4837 
    if self.ex is not None:
94 ashish 4838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4839 
      self.ex.write(oprot)
4840 
      oprot.writeFieldEnd()
4841 
    oprot.writeFieldStop()
4842 
    oprot.writeStructEnd()
4843 
 
3431 rajveer 4844 
  def validate(self):
4845 
    return
4846 
 
4847 
 
94 ashish 4848 
  def __repr__(self):
4849 
    L = ['%s=%r' % (key, value)
4850 
      for key, value in self.__dict__.iteritems()]
4851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4852 
 
4853 
  def __eq__(self, other):
4854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4855 
 
4856 
  def __ne__(self, other):
4857 
    return not (self == other)
4858 
 
132 ashish 4859 
class getTransactionsForShoppingCartId_args:
4860 
  """
4861 
  Attributes:
4862 
   - shoppingCartId
4863 
  """
4864 
 
4865 
  thrift_spec = (
4866 
    None, # 0
4867 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4868 
  )
4869 
 
4870 
  def __init__(self, shoppingCartId=None,):
4871 
    self.shoppingCartId = shoppingCartId
4872 
 
4873 
  def read(self, iprot):
4874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4876 
      return
4877 
    iprot.readStructBegin()
4878 
    while True:
4879 
      (fname, ftype, fid) = iprot.readFieldBegin()
4880 
      if ftype == TType.STOP:
4881 
        break
4882 
      if fid == 1:
4883 
        if ftype == TType.I64:
4884 
          self.shoppingCartId = iprot.readI64();
4885 
        else:
4886 
          iprot.skip(ftype)
4887 
      else:
4888 
        iprot.skip(ftype)
4889 
      iprot.readFieldEnd()
4890 
    iprot.readStructEnd()
4891 
 
4892 
  def write(self, oprot):
4893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4895 
      return
4896 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4897 
    if self.shoppingCartId is not None:
132 ashish 4898 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4899 
      oprot.writeI64(self.shoppingCartId)
4900 
      oprot.writeFieldEnd()
4901 
    oprot.writeFieldStop()
4902 
    oprot.writeStructEnd()
4903 
 
3431 rajveer 4904 
  def validate(self):
4905 
    return
4906 
 
4907 
 
132 ashish 4908 
  def __repr__(self):
4909 
    L = ['%s=%r' % (key, value)
4910 
      for key, value in self.__dict__.iteritems()]
4911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4912 
 
4913 
  def __eq__(self, other):
4914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4915 
 
4916 
  def __ne__(self, other):
4917 
    return not (self == other)
4918 
 
4919 
class getTransactionsForShoppingCartId_result:
4920 
  """
4921 
  Attributes:
4922 
   - success
4923 
   - ex
4924 
  """
4925 
 
4926 
  thrift_spec = (
4927 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4929 
  )
4930 
 
4931 
  def __init__(self, success=None, ex=None,):
4932 
    self.success = success
4933 
    self.ex = ex
4934 
 
4935 
  def read(self, iprot):
4936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4938 
      return
4939 
    iprot.readStructBegin()
4940 
    while True:
4941 
      (fname, ftype, fid) = iprot.readFieldBegin()
4942 
      if ftype == TType.STOP:
4943 
        break
4944 
      if fid == 0:
4945 
        if ftype == TType.LIST:
4946 
          self.success = []
685 chandransh 4947 
          (_etype24, _size21) = iprot.readListBegin()
4948 
          for _i25 in xrange(_size21):
4949 
            _elem26 = Transaction()
4950 
            _elem26.read(iprot)
4951 
            self.success.append(_elem26)
132 ashish 4952 
          iprot.readListEnd()
4953 
        else:
4954 
          iprot.skip(ftype)
4955 
      elif fid == 1:
4956 
        if ftype == TType.STRUCT:
4957 
          self.ex = TransactionServiceException()
4958 
          self.ex.read(iprot)
4959 
        else:
4960 
          iprot.skip(ftype)
4961 
      else:
4962 
        iprot.skip(ftype)
4963 
      iprot.readFieldEnd()
4964 
    iprot.readStructEnd()
4965 
 
4966 
  def write(self, oprot):
4967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4969 
      return
4970 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4971 
    if self.success is not None:
132 ashish 4972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4974 
      for iter27 in self.success:
4975 
        iter27.write(oprot)
132 ashish 4976 
      oprot.writeListEnd()
4977 
      oprot.writeFieldEnd()
3431 rajveer 4978 
    if self.ex is not None:
132 ashish 4979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4980 
      self.ex.write(oprot)
4981 
      oprot.writeFieldEnd()
4982 
    oprot.writeFieldStop()
4983 
    oprot.writeStructEnd()
4984 
 
3431 rajveer 4985 
  def validate(self):
4986 
    return
4987 
 
4988 
 
132 ashish 4989 
  def __repr__(self):
4990 
    L = ['%s=%r' % (key, value)
4991 
      for key, value in self.__dict__.iteritems()]
4992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4993 
 
4994 
  def __eq__(self, other):
4995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4996 
 
4997 
  def __ne__(self, other):
4998 
    return not (self == other)
4999 
 
94 ashish 5000 
class getTransactionStatus_args:
5001 
  """
5002 
  Attributes:
5003 
   - transactionId
5004 
  """
5005 
 
5006 
  thrift_spec = (
5007 
    None, # 0
5008 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5009 
  )
5010 
 
5011 
  def __init__(self, transactionId=None,):
5012 
    self.transactionId = transactionId
5013 
 
5014 
  def read(self, iprot):
5015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5017 
      return
5018 
    iprot.readStructBegin()
5019 
    while True:
5020 
      (fname, ftype, fid) = iprot.readFieldBegin()
5021 
      if ftype == TType.STOP:
5022 
        break
5023 
      if fid == 1:
5024 
        if ftype == TType.I64:
5025 
          self.transactionId = iprot.readI64();
5026 
        else:
5027 
          iprot.skip(ftype)
5028 
      else:
5029 
        iprot.skip(ftype)
5030 
      iprot.readFieldEnd()
5031 
    iprot.readStructEnd()
5032 
 
5033 
  def write(self, oprot):
5034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5036 
      return
5037 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5038 
    if self.transactionId is not None:
94 ashish 5039 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5040 
      oprot.writeI64(self.transactionId)
5041 
      oprot.writeFieldEnd()
5042 
    oprot.writeFieldStop()
5043 
    oprot.writeStructEnd()
5044 
 
3431 rajveer 5045 
  def validate(self):
5046 
    return
5047 
 
5048 
 
94 ashish 5049 
  def __repr__(self):
5050 
    L = ['%s=%r' % (key, value)
5051 
      for key, value in self.__dict__.iteritems()]
5052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5053 
 
5054 
  def __eq__(self, other):
5055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5056 
 
5057 
  def __ne__(self, other):
5058 
    return not (self == other)
5059 
 
5060 
class getTransactionStatus_result:
5061 
  """
5062 
  Attributes:
5063 
   - success
5064 
   - ex
5065 
  """
5066 
 
5067 
  thrift_spec = (
5068 
    (0, TType.I32, 'success', None, None, ), # 0
5069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5070 
  )
5071 
 
5072 
  def __init__(self, success=None, ex=None,):
5073 
    self.success = success
5074 
    self.ex = ex
5075 
 
5076 
  def read(self, iprot):
5077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5079 
      return
5080 
    iprot.readStructBegin()
5081 
    while True:
5082 
      (fname, ftype, fid) = iprot.readFieldBegin()
5083 
      if ftype == TType.STOP:
5084 
        break
5085 
      if fid == 0:
5086 
        if ftype == TType.I32:
5087 
          self.success = iprot.readI32();
5088 
        else:
5089 
          iprot.skip(ftype)
5090 
      elif fid == 1:
5091 
        if ftype == TType.STRUCT:
5092 
          self.ex = TransactionServiceException()
5093 
          self.ex.read(iprot)
5094 
        else:
5095 
          iprot.skip(ftype)
5096 
      else:
5097 
        iprot.skip(ftype)
5098 
      iprot.readFieldEnd()
5099 
    iprot.readStructEnd()
5100 
 
5101 
  def write(self, oprot):
5102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5104 
      return
5105 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5106 
    if self.success is not None:
94 ashish 5107 
      oprot.writeFieldBegin('success', TType.I32, 0)
5108 
      oprot.writeI32(self.success)
5109 
      oprot.writeFieldEnd()
3431 rajveer 5110 
    if self.ex is not None:
94 ashish 5111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5112 
      self.ex.write(oprot)
5113 
      oprot.writeFieldEnd()
5114 
    oprot.writeFieldStop()
5115 
    oprot.writeStructEnd()
5116 
 
3431 rajveer 5117 
  def validate(self):
5118 
    return
5119 
 
5120 
 
94 ashish 5121 
  def __repr__(self):
5122 
    L = ['%s=%r' % (key, value)
5123 
      for key, value in self.__dict__.iteritems()]
5124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5125 
 
5126 
  def __eq__(self, other):
5127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5128 
 
5129 
  def __ne__(self, other):
5130 
    return not (self == other)
5131 
 
5132 
class changeTransactionStatus_args:
5133 
  """
5134 
  Attributes:
5135 
   - transactionId
5136 
   - status
5137 
   - description
5138 
  """
5139 
 
5140 
  thrift_spec = (
5141 
    None, # 0
5142 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5143 
    (2, TType.I32, 'status', None, None, ), # 2
5144 
    (3, TType.STRING, 'description', None, None, ), # 3
5145 
  )
5146 
 
5147 
  def __init__(self, transactionId=None, status=None, description=None,):
5148 
    self.transactionId = transactionId
5149 
    self.status = status
5150 
    self.description = description
5151 
 
5152 
  def read(self, iprot):
5153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5155 
      return
5156 
    iprot.readStructBegin()
5157 
    while True:
5158 
      (fname, ftype, fid) = iprot.readFieldBegin()
5159 
      if ftype == TType.STOP:
5160 
        break
5161 
      if fid == 1:
5162 
        if ftype == TType.I64:
5163 
          self.transactionId = iprot.readI64();
5164 
        else:
5165 
          iprot.skip(ftype)
5166 
      elif fid == 2:
5167 
        if ftype == TType.I32:
5168 
          self.status = iprot.readI32();
5169 
        else:
5170 
          iprot.skip(ftype)
5171 
      elif fid == 3:
5172 
        if ftype == TType.STRING:
5173 
          self.description = iprot.readString();
5174 
        else:
5175 
          iprot.skip(ftype)
5176 
      else:
5177 
        iprot.skip(ftype)
5178 
      iprot.readFieldEnd()
5179 
    iprot.readStructEnd()
5180 
 
5181 
  def write(self, oprot):
5182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5184 
      return
5185 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5186 
    if self.transactionId is not None:
94 ashish 5187 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5188 
      oprot.writeI64(self.transactionId)
5189 
      oprot.writeFieldEnd()
3431 rajveer 5190 
    if self.status is not None:
94 ashish 5191 
      oprot.writeFieldBegin('status', TType.I32, 2)
5192 
      oprot.writeI32(self.status)
5193 
      oprot.writeFieldEnd()
3431 rajveer 5194 
    if self.description is not None:
94 ashish 5195 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5196 
      oprot.writeString(self.description)
5197 
      oprot.writeFieldEnd()
5198 
    oprot.writeFieldStop()
5199 
    oprot.writeStructEnd()
5200 
 
3431 rajveer 5201 
  def validate(self):
5202 
    return
5203 
 
5204 
 
94 ashish 5205 
  def __repr__(self):
5206 
    L = ['%s=%r' % (key, value)
5207 
      for key, value in self.__dict__.iteritems()]
5208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5209 
 
5210 
  def __eq__(self, other):
5211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5212 
 
5213 
  def __ne__(self, other):
5214 
    return not (self == other)
5215 
 
5216 
class changeTransactionStatus_result:
5217 
  """
5218 
  Attributes:
5219 
   - success
5220 
   - ex
5221 
  """
5222 
 
5223 
  thrift_spec = (
5224 
    (0, TType.BOOL, 'success', None, None, ), # 0
5225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5226 
  )
5227 
 
5228 
  def __init__(self, success=None, ex=None,):
5229 
    self.success = success
5230 
    self.ex = ex
5231 
 
5232 
  def read(self, iprot):
5233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5235 
      return
5236 
    iprot.readStructBegin()
5237 
    while True:
5238 
      (fname, ftype, fid) = iprot.readFieldBegin()
5239 
      if ftype == TType.STOP:
5240 
        break
5241 
      if fid == 0:
5242 
        if ftype == TType.BOOL:
5243 
          self.success = iprot.readBool();
5244 
        else:
5245 
          iprot.skip(ftype)
5246 
      elif fid == 1:
5247 
        if ftype == TType.STRUCT:
5248 
          self.ex = TransactionServiceException()
5249 
          self.ex.read(iprot)
5250 
        else:
5251 
          iprot.skip(ftype)
5252 
      else:
5253 
        iprot.skip(ftype)
5254 
      iprot.readFieldEnd()
5255 
    iprot.readStructEnd()
5256 
 
5257 
  def write(self, oprot):
5258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5260 
      return
5261 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5262 
    if self.success is not None:
94 ashish 5263 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5264 
      oprot.writeBool(self.success)
5265 
      oprot.writeFieldEnd()
3431 rajveer 5266 
    if self.ex is not None:
94 ashish 5267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5268 
      self.ex.write(oprot)
5269 
      oprot.writeFieldEnd()
5270 
    oprot.writeFieldStop()
5271 
    oprot.writeStructEnd()
5272 
 
3431 rajveer 5273 
  def validate(self):
5274 
    return
5275 
 
5276 
 
94 ashish 5277 
  def __repr__(self):
5278 
    L = ['%s=%r' % (key, value)
5279 
      for key, value in self.__dict__.iteritems()]
5280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5281 
 
5282 
  def __eq__(self, other):
5283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5284 
 
5285 
  def __ne__(self, other):
5286 
    return not (self == other)
5287 
 
1398 varun.gupt 5288 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5289 
  """
5290 
  Attributes:
5291 
   - transactionId
5292 
  """
5293 
 
5294 
  thrift_spec = (
5295 
    None, # 0
5296 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5297 
  )
5298 
 
5299 
  def __init__(self, transactionId=None,):
5300 
    self.transactionId = transactionId
5301 
 
5302 
  def read(self, iprot):
5303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5305 
      return
5306 
    iprot.readStructBegin()
5307 
    while True:
5308 
      (fname, ftype, fid) = iprot.readFieldBegin()
5309 
      if ftype == TType.STOP:
5310 
        break
5311 
      if fid == 1:
5312 
        if ftype == TType.I64:
5313 
          self.transactionId = iprot.readI64();
5314 
        else:
5315 
          iprot.skip(ftype)
5316 
      else:
5317 
        iprot.skip(ftype)
5318 
      iprot.readFieldEnd()
5319 
    iprot.readStructEnd()
5320 
 
5321 
  def write(self, oprot):
5322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5324 
      return
1398 varun.gupt 5325 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5326 
    if self.transactionId is not None:
1382 varun.gupt 5327 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5328 
      oprot.writeI64(self.transactionId)
5329 
      oprot.writeFieldEnd()
5330 
    oprot.writeFieldStop()
5331 
    oprot.writeStructEnd()
5332 
 
3431 rajveer 5333 
  def validate(self):
5334 
    return
5335 
 
5336 
 
1382 varun.gupt 5337 
  def __repr__(self):
5338 
    L = ['%s=%r' % (key, value)
5339 
      for key, value in self.__dict__.iteritems()]
5340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5341 
 
5342 
  def __eq__(self, other):
5343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5344 
 
5345 
  def __ne__(self, other):
5346 
    return not (self == other)
5347 
 
1398 varun.gupt 5348 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5349 
  """
5350 
  Attributes:
5351 
   - success
5352 
   - ex
5353 
  """
5354 
 
5355 
  thrift_spec = (
5356 
    (0, TType.BOOL, 'success', None, None, ), # 0
5357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5358 
  )
5359 
 
5360 
  def __init__(self, success=None, ex=None,):
5361 
    self.success = success
5362 
    self.ex = ex
5363 
 
5364 
  def read(self, iprot):
5365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5367 
      return
5368 
    iprot.readStructBegin()
5369 
    while True:
5370 
      (fname, ftype, fid) = iprot.readFieldBegin()
5371 
      if ftype == TType.STOP:
5372 
        break
5373 
      if fid == 0:
5374 
        if ftype == TType.BOOL:
5375 
          self.success = iprot.readBool();
5376 
        else:
5377 
          iprot.skip(ftype)
5378 
      elif fid == 1:
5379 
        if ftype == TType.STRUCT:
5380 
          self.ex = TransactionServiceException()
5381 
          self.ex.read(iprot)
5382 
        else:
5383 
          iprot.skip(ftype)
5384 
      else:
5385 
        iprot.skip(ftype)
5386 
      iprot.readFieldEnd()
5387 
    iprot.readStructEnd()
5388 
 
5389 
  def write(self, oprot):
5390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5392 
      return
1398 varun.gupt 5393 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5394 
    if self.success is not None:
1382 varun.gupt 5395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5396 
      oprot.writeBool(self.success)
5397 
      oprot.writeFieldEnd()
3431 rajveer 5398 
    if self.ex is not None:
1382 varun.gupt 5399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5400 
      self.ex.write(oprot)
5401 
      oprot.writeFieldEnd()
5402 
    oprot.writeFieldStop()
5403 
    oprot.writeStructEnd()
5404 
 
3431 rajveer 5405 
  def validate(self):
5406 
    return
5407 
 
5408 
 
1382 varun.gupt 5409 
  def __repr__(self):
5410 
    L = ['%s=%r' % (key, value)
5411 
      for key, value in self.__dict__.iteritems()]
5412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5413 
 
5414 
  def __eq__(self, other):
5415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5416 
 
5417 
  def __ne__(self, other):
5418 
    return not (self == other)
5419 
 
483 rajveer 5420 
class getAllOrders_args:
94 ashish 5421 
  """
5422 
  Attributes:
483 rajveer 5423 
   - status
5424 
   - from_date
5425 
   - to_date
5426 
   - warehouse_id
94 ashish 5427 
  """
5428 
 
5429 
  thrift_spec = (
5430 
    None, # 0
483 rajveer 5431 
    (1, TType.I32, 'status', None, None, ), # 1
5432 
    (2, TType.I64, 'from_date', None, None, ), # 2
5433 
    (3, TType.I64, 'to_date', None, None, ), # 3
5434 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5435 
  )
5436 
 
483 rajveer 5437 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5438 
    self.status = status
5439 
    self.from_date = from_date
5440 
    self.to_date = to_date
5441 
    self.warehouse_id = warehouse_id
94 ashish 5442 
 
5443 
  def read(self, iprot):
5444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5446 
      return
5447 
    iprot.readStructBegin()
5448 
    while True:
5449 
      (fname, ftype, fid) = iprot.readFieldBegin()
5450 
      if ftype == TType.STOP:
5451 
        break
5452 
      if fid == 1:
483 rajveer 5453 
        if ftype == TType.I32:
5454 
          self.status = iprot.readI32();
94 ashish 5455 
        else:
5456 
          iprot.skip(ftype)
483 rajveer 5457 
      elif fid == 2:
5458 
        if ftype == TType.I64:
5459 
          self.from_date = iprot.readI64();
94 ashish 5460 
        else:
5461 
          iprot.skip(ftype)
483 rajveer 5462 
      elif fid == 3:
5463 
        if ftype == TType.I64:
5464 
          self.to_date = iprot.readI64();
94 ashish 5465 
        else:
5466 
          iprot.skip(ftype)
483 rajveer 5467 
      elif fid == 4:
94 ashish 5468 
        if ftype == TType.I64:
483 rajveer 5469 
          self.warehouse_id = iprot.readI64();
94 ashish 5470 
        else:
5471 
          iprot.skip(ftype)
5472 
      else:
5473 
        iprot.skip(ftype)
5474 
      iprot.readFieldEnd()
5475 
    iprot.readStructEnd()
5476 
 
5477 
  def write(self, oprot):
5478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5480 
      return
483 rajveer 5481 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5482 
    if self.status is not None:
483 rajveer 5483 
      oprot.writeFieldBegin('status', TType.I32, 1)
5484 
      oprot.writeI32(self.status)
94 ashish 5485 
      oprot.writeFieldEnd()
3431 rajveer 5486 
    if self.from_date is not None:
483 rajveer 5487 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5488 
      oprot.writeI64(self.from_date)
94 ashish 5489 
      oprot.writeFieldEnd()
3431 rajveer 5490 
    if self.to_date is not None:
483 rajveer 5491 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5492 
      oprot.writeI64(self.to_date)
94 ashish 5493 
      oprot.writeFieldEnd()
3431 rajveer 5494 
    if self.warehouse_id is not None:
483 rajveer 5495 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5496 
      oprot.writeI64(self.warehouse_id)
94 ashish 5497 
      oprot.writeFieldEnd()
5498 
    oprot.writeFieldStop()
5499 
    oprot.writeStructEnd()
5500 
 
3431 rajveer 5501 
  def validate(self):
5502 
    return
5503 
 
5504 
 
94 ashish 5505 
  def __repr__(self):
5506 
    L = ['%s=%r' % (key, value)
5507 
      for key, value in self.__dict__.iteritems()]
5508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5509 
 
5510 
  def __eq__(self, other):
5511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5512 
 
5513 
  def __ne__(self, other):
5514 
    return not (self == other)
5515 
 
483 rajveer 5516 
class getAllOrders_result:
94 ashish 5517 
  """
5518 
  Attributes:
5519 
   - success
5520 
   - ex
5521 
  """
5522 
 
5523 
  thrift_spec = (
483 rajveer 5524 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5525 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5526 
  )
5527 
 
5528 
  def __init__(self, success=None, ex=None,):
5529 
    self.success = success
5530 
    self.ex = ex
5531 
 
5532 
  def read(self, iprot):
5533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5535 
      return
5536 
    iprot.readStructBegin()
5537 
    while True:
5538 
      (fname, ftype, fid) = iprot.readFieldBegin()
5539 
      if ftype == TType.STOP:
5540 
        break
5541 
      if fid == 0:
483 rajveer 5542 
        if ftype == TType.LIST:
5543 
          self.success = []
685 chandransh 5544 
          (_etype31, _size28) = iprot.readListBegin()
5545 
          for _i32 in xrange(_size28):
5546 
            _elem33 = Order()
5547 
            _elem33.read(iprot)
5548 
            self.success.append(_elem33)
483 rajveer 5549 
          iprot.readListEnd()
94 ashish 5550 
        else:
5551 
          iprot.skip(ftype)
5552 
      elif fid == 1:
5553 
        if ftype == TType.STRUCT:
5554 
          self.ex = TransactionServiceException()
5555 
          self.ex.read(iprot)
5556 
        else:
5557 
          iprot.skip(ftype)
5558 
      else:
5559 
        iprot.skip(ftype)
5560 
      iprot.readFieldEnd()
5561 
    iprot.readStructEnd()
5562 
 
5563 
  def write(self, oprot):
5564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5566 
      return
483 rajveer 5567 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5568 
    if self.success is not None:
483 rajveer 5569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5571 
      for iter34 in self.success:
5572 
        iter34.write(oprot)
483 rajveer 5573 
      oprot.writeListEnd()
94 ashish 5574 
      oprot.writeFieldEnd()
3431 rajveer 5575 
    if self.ex is not None:
94 ashish 5576 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5577 
      self.ex.write(oprot)
5578 
      oprot.writeFieldEnd()
5579 
    oprot.writeFieldStop()
5580 
    oprot.writeStructEnd()
5581 
 
3431 rajveer 5582 
  def validate(self):
5583 
    return
5584 
 
5585 
 
94 ashish 5586 
  def __repr__(self):
5587 
    L = ['%s=%r' % (key, value)
5588 
      for key, value in self.__dict__.iteritems()]
5589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5590 
 
5591 
  def __eq__(self, other):
5592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5593 
 
5594 
  def __ne__(self, other):
5595 
    return not (self == other)
5596 
 
4133 chandransh 5597 
class getOrdersInBatch_args:
5598 
  """
5599 
  Attributes:
5600 
   - statuses
5601 
   - offset
5602 
   - limit
5603 
   - warehouse_id
5604 
  """
5605 
 
5606 
  thrift_spec = (
5607 
    None, # 0
5608 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5609 
    (2, TType.I64, 'offset', None, None, ), # 2
5610 
    (3, TType.I64, 'limit', None, None, ), # 3
5611 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5612 
  )
5613 
 
5614 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5615 
    self.statuses = statuses
5616 
    self.offset = offset
5617 
    self.limit = limit
5618 
    self.warehouse_id = warehouse_id
5619 
 
5620 
  def read(self, iprot):
5621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5623 
      return
5624 
    iprot.readStructBegin()
5625 
    while True:
5626 
      (fname, ftype, fid) = iprot.readFieldBegin()
5627 
      if ftype == TType.STOP:
5628 
        break
5629 
      if fid == 1:
5630 
        if ftype == TType.LIST:
5631 
          self.statuses = []
5632 
          (_etype38, _size35) = iprot.readListBegin()
5633 
          for _i39 in xrange(_size35):
5634 
            _elem40 = iprot.readI32();
5635 
            self.statuses.append(_elem40)
5636 
          iprot.readListEnd()
5637 
        else:
5638 
          iprot.skip(ftype)
5639 
      elif fid == 2:
5640 
        if ftype == TType.I64:
5641 
          self.offset = iprot.readI64();
5642 
        else:
5643 
          iprot.skip(ftype)
5644 
      elif fid == 3:
5645 
        if ftype == TType.I64:
5646 
          self.limit = iprot.readI64();
5647 
        else:
5648 
          iprot.skip(ftype)
5649 
      elif fid == 4:
5650 
        if ftype == TType.I64:
5651 
          self.warehouse_id = iprot.readI64();
5652 
        else:
5653 
          iprot.skip(ftype)
5654 
      else:
5655 
        iprot.skip(ftype)
5656 
      iprot.readFieldEnd()
5657 
    iprot.readStructEnd()
5658 
 
5659 
  def write(self, oprot):
5660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5662 
      return
5663 
    oprot.writeStructBegin('getOrdersInBatch_args')
5664 
    if self.statuses is not None:
5665 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5666 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5667 
      for iter41 in self.statuses:
5668 
        oprot.writeI32(iter41)
5669 
      oprot.writeListEnd()
5670 
      oprot.writeFieldEnd()
5671 
    if self.offset is not None:
5672 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5673 
      oprot.writeI64(self.offset)
5674 
      oprot.writeFieldEnd()
5675 
    if self.limit is not None:
5676 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5677 
      oprot.writeI64(self.limit)
5678 
      oprot.writeFieldEnd()
5679 
    if self.warehouse_id is not None:
5680 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5681 
      oprot.writeI64(self.warehouse_id)
5682 
      oprot.writeFieldEnd()
5683 
    oprot.writeFieldStop()
5684 
    oprot.writeStructEnd()
5685 
 
5686 
  def validate(self):
5687 
    return
5688 
 
5689 
 
5690 
  def __repr__(self):
5691 
    L = ['%s=%r' % (key, value)
5692 
      for key, value in self.__dict__.iteritems()]
5693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5694 
 
5695 
  def __eq__(self, other):
5696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5697 
 
5698 
  def __ne__(self, other):
5699 
    return not (self == other)
5700 
 
5701 
class getOrdersInBatch_result:
5702 
  """
5703 
  Attributes:
5704 
   - success
5705 
   - ex
5706 
  """
5707 
 
5708 
  thrift_spec = (
5709 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5711 
  )
5712 
 
5713 
  def __init__(self, success=None, ex=None,):
5714 
    self.success = success
5715 
    self.ex = ex
5716 
 
5717 
  def read(self, iprot):
5718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5720 
      return
5721 
    iprot.readStructBegin()
5722 
    while True:
5723 
      (fname, ftype, fid) = iprot.readFieldBegin()
5724 
      if ftype == TType.STOP:
5725 
        break
5726 
      if fid == 0:
5727 
        if ftype == TType.LIST:
5728 
          self.success = []
5729 
          (_etype45, _size42) = iprot.readListBegin()
5730 
          for _i46 in xrange(_size42):
5731 
            _elem47 = Order()
5732 
            _elem47.read(iprot)
5733 
            self.success.append(_elem47)
5734 
          iprot.readListEnd()
5735 
        else:
5736 
          iprot.skip(ftype)
5737 
      elif fid == 1:
5738 
        if ftype == TType.STRUCT:
5739 
          self.ex = TransactionServiceException()
5740 
          self.ex.read(iprot)
5741 
        else:
5742 
          iprot.skip(ftype)
5743 
      else:
5744 
        iprot.skip(ftype)
5745 
      iprot.readFieldEnd()
5746 
    iprot.readStructEnd()
5747 
 
5748 
  def write(self, oprot):
5749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5751 
      return
5752 
    oprot.writeStructBegin('getOrdersInBatch_result')
5753 
    if self.success is not None:
5754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5755 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5756 
      for iter48 in self.success:
5757 
        iter48.write(oprot)
5758 
      oprot.writeListEnd()
5759 
      oprot.writeFieldEnd()
5760 
    if self.ex is not None:
5761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5762 
      self.ex.write(oprot)
5763 
      oprot.writeFieldEnd()
5764 
    oprot.writeFieldStop()
5765 
    oprot.writeStructEnd()
5766 
 
5767 
  def validate(self):
5768 
    return
5769 
 
5770 
 
5771 
  def __repr__(self):
5772 
    L = ['%s=%r' % (key, value)
5773 
      for key, value in self.__dict__.iteritems()]
5774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5775 
 
5776 
  def __eq__(self, other):
5777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5778 
 
5779 
  def __ne__(self, other):
5780 
    return not (self == other)
5781 
 
5782 
class getOrderCount_args:
5783 
  """
5784 
  Attributes:
5785 
   - statuses
5786 
   - warehouseId
5787 
  """
5788 
 
5789 
  thrift_spec = (
5790 
    None, # 0
5791 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5792 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5793 
  )
5794 
 
5795 
  def __init__(self, statuses=None, warehouseId=None,):
5796 
    self.statuses = statuses
5797 
    self.warehouseId = warehouseId
5798 
 
5799 
  def read(self, iprot):
5800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5802 
      return
5803 
    iprot.readStructBegin()
5804 
    while True:
5805 
      (fname, ftype, fid) = iprot.readFieldBegin()
5806 
      if ftype == TType.STOP:
5807 
        break
5808 
      if fid == 1:
5809 
        if ftype == TType.LIST:
5810 
          self.statuses = []
5811 
          (_etype52, _size49) = iprot.readListBegin()
5812 
          for _i53 in xrange(_size49):
5813 
            _elem54 = iprot.readI32();
5814 
            self.statuses.append(_elem54)
5815 
          iprot.readListEnd()
5816 
        else:
5817 
          iprot.skip(ftype)
5818 
      elif fid == 2:
5819 
        if ftype == TType.I64:
5820 
          self.warehouseId = iprot.readI64();
5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      else:
5824 
        iprot.skip(ftype)
5825 
      iprot.readFieldEnd()
5826 
    iprot.readStructEnd()
5827 
 
5828 
  def write(self, oprot):
5829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5831 
      return
5832 
    oprot.writeStructBegin('getOrderCount_args')
5833 
    if self.statuses is not None:
5834 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5835 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5836 
      for iter55 in self.statuses:
5837 
        oprot.writeI32(iter55)
5838 
      oprot.writeListEnd()
5839 
      oprot.writeFieldEnd()
5840 
    if self.warehouseId is not None:
5841 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5842 
      oprot.writeI64(self.warehouseId)
5843 
      oprot.writeFieldEnd()
5844 
    oprot.writeFieldStop()
5845 
    oprot.writeStructEnd()
5846 
 
5847 
  def validate(self):
5848 
    return
5849 
 
5850 
 
5851 
  def __repr__(self):
5852 
    L = ['%s=%r' % (key, value)
5853 
      for key, value in self.__dict__.iteritems()]
5854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5855 
 
5856 
  def __eq__(self, other):
5857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5858 
 
5859 
  def __ne__(self, other):
5860 
    return not (self == other)
5861 
 
5862 
class getOrderCount_result:
5863 
  """
5864 
  Attributes:
5865 
   - success
5866 
   - ex
5867 
  """
5868 
 
5869 
  thrift_spec = (
5870 
    (0, TType.I32, 'success', None, None, ), # 0
5871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5872 
  )
5873 
 
5874 
  def __init__(self, success=None, ex=None,):
5875 
    self.success = success
5876 
    self.ex = ex
5877 
 
5878 
  def read(self, iprot):
5879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5881 
      return
5882 
    iprot.readStructBegin()
5883 
    while True:
5884 
      (fname, ftype, fid) = iprot.readFieldBegin()
5885 
      if ftype == TType.STOP:
5886 
        break
5887 
      if fid == 0:
5888 
        if ftype == TType.I32:
5889 
          self.success = iprot.readI32();
5890 
        else:
5891 
          iprot.skip(ftype)
5892 
      elif fid == 1:
5893 
        if ftype == TType.STRUCT:
5894 
          self.ex = TransactionServiceException()
5895 
          self.ex.read(iprot)
5896 
        else:
5897 
          iprot.skip(ftype)
5898 
      else:
5899 
        iprot.skip(ftype)
5900 
      iprot.readFieldEnd()
5901 
    iprot.readStructEnd()
5902 
 
5903 
  def write(self, oprot):
5904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5906 
      return
5907 
    oprot.writeStructBegin('getOrderCount_result')
5908 
    if self.success is not None:
5909 
      oprot.writeFieldBegin('success', TType.I32, 0)
5910 
      oprot.writeI32(self.success)
5911 
      oprot.writeFieldEnd()
5912 
    if self.ex is not None:
5913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5914 
      self.ex.write(oprot)
5915 
      oprot.writeFieldEnd()
5916 
    oprot.writeFieldStop()
5917 
    oprot.writeStructEnd()
5918 
 
5919 
  def validate(self):
5920 
    return
5921 
 
5922 
 
5923 
  def __repr__(self):
5924 
    L = ['%s=%r' % (key, value)
5925 
      for key, value in self.__dict__.iteritems()]
5926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5927 
 
5928 
  def __eq__(self, other):
5929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5930 
 
5931 
  def __ne__(self, other):
5932 
    return not (self == other)
5933 
 
999 varun.gupt 5934 
class getOrdersByBillingDate_args:
5935 
  """
5936 
  Attributes:
5937 
   - status
5938 
   - start_billing_date
5939 
   - end_billing_date
5940 
   - warehouse_id
5941 
  """
5942 
 
5943 
  thrift_spec = (
5944 
    None, # 0
5945 
    (1, TType.I32, 'status', None, None, ), # 1
5946 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5947 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5948 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5949 
  )
5950 
 
5951 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5952 
    self.status = status
5953 
    self.start_billing_date = start_billing_date
5954 
    self.end_billing_date = end_billing_date
5955 
    self.warehouse_id = warehouse_id
5956 
 
5957 
  def read(self, iprot):
5958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5960 
      return
5961 
    iprot.readStructBegin()
5962 
    while True:
5963 
      (fname, ftype, fid) = iprot.readFieldBegin()
5964 
      if ftype == TType.STOP:
5965 
        break
5966 
      if fid == 1:
5967 
        if ftype == TType.I32:
5968 
          self.status = iprot.readI32();
5969 
        else:
5970 
          iprot.skip(ftype)
5971 
      elif fid == 2:
5972 
        if ftype == TType.I64:
5973 
          self.start_billing_date = iprot.readI64();
5974 
        else:
5975 
          iprot.skip(ftype)
5976 
      elif fid == 3:
5977 
        if ftype == TType.I64:
5978 
          self.end_billing_date = iprot.readI64();
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      elif fid == 4:
5982 
        if ftype == TType.I64:
5983 
          self.warehouse_id = iprot.readI64();
5984 
        else:
5985 
          iprot.skip(ftype)
5986 
      else:
5987 
        iprot.skip(ftype)
5988 
      iprot.readFieldEnd()
5989 
    iprot.readStructEnd()
5990 
 
5991 
  def write(self, oprot):
5992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5994 
      return
5995 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5996 
    if self.status is not None:
999 varun.gupt 5997 
      oprot.writeFieldBegin('status', TType.I32, 1)
5998 
      oprot.writeI32(self.status)
5999 
      oprot.writeFieldEnd()
3431 rajveer 6000 
    if self.start_billing_date is not None:
999 varun.gupt 6001 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6002 
      oprot.writeI64(self.start_billing_date)
6003 
      oprot.writeFieldEnd()
3431 rajveer 6004 
    if self.end_billing_date is not None:
999 varun.gupt 6005 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6006 
      oprot.writeI64(self.end_billing_date)
6007 
      oprot.writeFieldEnd()
3431 rajveer 6008 
    if self.warehouse_id is not None:
999 varun.gupt 6009 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6010 
      oprot.writeI64(self.warehouse_id)
6011 
      oprot.writeFieldEnd()
6012 
    oprot.writeFieldStop()
6013 
    oprot.writeStructEnd()
6014 
 
3431 rajveer 6015 
  def validate(self):
6016 
    return
6017 
 
6018 
 
999 varun.gupt 6019 
  def __repr__(self):
6020 
    L = ['%s=%r' % (key, value)
6021 
      for key, value in self.__dict__.iteritems()]
6022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6023 
 
6024 
  def __eq__(self, other):
6025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6026 
 
6027 
  def __ne__(self, other):
6028 
    return not (self == other)
6029 
 
6030 
class getOrdersByBillingDate_result:
6031 
  """
6032 
  Attributes:
6033 
   - success
6034 
   - ex
6035 
  """
6036 
 
6037 
  thrift_spec = (
6038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6040 
  )
6041 
 
6042 
  def __init__(self, success=None, ex=None,):
6043 
    self.success = success
6044 
    self.ex = ex
6045 
 
6046 
  def read(self, iprot):
6047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6049 
      return
6050 
    iprot.readStructBegin()
6051 
    while True:
6052 
      (fname, ftype, fid) = iprot.readFieldBegin()
6053 
      if ftype == TType.STOP:
6054 
        break
6055 
      if fid == 0:
6056 
        if ftype == TType.LIST:
6057 
          self.success = []
4133 chandransh 6058 
          (_etype59, _size56) = iprot.readListBegin()
6059 
          for _i60 in xrange(_size56):
6060 
            _elem61 = Order()
6061 
            _elem61.read(iprot)
6062 
            self.success.append(_elem61)
999 varun.gupt 6063 
          iprot.readListEnd()
6064 
        else:
6065 
          iprot.skip(ftype)
6066 
      elif fid == 1:
6067 
        if ftype == TType.STRUCT:
6068 
          self.ex = TransactionServiceException()
6069 
          self.ex.read(iprot)
6070 
        else:
6071 
          iprot.skip(ftype)
6072 
      else:
6073 
        iprot.skip(ftype)
6074 
      iprot.readFieldEnd()
6075 
    iprot.readStructEnd()
6076 
 
6077 
  def write(self, oprot):
6078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6080 
      return
6081 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6082 
    if self.success is not None:
999 varun.gupt 6083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6085 
      for iter62 in self.success:
6086 
        iter62.write(oprot)
999 varun.gupt 6087 
      oprot.writeListEnd()
6088 
      oprot.writeFieldEnd()
3431 rajveer 6089 
    if self.ex is not None:
999 varun.gupt 6090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6091 
      self.ex.write(oprot)
6092 
      oprot.writeFieldEnd()
6093 
    oprot.writeFieldStop()
6094 
    oprot.writeStructEnd()
6095 
 
3431 rajveer 6096 
  def validate(self):
6097 
    return
6098 
 
6099 
 
999 varun.gupt 6100 
  def __repr__(self):
6101 
    L = ['%s=%r' % (key, value)
6102 
      for key, value in self.__dict__.iteritems()]
6103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6104 
 
6105 
  def __eq__(self, other):
6106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6107 
 
6108 
  def __ne__(self, other):
6109 
    return not (self == other)
6110 
 
3427 chandransh 6111 
class getOrdersByShippingDate_args:
6112 
  """
6113 
  Attributes:
6114 
   - fromShippingDate
6115 
   - toShippingDate
6116 
   - providerId
6117 
   - warehouseId
3451 chandransh 6118 
   - cod
3427 chandransh 6119 
  """
6120 
 
6121 
  thrift_spec = (
6122 
    None, # 0
6123 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6124 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6125 
    (3, TType.I64, 'providerId', None, None, ), # 3
6126 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6127 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6128 
  )
6129 
 
3451 chandransh 6130 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6131 
    self.fromShippingDate = fromShippingDate
6132 
    self.toShippingDate = toShippingDate
6133 
    self.providerId = providerId
6134 
    self.warehouseId = warehouseId
3451 chandransh 6135 
    self.cod = cod
3427 chandransh 6136 
 
6137 
  def read(self, iprot):
6138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6140 
      return
6141 
    iprot.readStructBegin()
6142 
    while True:
6143 
      (fname, ftype, fid) = iprot.readFieldBegin()
6144 
      if ftype == TType.STOP:
6145 
        break
6146 
      if fid == 1:
6147 
        if ftype == TType.I64:
6148 
          self.fromShippingDate = iprot.readI64();
6149 
        else:
6150 
          iprot.skip(ftype)
6151 
      elif fid == 2:
6152 
        if ftype == TType.I64:
6153 
          self.toShippingDate = iprot.readI64();
6154 
        else:
6155 
          iprot.skip(ftype)
6156 
      elif fid == 3:
6157 
        if ftype == TType.I64:
6158 
          self.providerId = iprot.readI64();
6159 
        else:
6160 
          iprot.skip(ftype)
6161 
      elif fid == 4:
6162 
        if ftype == TType.I64:
6163 
          self.warehouseId = iprot.readI64();
6164 
        else:
6165 
          iprot.skip(ftype)
3451 chandransh 6166 
      elif fid == 5:
6167 
        if ftype == TType.BOOL:
6168 
          self.cod = iprot.readBool();
6169 
        else:
6170 
          iprot.skip(ftype)
3427 chandransh 6171 
      else:
6172 
        iprot.skip(ftype)
6173 
      iprot.readFieldEnd()
6174 
    iprot.readStructEnd()
6175 
 
6176 
  def write(self, oprot):
6177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6179 
      return
6180 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6181 
    if self.fromShippingDate is not None:
3427 chandransh 6182 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6183 
      oprot.writeI64(self.fromShippingDate)
6184 
      oprot.writeFieldEnd()
3431 rajveer 6185 
    if self.toShippingDate is not None:
3427 chandransh 6186 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6187 
      oprot.writeI64(self.toShippingDate)
6188 
      oprot.writeFieldEnd()
3431 rajveer 6189 
    if self.providerId is not None:
3427 chandransh 6190 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6191 
      oprot.writeI64(self.providerId)
6192 
      oprot.writeFieldEnd()
3431 rajveer 6193 
    if self.warehouseId is not None:
3427 chandransh 6194 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6195 
      oprot.writeI64(self.warehouseId)
6196 
      oprot.writeFieldEnd()
3451 chandransh 6197 
    if self.cod is not None:
6198 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6199 
      oprot.writeBool(self.cod)
6200 
      oprot.writeFieldEnd()
3427 chandransh 6201 
    oprot.writeFieldStop()
6202 
    oprot.writeStructEnd()
6203 
 
3431 rajveer 6204 
  def validate(self):
6205 
    return
6206 
 
6207 
 
3427 chandransh 6208 
  def __repr__(self):
6209 
    L = ['%s=%r' % (key, value)
6210 
      for key, value in self.__dict__.iteritems()]
6211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6212 
 
6213 
  def __eq__(self, other):
6214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6215 
 
6216 
  def __ne__(self, other):
6217 
    return not (self == other)
6218 
 
6219 
class getOrdersByShippingDate_result:
6220 
  """
6221 
  Attributes:
6222 
   - success
6223 
   - ex
6224 
  """
6225 
 
6226 
  thrift_spec = (
6227 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6228 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6229 
  )
6230 
 
6231 
  def __init__(self, success=None, ex=None,):
6232 
    self.success = success
6233 
    self.ex = ex
6234 
 
6235 
  def read(self, iprot):
6236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6238 
      return
6239 
    iprot.readStructBegin()
6240 
    while True:
6241 
      (fname, ftype, fid) = iprot.readFieldBegin()
6242 
      if ftype == TType.STOP:
6243 
        break
6244 
      if fid == 0:
6245 
        if ftype == TType.LIST:
6246 
          self.success = []
4133 chandransh 6247 
          (_etype66, _size63) = iprot.readListBegin()
6248 
          for _i67 in xrange(_size63):
6249 
            _elem68 = Order()
6250 
            _elem68.read(iprot)
6251 
            self.success.append(_elem68)
3427 chandransh 6252 
          iprot.readListEnd()
6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      elif fid == 1:
6256 
        if ftype == TType.STRUCT:
6257 
          self.ex = TransactionServiceException()
6258 
          self.ex.read(iprot)
6259 
        else:
6260 
          iprot.skip(ftype)
6261 
      else:
6262 
        iprot.skip(ftype)
6263 
      iprot.readFieldEnd()
6264 
    iprot.readStructEnd()
6265 
 
6266 
  def write(self, oprot):
6267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6269 
      return
6270 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6271 
    if self.success is not None:
3427 chandransh 6272 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6273 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6274 
      for iter69 in self.success:
6275 
        iter69.write(oprot)
3427 chandransh 6276 
      oprot.writeListEnd()
6277 
      oprot.writeFieldEnd()
3431 rajveer 6278 
    if self.ex is not None:
3427 chandransh 6279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6280 
      self.ex.write(oprot)
6281 
      oprot.writeFieldEnd()
6282 
    oprot.writeFieldStop()
6283 
    oprot.writeStructEnd()
6284 
 
3431 rajveer 6285 
  def validate(self):
6286 
    return
6287 
 
6288 
 
3427 chandransh 6289 
  def __repr__(self):
6290 
    L = ['%s=%r' % (key, value)
6291 
      for key, value in self.__dict__.iteritems()]
6292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6293 
 
6294 
  def __eq__(self, other):
6295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6296 
 
6297 
  def __ne__(self, other):
6298 
    return not (self == other)
6299 
 
1382 varun.gupt 6300 
class getReturnableOrdersForCustomer_args:
6301 
  """
6302 
  Attributes:
6303 
   - customer_id
6304 
   - limit
6305 
  """
6306 
 
6307 
  thrift_spec = (
6308 
    None, # 0
6309 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6310 
    (2, TType.I64, 'limit', None, None, ), # 2
6311 
  )
6312 
 
6313 
  def __init__(self, customer_id=None, limit=None,):
6314 
    self.customer_id = customer_id
6315 
    self.limit = limit
6316 
 
6317 
  def read(self, iprot):
6318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6320 
      return
6321 
    iprot.readStructBegin()
6322 
    while True:
6323 
      (fname, ftype, fid) = iprot.readFieldBegin()
6324 
      if ftype == TType.STOP:
6325 
        break
6326 
      if fid == 1:
6327 
        if ftype == TType.I64:
6328 
          self.customer_id = iprot.readI64();
6329 
        else:
6330 
          iprot.skip(ftype)
6331 
      elif fid == 2:
6332 
        if ftype == TType.I64:
6333 
          self.limit = iprot.readI64();
6334 
        else:
6335 
          iprot.skip(ftype)
6336 
      else:
6337 
        iprot.skip(ftype)
6338 
      iprot.readFieldEnd()
6339 
    iprot.readStructEnd()
6340 
 
6341 
  def write(self, oprot):
6342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6344 
      return
6345 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6346 
    if self.customer_id is not None:
1382 varun.gupt 6347 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6348 
      oprot.writeI64(self.customer_id)
6349 
      oprot.writeFieldEnd()
3431 rajveer 6350 
    if self.limit is not None:
1382 varun.gupt 6351 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6352 
      oprot.writeI64(self.limit)
6353 
      oprot.writeFieldEnd()
6354 
    oprot.writeFieldStop()
6355 
    oprot.writeStructEnd()
6356 
 
3431 rajveer 6357 
  def validate(self):
6358 
    return
6359 
 
6360 
 
1382 varun.gupt 6361 
  def __repr__(self):
6362 
    L = ['%s=%r' % (key, value)
6363 
      for key, value in self.__dict__.iteritems()]
6364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6365 
 
6366 
  def __eq__(self, other):
6367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6368 
 
6369 
  def __ne__(self, other):
6370 
    return not (self == other)
6371 
 
6372 
class getReturnableOrdersForCustomer_result:
6373 
  """
6374 
  Attributes:
6375 
   - success
6376 
   - ex
6377 
  """
6378 
 
6379 
  thrift_spec = (
6380 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6381 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6382 
  )
6383 
 
6384 
  def __init__(self, success=None, ex=None,):
6385 
    self.success = success
6386 
    self.ex = ex
6387 
 
6388 
  def read(self, iprot):
6389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6391 
      return
6392 
    iprot.readStructBegin()
6393 
    while True:
6394 
      (fname, ftype, fid) = iprot.readFieldBegin()
6395 
      if ftype == TType.STOP:
6396 
        break
6397 
      if fid == 0:
6398 
        if ftype == TType.LIST:
6399 
          self.success = []
4133 chandransh 6400 
          (_etype73, _size70) = iprot.readListBegin()
6401 
          for _i74 in xrange(_size70):
6402 
            _elem75 = iprot.readI64();
6403 
            self.success.append(_elem75)
1382 varun.gupt 6404 
          iprot.readListEnd()
6405 
        else:
6406 
          iprot.skip(ftype)
6407 
      elif fid == 1:
6408 
        if ftype == TType.STRUCT:
6409 
          self.ex = TransactionServiceException()
6410 
          self.ex.read(iprot)
6411 
        else:
6412 
          iprot.skip(ftype)
6413 
      else:
6414 
        iprot.skip(ftype)
6415 
      iprot.readFieldEnd()
6416 
    iprot.readStructEnd()
6417 
 
6418 
  def write(self, oprot):
6419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6421 
      return
6422 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6423 
    if self.success is not None:
1382 varun.gupt 6424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6425 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6426 
      for iter76 in self.success:
6427 
        oprot.writeI64(iter76)
1382 varun.gupt 6428 
      oprot.writeListEnd()
6429 
      oprot.writeFieldEnd()
3431 rajveer 6430 
    if self.ex is not None:
1382 varun.gupt 6431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6432 
      self.ex.write(oprot)
6433 
      oprot.writeFieldEnd()
6434 
    oprot.writeFieldStop()
6435 
    oprot.writeStructEnd()
6436 
 
3431 rajveer 6437 
  def validate(self):
6438 
    return
6439 
 
6440 
 
1382 varun.gupt 6441 
  def __repr__(self):
6442 
    L = ['%s=%r' % (key, value)
6443 
      for key, value in self.__dict__.iteritems()]
6444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6445 
 
6446 
  def __eq__(self, other):
6447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6448 
 
6449 
  def __ne__(self, other):
6450 
    return not (self == other)
6451 
 
6452 
class getCancellableOrdersForCustomer_args:
6453 
  """
6454 
  Attributes:
6455 
   - customer_id
6456 
   - limit
6457 
  """
6458 
 
6459 
  thrift_spec = (
6460 
    None, # 0
6461 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6462 
    (2, TType.I64, 'limit', None, None, ), # 2
6463 
  )
6464 
 
6465 
  def __init__(self, customer_id=None, limit=None,):
6466 
    self.customer_id = customer_id
6467 
    self.limit = limit
6468 
 
6469 
  def read(self, iprot):
6470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6472 
      return
6473 
    iprot.readStructBegin()
6474 
    while True:
6475 
      (fname, ftype, fid) = iprot.readFieldBegin()
6476 
      if ftype == TType.STOP:
6477 
        break
6478 
      if fid == 1:
6479 
        if ftype == TType.I64:
6480 
          self.customer_id = iprot.readI64();
6481 
        else:
6482 
          iprot.skip(ftype)
6483 
      elif fid == 2:
6484 
        if ftype == TType.I64:
6485 
          self.limit = iprot.readI64();
6486 
        else:
6487 
          iprot.skip(ftype)
6488 
      else:
6489 
        iprot.skip(ftype)
6490 
      iprot.readFieldEnd()
6491 
    iprot.readStructEnd()
6492 
 
6493 
  def write(self, oprot):
6494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6496 
      return
6497 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6498 
    if self.customer_id is not None:
1382 varun.gupt 6499 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6500 
      oprot.writeI64(self.customer_id)
6501 
      oprot.writeFieldEnd()
3431 rajveer 6502 
    if self.limit is not None:
1382 varun.gupt 6503 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6504 
      oprot.writeI64(self.limit)
6505 
      oprot.writeFieldEnd()
6506 
    oprot.writeFieldStop()
6507 
    oprot.writeStructEnd()
6508 
 
3431 rajveer 6509 
  def validate(self):
6510 
    return
6511 
 
6512 
 
1382 varun.gupt 6513 
  def __repr__(self):
6514 
    L = ['%s=%r' % (key, value)
6515 
      for key, value in self.__dict__.iteritems()]
6516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6517 
 
6518 
  def __eq__(self, other):
6519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6520 
 
6521 
  def __ne__(self, other):
6522 
    return not (self == other)
6523 
 
6524 
class getCancellableOrdersForCustomer_result:
6525 
  """
6526 
  Attributes:
6527 
   - success
6528 
   - ex
6529 
  """
6530 
 
6531 
  thrift_spec = (
6532 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6534 
  )
6535 
 
6536 
  def __init__(self, success=None, ex=None,):
6537 
    self.success = success
6538 
    self.ex = ex
6539 
 
6540 
  def read(self, iprot):
6541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6543 
      return
6544 
    iprot.readStructBegin()
6545 
    while True:
6546 
      (fname, ftype, fid) = iprot.readFieldBegin()
6547 
      if ftype == TType.STOP:
6548 
        break
6549 
      if fid == 0:
6550 
        if ftype == TType.LIST:
6551 
          self.success = []
4133 chandransh 6552 
          (_etype80, _size77) = iprot.readListBegin()
6553 
          for _i81 in xrange(_size77):
6554 
            _elem82 = iprot.readI64();
6555 
            self.success.append(_elem82)
1382 varun.gupt 6556 
          iprot.readListEnd()
6557 
        else:
6558 
          iprot.skip(ftype)
6559 
      elif fid == 1:
6560 
        if ftype == TType.STRUCT:
6561 
          self.ex = TransactionServiceException()
6562 
          self.ex.read(iprot)
6563 
        else:
6564 
          iprot.skip(ftype)
6565 
      else:
6566 
        iprot.skip(ftype)
6567 
      iprot.readFieldEnd()
6568 
    iprot.readStructEnd()
6569 
 
6570 
  def write(self, oprot):
6571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6573 
      return
6574 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6575 
    if self.success is not None:
1382 varun.gupt 6576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6577 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6578 
      for iter83 in self.success:
6579 
        oprot.writeI64(iter83)
1382 varun.gupt 6580 
      oprot.writeListEnd()
6581 
      oprot.writeFieldEnd()
3431 rajveer 6582 
    if self.ex is not None:
1382 varun.gupt 6583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6584 
      self.ex.write(oprot)
6585 
      oprot.writeFieldEnd()
6586 
    oprot.writeFieldStop()
6587 
    oprot.writeStructEnd()
6588 
 
3431 rajveer 6589 
  def validate(self):
6590 
    return
6591 
 
6592 
 
1382 varun.gupt 6593 
  def __repr__(self):
6594 
    L = ['%s=%r' % (key, value)
6595 
      for key, value in self.__dict__.iteritems()]
6596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6597 
 
6598 
  def __eq__(self, other):
6599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6600 
 
6601 
  def __ne__(self, other):
6602 
    return not (self == other)
6603 
 
483 rajveer 6604 
class changeOrderStatus_args:
94 ashish 6605 
  """
6606 
  Attributes:
483 rajveer 6607 
   - orderId
6608 
   - status
6609 
   - description
94 ashish 6610 
  """
6611 
 
6612 
  thrift_spec = (
6613 
    None, # 0
483 rajveer 6614 
    (1, TType.I64, 'orderId', None, None, ), # 1
6615 
    (2, TType.I32, 'status', None, None, ), # 2
6616 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6617 
  )
6618 
 
483 rajveer 6619 
  def __init__(self, orderId=None, status=None, description=None,):
6620 
    self.orderId = orderId
6621 
    self.status = status
6622 
    self.description = description
94 ashish 6623 
 
6624 
  def read(self, iprot):
6625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6627 
      return
6628 
    iprot.readStructBegin()
6629 
    while True:
6630 
      (fname, ftype, fid) = iprot.readFieldBegin()
6631 
      if ftype == TType.STOP:
6632 
        break
6633 
      if fid == 1:
6634 
        if ftype == TType.I64:
483 rajveer 6635 
          self.orderId = iprot.readI64();
94 ashish 6636 
        else:
6637 
          iprot.skip(ftype)
6638 
      elif fid == 2:
483 rajveer 6639 
        if ftype == TType.I32:
6640 
          self.status = iprot.readI32();
94 ashish 6641 
        else:
6642 
          iprot.skip(ftype)
483 rajveer 6643 
      elif fid == 3:
6644 
        if ftype == TType.STRING:
6645 
          self.description = iprot.readString();
6646 
        else:
6647 
          iprot.skip(ftype)
94 ashish 6648 
      else:
6649 
        iprot.skip(ftype)
6650 
      iprot.readFieldEnd()
6651 
    iprot.readStructEnd()
6652 
 
6653 
  def write(self, oprot):
6654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6656 
      return
483 rajveer 6657 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6658 
    if self.orderId is not None:
483 rajveer 6659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6660 
      oprot.writeI64(self.orderId)
94 ashish 6661 
      oprot.writeFieldEnd()
3431 rajveer 6662 
    if self.status is not None:
483 rajveer 6663 
      oprot.writeFieldBegin('status', TType.I32, 2)
6664 
      oprot.writeI32(self.status)
94 ashish 6665 
      oprot.writeFieldEnd()
3431 rajveer 6666 
    if self.description is not None:
483 rajveer 6667 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6668 
      oprot.writeString(self.description)
6669 
      oprot.writeFieldEnd()
94 ashish 6670 
    oprot.writeFieldStop()
6671 
    oprot.writeStructEnd()
6672 
 
3431 rajveer 6673 
  def validate(self):
6674 
    return
6675 
 
6676 
 
94 ashish 6677 
  def __repr__(self):
6678 
    L = ['%s=%r' % (key, value)
6679 
      for key, value in self.__dict__.iteritems()]
6680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6681 
 
6682 
  def __eq__(self, other):
6683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6684 
 
6685 
  def __ne__(self, other):
6686 
    return not (self == other)
6687 
 
483 rajveer 6688 
class changeOrderStatus_result:
94 ashish 6689 
  """
6690 
  Attributes:
6691 
   - success
6692 
   - ex
6693 
  """
6694 
 
6695 
  thrift_spec = (
6696 
    (0, TType.BOOL, 'success', None, None, ), # 0
6697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6698 
  )
6699 
 
6700 
  def __init__(self, success=None, ex=None,):
6701 
    self.success = success
6702 
    self.ex = ex
6703 
 
6704 
  def read(self, iprot):
6705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6707 
      return
6708 
    iprot.readStructBegin()
6709 
    while True:
6710 
      (fname, ftype, fid) = iprot.readFieldBegin()
6711 
      if ftype == TType.STOP:
6712 
        break
6713 
      if fid == 0:
6714 
        if ftype == TType.BOOL:
6715 
          self.success = iprot.readBool();
6716 
        else:
6717 
          iprot.skip(ftype)
6718 
      elif fid == 1:
6719 
        if ftype == TType.STRUCT:
6720 
          self.ex = TransactionServiceException()
6721 
          self.ex.read(iprot)
6722 
        else:
6723 
          iprot.skip(ftype)
6724 
      else:
6725 
        iprot.skip(ftype)
6726 
      iprot.readFieldEnd()
6727 
    iprot.readStructEnd()
6728 
 
6729 
  def write(self, oprot):
6730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6732 
      return
483 rajveer 6733 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6734 
    if self.success is not None:
94 ashish 6735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6736 
      oprot.writeBool(self.success)
6737 
      oprot.writeFieldEnd()
3431 rajveer 6738 
    if self.ex is not None:
94 ashish 6739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6740 
      self.ex.write(oprot)
6741 
      oprot.writeFieldEnd()
6742 
    oprot.writeFieldStop()
6743 
    oprot.writeStructEnd()
6744 
 
3431 rajveer 6745 
  def validate(self):
6746 
    return
6747 
 
6748 
 
94 ashish 6749 
  def __repr__(self):
6750 
    L = ['%s=%r' % (key, value)
6751 
      for key, value in self.__dict__.iteritems()]
6752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6753 
 
6754 
  def __eq__(self, other):
6755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6756 
 
6757 
  def __ne__(self, other):
6758 
    return not (self == other)
6759 
 
3064 chandransh 6760 
class getOrdersForTransaction_args:
494 rajveer 6761 
  """
6762 
  Attributes:
3064 chandransh 6763 
   - transactionId
6764 
   - customerId
494 rajveer 6765 
  """
6766 
 
6767 
  thrift_spec = (
6768 
    None, # 0
3064 chandransh 6769 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6770 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6771 
  )
6772 
 
3064 chandransh 6773 
  def __init__(self, transactionId=None, customerId=None,):
6774 
    self.transactionId = transactionId
6775 
    self.customerId = customerId
494 rajveer 6776 
 
6777 
  def read(self, iprot):
6778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6780 
      return
6781 
    iprot.readStructBegin()
6782 
    while True:
6783 
      (fname, ftype, fid) = iprot.readFieldBegin()
6784 
      if ftype == TType.STOP:
6785 
        break
6786 
      if fid == 1:
6787 
        if ftype == TType.I64:
3064 chandransh 6788 
          self.transactionId = iprot.readI64();
494 rajveer 6789 
        else:
6790 
          iprot.skip(ftype)
6791 
      elif fid == 2:
3064 chandransh 6792 
        if ftype == TType.I64:
6793 
          self.customerId = iprot.readI64();
494 rajveer 6794 
        else:
6795 
          iprot.skip(ftype)
6796 
      else:
6797 
        iprot.skip(ftype)
6798 
      iprot.readFieldEnd()
6799 
    iprot.readStructEnd()
6800 
 
6801 
  def write(self, oprot):
6802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6804 
      return
3064 chandransh 6805 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6806 
    if self.transactionId is not None:
3064 chandransh 6807 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6808 
      oprot.writeI64(self.transactionId)
494 rajveer 6809 
      oprot.writeFieldEnd()
3431 rajveer 6810 
    if self.customerId is not None:
3064 chandransh 6811 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6812 
      oprot.writeI64(self.customerId)
494 rajveer 6813 
      oprot.writeFieldEnd()
6814 
    oprot.writeFieldStop()
6815 
    oprot.writeStructEnd()
6816 
 
3431 rajveer 6817 
  def validate(self):
6818 
    return
6819 
 
6820 
 
494 rajveer 6821 
  def __repr__(self):
6822 
    L = ['%s=%r' % (key, value)
6823 
      for key, value in self.__dict__.iteritems()]
6824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6825 
 
6826 
  def __eq__(self, other):
6827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6828 
 
6829 
  def __ne__(self, other):
6830 
    return not (self == other)
6831 
 
3064 chandransh 6832 
class getOrdersForTransaction_result:
494 rajveer 6833 
  """
6834 
  Attributes:
6835 
   - success
6836 
   - ex
6837 
  """
6838 
 
6839 
  thrift_spec = (
3064 chandransh 6840 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6841 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6842 
  )
6843 
 
6844 
  def __init__(self, success=None, ex=None,):
6845 
    self.success = success
6846 
    self.ex = ex
6847 
 
6848 
  def read(self, iprot):
6849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6851 
      return
6852 
    iprot.readStructBegin()
6853 
    while True:
6854 
      (fname, ftype, fid) = iprot.readFieldBegin()
6855 
      if ftype == TType.STOP:
6856 
        break
6857 
      if fid == 0:
3064 chandransh 6858 
        if ftype == TType.LIST:
6859 
          self.success = []
4133 chandransh 6860 
          (_etype87, _size84) = iprot.readListBegin()
6861 
          for _i88 in xrange(_size84):
6862 
            _elem89 = Order()
6863 
            _elem89.read(iprot)
6864 
            self.success.append(_elem89)
3064 chandransh 6865 
          iprot.readListEnd()
494 rajveer 6866 
        else:
6867 
          iprot.skip(ftype)
6868 
      elif fid == 1:
6869 
        if ftype == TType.STRUCT:
6870 
          self.ex = TransactionServiceException()
6871 
          self.ex.read(iprot)
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      else:
6875 
        iprot.skip(ftype)
6876 
      iprot.readFieldEnd()
6877 
    iprot.readStructEnd()
6878 
 
6879 
  def write(self, oprot):
6880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6882 
      return
3064 chandransh 6883 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6884 
    if self.success is not None:
3064 chandransh 6885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6887 
      for iter90 in self.success:
6888 
        iter90.write(oprot)
3064 chandransh 6889 
      oprot.writeListEnd()
494 rajveer 6890 
      oprot.writeFieldEnd()
3431 rajveer 6891 
    if self.ex is not None:
494 rajveer 6892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6893 
      self.ex.write(oprot)
6894 
      oprot.writeFieldEnd()
6895 
    oprot.writeFieldStop()
6896 
    oprot.writeStructEnd()
6897 
 
3431 rajveer 6898 
  def validate(self):
6899 
    return
6900 
 
6901 
 
494 rajveer 6902 
  def __repr__(self):
6903 
    L = ['%s=%r' % (key, value)
6904 
      for key, value in self.__dict__.iteritems()]
6905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6906 
 
6907 
  def __eq__(self, other):
6908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6909 
 
6910 
  def __ne__(self, other):
6911 
    return not (self == other)
6912 
 
3064 chandransh 6913 
class getOrdersForCustomer_args:
1149 chandransh 6914 
  """
6915 
  Attributes:
3064 chandransh 6916 
   - customerId
6917 
   - from_date
6918 
   - to_date
6919 
   - statuses
1149 chandransh 6920 
  """
6921 
 
6922 
  thrift_spec = (
6923 
    None, # 0
3064 chandransh 6924 
    (1, TType.I64, 'customerId', None, None, ), # 1
6925 
    (2, TType.I64, 'from_date', None, None, ), # 2
6926 
    (3, TType.I64, 'to_date', None, None, ), # 3
6927 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6928 
  )
6929 
 
3064 chandransh 6930 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6931 
    self.customerId = customerId
6932 
    self.from_date = from_date
6933 
    self.to_date = to_date
6934 
    self.statuses = statuses
1149 chandransh 6935 
 
6936 
  def read(self, iprot):
6937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6939 
      return
6940 
    iprot.readStructBegin()
6941 
    while True:
6942 
      (fname, ftype, fid) = iprot.readFieldBegin()
6943 
      if ftype == TType.STOP:
6944 
        break
6945 
      if fid == 1:
6946 
        if ftype == TType.I64:
3064 chandransh 6947 
          self.customerId = iprot.readI64();
1149 chandransh 6948 
        else:
6949 
          iprot.skip(ftype)
6950 
      elif fid == 2:
6951 
        if ftype == TType.I64:
3064 chandransh 6952 
          self.from_date = iprot.readI64();
1149 chandransh 6953 
        else:
6954 
          iprot.skip(ftype)
2783 chandransh 6955 
      elif fid == 3:
6956 
        if ftype == TType.I64:
3064 chandransh 6957 
          self.to_date = iprot.readI64();
2783 chandransh 6958 
        else:
6959 
          iprot.skip(ftype)
6960 
      elif fid == 4:
3064 chandransh 6961 
        if ftype == TType.LIST:
6962 
          self.statuses = []
4133 chandransh 6963 
          (_etype94, _size91) = iprot.readListBegin()
6964 
          for _i95 in xrange(_size91):
6965 
            _elem96 = iprot.readI32();
6966 
            self.statuses.append(_elem96)
3064 chandransh 6967 
          iprot.readListEnd()
2783 chandransh 6968 
        else:
6969 
          iprot.skip(ftype)
1149 chandransh 6970 
      else:
6971 
        iprot.skip(ftype)
6972 
      iprot.readFieldEnd()
6973 
    iprot.readStructEnd()
6974 
 
6975 
  def write(self, oprot):
6976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6978 
      return
3064 chandransh 6979 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6980 
    if self.customerId is not None:
3064 chandransh 6981 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6982 
      oprot.writeI64(self.customerId)
1149 chandransh 6983 
      oprot.writeFieldEnd()
3431 rajveer 6984 
    if self.from_date is not None:
3064 chandransh 6985 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6986 
      oprot.writeI64(self.from_date)
1149 chandransh 6987 
      oprot.writeFieldEnd()
3431 rajveer 6988 
    if self.to_date is not None:
3064 chandransh 6989 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6990 
      oprot.writeI64(self.to_date)
2783 chandransh 6991 
      oprot.writeFieldEnd()
3431 rajveer 6992 
    if self.statuses is not None:
3064 chandransh 6993 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6994 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6995 
      for iter97 in self.statuses:
6996 
        oprot.writeI32(iter97)
3064 chandransh 6997 
      oprot.writeListEnd()
2783 chandransh 6998 
      oprot.writeFieldEnd()
1149 chandransh 6999 
    oprot.writeFieldStop()
7000 
    oprot.writeStructEnd()
7001 
 
3431 rajveer 7002 
  def validate(self):
7003 
    return
7004 
 
7005 
 
1149 chandransh 7006 
  def __repr__(self):
7007 
    L = ['%s=%r' % (key, value)
7008 
      for key, value in self.__dict__.iteritems()]
7009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7010 
 
7011 
  def __eq__(self, other):
7012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7013 
 
7014 
  def __ne__(self, other):
7015 
    return not (self == other)
7016 
 
3064 chandransh 7017 
class getOrdersForCustomer_result:
1149 chandransh 7018 
  """
7019 
  Attributes:
7020 
   - success
7021 
   - ex
7022 
  """
7023 
 
7024 
  thrift_spec = (
3064 chandransh 7025 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7027 
  )
7028 
 
7029 
  def __init__(self, success=None, ex=None,):
7030 
    self.success = success
7031 
    self.ex = ex
7032 
 
7033 
  def read(self, iprot):
7034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7036 
      return
7037 
    iprot.readStructBegin()
7038 
    while True:
7039 
      (fname, ftype, fid) = iprot.readFieldBegin()
7040 
      if ftype == TType.STOP:
7041 
        break
7042 
      if fid == 0:
3064 chandransh 7043 
        if ftype == TType.LIST:
7044 
          self.success = []
4133 chandransh 7045 
          (_etype101, _size98) = iprot.readListBegin()
7046 
          for _i102 in xrange(_size98):
7047 
            _elem103 = Order()
7048 
            _elem103.read(iprot)
7049 
            self.success.append(_elem103)
3064 chandransh 7050 
          iprot.readListEnd()
1149 chandransh 7051 
        else:
7052 
          iprot.skip(ftype)
7053 
      elif fid == 1:
7054 
        if ftype == TType.STRUCT:
7055 
          self.ex = TransactionServiceException()
7056 
          self.ex.read(iprot)
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
3064 chandransh 7068 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7069 
    if self.success is not None:
3064 chandransh 7070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7071 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7072 
      for iter104 in self.success:
7073 
        iter104.write(oprot)
3064 chandransh 7074 
      oprot.writeListEnd()
1149 chandransh 7075 
      oprot.writeFieldEnd()
3431 rajveer 7076 
    if self.ex is not None:
1149 chandransh 7077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7078 
      self.ex.write(oprot)
7079 
      oprot.writeFieldEnd()
7080 
    oprot.writeFieldStop()
7081 
    oprot.writeStructEnd()
7082 
 
3431 rajveer 7083 
  def validate(self):
7084 
    return
7085 
 
7086 
 
1149 chandransh 7087 
  def __repr__(self):
7088 
    L = ['%s=%r' % (key, value)
7089 
      for key, value in self.__dict__.iteritems()]
7090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7091 
 
7092 
  def __eq__(self, other):
7093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7094 
 
7095 
  def __ne__(self, other):
7096 
    return not (self == other)
7097 
 
3064 chandransh 7098 
class createOrder_args:
921 rajveer 7099 
  """
7100 
  Attributes:
3064 chandransh 7101 
   - order
921 rajveer 7102 
  """
7103 
 
7104 
  thrift_spec = (
7105 
    None, # 0
3064 chandransh 7106 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7107 
  )
7108 
 
3064 chandransh 7109 
  def __init__(self, order=None,):
7110 
    self.order = order
921 rajveer 7111 
 
7112 
  def read(self, iprot):
7113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7115 
      return
7116 
    iprot.readStructBegin()
7117 
    while True:
7118 
      (fname, ftype, fid) = iprot.readFieldBegin()
7119 
      if ftype == TType.STOP:
7120 
        break
7121 
      if fid == 1:
3064 chandransh 7122 
        if ftype == TType.STRUCT:
7123 
          self.order = Order()
7124 
          self.order.read(iprot)
921 rajveer 7125 
        else:
7126 
          iprot.skip(ftype)
7127 
      else:
7128 
        iprot.skip(ftype)
7129 
      iprot.readFieldEnd()
7130 
    iprot.readStructEnd()
7131 
 
7132 
  def write(self, oprot):
7133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7135 
      return
3064 chandransh 7136 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7137 
    if self.order is not None:
3064 chandransh 7138 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7139 
      self.order.write(oprot)
921 rajveer 7140 
      oprot.writeFieldEnd()
7141 
    oprot.writeFieldStop()
7142 
    oprot.writeStructEnd()
7143 
 
3431 rajveer 7144 
  def validate(self):
7145 
    return
7146 
 
7147 
 
921 rajveer 7148 
  def __repr__(self):
7149 
    L = ['%s=%r' % (key, value)
7150 
      for key, value in self.__dict__.iteritems()]
7151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7152 
 
7153 
  def __eq__(self, other):
7154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7155 
 
7156 
  def __ne__(self, other):
7157 
    return not (self == other)
7158 
 
3064 chandransh 7159 
class createOrder_result:
921 rajveer 7160 
  """
7161 
  Attributes:
7162 
   - success
7163 
   - ex
7164 
  """
7165 
 
7166 
  thrift_spec = (
3064 chandransh 7167 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7169 
  )
7170 
 
7171 
  def __init__(self, success=None, ex=None,):
7172 
    self.success = success
7173 
    self.ex = ex
7174 
 
7175 
  def read(self, iprot):
7176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7178 
      return
7179 
    iprot.readStructBegin()
7180 
    while True:
7181 
      (fname, ftype, fid) = iprot.readFieldBegin()
7182 
      if ftype == TType.STOP:
7183 
        break
7184 
      if fid == 0:
3064 chandransh 7185 
        if ftype == TType.I64:
7186 
          self.success = iprot.readI64();
921 rajveer 7187 
        else:
7188 
          iprot.skip(ftype)
7189 
      elif fid == 1:
7190 
        if ftype == TType.STRUCT:
7191 
          self.ex = TransactionServiceException()
7192 
          self.ex.read(iprot)
7193 
        else:
7194 
          iprot.skip(ftype)
7195 
      else:
7196 
        iprot.skip(ftype)
7197 
      iprot.readFieldEnd()
7198 
    iprot.readStructEnd()
7199 
 
7200 
  def write(self, oprot):
7201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7203 
      return
3064 chandransh 7204 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7205 
    if self.success is not None:
3064 chandransh 7206 
      oprot.writeFieldBegin('success', TType.I64, 0)
7207 
      oprot.writeI64(self.success)
921 rajveer 7208 
      oprot.writeFieldEnd()
3431 rajveer 7209 
    if self.ex is not None:
921 rajveer 7210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7211 
      self.ex.write(oprot)
7212 
      oprot.writeFieldEnd()
7213 
    oprot.writeFieldStop()
7214 
    oprot.writeStructEnd()
7215 
 
3431 rajveer 7216 
  def validate(self):
7217 
    return
7218 
 
7219 
 
921 rajveer 7220 
  def __repr__(self):
7221 
    L = ['%s=%r' % (key, value)
7222 
      for key, value in self.__dict__.iteritems()]
7223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7224 
 
7225 
  def __eq__(self, other):
7226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7227 
 
7228 
  def __ne__(self, other):
7229 
    return not (self == other)
7230 
 
3064 chandransh 7231 
class getOrder_args:
921 rajveer 7232 
  """
7233 
  Attributes:
3064 chandransh 7234 
   - id
921 rajveer 7235 
  """
7236 
 
7237 
  thrift_spec = (
7238 
    None, # 0
3064 chandransh 7239 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7240 
  )
7241 
 
3064 chandransh 7242 
  def __init__(self, id=None,):
7243 
    self.id = id
921 rajveer 7244 
 
7245 
  def read(self, iprot):
7246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7248 
      return
7249 
    iprot.readStructBegin()
7250 
    while True:
7251 
      (fname, ftype, fid) = iprot.readFieldBegin()
7252 
      if ftype == TType.STOP:
7253 
        break
7254 
      if fid == 1:
7255 
        if ftype == TType.I64:
3064 chandransh 7256 
          self.id = iprot.readI64();
921 rajveer 7257 
        else:
7258 
          iprot.skip(ftype)
7259 
      else:
7260 
        iprot.skip(ftype)
7261 
      iprot.readFieldEnd()
7262 
    iprot.readStructEnd()
7263 
 
7264 
  def write(self, oprot):
7265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7267 
      return
3064 chandransh 7268 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7269 
    if self.id is not None:
3064 chandransh 7270 
      oprot.writeFieldBegin('id', TType.I64, 1)
7271 
      oprot.writeI64(self.id)
921 rajveer 7272 
      oprot.writeFieldEnd()
7273 
    oprot.writeFieldStop()
7274 
    oprot.writeStructEnd()
7275 
 
3431 rajveer 7276 
  def validate(self):
7277 
    return
7278 
 
7279 
 
921 rajveer 7280 
  def __repr__(self):
7281 
    L = ['%s=%r' % (key, value)
7282 
      for key, value in self.__dict__.iteritems()]
7283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7284 
 
7285 
  def __eq__(self, other):
7286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7287 
 
7288 
  def __ne__(self, other):
7289 
    return not (self == other)
7290 
 
3064 chandransh 7291 
class getOrder_result:
921 rajveer 7292 
  """
7293 
  Attributes:
7294 
   - success
7295 
   - ex
7296 
  """
7297 
 
7298 
  thrift_spec = (
3064 chandransh 7299 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7301 
  )
7302 
 
7303 
  def __init__(self, success=None, ex=None,):
7304 
    self.success = success
7305 
    self.ex = ex
7306 
 
7307 
  def read(self, iprot):
7308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7310 
      return
7311 
    iprot.readStructBegin()
7312 
    while True:
7313 
      (fname, ftype, fid) = iprot.readFieldBegin()
7314 
      if ftype == TType.STOP:
7315 
        break
7316 
      if fid == 0:
3064 chandransh 7317 
        if ftype == TType.STRUCT:
7318 
          self.success = Order()
7319 
          self.success.read(iprot)
921 rajveer 7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      elif fid == 1:
7323 
        if ftype == TType.STRUCT:
7324 
          self.ex = TransactionServiceException()
7325 
          self.ex.read(iprot)
7326 
        else:
7327 
          iprot.skip(ftype)
7328 
      else:
7329 
        iprot.skip(ftype)
7330 
      iprot.readFieldEnd()
7331 
    iprot.readStructEnd()
7332 
 
7333 
  def write(self, oprot):
7334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7336 
      return
3064 chandransh 7337 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7338 
    if self.success is not None:
3064 chandransh 7339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7340 
      self.success.write(oprot)
921 rajveer 7341 
      oprot.writeFieldEnd()
3431 rajveer 7342 
    if self.ex is not None:
921 rajveer 7343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7344 
      self.ex.write(oprot)
7345 
      oprot.writeFieldEnd()
7346 
    oprot.writeFieldStop()
7347 
    oprot.writeStructEnd()
7348 
 
3431 rajveer 7349 
  def validate(self):
7350 
    return
7351 
 
7352 
 
921 rajveer 7353 
  def __repr__(self):
7354 
    L = ['%s=%r' % (key, value)
7355 
      for key, value in self.__dict__.iteritems()]
7356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7357 
 
7358 
  def __eq__(self, other):
7359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7360 
 
7361 
  def __ne__(self, other):
7362 
    return not (self == other)
7363 
 
3064 chandransh 7364 
class getLineItemsForOrder_args:
94 ashish 7365 
  """
7366 
  Attributes:
3064 chandransh 7367 
   - orderId
94 ashish 7368 
  """
7369 
 
7370 
  thrift_spec = (
7371 
    None, # 0
3064 chandransh 7372 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7373 
  )
7374 
 
3064 chandransh 7375 
  def __init__(self, orderId=None,):
7376 
    self.orderId = orderId
94 ashish 7377 
 
7378 
  def read(self, iprot):
7379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7381 
      return
7382 
    iprot.readStructBegin()
7383 
    while True:
7384 
      (fname, ftype, fid) = iprot.readFieldBegin()
7385 
      if ftype == TType.STOP:
7386 
        break
7387 
      if fid == 1:
7388 
        if ftype == TType.I64:
3064 chandransh 7389 
          self.orderId = iprot.readI64();
94 ashish 7390 
        else:
7391 
          iprot.skip(ftype)
7392 
      else:
7393 
        iprot.skip(ftype)
7394 
      iprot.readFieldEnd()
7395 
    iprot.readStructEnd()
7396 
 
7397 
  def write(self, oprot):
7398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7400 
      return
3064 chandransh 7401 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7402 
    if self.orderId is not None:
3064 chandransh 7403 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7404 
      oprot.writeI64(self.orderId)
94 ashish 7405 
      oprot.writeFieldEnd()
7406 
    oprot.writeFieldStop()
7407 
    oprot.writeStructEnd()
7408 
 
3431 rajveer 7409 
  def validate(self):
7410 
    return
7411 
 
7412 
 
94 ashish 7413 
  def __repr__(self):
7414 
    L = ['%s=%r' % (key, value)
7415 
      for key, value in self.__dict__.iteritems()]
7416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7417 
 
7418 
  def __eq__(self, other):
7419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7420 
 
7421 
  def __ne__(self, other):
7422 
    return not (self == other)
7423 
 
3064 chandransh 7424 
class getLineItemsForOrder_result:
94 ashish 7425 
  """
7426 
  Attributes:
7427 
   - success
7428 
   - ex
7429 
  """
7430 
 
7431 
  thrift_spec = (
3064 chandransh 7432 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7433 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7434 
  )
7435 
 
7436 
  def __init__(self, success=None, ex=None,):
7437 
    self.success = success
7438 
    self.ex = ex
7439 
 
7440 
  def read(self, iprot):
7441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7443 
      return
7444 
    iprot.readStructBegin()
7445 
    while True:
7446 
      (fname, ftype, fid) = iprot.readFieldBegin()
7447 
      if ftype == TType.STOP:
7448 
        break
7449 
      if fid == 0:
483 rajveer 7450 
        if ftype == TType.LIST:
7451 
          self.success = []
4133 chandransh 7452 
          (_etype108, _size105) = iprot.readListBegin()
7453 
          for _i109 in xrange(_size105):
7454 
            _elem110 = LineItem()
7455 
            _elem110.read(iprot)
7456 
            self.success.append(_elem110)
483 rajveer 7457 
          iprot.readListEnd()
94 ashish 7458 
        else:
7459 
          iprot.skip(ftype)
7460 
      elif fid == 1:
7461 
        if ftype == TType.STRUCT:
7462 
          self.ex = TransactionServiceException()
7463 
          self.ex.read(iprot)
7464 
        else:
7465 
          iprot.skip(ftype)
7466 
      else:
7467 
        iprot.skip(ftype)
7468 
      iprot.readFieldEnd()
7469 
    iprot.readStructEnd()
7470 
 
7471 
  def write(self, oprot):
7472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7474 
      return
3064 chandransh 7475 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7476 
    if self.success is not None:
483 rajveer 7477 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7478 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7479 
      for iter111 in self.success:
7480 
        iter111.write(oprot)
483 rajveer 7481 
      oprot.writeListEnd()
94 ashish 7482 
      oprot.writeFieldEnd()
3431 rajveer 7483 
    if self.ex is not None:
94 ashish 7484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7485 
      self.ex.write(oprot)
7486 
      oprot.writeFieldEnd()
7487 
    oprot.writeFieldStop()
7488 
    oprot.writeStructEnd()
7489 
 
3431 rajveer 7490 
  def validate(self):
7491 
    return
7492 
 
7493 
 
94 ashish 7494 
  def __repr__(self):
7495 
    L = ['%s=%r' % (key, value)
7496 
      for key, value in self.__dict__.iteritems()]
7497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7498 
 
7499 
  def __eq__(self, other):
7500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7501 
 
7502 
  def __ne__(self, other):
7503 
    return not (self == other)
7504 
 
3064 chandransh 7505 
class getOrderForCustomer_args:
94 ashish 7506 
  """
7507 
  Attributes:
3064 chandransh 7508 
   - orderId
483 rajveer 7509 
   - customerId
94 ashish 7510 
  """
7511 
 
7512 
  thrift_spec = (
7513 
    None, # 0
3064 chandransh 7514 
    (1, TType.I64, 'orderId', None, None, ), # 1
7515 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7516 
  )
7517 
 
3064 chandransh 7518 
  def __init__(self, orderId=None, customerId=None,):
7519 
    self.orderId = orderId
483 rajveer 7520 
    self.customerId = customerId
94 ashish 7521 
 
7522 
  def read(self, iprot):
7523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7525 
      return
7526 
    iprot.readStructBegin()
7527 
    while True:
7528 
      (fname, ftype, fid) = iprot.readFieldBegin()
7529 
      if ftype == TType.STOP:
7530 
        break
7531 
      if fid == 1:
7532 
        if ftype == TType.I64:
3064 chandransh 7533 
          self.orderId = iprot.readI64();
94 ashish 7534 
        else:
7535 
          iprot.skip(ftype)
7536 
      elif fid == 2:
7537 
        if ftype == TType.I64:
3064 chandransh 7538 
          self.customerId = iprot.readI64();
94 ashish 7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      else:
7542 
        iprot.skip(ftype)
7543 
      iprot.readFieldEnd()
7544 
    iprot.readStructEnd()
7545 
 
7546 
  def write(self, oprot):
7547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7549 
      return
3064 chandransh 7550 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7551 
    if self.orderId is not None:
3064 chandransh 7552 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7553 
      oprot.writeI64(self.orderId)
7554 
      oprot.writeFieldEnd()
3431 rajveer 7555 
    if self.customerId is not None:
3064 chandransh 7556 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7557 
      oprot.writeI64(self.customerId)
94 ashish 7558 
      oprot.writeFieldEnd()
7559 
    oprot.writeFieldStop()
7560 
    oprot.writeStructEnd()
7561 
 
3431 rajveer 7562 
  def validate(self):
7563 
    return
7564 
 
7565 
 
94 ashish 7566 
  def __repr__(self):
7567 
    L = ['%s=%r' % (key, value)
7568 
      for key, value in self.__dict__.iteritems()]
7569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7570 
 
7571 
  def __eq__(self, other):
7572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7573 
 
7574 
  def __ne__(self, other):
7575 
    return not (self == other)
7576 
 
3064 chandransh 7577 
class getOrderForCustomer_result:
94 ashish 7578 
  """
7579 
  Attributes:
7580 
   - success
7581 
   - ex
7582 
  """
7583 
 
7584 
  thrift_spec = (
3064 chandransh 7585 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7587 
  )
7588 
 
7589 
  def __init__(self, success=None, ex=None,):
7590 
    self.success = success
7591 
    self.ex = ex
7592 
 
7593 
  def read(self, iprot):
7594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7596 
      return
7597 
    iprot.readStructBegin()
7598 
    while True:
7599 
      (fname, ftype, fid) = iprot.readFieldBegin()
7600 
      if ftype == TType.STOP:
7601 
        break
7602 
      if fid == 0:
3064 chandransh 7603 
        if ftype == TType.STRUCT:
7604 
          self.success = Order()
7605 
          self.success.read(iprot)
94 ashish 7606 
        else:
7607 
          iprot.skip(ftype)
7608 
      elif fid == 1:
7609 
        if ftype == TType.STRUCT:
7610 
          self.ex = TransactionServiceException()
7611 
          self.ex.read(iprot)
7612 
        else:
7613 
          iprot.skip(ftype)
7614 
      else:
7615 
        iprot.skip(ftype)
7616 
      iprot.readFieldEnd()
7617 
    iprot.readStructEnd()
7618 
 
7619 
  def write(self, oprot):
7620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7622 
      return
3064 chandransh 7623 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7624 
    if self.success is not None:
3064 chandransh 7625 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7626 
      self.success.write(oprot)
94 ashish 7627 
      oprot.writeFieldEnd()
3431 rajveer 7628 
    if self.ex is not None:
94 ashish 7629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7630 
      self.ex.write(oprot)
7631 
      oprot.writeFieldEnd()
7632 
    oprot.writeFieldStop()
7633 
    oprot.writeStructEnd()
7634 
 
3431 rajveer 7635 
  def validate(self):
7636 
    return
7637 
 
7638 
 
94 ashish 7639 
  def __repr__(self):
7640 
    L = ['%s=%r' % (key, value)
7641 
      for key, value in self.__dict__.iteritems()]
7642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7643 
 
7644 
  def __eq__(self, other):
7645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7646 
 
7647 
  def __ne__(self, other):
7648 
    return not (self == other)
7649 
 
3064 chandransh 7650 
class getAlerts_args:
94 ashish 7651 
  """
7652 
  Attributes:
4394 rajveer 7653 
   - type
7654 
   - status
7655 
   - timestamp
94 ashish 7656 
  """
7657 
 
7658 
  thrift_spec = (
7659 
    None, # 0
4394 rajveer 7660 
    (1, TType.I64, 'type', None, None, ), # 1
7661 
    (2, TType.I64, 'status', None, None, ), # 2
7662 
    (3, TType.I64, 'timestamp', None, None, ), # 3
94 ashish 7663 
  )
7664 
 
4394 rajveer 7665 
  def __init__(self, type=None, status=None, timestamp=None,):
7666 
    self.type = type
7667 
    self.status = status
7668 
    self.timestamp = timestamp
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:
4394 rajveer 7681 
          self.type = iprot.readI64();
94 ashish 7682 
        else:
7683 
          iprot.skip(ftype)
3064 chandransh 7684 
      elif fid == 2:
4394 rajveer 7685 
        if ftype == TType.I64:
7686 
          self.status = iprot.readI64();
3064 chandransh 7687 
        else:
7688 
          iprot.skip(ftype)
4394 rajveer 7689 
      elif fid == 3:
7690 
        if ftype == TType.I64:
7691 
          self.timestamp = iprot.readI64();
7692 
        else:
7693 
          iprot.skip(ftype)
94 ashish 7694 
      else:
7695 
        iprot.skip(ftype)
7696 
      iprot.readFieldEnd()
7697 
    iprot.readStructEnd()
7698 
 
7699 
  def write(self, oprot):
7700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7702 
      return
3064 chandransh 7703 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 7704 
    if self.type is not None:
7705 
      oprot.writeFieldBegin('type', TType.I64, 1)
7706 
      oprot.writeI64(self.type)
94 ashish 7707 
      oprot.writeFieldEnd()
4394 rajveer 7708 
    if self.status is not None:
7709 
      oprot.writeFieldBegin('status', TType.I64, 2)
7710 
      oprot.writeI64(self.status)
3064 chandransh 7711 
      oprot.writeFieldEnd()
4394 rajveer 7712 
    if self.timestamp is not None:
7713 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
7714 
      oprot.writeI64(self.timestamp)
7715 
      oprot.writeFieldEnd()
94 ashish 7716 
    oprot.writeFieldStop()
7717 
    oprot.writeStructEnd()
7718 
 
3431 rajveer 7719 
  def validate(self):
7720 
    return
7721 
 
7722 
 
94 ashish 7723 
  def __repr__(self):
7724 
    L = ['%s=%r' % (key, value)
7725 
      for key, value in self.__dict__.iteritems()]
7726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7727 
 
7728 
  def __eq__(self, other):
7729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7730 
 
7731 
  def __ne__(self, other):
7732 
    return not (self == other)
7733 
 
3064 chandransh 7734 
class getAlerts_result:
94 ashish 7735 
  """
7736 
  Attributes:
7737 
   - success
7738 
  """
7739 
 
7740 
  thrift_spec = (
3064 chandransh 7741 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7742 
  )
7743 
 
3064 chandransh 7744 
  def __init__(self, success=None,):
94 ashish 7745 
    self.success = success
7746 
 
7747 
  def read(self, iprot):
7748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7750 
      return
7751 
    iprot.readStructBegin()
7752 
    while True:
7753 
      (fname, ftype, fid) = iprot.readFieldBegin()
7754 
      if ftype == TType.STOP:
7755 
        break
7756 
      if fid == 0:
3064 chandransh 7757 
        if ftype == TType.LIST:
7758 
          self.success = []
4133 chandransh 7759 
          (_etype115, _size112) = iprot.readListBegin()
7760 
          for _i116 in xrange(_size112):
7761 
            _elem117 = Alert()
7762 
            _elem117.read(iprot)
7763 
            self.success.append(_elem117)
3064 chandransh 7764 
          iprot.readListEnd()
94 ashish 7765 
        else:
7766 
          iprot.skip(ftype)
7767 
      else:
7768 
        iprot.skip(ftype)
7769 
      iprot.readFieldEnd()
7770 
    iprot.readStructEnd()
7771 
 
7772 
  def write(self, oprot):
7773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7775 
      return
3064 chandransh 7776 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7777 
    if self.success is not None:
3064 chandransh 7778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7780 
      for iter118 in self.success:
7781 
        iter118.write(oprot)
3064 chandransh 7782 
      oprot.writeListEnd()
94 ashish 7783 
      oprot.writeFieldEnd()
7784 
    oprot.writeFieldStop()
7785 
    oprot.writeStructEnd()
7786 
 
3431 rajveer 7787 
  def validate(self):
7788 
    return
7789 
 
7790 
 
94 ashish 7791 
  def __repr__(self):
7792 
    L = ['%s=%r' % (key, value)
7793 
      for key, value in self.__dict__.iteritems()]
7794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7795 
 
7796 
  def __eq__(self, other):
7797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7798 
 
7799 
  def __ne__(self, other):
7800 
    return not (self == other)
7801 
 
4394 rajveer 7802 
class addAlert_args:
94 ashish 7803 
  """
7804 
  Attributes:
3064 chandransh 7805 
   - type
4394 rajveer 7806 
   - description
94 ashish 7807 
  """
7808 
 
7809 
  thrift_spec = (
7810 
    None, # 0
4394 rajveer 7811 
    (1, TType.I64, 'type', None, None, ), # 1
7812 
    (2, TType.STRING, 'description', None, None, ), # 2
94 ashish 7813 
  )
7814 
 
4394 rajveer 7815 
  def __init__(self, type=None, description=None,):
3064 chandransh 7816 
    self.type = type
4394 rajveer 7817 
    self.description = description
94 ashish 7818 
 
7819 
  def read(self, iprot):
7820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7822 
      return
7823 
    iprot.readStructBegin()
7824 
    while True:
7825 
      (fname, ftype, fid) = iprot.readFieldBegin()
7826 
      if ftype == TType.STOP:
7827 
        break
7828 
      if fid == 1:
7829 
        if ftype == TType.I64:
4394 rajveer 7830 
          self.type = iprot.readI64();
94 ashish 7831 
        else:
7832 
          iprot.skip(ftype)
3064 chandransh 7833 
      elif fid == 2:
7834 
        if ftype == TType.STRING:
4394 rajveer 7835 
          self.description = iprot.readString();
3064 chandransh 7836 
        else:
7837 
          iprot.skip(ftype)
94 ashish 7838 
      else:
7839 
        iprot.skip(ftype)
7840 
      iprot.readFieldEnd()
7841 
    iprot.readStructEnd()
7842 
 
7843 
  def write(self, oprot):
7844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7846 
      return
4394 rajveer 7847 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 7848 
    if self.type is not None:
4394 rajveer 7849 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 7850 
      oprot.writeI64(self.type)
7851 
      oprot.writeFieldEnd()
4394 rajveer 7852 
    if self.description is not None:
7853 
      oprot.writeFieldBegin('description', TType.STRING, 2)
7854 
      oprot.writeString(self.description)
3064 chandransh 7855 
      oprot.writeFieldEnd()
94 ashish 7856 
    oprot.writeFieldStop()
7857 
    oprot.writeStructEnd()
7858 
 
3431 rajveer 7859 
  def validate(self):
7860 
    return
7861 
 
7862 
 
94 ashish 7863 
  def __repr__(self):
7864 
    L = ['%s=%r' % (key, value)
7865 
      for key, value in self.__dict__.iteritems()]
7866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7867 
 
7868 
  def __eq__(self, other):
7869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7870 
 
7871 
  def __ne__(self, other):
7872 
    return not (self == other)
7873 
 
4394 rajveer 7874 
class addAlert_result:
3064 chandransh 7875 
 
7876 
  thrift_spec = (
7877 
  )
7878 
 
7879 
  def read(self, iprot):
7880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7882 
      return
7883 
    iprot.readStructBegin()
7884 
    while True:
7885 
      (fname, ftype, fid) = iprot.readFieldBegin()
7886 
      if ftype == TType.STOP:
7887 
        break
7888 
      else:
7889 
        iprot.skip(ftype)
7890 
      iprot.readFieldEnd()
7891 
    iprot.readStructEnd()
7892 
 
7893 
  def write(self, oprot):
7894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7896 
      return
4394 rajveer 7897 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 7898 
    oprot.writeFieldStop()
7899 
    oprot.writeStructEnd()
7900 
 
3431 rajveer 7901 
  def validate(self):
7902 
    return
7903 
 
7904 
 
3064 chandransh 7905 
  def __repr__(self):
7906 
    L = ['%s=%r' % (key, value)
7907 
      for key, value in self.__dict__.iteritems()]
7908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7909 
 
7910 
  def __eq__(self, other):
7911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7912 
 
7913 
  def __ne__(self, other):
7914 
    return not (self == other)
7915 
 
7916 
class getValidOrderCount_args:
7917 
 
7918 
  thrift_spec = (
7919 
  )
7920 
 
7921 
  def read(self, iprot):
7922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7924 
      return
7925 
    iprot.readStructBegin()
7926 
    while True:
7927 
      (fname, ftype, fid) = iprot.readFieldBegin()
7928 
      if ftype == TType.STOP:
7929 
        break
7930 
      else:
7931 
        iprot.skip(ftype)
7932 
      iprot.readFieldEnd()
7933 
    iprot.readStructEnd()
7934 
 
7935 
  def write(self, oprot):
7936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7938 
      return
7939 
    oprot.writeStructBegin('getValidOrderCount_args')
7940 
    oprot.writeFieldStop()
7941 
    oprot.writeStructEnd()
7942 
 
3431 rajveer 7943 
  def validate(self):
7944 
    return
7945 
 
7946 
 
3064 chandransh 7947 
  def __repr__(self):
7948 
    L = ['%s=%r' % (key, value)
7949 
      for key, value in self.__dict__.iteritems()]
7950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7951 
 
7952 
  def __eq__(self, other):
7953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7954 
 
7955 
  def __ne__(self, other):
7956 
    return not (self == other)
7957 
 
7958 
class getValidOrderCount_result:
94 ashish 7959 
  """
7960 
  Attributes:
7961 
   - success
7962 
  """
7963 
 
7964 
  thrift_spec = (
3064 chandransh 7965 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7966 
  )
7967 
 
3064 chandransh 7968 
  def __init__(self, success=None,):
94 ashish 7969 
    self.success = success
7970 
 
7971 
  def read(self, iprot):
7972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7974 
      return
7975 
    iprot.readStructBegin()
7976 
    while True:
7977 
      (fname, ftype, fid) = iprot.readFieldBegin()
7978 
      if ftype == TType.STOP:
7979 
        break
7980 
      if fid == 0:
3064 chandransh 7981 
        if ftype == TType.I64:
7982 
          self.success = iprot.readI64();
94 ashish 7983 
        else:
7984 
          iprot.skip(ftype)
7985 
      else:
7986 
        iprot.skip(ftype)
7987 
      iprot.readFieldEnd()
7988 
    iprot.readStructEnd()
7989 
 
7990 
  def write(self, oprot):
7991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7993 
      return
3064 chandransh 7994 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7995 
    if self.success is not None:
3064 chandransh 7996 
      oprot.writeFieldBegin('success', TType.I64, 0)
7997 
      oprot.writeI64(self.success)
94 ashish 7998 
      oprot.writeFieldEnd()
7999 
    oprot.writeFieldStop()
8000 
    oprot.writeStructEnd()
8001 
 
3431 rajveer 8002 
  def validate(self):
8003 
    return
8004 
 
8005 
 
94 ashish 8006 
  def __repr__(self):
8007 
    L = ['%s=%r' % (key, value)
8008 
      for key, value in self.__dict__.iteritems()]
8009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8010 
 
8011 
  def __eq__(self, other):
8012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8013 
 
8014 
  def __ne__(self, other):
8015 
    return not (self == other)
8016 
 
3064 chandransh 8017 
class getNoOfCustomersWithSuccessfulTransaction_args:
8018 
 
8019 
  thrift_spec = (
8020 
  )
8021 
 
8022 
  def read(self, iprot):
8023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8025 
      return
8026 
    iprot.readStructBegin()
8027 
    while True:
8028 
      (fname, ftype, fid) = iprot.readFieldBegin()
8029 
      if ftype == TType.STOP:
8030 
        break
8031 
      else:
8032 
        iprot.skip(ftype)
8033 
      iprot.readFieldEnd()
8034 
    iprot.readStructEnd()
8035 
 
8036 
  def write(self, oprot):
8037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8039 
      return
8040 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8041 
    oprot.writeFieldStop()
8042 
    oprot.writeStructEnd()
8043 
 
3431 rajveer 8044 
  def validate(self):
8045 
    return
8046 
 
8047 
 
3064 chandransh 8048 
  def __repr__(self):
8049 
    L = ['%s=%r' % (key, value)
8050 
      for key, value in self.__dict__.iteritems()]
8051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8052 
 
8053 
  def __eq__(self, other):
8054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8055 
 
8056 
  def __ne__(self, other):
8057 
    return not (self == other)
8058 
 
8059 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8060 
  """
8061 
  Attributes:
3064 chandransh 8062 
   - success
94 ashish 8063 
  """
8064 
 
8065 
  thrift_spec = (
3064 chandransh 8066 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8067 
  )
8068 
 
3064 chandransh 8069 
  def __init__(self, success=None,):
8070 
    self.success = success
94 ashish 8071 
 
8072 
  def read(self, iprot):
8073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8075 
      return
8076 
    iprot.readStructBegin()
8077 
    while True:
8078 
      (fname, ftype, fid) = iprot.readFieldBegin()
8079 
      if ftype == TType.STOP:
8080 
        break
3064 chandransh 8081 
      if fid == 0:
94 ashish 8082 
        if ftype == TType.I64:
3064 chandransh 8083 
          self.success = iprot.readI64();
94 ashish 8084 
        else:
8085 
          iprot.skip(ftype)
8086 
      else:
8087 
        iprot.skip(ftype)
8088 
      iprot.readFieldEnd()
8089 
    iprot.readStructEnd()
8090 
 
8091 
  def write(self, oprot):
8092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8094 
      return
3064 chandransh 8095 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8096 
    if self.success is not None:
3064 chandransh 8097 
      oprot.writeFieldBegin('success', TType.I64, 0)
8098 
      oprot.writeI64(self.success)
94 ashish 8099 
      oprot.writeFieldEnd()
8100 
    oprot.writeFieldStop()
8101 
    oprot.writeStructEnd()
8102 
 
3431 rajveer 8103 
  def validate(self):
8104 
    return
8105 
 
8106 
 
94 ashish 8107 
  def __repr__(self):
8108 
    L = ['%s=%r' % (key, value)
8109 
      for key, value in self.__dict__.iteritems()]
8110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8111 
 
8112 
  def __eq__(self, other):
8113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8114 
 
8115 
  def __ne__(self, other):
8116 
    return not (self == other)
8117 
 
3064 chandransh 8118 
class getValidOrdersAmountRange_args:
8119 
 
8120 
  thrift_spec = (
8121 
  )
8122 
 
8123 
  def read(self, iprot):
8124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8126 
      return
8127 
    iprot.readStructBegin()
8128 
    while True:
8129 
      (fname, ftype, fid) = iprot.readFieldBegin()
8130 
      if ftype == TType.STOP:
8131 
        break
8132 
      else:
8133 
        iprot.skip(ftype)
8134 
      iprot.readFieldEnd()
8135 
    iprot.readStructEnd()
8136 
 
8137 
  def write(self, oprot):
8138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8140 
      return
8141 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8142 
    oprot.writeFieldStop()
8143 
    oprot.writeStructEnd()
8144 
 
3431 rajveer 8145 
  def validate(self):
8146 
    return
8147 
 
8148 
 
3064 chandransh 8149 
  def __repr__(self):
8150 
    L = ['%s=%r' % (key, value)
8151 
      for key, value in self.__dict__.iteritems()]
8152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8153 
 
8154 
  def __eq__(self, other):
8155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8156 
 
8157 
  def __ne__(self, other):
8158 
    return not (self == other)
8159 
 
8160 
class getValidOrdersAmountRange_result:
94 ashish 8161 
  """
8162 
  Attributes:
8163 
   - success
8164 
  """
8165 
 
8166 
  thrift_spec = (
3064 chandransh 8167 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8168 
  )
8169 
 
3064 chandransh 8170 
  def __init__(self, success=None,):
94 ashish 8171 
    self.success = success
8172 
 
8173 
  def read(self, iprot):
8174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8176 
      return
8177 
    iprot.readStructBegin()
8178 
    while True:
8179 
      (fname, ftype, fid) = iprot.readFieldBegin()
8180 
      if ftype == TType.STOP:
8181 
        break
8182 
      if fid == 0:
483 rajveer 8183 
        if ftype == TType.LIST:
8184 
          self.success = []
4133 chandransh 8185 
          (_etype122, _size119) = iprot.readListBegin()
8186 
          for _i123 in xrange(_size119):
8187 
            _elem124 = iprot.readDouble();
8188 
            self.success.append(_elem124)
483 rajveer 8189 
          iprot.readListEnd()
94 ashish 8190 
        else:
8191 
          iprot.skip(ftype)
8192 
      else:
8193 
        iprot.skip(ftype)
8194 
      iprot.readFieldEnd()
8195 
    iprot.readStructEnd()
8196 
 
8197 
  def write(self, oprot):
8198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8200 
      return
3064 chandransh 8201 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8202 
    if self.success is not None:
483 rajveer 8203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8204 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8205 
      for iter125 in self.success:
8206 
        oprot.writeDouble(iter125)
483 rajveer 8207 
      oprot.writeListEnd()
94 ashish 8208 
      oprot.writeFieldEnd()
8209 
    oprot.writeFieldStop()
8210 
    oprot.writeStructEnd()
8211 
 
3431 rajveer 8212 
  def validate(self):
8213 
    return
8214 
 
8215 
 
94 ashish 8216 
  def __repr__(self):
8217 
    L = ['%s=%r' % (key, value)
8218 
      for key, value in self.__dict__.iteritems()]
8219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8220 
 
8221 
  def __eq__(self, other):
8222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8223 
 
8224 
  def __ne__(self, other):
8225 
    return not (self == other)
8226 
 
3064 chandransh 8227 
class getValidOrders_args:
1528 ankur.sing 8228 
  """
8229 
  Attributes:
3064 chandransh 8230 
   - limit
1528 ankur.sing 8231 
  """
8232 
 
8233 
  thrift_spec = (
8234 
    None, # 0
3064 chandransh 8235 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8236 
  )
8237 
 
3064 chandransh 8238 
  def __init__(self, limit=None,):
8239 
    self.limit = limit
1528 ankur.sing 8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 1:
8251 
        if ftype == TType.I64:
3064 chandransh 8252 
          self.limit = iprot.readI64();
1528 ankur.sing 8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
3064 chandransh 8264 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8265 
    if self.limit is not None:
3064 chandransh 8266 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8267 
      oprot.writeI64(self.limit)
1528 ankur.sing 8268 
      oprot.writeFieldEnd()
8269 
    oprot.writeFieldStop()
8270 
    oprot.writeStructEnd()
8271 
 
3431 rajveer 8272 
  def validate(self):
8273 
    return
8274 
 
8275 
 
1528 ankur.sing 8276 
  def __repr__(self):
8277 
    L = ['%s=%r' % (key, value)
8278 
      for key, value in self.__dict__.iteritems()]
8279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8280 
 
8281 
  def __eq__(self, other):
8282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8283 
 
8284 
  def __ne__(self, other):
8285 
    return not (self == other)
8286 
 
3064 chandransh 8287 
class getValidOrders_result:
1528 ankur.sing 8288 
  """
8289 
  Attributes:
8290 
   - success
8291 
  """
8292 
 
8293 
  thrift_spec = (
3064 chandransh 8294 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8295 
  )
8296 
 
3064 chandransh 8297 
  def __init__(self, success=None,):
1528 ankur.sing 8298 
    self.success = success
8299 
 
8300 
  def read(self, iprot):
8301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8303 
      return
8304 
    iprot.readStructBegin()
8305 
    while True:
8306 
      (fname, ftype, fid) = iprot.readFieldBegin()
8307 
      if ftype == TType.STOP:
8308 
        break
8309 
      if fid == 0:
3064 chandransh 8310 
        if ftype == TType.LIST:
8311 
          self.success = []
4133 chandransh 8312 
          (_etype129, _size126) = iprot.readListBegin()
8313 
          for _i130 in xrange(_size126):
8314 
            _elem131 = Order()
8315 
            _elem131.read(iprot)
8316 
            self.success.append(_elem131)
3064 chandransh 8317 
          iprot.readListEnd()
1528 ankur.sing 8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
3064 chandransh 8329 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8330 
    if self.success is not None:
3064 chandransh 8331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8333 
      for iter132 in self.success:
8334 
        iter132.write(oprot)
3064 chandransh 8335 
      oprot.writeListEnd()
1528 ankur.sing 8336 
      oprot.writeFieldEnd()
8337 
    oprot.writeFieldStop()
8338 
    oprot.writeStructEnd()
8339 
 
3431 rajveer 8340 
  def validate(self):
8341 
    return
8342 
 
8343 
 
1528 ankur.sing 8344 
  def __repr__(self):
8345 
    L = ['%s=%r' % (key, value)
8346 
      for key, value in self.__dict__.iteritems()]
8347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8348 
 
8349 
  def __eq__(self, other):
8350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8351 
 
8352 
  def __ne__(self, other):
8353 
    return not (self == other)
8354 
 
1220 chandransh 8355 
class batchOrders_args:
8356 
  """
8357 
  Attributes:
8358 
   - warehouseId
8359 
  """
8360 
 
8361 
  thrift_spec = (
8362 
    None, # 0
8363 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8364 
  )
8365 
 
8366 
  def __init__(self, warehouseId=None,):
8367 
    self.warehouseId = warehouseId
8368 
 
8369 
  def read(self, iprot):
8370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8372 
      return
8373 
    iprot.readStructBegin()
8374 
    while True:
8375 
      (fname, ftype, fid) = iprot.readFieldBegin()
8376 
      if ftype == TType.STOP:
8377 
        break
8378 
      if fid == 1:
8379 
        if ftype == TType.I64:
8380 
          self.warehouseId = iprot.readI64();
8381 
        else:
8382 
          iprot.skip(ftype)
8383 
      else:
8384 
        iprot.skip(ftype)
8385 
      iprot.readFieldEnd()
8386 
    iprot.readStructEnd()
8387 
 
8388 
  def write(self, oprot):
8389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8391 
      return
8392 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8393 
    if self.warehouseId is not None:
1220 chandransh 8394 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8395 
      oprot.writeI64(self.warehouseId)
8396 
      oprot.writeFieldEnd()
8397 
    oprot.writeFieldStop()
8398 
    oprot.writeStructEnd()
8399 
 
3431 rajveer 8400 
  def validate(self):
8401 
    return
8402 
 
8403 
 
1220 chandransh 8404 
  def __repr__(self):
8405 
    L = ['%s=%r' % (key, value)
8406 
      for key, value in self.__dict__.iteritems()]
8407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8408 
 
8409 
  def __eq__(self, other):
8410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8411 
 
8412 
  def __ne__(self, other):
8413 
    return not (self == other)
8414 
 
8415 
class batchOrders_result:
8416 
  """
8417 
  Attributes:
8418 
   - success
8419 
   - ex
8420 
  """
8421 
 
8422 
  thrift_spec = (
8423 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8425 
  )
8426 
 
8427 
  def __init__(self, success=None, ex=None,):
8428 
    self.success = success
8429 
    self.ex = ex
8430 
 
8431 
  def read(self, iprot):
8432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8434 
      return
8435 
    iprot.readStructBegin()
8436 
    while True:
8437 
      (fname, ftype, fid) = iprot.readFieldBegin()
8438 
      if ftype == TType.STOP:
8439 
        break
8440 
      if fid == 0:
8441 
        if ftype == TType.LIST:
8442 
          self.success = []
4133 chandransh 8443 
          (_etype136, _size133) = iprot.readListBegin()
8444 
          for _i137 in xrange(_size133):
8445 
            _elem138 = Order()
8446 
            _elem138.read(iprot)
8447 
            self.success.append(_elem138)
1220 chandransh 8448 
          iprot.readListEnd()
8449 
        else:
8450 
          iprot.skip(ftype)
8451 
      elif fid == 1:
8452 
        if ftype == TType.STRUCT:
8453 
          self.ex = TransactionServiceException()
8454 
          self.ex.read(iprot)
8455 
        else:
8456 
          iprot.skip(ftype)
8457 
      else:
8458 
        iprot.skip(ftype)
8459 
      iprot.readFieldEnd()
8460 
    iprot.readStructEnd()
8461 
 
8462 
  def write(self, oprot):
8463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8465 
      return
8466 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8467 
    if self.success is not None:
1220 chandransh 8468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8470 
      for iter139 in self.success:
8471 
        iter139.write(oprot)
1220 chandransh 8472 
      oprot.writeListEnd()
8473 
      oprot.writeFieldEnd()
3431 rajveer 8474 
    if self.ex is not None:
1220 chandransh 8475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8476 
      self.ex.write(oprot)
8477 
      oprot.writeFieldEnd()
8478 
    oprot.writeFieldStop()
8479 
    oprot.writeStructEnd()
8480 
 
3431 rajveer 8481 
  def validate(self):
8482 
    return
8483 
 
8484 
 
1220 chandransh 8485 
  def __repr__(self):
8486 
    L = ['%s=%r' % (key, value)
8487 
      for key, value in self.__dict__.iteritems()]
8488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8489 
 
8490 
  def __eq__(self, other):
8491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8492 
 
8493 
  def __ne__(self, other):
8494 
    return not (self == other)
8495 
 
1208 chandransh 8496 
class markOrderAsOutOfStock_args:
8497 
  """
8498 
  Attributes:
8499 
   - orderId
8500 
  """
8501 
 
8502 
  thrift_spec = (
8503 
    None, # 0
8504 
    (1, TType.I64, 'orderId', None, None, ), # 1
8505 
  )
8506 
 
8507 
  def __init__(self, orderId=None,):
8508 
    self.orderId = orderId
8509 
 
8510 
  def read(self, iprot):
8511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8513 
      return
8514 
    iprot.readStructBegin()
8515 
    while True:
8516 
      (fname, ftype, fid) = iprot.readFieldBegin()
8517 
      if ftype == TType.STOP:
8518 
        break
8519 
      if fid == 1:
8520 
        if ftype == TType.I64:
8521 
          self.orderId = iprot.readI64();
8522 
        else:
8523 
          iprot.skip(ftype)
8524 
      else:
8525 
        iprot.skip(ftype)
8526 
      iprot.readFieldEnd()
8527 
    iprot.readStructEnd()
8528 
 
8529 
  def write(self, oprot):
8530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8532 
      return
8533 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8534 
    if self.orderId is not None:
1208 chandransh 8535 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8536 
      oprot.writeI64(self.orderId)
8537 
      oprot.writeFieldEnd()
8538 
    oprot.writeFieldStop()
8539 
    oprot.writeStructEnd()
8540 
 
3431 rajveer 8541 
  def validate(self):
8542 
    return
8543 
 
8544 
 
1208 chandransh 8545 
  def __repr__(self):
8546 
    L = ['%s=%r' % (key, value)
8547 
      for key, value in self.__dict__.iteritems()]
8548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8549 
 
8550 
  def __eq__(self, other):
8551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8552 
 
8553 
  def __ne__(self, other):
8554 
    return not (self == other)
8555 
 
8556 
class markOrderAsOutOfStock_result:
8557 
  """
8558 
  Attributes:
8559 
   - success
8560 
   - ex
8561 
  """
8562 
 
8563 
  thrift_spec = (
8564 
    (0, TType.BOOL, 'success', None, None, ), # 0
8565 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8566 
  )
8567 
 
8568 
  def __init__(self, success=None, ex=None,):
8569 
    self.success = success
8570 
    self.ex = ex
8571 
 
8572 
  def read(self, iprot):
8573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8575 
      return
8576 
    iprot.readStructBegin()
8577 
    while True:
8578 
      (fname, ftype, fid) = iprot.readFieldBegin()
8579 
      if ftype == TType.STOP:
8580 
        break
8581 
      if fid == 0:
8582 
        if ftype == TType.BOOL:
8583 
          self.success = iprot.readBool();
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      elif fid == 1:
8587 
        if ftype == TType.STRUCT:
8588 
          self.ex = TransactionServiceException()
8589 
          self.ex.read(iprot)
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      else:
8593 
        iprot.skip(ftype)
8594 
      iprot.readFieldEnd()
8595 
    iprot.readStructEnd()
8596 
 
8597 
  def write(self, oprot):
8598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8600 
      return
8601 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8602 
    if self.success is not None:
1208 chandransh 8603 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8604 
      oprot.writeBool(self.success)
8605 
      oprot.writeFieldEnd()
3431 rajveer 8606 
    if self.ex is not None:
1208 chandransh 8607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8608 
      self.ex.write(oprot)
8609 
      oprot.writeFieldEnd()
8610 
    oprot.writeFieldStop()
8611 
    oprot.writeStructEnd()
8612 
 
3431 rajveer 8613 
  def validate(self):
8614 
    return
8615 
 
8616 
 
1208 chandransh 8617 
  def __repr__(self):
8618 
    L = ['%s=%r' % (key, value)
8619 
      for key, value in self.__dict__.iteritems()]
8620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8621 
 
8622 
  def __eq__(self, other):
8623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8624 
 
8625 
  def __ne__(self, other):
8626 
    return not (self == other)
8627 
 
3064 chandransh 8628 
class verifyOrder_args:
759 chandransh 8629 
  """
8630 
  Attributes:
3064 chandransh 8631 
   - orderId
759 chandransh 8632 
  """
8633 
 
8634 
  thrift_spec = (
8635 
    None, # 0
3064 chandransh 8636 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8637 
  )
8638 
 
3064 chandransh 8639 
  def __init__(self, orderId=None,):
8640 
    self.orderId = orderId
759 chandransh 8641 
 
8642 
  def read(self, iprot):
8643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8645 
      return
8646 
    iprot.readStructBegin()
8647 
    while True:
8648 
      (fname, ftype, fid) = iprot.readFieldBegin()
8649 
      if ftype == TType.STOP:
8650 
        break
8651 
      if fid == 1:
8652 
        if ftype == TType.I64:
3064 chandransh 8653 
          self.orderId = iprot.readI64();
759 chandransh 8654 
        else:
8655 
          iprot.skip(ftype)
8656 
      else:
8657 
        iprot.skip(ftype)
8658 
      iprot.readFieldEnd()
8659 
    iprot.readStructEnd()
8660 
 
8661 
  def write(self, oprot):
8662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8664 
      return
3064 chandransh 8665 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8666 
    if self.orderId is not None:
3064 chandransh 8667 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8668 
      oprot.writeI64(self.orderId)
759 chandransh 8669 
      oprot.writeFieldEnd()
8670 
    oprot.writeFieldStop()
8671 
    oprot.writeStructEnd()
8672 
 
3431 rajveer 8673 
  def validate(self):
8674 
    return
8675 
 
8676 
 
759 chandransh 8677 
  def __repr__(self):
8678 
    L = ['%s=%r' % (key, value)
8679 
      for key, value in self.__dict__.iteritems()]
8680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8681 
 
8682 
  def __eq__(self, other):
8683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8684 
 
8685 
  def __ne__(self, other):
8686 
    return not (self == other)
8687 
 
3064 chandransh 8688 
class verifyOrder_result:
759 chandransh 8689 
  """
8690 
  Attributes:
8691 
   - success
8692 
   - ex
8693 
  """
8694 
 
8695 
  thrift_spec = (
8696 
    (0, TType.BOOL, 'success', None, None, ), # 0
8697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8698 
  )
8699 
 
8700 
  def __init__(self, success=None, ex=None,):
8701 
    self.success = success
8702 
    self.ex = ex
8703 
 
8704 
  def read(self, iprot):
8705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8707 
      return
8708 
    iprot.readStructBegin()
8709 
    while True:
8710 
      (fname, ftype, fid) = iprot.readFieldBegin()
8711 
      if ftype == TType.STOP:
8712 
        break
8713 
      if fid == 0:
8714 
        if ftype == TType.BOOL:
8715 
          self.success = iprot.readBool();
8716 
        else:
8717 
          iprot.skip(ftype)
8718 
      elif fid == 1:
8719 
        if ftype == TType.STRUCT:
8720 
          self.ex = TransactionServiceException()
8721 
          self.ex.read(iprot)
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      else:
8725 
        iprot.skip(ftype)
8726 
      iprot.readFieldEnd()
8727 
    iprot.readStructEnd()
8728 
 
8729 
  def write(self, oprot):
8730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8732 
      return
3064 chandransh 8733 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8734 
    if self.success is not None:
759 chandransh 8735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8736 
      oprot.writeBool(self.success)
8737 
      oprot.writeFieldEnd()
3431 rajveer 8738 
    if self.ex is not None:
759 chandransh 8739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8740 
      self.ex.write(oprot)
8741 
      oprot.writeFieldEnd()
8742 
    oprot.writeFieldStop()
8743 
    oprot.writeStructEnd()
8744 
 
3431 rajveer 8745 
  def validate(self):
8746 
    return
8747 
 
8748 
 
759 chandransh 8749 
  def __repr__(self):
8750 
    L = ['%s=%r' % (key, value)
8751 
      for key, value in self.__dict__.iteritems()]
8752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8753 
 
8754 
  def __eq__(self, other):
8755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8756 
 
8757 
  def __ne__(self, other):
8758 
    return not (self == other)
8759 
 
3064 chandransh 8760 
class acceptOrder_args:
1113 chandransh 8761 
  """
8762 
  Attributes:
3064 chandransh 8763 
   - orderId
1113 chandransh 8764 
  """
8765 
 
8766 
  thrift_spec = (
8767 
    None, # 0
3064 chandransh 8768 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8769 
  )
8770 
 
3064 chandransh 8771 
  def __init__(self, orderId=None,):
8772 
    self.orderId = orderId
1113 chandransh 8773 
 
8774 
  def read(self, iprot):
8775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8777 
      return
8778 
    iprot.readStructBegin()
8779 
    while True:
8780 
      (fname, ftype, fid) = iprot.readFieldBegin()
8781 
      if ftype == TType.STOP:
8782 
        break
8783 
      if fid == 1:
8784 
        if ftype == TType.I64:
3064 chandransh 8785 
          self.orderId = iprot.readI64();
1113 chandransh 8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
3064 chandransh 8797 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8798 
    if self.orderId is not None:
3064 chandransh 8799 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8800 
      oprot.writeI64(self.orderId)
1113 chandransh 8801 
      oprot.writeFieldEnd()
8802 
    oprot.writeFieldStop()
8803 
    oprot.writeStructEnd()
8804 
 
3431 rajveer 8805 
  def validate(self):
8806 
    return
8807 
 
8808 
 
1113 chandransh 8809 
  def __repr__(self):
8810 
    L = ['%s=%r' % (key, value)
8811 
      for key, value in self.__dict__.iteritems()]
8812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8813 
 
8814 
  def __eq__(self, other):
8815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8816 
 
8817 
  def __ne__(self, other):
8818 
    return not (self == other)
8819 
 
3064 chandransh 8820 
class acceptOrder_result:
1113 chandransh 8821 
  """
8822 
  Attributes:
8823 
   - success
8824 
   - ex
8825 
  """
8826 
 
8827 
  thrift_spec = (
3064 chandransh 8828 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8830 
  )
8831 
 
8832 
  def __init__(self, success=None, ex=None,):
8833 
    self.success = success
8834 
    self.ex = ex
8835 
 
8836 
  def read(self, iprot):
8837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8839 
      return
8840 
    iprot.readStructBegin()
8841 
    while True:
8842 
      (fname, ftype, fid) = iprot.readFieldBegin()
8843 
      if ftype == TType.STOP:
8844 
        break
8845 
      if fid == 0:
3064 chandransh 8846 
        if ftype == TType.BOOL:
8847 
          self.success = iprot.readBool();
1113 chandransh 8848 
        else:
8849 
          iprot.skip(ftype)
8850 
      elif fid == 1:
8851 
        if ftype == TType.STRUCT:
8852 
          self.ex = TransactionServiceException()
8853 
          self.ex.read(iprot)
8854 
        else:
8855 
          iprot.skip(ftype)
8856 
      else:
8857 
        iprot.skip(ftype)
8858 
      iprot.readFieldEnd()
8859 
    iprot.readStructEnd()
8860 
 
8861 
  def write(self, oprot):
8862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8864 
      return
3064 chandransh 8865 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8866 
    if self.success is not None:
3064 chandransh 8867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8868 
      oprot.writeBool(self.success)
1113 chandransh 8869 
      oprot.writeFieldEnd()
3431 rajveer 8870 
    if self.ex is not None:
1113 chandransh 8871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8872 
      self.ex.write(oprot)
8873 
      oprot.writeFieldEnd()
8874 
    oprot.writeFieldStop()
8875 
    oprot.writeStructEnd()
8876 
 
3431 rajveer 8877 
  def validate(self):
8878 
    return
8879 
 
8880 
 
1113 chandransh 8881 
  def __repr__(self):
8882 
    L = ['%s=%r' % (key, value)
8883 
      for key, value in self.__dict__.iteritems()]
8884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8885 
 
8886 
  def __eq__(self, other):
8887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8888 
 
8889 
  def __ne__(self, other):
8890 
    return not (self == other)
8891 
 
3064 chandransh 8892 
class addBillingDetails_args:
1135 chandransh 8893 
  """
8894 
  Attributes:
3064 chandransh 8895 
   - orderId
8896 
   - invoice_number
4283 anupam.sin 8897 
   - imeiNumber
8898 
   - itemNumber
3064 chandransh 8899 
   - billed_by
4264 rajveer 8900 
   - jacketNumber
4283 anupam.sin 8901 
   - billingType
8902 
   - vendorId
1135 chandransh 8903 
  """
8904 
 
8905 
  thrift_spec = (
8906 
    None, # 0
3064 chandransh 8907 
    (1, TType.I64, 'orderId', None, None, ), # 1
8908 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8909 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8910 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8911 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8912 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8913 
    (7, TType.I64, 'billingType', None, None, ), # 7
8914 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8915 
  )
8916 
 
4283 anupam.sin 8917 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8918 
    self.orderId = orderId
8919 
    self.invoice_number = invoice_number
4283 anupam.sin 8920 
    self.imeiNumber = imeiNumber
8921 
    self.itemNumber = itemNumber
3064 chandransh 8922 
    self.billed_by = billed_by
4264 rajveer 8923 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8924 
    self.billingType = billingType
8925 
    self.vendorId = vendorId
1135 chandransh 8926 
 
8927 
  def read(self, iprot):
8928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8930 
      return
8931 
    iprot.readStructBegin()
8932 
    while True:
8933 
      (fname, ftype, fid) = iprot.readFieldBegin()
8934 
      if ftype == TType.STOP:
8935 
        break
8936 
      if fid == 1:
8937 
        if ftype == TType.I64:
3064 chandransh 8938 
          self.orderId = iprot.readI64();
1135 chandransh 8939 
        else:
8940 
          iprot.skip(ftype)
8941 
      elif fid == 2:
3064 chandransh 8942 
        if ftype == TType.STRING:
8943 
          self.invoice_number = iprot.readString();
1135 chandransh 8944 
        else:
8945 
          iprot.skip(ftype)
3064 chandransh 8946 
      elif fid == 3:
4264 rajveer 8947 
        if ftype == TType.I64:
3064 chandransh 8948 
          self.imeiNumber = iprot.readI64();
8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      elif fid == 4:
8952 
        if ftype == TType.STRING:
8953 
          self.itemNumber = iprot.readString();
8954 
        else:
8955 
          iprot.skip(ftype)
8956 
      elif fid == 5:
8957 
        if ftype == TType.STRING:
4283 anupam.sin 8958 
          self.billed_by = iprot.readString();
3064 chandransh 8959 
        else:
8960 
          iprot.skip(ftype)
8961 
      elif fid == 6:
8962 
        if ftype == TType.I64:
4283 anupam.sin 8963 
          self.jacketNumber = iprot.readI64();
8964 
        else:
8965 
          iprot.skip(ftype)
8966 
      elif fid == 7:
8967 
        if ftype == TType.I64:
3064 chandransh 8968 
          self.billingType = iprot.readI64();
8969 
        else:
8970 
          iprot.skip(ftype)
4283 anupam.sin 8971 
      elif fid == 8:
8972 
        if ftype == TType.I64:
8973 
          self.vendorId = iprot.readI64();
8974 
        else:
8975 
          iprot.skip(ftype)
1246 chandransh 8976 
      else:
8977 
        iprot.skip(ftype)
8978 
      iprot.readFieldEnd()
8979 
    iprot.readStructEnd()
8980 
 
8981 
  def write(self, oprot):
8982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8984 
      return
4283 anupam.sin 8985 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8986 
    if self.orderId is not None:
3064 chandransh 8987 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8988 
      oprot.writeI64(self.orderId)
1246 chandransh 8989 
      oprot.writeFieldEnd()
4283 anupam.sin 8990 
    if self.invoice_number is not None:
8991 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8992 
      oprot.writeString(self.invoice_number)
1246 chandransh 8993 
      oprot.writeFieldEnd()
3431 rajveer 8994 
    if self.imeiNumber is not None:
3064 chandransh 8995 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8996 
      oprot.writeI64(self.imeiNumber)
8997 
      oprot.writeFieldEnd()
3431 rajveer 8998 
    if self.itemNumber is not None:
3064 chandransh 8999 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9000 
      oprot.writeString(self.itemNumber)
9001 
      oprot.writeFieldEnd()
4283 anupam.sin 9002 
    if self.billed_by is not None:
9003 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9004 
      oprot.writeString(self.billed_by)
3064 chandransh 9005 
      oprot.writeFieldEnd()
4283 anupam.sin 9006 
    if self.jacketNumber is not None:
9007 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9008 
      oprot.writeI64(self.jacketNumber)
9009 
      oprot.writeFieldEnd()
3431 rajveer 9010 
    if self.billingType is not None:
4283 anupam.sin 9011 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9012 
      oprot.writeI64(self.billingType)
9013 
      oprot.writeFieldEnd()
4283 anupam.sin 9014 
    if self.vendorId is not None:
9015 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9016 
      oprot.writeI64(self.vendorId)
9017 
      oprot.writeFieldEnd()
1246 chandransh 9018 
    oprot.writeFieldStop()
9019 
    oprot.writeStructEnd()
9020 
 
3431 rajveer 9021 
  def validate(self):
9022 
    return
9023 
 
9024 
 
1246 chandransh 9025 
  def __repr__(self):
9026 
    L = ['%s=%r' % (key, value)
9027 
      for key, value in self.__dict__.iteritems()]
9028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9029 
 
9030 
  def __eq__(self, other):
9031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9032 
 
9033 
  def __ne__(self, other):
9034 
    return not (self == other)
9035 
 
4283 anupam.sin 9036 
class addBillingDetails_result:
1246 chandransh 9037 
  """
9038 
  Attributes:
3064 chandransh 9039 
   - success
1246 chandransh 9040 
   - ex
9041 
  """
9042 
 
9043 
  thrift_spec = (
3064 chandransh 9044 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9046 
  )
9047 
 
3064 chandransh 9048 
  def __init__(self, success=None, ex=None,):
9049 
    self.success = success
1246 chandransh 9050 
    self.ex = ex
9051 
 
9052 
  def read(self, iprot):
9053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9055 
      return
9056 
    iprot.readStructBegin()
9057 
    while True:
9058 
      (fname, ftype, fid) = iprot.readFieldBegin()
9059 
      if ftype == TType.STOP:
9060 
        break
3064 chandransh 9061 
      if fid == 0:
9062 
        if ftype == TType.BOOL:
9063 
          self.success = iprot.readBool();
9064 
        else:
9065 
          iprot.skip(ftype)
9066 
      elif fid == 1:
1246 chandransh 9067 
        if ftype == TType.STRUCT:
9068 
          self.ex = TransactionServiceException()
9069 
          self.ex.read(iprot)
9070 
        else:
9071 
          iprot.skip(ftype)
9072 
      else:
9073 
        iprot.skip(ftype)
9074 
      iprot.readFieldEnd()
9075 
    iprot.readStructEnd()
9076 
 
9077 
  def write(self, oprot):
9078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9080 
      return
4283 anupam.sin 9081 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9082 
    if self.success is not None:
3064 chandransh 9083 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9084 
      oprot.writeBool(self.success)
9085 
      oprot.writeFieldEnd()
3431 rajveer 9086 
    if self.ex is not None:
1246 chandransh 9087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9088 
      self.ex.write(oprot)
9089 
      oprot.writeFieldEnd()
9090 
    oprot.writeFieldStop()
9091 
    oprot.writeStructEnd()
9092 
 
3431 rajveer 9093 
  def validate(self):
9094 
    return
9095 
 
9096 
 
1246 chandransh 9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
3064 chandransh 9108 
class markOrdersAsManifested_args:
1408 ankur.sing 9109 
  """
9110 
  Attributes:
3064 chandransh 9111 
   - warehouseId
1408 ankur.sing 9112 
   - providerId
3064 chandransh 9113 
   - cod
1408 ankur.sing 9114 
  """
9115 
 
9116 
  thrift_spec = (
9117 
    None, # 0
3064 chandransh 9118 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9119 
    (2, TType.I64, 'providerId', None, None, ), # 2
9120 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9121 
  )
9122 
 
3064 chandransh 9123 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9124 
    self.warehouseId = warehouseId
1408 ankur.sing 9125 
    self.providerId = providerId
3064 chandransh 9126 
    self.cod = cod
1408 ankur.sing 9127 
 
9128 
  def read(self, iprot):
9129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9131 
      return
9132 
    iprot.readStructBegin()
9133 
    while True:
9134 
      (fname, ftype, fid) = iprot.readFieldBegin()
9135 
      if ftype == TType.STOP:
9136 
        break
9137 
      if fid == 1:
9138 
        if ftype == TType.I64:
3064 chandransh 9139 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9140 
        else:
9141 
          iprot.skip(ftype)
9142 
      elif fid == 2:
9143 
        if ftype == TType.I64:
3064 chandransh 9144 
          self.providerId = iprot.readI64();
1408 ankur.sing 9145 
        else:
9146 
          iprot.skip(ftype)
3064 chandransh 9147 
      elif fid == 3:
9148 
        if ftype == TType.BOOL:
9149 
          self.cod = iprot.readBool();
9150 
        else:
9151 
          iprot.skip(ftype)
1408 ankur.sing 9152 
      else:
9153 
        iprot.skip(ftype)
9154 
      iprot.readFieldEnd()
9155 
    iprot.readStructEnd()
9156 
 
9157 
  def write(self, oprot):
9158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9160 
      return
3064 chandransh 9161 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9162 
    if self.warehouseId is not None:
3064 chandransh 9163 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9164 
      oprot.writeI64(self.warehouseId)
9165 
      oprot.writeFieldEnd()
3431 rajveer 9166 
    if self.providerId is not None:
3064 chandransh 9167 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9168 
      oprot.writeI64(self.providerId)
9169 
      oprot.writeFieldEnd()
3431 rajveer 9170 
    if self.cod is not None:
3064 chandransh 9171 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9172 
      oprot.writeBool(self.cod)
1408 ankur.sing 9173 
      oprot.writeFieldEnd()
9174 
    oprot.writeFieldStop()
9175 
    oprot.writeStructEnd()
9176 
 
3431 rajveer 9177 
  def validate(self):
9178 
    return
9179 
 
9180 
 
1408 ankur.sing 9181 
  def __repr__(self):
9182 
    L = ['%s=%r' % (key, value)
9183 
      for key, value in self.__dict__.iteritems()]
9184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9185 
 
9186 
  def __eq__(self, other):
9187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9188 
 
9189 
  def __ne__(self, other):
9190 
    return not (self == other)
9191 
 
3064 chandransh 9192 
class markOrdersAsManifested_result:
1408 ankur.sing 9193 
  """
9194 
  Attributes:
9195 
   - success
3064 chandransh 9196 
   - ex
1408 ankur.sing 9197 
  """
9198 
 
9199 
  thrift_spec = (
3064 chandransh 9200 
    (0, TType.BOOL, 'success', None, None, ), # 0
9201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9202 
  )
9203 
 
3064 chandransh 9204 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9205 
    self.success = success
3064 chandransh 9206 
    self.ex = ex
1408 ankur.sing 9207 
 
9208 
  def read(self, iprot):
9209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9211 
      return
9212 
    iprot.readStructBegin()
9213 
    while True:
9214 
      (fname, ftype, fid) = iprot.readFieldBegin()
9215 
      if ftype == TType.STOP:
9216 
        break
9217 
      if fid == 0:
3064 chandransh 9218 
        if ftype == TType.BOOL:
9219 
          self.success = iprot.readBool();
1408 ankur.sing 9220 
        else:
9221 
          iprot.skip(ftype)
3064 chandransh 9222 
      elif fid == 1:
9223 
        if ftype == TType.STRUCT:
9224 
          self.ex = TransactionServiceException()
9225 
          self.ex.read(iprot)
9226 
        else:
9227 
          iprot.skip(ftype)
1408 ankur.sing 9228 
      else:
9229 
        iprot.skip(ftype)
9230 
      iprot.readFieldEnd()
9231 
    iprot.readStructEnd()
9232 
 
9233 
  def write(self, oprot):
9234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9236 
      return
3064 chandransh 9237 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9238 
    if self.success is not None:
3064 chandransh 9239 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9240 
      oprot.writeBool(self.success)
1408 ankur.sing 9241 
      oprot.writeFieldEnd()
3431 rajveer 9242 
    if self.ex is not None:
3064 chandransh 9243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9244 
      self.ex.write(oprot)
9245 
      oprot.writeFieldEnd()
1408 ankur.sing 9246 
    oprot.writeFieldStop()
9247 
    oprot.writeStructEnd()
9248 
 
3431 rajveer 9249 
  def validate(self):
9250 
    return
9251 
 
9252 
 
1408 ankur.sing 9253 
  def __repr__(self):
9254 
    L = ['%s=%r' % (key, value)
9255 
      for key, value in self.__dict__.iteritems()]
9256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9257 
 
9258 
  def __eq__(self, other):
9259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9260 
 
9261 
  def __ne__(self, other):
9262 
    return not (self == other)
9263 
 
3064 chandransh 9264 
class markOrdersAsPickedUp_args:
304 ashish 9265 
  """
9266 
  Attributes:
3064 chandransh 9267 
   - providerId
9268 
   - pickupDetails
304 ashish 9269 
  """
94 ashish 9270 
 
304 ashish 9271 
  thrift_spec = (
9272 
    None, # 0
3064 chandransh 9273 
    (1, TType.I64, 'providerId', None, None, ), # 1
9274 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9275 
  )
9276 
 
3064 chandransh 9277 
  def __init__(self, providerId=None, pickupDetails=None,):
9278 
    self.providerId = providerId
9279 
    self.pickupDetails = pickupDetails
304 ashish 9280 
 
9281 
  def read(self, iprot):
9282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9284 
      return
9285 
    iprot.readStructBegin()
9286 
    while True:
9287 
      (fname, ftype, fid) = iprot.readFieldBegin()
9288 
      if ftype == TType.STOP:
9289 
        break
9290 
      if fid == 1:
9291 
        if ftype == TType.I64:
3064 chandransh 9292 
          self.providerId = iprot.readI64();
304 ashish 9293 
        else:
9294 
          iprot.skip(ftype)
9295 
      elif fid == 2:
3064 chandransh 9296 
        if ftype == TType.MAP:
9297 
          self.pickupDetails = {}
4133 chandransh 9298 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9299 
          for _i144 in xrange(_size140):
9300 
            _key145 = iprot.readString();
9301 
            _val146 = iprot.readString();
9302 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9303 
          iprot.readMapEnd()
304 ashish 9304 
        else:
9305 
          iprot.skip(ftype)
9306 
      else:
9307 
        iprot.skip(ftype)
9308 
      iprot.readFieldEnd()
9309 
    iprot.readStructEnd()
9310 
 
9311 
  def write(self, oprot):
9312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9314 
      return
3064 chandransh 9315 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9316 
    if self.providerId is not None:
3064 chandransh 9317 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9318 
      oprot.writeI64(self.providerId)
304 ashish 9319 
      oprot.writeFieldEnd()
3431 rajveer 9320 
    if self.pickupDetails is not None:
3064 chandransh 9321 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9322 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9323 
      for kiter147,viter148 in self.pickupDetails.items():
9324 
        oprot.writeString(kiter147)
9325 
        oprot.writeString(viter148)
3064 chandransh 9326 
      oprot.writeMapEnd()
304 ashish 9327 
      oprot.writeFieldEnd()
9328 
    oprot.writeFieldStop()
9329 
    oprot.writeStructEnd()
9330 
 
3431 rajveer 9331 
  def validate(self):
9332 
    return
9333 
 
9334 
 
304 ashish 9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
3064 chandransh 9346 
class markOrdersAsPickedUp_result:
304 ashish 9347 
  """
9348 
  Attributes:
9349 
   - success
3064 chandransh 9350 
   - ex
304 ashish 9351 
  """
9352 
 
9353 
  thrift_spec = (
3064 chandransh 9354 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9356 
  )
9357 
 
3064 chandransh 9358 
  def __init__(self, success=None, ex=None,):
304 ashish 9359 
    self.success = success
3064 chandransh 9360 
    self.ex = ex
304 ashish 9361 
 
9362 
  def read(self, iprot):
9363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9365 
      return
9366 
    iprot.readStructBegin()
9367 
    while True:
9368 
      (fname, ftype, fid) = iprot.readFieldBegin()
9369 
      if ftype == TType.STOP:
9370 
        break
9371 
      if fid == 0:
9372 
        if ftype == TType.LIST:
9373 
          self.success = []
4133 chandransh 9374 
          (_etype152, _size149) = iprot.readListBegin()
9375 
          for _i153 in xrange(_size149):
9376 
            _elem154 = Order()
9377 
            _elem154.read(iprot)
9378 
            self.success.append(_elem154)
304 ashish 9379 
          iprot.readListEnd()
9380 
        else:
9381 
          iprot.skip(ftype)
3064 chandransh 9382 
      elif fid == 1:
9383 
        if ftype == TType.STRUCT:
9384 
          self.ex = TransactionServiceException()
9385 
          self.ex.read(iprot)
9386 
        else:
9387 
          iprot.skip(ftype)
304 ashish 9388 
      else:
9389 
        iprot.skip(ftype)
9390 
      iprot.readFieldEnd()
9391 
    iprot.readStructEnd()
9392 
 
9393 
  def write(self, oprot):
9394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9396 
      return
3064 chandransh 9397 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9398 
    if self.success is not None:
304 ashish 9399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9400 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9401 
      for iter155 in self.success:
9402 
        iter155.write(oprot)
304 ashish 9403 
      oprot.writeListEnd()
9404 
      oprot.writeFieldEnd()
3431 rajveer 9405 
    if self.ex is not None:
3064 chandransh 9406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9407 
      self.ex.write(oprot)
9408 
      oprot.writeFieldEnd()
304 ashish 9409 
    oprot.writeFieldStop()
9410 
    oprot.writeStructEnd()
9411 
 
3431 rajveer 9412 
  def validate(self):
9413 
    return
9414 
 
9415 
 
304 ashish 9416 
  def __repr__(self):
9417 
    L = ['%s=%r' % (key, value)
9418 
      for key, value in self.__dict__.iteritems()]
9419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9420 
 
9421 
  def __eq__(self, other):
9422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9423 
 
9424 
  def __ne__(self, other):
9425 
    return not (self == other)
9426 
 
3064 chandransh 9427 
class markOrdersAsDelivered_args:
304 ashish 9428 
  """
9429 
  Attributes:
3064 chandransh 9430 
   - providerId
9431 
   - deliveredOrders
304 ashish 9432 
  """
9433 
 
9434 
  thrift_spec = (
9435 
    None, # 0
3064 chandransh 9436 
    (1, TType.I64, 'providerId', None, None, ), # 1
9437 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9438 
  )
9439 
 
3064 chandransh 9440 
  def __init__(self, providerId=None, deliveredOrders=None,):
9441 
    self.providerId = providerId
9442 
    self.deliveredOrders = deliveredOrders
304 ashish 9443 
 
9444 
  def read(self, iprot):
9445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9447 
      return
9448 
    iprot.readStructBegin()
9449 
    while True:
9450 
      (fname, ftype, fid) = iprot.readFieldBegin()
9451 
      if ftype == TType.STOP:
9452 
        break
9453 
      if fid == 1:
9454 
        if ftype == TType.I64:
3064 chandransh 9455 
          self.providerId = iprot.readI64();
304 ashish 9456 
        else:
9457 
          iprot.skip(ftype)
9458 
      elif fid == 2:
3064 chandransh 9459 
        if ftype == TType.MAP:
9460 
          self.deliveredOrders = {}
4133 chandransh 9461 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9462 
          for _i160 in xrange(_size156):
9463 
            _key161 = iprot.readString();
9464 
            _val162 = iprot.readString();
9465 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9466 
          iprot.readMapEnd()
304 ashish 9467 
        else:
9468 
          iprot.skip(ftype)
9469 
      else:
9470 
        iprot.skip(ftype)
9471 
      iprot.readFieldEnd()
9472 
    iprot.readStructEnd()
9473 
 
9474 
  def write(self, oprot):
9475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9477 
      return
3064 chandransh 9478 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9479 
    if self.providerId is not None:
3064 chandransh 9480 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9481 
      oprot.writeI64(self.providerId)
304 ashish 9482 
      oprot.writeFieldEnd()
3431 rajveer 9483 
    if self.deliveredOrders is not None:
3064 chandransh 9484 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9485 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9486 
      for kiter163,viter164 in self.deliveredOrders.items():
9487 
        oprot.writeString(kiter163)
9488 
        oprot.writeString(viter164)
3064 chandransh 9489 
      oprot.writeMapEnd()
304 ashish 9490 
      oprot.writeFieldEnd()
9491 
    oprot.writeFieldStop()
9492 
    oprot.writeStructEnd()
9493 
 
3431 rajveer 9494 
  def validate(self):
9495 
    return
9496 
 
9497 
 
304 ashish 9498 
  def __repr__(self):
9499 
    L = ['%s=%r' % (key, value)
9500 
      for key, value in self.__dict__.iteritems()]
9501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9502 
 
9503 
  def __eq__(self, other):
9504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9505 
 
9506 
  def __ne__(self, other):
9507 
    return not (self == other)
9508 
 
3064 chandransh 9509 
class markOrdersAsDelivered_result:
9510 
  """
9511 
  Attributes:
9512 
   - ex
9513 
  """
304 ashish 9514 
 
9515 
  thrift_spec = (
3064 chandransh 9516 
    None, # 0
9517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9518 
  )
9519 
 
3064 chandransh 9520 
  def __init__(self, ex=None,):
9521 
    self.ex = ex
304 ashish 9522 
 
1596 ankur.sing 9523 
  def read(self, iprot):
9524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9526 
      return
9527 
    iprot.readStructBegin()
9528 
    while True:
9529 
      (fname, ftype, fid) = iprot.readFieldBegin()
9530 
      if ftype == TType.STOP:
9531 
        break
3064 chandransh 9532 
      if fid == 1:
9533 
        if ftype == TType.STRUCT:
9534 
          self.ex = TransactionServiceException()
9535 
          self.ex.read(iprot)
9536 
        else:
9537 
          iprot.skip(ftype)
1596 ankur.sing 9538 
      else:
9539 
        iprot.skip(ftype)
9540 
      iprot.readFieldEnd()
9541 
    iprot.readStructEnd()
9542 
 
9543 
  def write(self, oprot):
9544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9546 
      return
3064 chandransh 9547 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9548 
    if self.ex is not None:
3064 chandransh 9549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9550 
      self.ex.write(oprot)
9551 
      oprot.writeFieldEnd()
1596 ankur.sing 9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
3431 rajveer 9555 
  def validate(self):
9556 
    return
9557 
 
9558 
 
1596 ankur.sing 9559 
  def __repr__(self):
9560 
    L = ['%s=%r' % (key, value)
9561 
      for key, value in self.__dict__.iteritems()]
9562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9563 
 
9564 
  def __eq__(self, other):
9565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9566 
 
9567 
  def __ne__(self, other):
9568 
    return not (self == other)
9569 
 
3064 chandransh 9570 
class markOrdersAsFailed_args:
1596 ankur.sing 9571 
  """
9572 
  Attributes:
3064 chandransh 9573 
   - providerId
9574 
   - returnedOrders
1596 ankur.sing 9575 
  """
9576 
 
9577 
  thrift_spec = (
3064 chandransh 9578 
    None, # 0
9579 
    (1, TType.I64, 'providerId', None, None, ), # 1
9580 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9581 
  )
9582 
 
3064 chandransh 9583 
  def __init__(self, providerId=None, returnedOrders=None,):
9584 
    self.providerId = providerId
9585 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9586 
 
9587 
  def read(self, iprot):
9588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9590 
      return
9591 
    iprot.readStructBegin()
9592 
    while True:
9593 
      (fname, ftype, fid) = iprot.readFieldBegin()
9594 
      if ftype == TType.STOP:
9595 
        break
3064 chandransh 9596 
      if fid == 1:
1596 ankur.sing 9597 
        if ftype == TType.I64:
3064 chandransh 9598 
          self.providerId = iprot.readI64();
1596 ankur.sing 9599 
        else:
9600 
          iprot.skip(ftype)
3064 chandransh 9601 
      elif fid == 2:
9602 
        if ftype == TType.MAP:
9603 
          self.returnedOrders = {}
4133 chandransh 9604 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9605 
          for _i169 in xrange(_size165):
9606 
            _key170 = iprot.readString();
9607 
            _val171 = iprot.readString();
9608 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9609 
          iprot.readMapEnd()
9610 
        else:
9611 
          iprot.skip(ftype)
1596 ankur.sing 9612 
      else:
9613 
        iprot.skip(ftype)
9614 
      iprot.readFieldEnd()
9615 
    iprot.readStructEnd()
9616 
 
9617 
  def write(self, oprot):
9618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9620 
      return
3064 chandransh 9621 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9622 
    if self.providerId is not None:
3064 chandransh 9623 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9624 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9625 
      oprot.writeFieldEnd()
3431 rajveer 9626 
    if self.returnedOrders is not None:
3064 chandransh 9627 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9628 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9629 
      for kiter172,viter173 in self.returnedOrders.items():
9630 
        oprot.writeString(kiter172)
9631 
        oprot.writeString(viter173)
3064 chandransh 9632 
      oprot.writeMapEnd()
9633 
      oprot.writeFieldEnd()
1596 ankur.sing 9634 
    oprot.writeFieldStop()
9635 
    oprot.writeStructEnd()
9636 
 
3431 rajveer 9637 
  def validate(self):
9638 
    return
9639 
 
9640 
 
1596 ankur.sing 9641 
  def __repr__(self):
9642 
    L = ['%s=%r' % (key, value)
9643 
      for key, value in self.__dict__.iteritems()]
9644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9645 
 
9646 
  def __eq__(self, other):
9647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9648 
 
9649 
  def __ne__(self, other):
9650 
    return not (self == other)
9651 
 
3064 chandransh 9652 
class markOrdersAsFailed_result:
9653 
  """
9654 
  Attributes:
9655 
   - ex
9656 
  """
1596 ankur.sing 9657 
 
1627 ankur.sing 9658 
  thrift_spec = (
3064 chandransh 9659 
    None, # 0
9660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9661 
  )
9662 
 
3064 chandransh 9663 
  def __init__(self, ex=None,):
9664 
    self.ex = ex
9665 
 
1627 ankur.sing 9666 
  def read(self, iprot):
9667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9669 
      return
9670 
    iprot.readStructBegin()
9671 
    while True:
9672 
      (fname, ftype, fid) = iprot.readFieldBegin()
9673 
      if ftype == TType.STOP:
9674 
        break
3064 chandransh 9675 
      if fid == 1:
9676 
        if ftype == TType.STRUCT:
9677 
          self.ex = TransactionServiceException()
9678 
          self.ex.read(iprot)
9679 
        else:
9680 
          iprot.skip(ftype)
1627 ankur.sing 9681 
      else:
9682 
        iprot.skip(ftype)
9683 
      iprot.readFieldEnd()
9684 
    iprot.readStructEnd()
9685 
 
9686 
  def write(self, oprot):
9687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9689 
      return
3064 chandransh 9690 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9691 
    if self.ex is not None:
3064 chandransh 9692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9693 
      self.ex.write(oprot)
9694 
      oprot.writeFieldEnd()
1627 ankur.sing 9695 
    oprot.writeFieldStop()
9696 
    oprot.writeStructEnd()
9697 
 
3431 rajveer 9698 
  def validate(self):
9699 
    return
9700 
 
9701 
 
1627 ankur.sing 9702 
  def __repr__(self):
9703 
    L = ['%s=%r' % (key, value)
9704 
      for key, value in self.__dict__.iteritems()]
9705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9706 
 
9707 
  def __eq__(self, other):
9708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9709 
 
9710 
  def __ne__(self, other):
9711 
    return not (self == other)
9712 
 
3064 chandransh 9713 
class updateNonDeliveryReason_args:
1627 ankur.sing 9714 
  """
9715 
  Attributes:
3064 chandransh 9716 
   - providerId
9717 
   - undeliveredOrders
1627 ankur.sing 9718 
  """
9719 
 
9720 
  thrift_spec = (
3064 chandransh 9721 
    None, # 0
9722 
    (1, TType.I64, 'providerId', None, None, ), # 1
9723 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9724 
  )
9725 
 
3064 chandransh 9726 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9727 
    self.providerId = providerId
9728 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9729 
 
9730 
  def read(self, iprot):
9731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9733 
      return
9734 
    iprot.readStructBegin()
9735 
    while True:
9736 
      (fname, ftype, fid) = iprot.readFieldBegin()
9737 
      if ftype == TType.STOP:
9738 
        break
3064 chandransh 9739 
      if fid == 1:
1627 ankur.sing 9740 
        if ftype == TType.I64:
3064 chandransh 9741 
          self.providerId = iprot.readI64();
1627 ankur.sing 9742 
        else:
9743 
          iprot.skip(ftype)
3064 chandransh 9744 
      elif fid == 2:
9745 
        if ftype == TType.MAP:
9746 
          self.undeliveredOrders = {}
4133 chandransh 9747 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9748 
          for _i178 in xrange(_size174):
9749 
            _key179 = iprot.readString();
9750 
            _val180 = iprot.readString();
9751 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9752 
          iprot.readMapEnd()
9753 
        else:
9754 
          iprot.skip(ftype)
1627 ankur.sing 9755 
      else:
9756 
        iprot.skip(ftype)
9757 
      iprot.readFieldEnd()
9758 
    iprot.readStructEnd()
9759 
 
9760 
  def write(self, oprot):
9761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9763 
      return
3064 chandransh 9764 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9765 
    if self.providerId is not None:
3064 chandransh 9766 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9767 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9768 
      oprot.writeFieldEnd()
3431 rajveer 9769 
    if self.undeliveredOrders is not None:
3064 chandransh 9770 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9771 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9772 
      for kiter181,viter182 in self.undeliveredOrders.items():
9773 
        oprot.writeString(kiter181)
9774 
        oprot.writeString(viter182)
3064 chandransh 9775 
      oprot.writeMapEnd()
9776 
      oprot.writeFieldEnd()
1627 ankur.sing 9777 
    oprot.writeFieldStop()
9778 
    oprot.writeStructEnd()
9779 
 
3431 rajveer 9780 
  def validate(self):
9781 
    return
9782 
 
9783 
 
1627 ankur.sing 9784 
  def __repr__(self):
9785 
    L = ['%s=%r' % (key, value)
9786 
      for key, value in self.__dict__.iteritems()]
9787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9788 
 
9789 
  def __eq__(self, other):
9790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9791 
 
9792 
  def __ne__(self, other):
9793 
    return not (self == other)
9794 
 
3064 chandransh 9795 
class updateNonDeliveryReason_result:
1627 ankur.sing 9796 
  """
9797 
  Attributes:
3064 chandransh 9798 
   - ex
1627 ankur.sing 9799 
  """
9800 
 
9801 
  thrift_spec = (
3064 chandransh 9802 
    None, # 0
9803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9804 
  )
9805 
 
3064 chandransh 9806 
  def __init__(self, ex=None,):
9807 
    self.ex = ex
1627 ankur.sing 9808 
 
9809 
  def read(self, iprot):
9810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9812 
      return
9813 
    iprot.readStructBegin()
9814 
    while True:
9815 
      (fname, ftype, fid) = iprot.readFieldBegin()
9816 
      if ftype == TType.STOP:
9817 
        break
3064 chandransh 9818 
      if fid == 1:
9819 
        if ftype == TType.STRUCT:
9820 
          self.ex = TransactionServiceException()
9821 
          self.ex.read(iprot)
1627 ankur.sing 9822 
        else:
9823 
          iprot.skip(ftype)
9824 
      else:
9825 
        iprot.skip(ftype)
9826 
      iprot.readFieldEnd()
9827 
    iprot.readStructEnd()
9828 
 
9829 
  def write(self, oprot):
9830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9832 
      return
3064 chandransh 9833 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9834 
    if self.ex is not None:
3064 chandransh 9835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9836 
      self.ex.write(oprot)
1627 ankur.sing 9837 
      oprot.writeFieldEnd()
9838 
    oprot.writeFieldStop()
9839 
    oprot.writeStructEnd()
9840 
 
3431 rajveer 9841 
  def validate(self):
9842 
    return
9843 
 
9844 
 
1627 ankur.sing 9845 
  def __repr__(self):
9846 
    L = ['%s=%r' % (key, value)
9847 
      for key, value in self.__dict__.iteritems()]
9848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9849 
 
9850 
  def __eq__(self, other):
9851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9852 
 
9853 
  def __ne__(self, other):
9854 
    return not (self == other)
9855 
 
3064 chandransh 9856 
class getUndeliveredOrders_args:
1886 ankur.sing 9857 
  """
9858 
  Attributes:
3064 chandransh 9859 
   - providerId
9860 
   - warehouseId
1886 ankur.sing 9861 
  """
1627 ankur.sing 9862 
 
1886 ankur.sing 9863 
  thrift_spec = (
9864 
    None, # 0
3064 chandransh 9865 
    (1, TType.I64, 'providerId', None, None, ), # 1
9866 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9867 
  )
9868 
 
3064 chandransh 9869 
  def __init__(self, providerId=None, warehouseId=None,):
9870 
    self.providerId = providerId
9871 
    self.warehouseId = warehouseId
1886 ankur.sing 9872 
 
9873 
  def read(self, iprot):
9874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9876 
      return
9877 
    iprot.readStructBegin()
9878 
    while True:
9879 
      (fname, ftype, fid) = iprot.readFieldBegin()
9880 
      if ftype == TType.STOP:
9881 
        break
9882 
      if fid == 1:
9883 
        if ftype == TType.I64:
3064 chandransh 9884 
          self.providerId = iprot.readI64();
1886 ankur.sing 9885 
        else:
9886 
          iprot.skip(ftype)
3064 chandransh 9887 
      elif fid == 2:
9888 
        if ftype == TType.I64:
9889 
          self.warehouseId = iprot.readI64();
9890 
        else:
9891 
          iprot.skip(ftype)
1886 ankur.sing 9892 
      else:
9893 
        iprot.skip(ftype)
9894 
      iprot.readFieldEnd()
9895 
    iprot.readStructEnd()
9896 
 
9897 
  def write(self, oprot):
9898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9900 
      return
3064 chandransh 9901 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9902 
    if self.providerId is not None:
3064 chandransh 9903 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9904 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9905 
      oprot.writeFieldEnd()
3431 rajveer 9906 
    if self.warehouseId is not None:
3064 chandransh 9907 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9908 
      oprot.writeI64(self.warehouseId)
9909 
      oprot.writeFieldEnd()
1886 ankur.sing 9910 
    oprot.writeFieldStop()
9911 
    oprot.writeStructEnd()
9912 
 
3431 rajveer 9913 
  def validate(self):
9914 
    return
9915 
 
9916 
 
1886 ankur.sing 9917 
  def __repr__(self):
9918 
    L = ['%s=%r' % (key, value)
9919 
      for key, value in self.__dict__.iteritems()]
9920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9921 
 
9922 
  def __eq__(self, other):
9923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9924 
 
9925 
  def __ne__(self, other):
9926 
    return not (self == other)
9927 
 
3064 chandransh 9928 
class getUndeliveredOrders_result:
1886 ankur.sing 9929 
  """
9930 
  Attributes:
9931 
   - success
9932 
  """
9933 
 
9934 
  thrift_spec = (
9935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9936 
  )
9937 
 
9938 
  def __init__(self, success=None,):
9939 
    self.success = success
9940 
 
9941 
  def read(self, iprot):
9942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9944 
      return
9945 
    iprot.readStructBegin()
9946 
    while True:
9947 
      (fname, ftype, fid) = iprot.readFieldBegin()
9948 
      if ftype == TType.STOP:
9949 
        break
9950 
      if fid == 0:
9951 
        if ftype == TType.LIST:
9952 
          self.success = []
4133 chandransh 9953 
          (_etype186, _size183) = iprot.readListBegin()
9954 
          for _i187 in xrange(_size183):
9955 
            _elem188 = Order()
9956 
            _elem188.read(iprot)
9957 
            self.success.append(_elem188)
1886 ankur.sing 9958 
          iprot.readListEnd()
9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      else:
9962 
        iprot.skip(ftype)
9963 
      iprot.readFieldEnd()
9964 
    iprot.readStructEnd()
9965 
 
9966 
  def write(self, oprot):
9967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9969 
      return
3064 chandransh 9970 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9971 
    if self.success is not None:
1886 ankur.sing 9972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9974 
      for iter189 in self.success:
9975 
        iter189.write(oprot)
1886 ankur.sing 9976 
      oprot.writeListEnd()
9977 
      oprot.writeFieldEnd()
9978 
    oprot.writeFieldStop()
9979 
    oprot.writeStructEnd()
9980 
 
3431 rajveer 9981 
  def validate(self):
9982 
    return
9983 
 
9984 
 
1886 ankur.sing 9985 
  def __repr__(self):
9986 
    L = ['%s=%r' % (key, value)
9987 
      for key, value in self.__dict__.iteritems()]
9988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9989 
 
9990 
  def __eq__(self, other):
9991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9992 
 
9993 
  def __ne__(self, other):
9994 
    return not (self == other)
9995 
 
2536 chandransh 9996 
class toggleDOAFlag_args:
9997 
  """
9998 
  Attributes:
9999 
   - orderId
10000 
  """
1886 ankur.sing 10001 
 
2536 chandransh 10002 
  thrift_spec = (
10003 
    None, # 0
10004 
    (1, TType.I64, 'orderId', None, None, ), # 1
10005 
  )
10006 
 
10007 
  def __init__(self, orderId=None,):
10008 
    self.orderId = orderId
10009 
 
10010 
  def read(self, iprot):
10011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10013 
      return
10014 
    iprot.readStructBegin()
10015 
    while True:
10016 
      (fname, ftype, fid) = iprot.readFieldBegin()
10017 
      if ftype == TType.STOP:
10018 
        break
10019 
      if fid == 1:
10020 
        if ftype == TType.I64:
10021 
          self.orderId = iprot.readI64();
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      else:
10025 
        iprot.skip(ftype)
10026 
      iprot.readFieldEnd()
10027 
    iprot.readStructEnd()
10028 
 
10029 
  def write(self, oprot):
10030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10032 
      return
10033 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10034 
    if self.orderId is not None:
2536 chandransh 10035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10036 
      oprot.writeI64(self.orderId)
10037 
      oprot.writeFieldEnd()
10038 
    oprot.writeFieldStop()
10039 
    oprot.writeStructEnd()
10040 
 
3431 rajveer 10041 
  def validate(self):
10042 
    return
10043 
 
10044 
 
2536 chandransh 10045 
  def __repr__(self):
10046 
    L = ['%s=%r' % (key, value)
10047 
      for key, value in self.__dict__.iteritems()]
10048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10049 
 
10050 
  def __eq__(self, other):
10051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10052 
 
10053 
  def __ne__(self, other):
10054 
    return not (self == other)
10055 
 
10056 
class toggleDOAFlag_result:
10057 
  """
10058 
  Attributes:
10059 
   - success
10060 
   - ex
10061 
  """
10062 
 
10063 
  thrift_spec = (
10064 
    (0, TType.BOOL, 'success', None, None, ), # 0
10065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10066 
  )
10067 
 
10068 
  def __init__(self, success=None, ex=None,):
10069 
    self.success = success
10070 
    self.ex = ex
10071 
 
10072 
  def read(self, iprot):
10073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10075 
      return
10076 
    iprot.readStructBegin()
10077 
    while True:
10078 
      (fname, ftype, fid) = iprot.readFieldBegin()
10079 
      if ftype == TType.STOP:
10080 
        break
10081 
      if fid == 0:
10082 
        if ftype == TType.BOOL:
10083 
          self.success = iprot.readBool();
10084 
        else:
10085 
          iprot.skip(ftype)
10086 
      elif fid == 1:
10087 
        if ftype == TType.STRUCT:
10088 
          self.ex = TransactionServiceException()
10089 
          self.ex.read(iprot)
10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      else:
10093 
        iprot.skip(ftype)
10094 
      iprot.readFieldEnd()
10095 
    iprot.readStructEnd()
10096 
 
10097 
  def write(self, oprot):
10098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10100 
      return
10101 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10102 
    if self.success is not None:
2536 chandransh 10103 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10104 
      oprot.writeBool(self.success)
10105 
      oprot.writeFieldEnd()
3431 rajveer 10106 
    if self.ex is not None:
2536 chandransh 10107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10108 
      self.ex.write(oprot)
10109 
      oprot.writeFieldEnd()
10110 
    oprot.writeFieldStop()
10111 
    oprot.writeStructEnd()
10112 
 
3431 rajveer 10113 
  def validate(self):
10114 
    return
10115 
 
10116 
 
2536 chandransh 10117 
  def __repr__(self):
10118 
    L = ['%s=%r' % (key, value)
10119 
      for key, value in self.__dict__.iteritems()]
10120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10121 
 
10122 
  def __eq__(self, other):
10123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10124 
 
10125 
  def __ne__(self, other):
10126 
    return not (self == other)
10127 
 
10128 
class requestPickupNumber_args:
10129 
  """
10130 
  Attributes:
10131 
   - orderId
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    None, # 0
10136 
    (1, TType.I64, 'orderId', None, None, ), # 1
10137 
  )
10138 
 
10139 
  def __init__(self, orderId=None,):
10140 
    self.orderId = orderId
10141 
 
10142 
  def read(self, iprot):
10143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10145 
      return
10146 
    iprot.readStructBegin()
10147 
    while True:
10148 
      (fname, ftype, fid) = iprot.readFieldBegin()
10149 
      if ftype == TType.STOP:
10150 
        break
10151 
      if fid == 1:
10152 
        if ftype == TType.I64:
10153 
          self.orderId = iprot.readI64();
10154 
        else:
10155 
          iprot.skip(ftype)
10156 
      else:
10157 
        iprot.skip(ftype)
10158 
      iprot.readFieldEnd()
10159 
    iprot.readStructEnd()
10160 
 
10161 
  def write(self, oprot):
10162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10164 
      return
10165 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10166 
    if self.orderId is not None:
2536 chandransh 10167 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10168 
      oprot.writeI64(self.orderId)
10169 
      oprot.writeFieldEnd()
10170 
    oprot.writeFieldStop()
10171 
    oprot.writeStructEnd()
10172 
 
3431 rajveer 10173 
  def validate(self):
10174 
    return
10175 
 
10176 
 
2536 chandransh 10177 
  def __repr__(self):
10178 
    L = ['%s=%r' % (key, value)
10179 
      for key, value in self.__dict__.iteritems()]
10180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10181 
 
10182 
  def __eq__(self, other):
10183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10184 
 
10185 
  def __ne__(self, other):
10186 
    return not (self == other)
10187 
 
10188 
class requestPickupNumber_result:
10189 
  """
10190 
  Attributes:
10191 
   - success
10192 
   - ex
10193 
  """
10194 
 
10195 
  thrift_spec = (
10196 
    (0, TType.BOOL, 'success', None, None, ), # 0
10197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10198 
  )
10199 
 
10200 
  def __init__(self, success=None, ex=None,):
10201 
    self.success = success
10202 
    self.ex = ex
10203 
 
10204 
  def read(self, iprot):
10205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10207 
      return
10208 
    iprot.readStructBegin()
10209 
    while True:
10210 
      (fname, ftype, fid) = iprot.readFieldBegin()
10211 
      if ftype == TType.STOP:
10212 
        break
10213 
      if fid == 0:
10214 
        if ftype == TType.BOOL:
10215 
          self.success = iprot.readBool();
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      elif fid == 1:
10219 
        if ftype == TType.STRUCT:
10220 
          self.ex = TransactionServiceException()
10221 
          self.ex.read(iprot)
10222 
        else:
10223 
          iprot.skip(ftype)
10224 
      else:
10225 
        iprot.skip(ftype)
10226 
      iprot.readFieldEnd()
10227 
    iprot.readStructEnd()
10228 
 
10229 
  def write(self, oprot):
10230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10232 
      return
10233 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10234 
    if self.success is not None:
2536 chandransh 10235 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10236 
      oprot.writeBool(self.success)
10237 
      oprot.writeFieldEnd()
3431 rajveer 10238 
    if self.ex is not None:
2536 chandransh 10239 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10240 
      self.ex.write(oprot)
10241 
      oprot.writeFieldEnd()
10242 
    oprot.writeFieldStop()
10243 
    oprot.writeStructEnd()
10244 
 
3431 rajveer 10245 
  def validate(self):
10246 
    return
10247 
 
10248 
 
2536 chandransh 10249 
  def __repr__(self):
10250 
    L = ['%s=%r' % (key, value)
10251 
      for key, value in self.__dict__.iteritems()]
10252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10253 
 
10254 
  def __eq__(self, other):
10255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10256 
 
10257 
  def __ne__(self, other):
10258 
    return not (self == other)
10259 
 
10260 
class authorizePickup_args:
10261 
  """
10262 
  Attributes:
10263 
   - orderId
10264 
   - pickupNumber
10265 
  """
10266 
 
10267 
  thrift_spec = (
10268 
    None, # 0
10269 
    (1, TType.I64, 'orderId', None, None, ), # 1
10270 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10271 
  )
10272 
 
10273 
  def __init__(self, orderId=None, pickupNumber=None,):
10274 
    self.orderId = orderId
10275 
    self.pickupNumber = pickupNumber
10276 
 
10277 
  def read(self, iprot):
10278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10280 
      return
10281 
    iprot.readStructBegin()
10282 
    while True:
10283 
      (fname, ftype, fid) = iprot.readFieldBegin()
10284 
      if ftype == TType.STOP:
10285 
        break
10286 
      if fid == 1:
10287 
        if ftype == TType.I64:
10288 
          self.orderId = iprot.readI64();
10289 
        else:
10290 
          iprot.skip(ftype)
10291 
      elif fid == 2:
10292 
        if ftype == TType.STRING:
10293 
          self.pickupNumber = iprot.readString();
10294 
        else:
10295 
          iprot.skip(ftype)
10296 
      else:
10297 
        iprot.skip(ftype)
10298 
      iprot.readFieldEnd()
10299 
    iprot.readStructEnd()
10300 
 
10301 
  def write(self, oprot):
10302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10304 
      return
10305 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10306 
    if self.orderId is not None:
2536 chandransh 10307 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10308 
      oprot.writeI64(self.orderId)
10309 
      oprot.writeFieldEnd()
3431 rajveer 10310 
    if self.pickupNumber is not None:
2536 chandransh 10311 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10312 
      oprot.writeString(self.pickupNumber)
10313 
      oprot.writeFieldEnd()
10314 
    oprot.writeFieldStop()
10315 
    oprot.writeStructEnd()
10316 
 
3431 rajveer 10317 
  def validate(self):
10318 
    return
10319 
 
10320 
 
2536 chandransh 10321 
  def __repr__(self):
10322 
    L = ['%s=%r' % (key, value)
10323 
      for key, value in self.__dict__.iteritems()]
10324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10325 
 
10326 
  def __eq__(self, other):
10327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10328 
 
10329 
  def __ne__(self, other):
10330 
    return not (self == other)
10331 
 
10332 
class authorizePickup_result:
10333 
  """
10334 
  Attributes:
10335 
   - success
10336 
   - ex
10337 
  """
10338 
 
10339 
  thrift_spec = (
10340 
    (0, TType.BOOL, 'success', None, None, ), # 0
10341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10342 
  )
10343 
 
10344 
  def __init__(self, success=None, ex=None,):
10345 
    self.success = success
10346 
    self.ex = ex
10347 
 
10348 
  def read(self, iprot):
10349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10351 
      return
10352 
    iprot.readStructBegin()
10353 
    while True:
10354 
      (fname, ftype, fid) = iprot.readFieldBegin()
10355 
      if ftype == TType.STOP:
10356 
        break
10357 
      if fid == 0:
10358 
        if ftype == TType.BOOL:
10359 
          self.success = iprot.readBool();
10360 
        else:
10361 
          iprot.skip(ftype)
10362 
      elif fid == 1:
10363 
        if ftype == TType.STRUCT:
10364 
          self.ex = TransactionServiceException()
10365 
          self.ex.read(iprot)
10366 
        else:
10367 
          iprot.skip(ftype)
10368 
      else:
10369 
        iprot.skip(ftype)
10370 
      iprot.readFieldEnd()
10371 
    iprot.readStructEnd()
10372 
 
10373 
  def write(self, oprot):
10374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10376 
      return
10377 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10378 
    if self.success is not None:
2536 chandransh 10379 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10380 
      oprot.writeBool(self.success)
10381 
      oprot.writeFieldEnd()
3431 rajveer 10382 
    if self.ex is not None:
2536 chandransh 10383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10384 
      self.ex.write(oprot)
10385 
      oprot.writeFieldEnd()
10386 
    oprot.writeFieldStop()
10387 
    oprot.writeStructEnd()
10388 
 
3431 rajveer 10389 
  def validate(self):
10390 
    return
10391 
 
10392 
 
2536 chandransh 10393 
  def __repr__(self):
10394 
    L = ['%s=%r' % (key, value)
10395 
      for key, value in self.__dict__.iteritems()]
10396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10397 
 
10398 
  def __eq__(self, other):
10399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10400 
 
10401 
  def __ne__(self, other):
10402 
    return not (self == other)
10403 
 
2764 chandransh 10404 
class markDoasAsPickedUp_args:
10405 
  """
10406 
  Attributes:
10407 
   - providerId
10408 
   - pickupDetails
10409 
  """
10410 
 
10411 
  thrift_spec = (
10412 
    None, # 0
10413 
    (1, TType.I64, 'providerId', None, None, ), # 1
10414 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10415 
  )
10416 
 
10417 
  def __init__(self, providerId=None, pickupDetails=None,):
10418 
    self.providerId = providerId
10419 
    self.pickupDetails = pickupDetails
10420 
 
10421 
  def read(self, iprot):
10422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10424 
      return
10425 
    iprot.readStructBegin()
10426 
    while True:
10427 
      (fname, ftype, fid) = iprot.readFieldBegin()
10428 
      if ftype == TType.STOP:
10429 
        break
10430 
      if fid == 1:
10431 
        if ftype == TType.I64:
10432 
          self.providerId = iprot.readI64();
10433 
        else:
10434 
          iprot.skip(ftype)
10435 
      elif fid == 2:
10436 
        if ftype == TType.MAP:
10437 
          self.pickupDetails = {}
4133 chandransh 10438 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10439 
          for _i194 in xrange(_size190):
10440 
            _key195 = iprot.readString();
10441 
            _val196 = iprot.readString();
10442 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10443 
          iprot.readMapEnd()
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      else:
10447 
        iprot.skip(ftype)
10448 
      iprot.readFieldEnd()
10449 
    iprot.readStructEnd()
10450 
 
10451 
  def write(self, oprot):
10452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10454 
      return
10455 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10456 
    if self.providerId is not None:
2764 chandransh 10457 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10458 
      oprot.writeI64(self.providerId)
10459 
      oprot.writeFieldEnd()
3431 rajveer 10460 
    if self.pickupDetails is not None:
2764 chandransh 10461 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10462 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10463 
      for kiter197,viter198 in self.pickupDetails.items():
10464 
        oprot.writeString(kiter197)
10465 
        oprot.writeString(viter198)
2764 chandransh 10466 
      oprot.writeMapEnd()
10467 
      oprot.writeFieldEnd()
10468 
    oprot.writeFieldStop()
10469 
    oprot.writeStructEnd()
10470 
 
3431 rajveer 10471 
  def validate(self):
10472 
    return
10473 
 
10474 
 
2764 chandransh 10475 
  def __repr__(self):
10476 
    L = ['%s=%r' % (key, value)
10477 
      for key, value in self.__dict__.iteritems()]
10478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10479 
 
10480 
  def __eq__(self, other):
10481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10482 
 
10483 
  def __ne__(self, other):
10484 
    return not (self == other)
10485 
 
10486 
class markDoasAsPickedUp_result:
10487 
  """
10488 
  Attributes:
10489 
   - success
10490 
  """
10491 
 
10492 
  thrift_spec = (
10493 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10494 
  )
10495 
 
10496 
  def __init__(self, success=None,):
10497 
    self.success = success
10498 
 
10499 
  def read(self, iprot):
10500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10502 
      return
10503 
    iprot.readStructBegin()
10504 
    while True:
10505 
      (fname, ftype, fid) = iprot.readFieldBegin()
10506 
      if ftype == TType.STOP:
10507 
        break
10508 
      if fid == 0:
10509 
        if ftype == TType.LIST:
10510 
          self.success = []
4133 chandransh 10511 
          (_etype202, _size199) = iprot.readListBegin()
10512 
          for _i203 in xrange(_size199):
10513 
            _elem204 = Order()
10514 
            _elem204.read(iprot)
10515 
            self.success.append(_elem204)
2764 chandransh 10516 
          iprot.readListEnd()
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      else:
10520 
        iprot.skip(ftype)
10521 
      iprot.readFieldEnd()
10522 
    iprot.readStructEnd()
10523 
 
10524 
  def write(self, oprot):
10525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10527 
      return
10528 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10529 
    if self.success is not None:
2764 chandransh 10530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10532 
      for iter205 in self.success:
10533 
        iter205.write(oprot)
2764 chandransh 10534 
      oprot.writeListEnd()
10535 
      oprot.writeFieldEnd()
10536 
    oprot.writeFieldStop()
10537 
    oprot.writeStructEnd()
10538 
 
3431 rajveer 10539 
  def validate(self):
10540 
    return
10541 
 
10542 
 
2764 chandransh 10543 
  def __repr__(self):
10544 
    L = ['%s=%r' % (key, value)
10545 
      for key, value in self.__dict__.iteritems()]
10546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10547 
 
10548 
  def __eq__(self, other):
10549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10550 
 
10551 
  def __ne__(self, other):
10552 
    return not (self == other)
10553 
 
2616 chandransh 10554 
class receiveReturn_args:
2591 chandransh 10555 
  """
10556 
  Attributes:
10557 
   - orderId
10558 
  """
2536 chandransh 10559 
 
2591 chandransh 10560 
  thrift_spec = (
10561 
    None, # 0
10562 
    (1, TType.I64, 'orderId', None, None, ), # 1
10563 
  )
10564 
 
10565 
  def __init__(self, orderId=None,):
10566 
    self.orderId = orderId
10567 
 
10568 
  def read(self, iprot):
10569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10571 
      return
10572 
    iprot.readStructBegin()
10573 
    while True:
10574 
      (fname, ftype, fid) = iprot.readFieldBegin()
10575 
      if ftype == TType.STOP:
10576 
        break
10577 
      if fid == 1:
10578 
        if ftype == TType.I64:
10579 
          self.orderId = iprot.readI64();
10580 
        else:
10581 
          iprot.skip(ftype)
10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
2616 chandransh 10591 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10592 
    if self.orderId is not None:
2591 chandransh 10593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10594 
      oprot.writeI64(self.orderId)
10595 
      oprot.writeFieldEnd()
10596 
    oprot.writeFieldStop()
10597 
    oprot.writeStructEnd()
10598 
 
3431 rajveer 10599 
  def validate(self):
10600 
    return
10601 
 
10602 
 
2591 chandransh 10603 
  def __repr__(self):
10604 
    L = ['%s=%r' % (key, value)
10605 
      for key, value in self.__dict__.iteritems()]
10606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10607 
 
10608 
  def __eq__(self, other):
10609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10610 
 
10611 
  def __ne__(self, other):
10612 
    return not (self == other)
10613 
 
2616 chandransh 10614 
class receiveReturn_result:
2591 chandransh 10615 
  """
10616 
  Attributes:
10617 
   - success
10618 
   - ex
10619 
  """
10620 
 
10621 
  thrift_spec = (
10622 
    (0, TType.BOOL, 'success', None, None, ), # 0
10623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10624 
  )
10625 
 
10626 
  def __init__(self, success=None, ex=None,):
10627 
    self.success = success
10628 
    self.ex = ex
10629 
 
10630 
  def read(self, iprot):
10631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10633 
      return
10634 
    iprot.readStructBegin()
10635 
    while True:
10636 
      (fname, ftype, fid) = iprot.readFieldBegin()
10637 
      if ftype == TType.STOP:
10638 
        break
10639 
      if fid == 0:
10640 
        if ftype == TType.BOOL:
10641 
          self.success = iprot.readBool();
10642 
        else:
10643 
          iprot.skip(ftype)
10644 
      elif fid == 1:
10645 
        if ftype == TType.STRUCT:
10646 
          self.ex = TransactionServiceException()
10647 
          self.ex.read(iprot)
10648 
        else:
10649 
          iprot.skip(ftype)
10650 
      else:
10651 
        iprot.skip(ftype)
10652 
      iprot.readFieldEnd()
10653 
    iprot.readStructEnd()
10654 
 
10655 
  def write(self, oprot):
10656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10658 
      return
2616 chandransh 10659 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10660 
    if self.success is not None:
2591 chandransh 10661 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10662 
      oprot.writeBool(self.success)
10663 
      oprot.writeFieldEnd()
3431 rajveer 10664 
    if self.ex is not None:
2591 chandransh 10665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10666 
      self.ex.write(oprot)
10667 
      oprot.writeFieldEnd()
10668 
    oprot.writeFieldStop()
10669 
    oprot.writeStructEnd()
10670 
 
3431 rajveer 10671 
  def validate(self):
10672 
    return
10673 
 
10674 
 
2591 chandransh 10675 
  def __repr__(self):
10676 
    L = ['%s=%r' % (key, value)
10677 
      for key, value in self.__dict__.iteritems()]
10678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10679 
 
10680 
  def __eq__(self, other):
10681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10682 
 
10683 
  def __ne__(self, other):
10684 
    return not (self == other)
10685 
 
10686 
class validateDoa_args:
10687 
  """
10688 
  Attributes:
10689 
   - orderId
10690 
   - isValid
10691 
  """
10692 
 
10693 
  thrift_spec = (
10694 
    None, # 0
10695 
    (1, TType.I64, 'orderId', None, None, ), # 1
10696 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10697 
  )
10698 
 
10699 
  def __init__(self, orderId=None, isValid=None,):
10700 
    self.orderId = orderId
10701 
    self.isValid = isValid
10702 
 
10703 
  def read(self, iprot):
10704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10706 
      return
10707 
    iprot.readStructBegin()
10708 
    while True:
10709 
      (fname, ftype, fid) = iprot.readFieldBegin()
10710 
      if ftype == TType.STOP:
10711 
        break
10712 
      if fid == 1:
10713 
        if ftype == TType.I64:
10714 
          self.orderId = iprot.readI64();
10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      elif fid == 2:
10718 
        if ftype == TType.BOOL:
10719 
          self.isValid = iprot.readBool();
10720 
        else:
10721 
          iprot.skip(ftype)
10722 
      else:
10723 
        iprot.skip(ftype)
10724 
      iprot.readFieldEnd()
10725 
    iprot.readStructEnd()
10726 
 
10727 
  def write(self, oprot):
10728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10730 
      return
10731 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10732 
    if self.orderId is not None:
2591 chandransh 10733 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10734 
      oprot.writeI64(self.orderId)
10735 
      oprot.writeFieldEnd()
3431 rajveer 10736 
    if self.isValid is not None:
2591 chandransh 10737 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10738 
      oprot.writeBool(self.isValid)
10739 
      oprot.writeFieldEnd()
10740 
    oprot.writeFieldStop()
10741 
    oprot.writeStructEnd()
10742 
 
3431 rajveer 10743 
  def validate(self):
10744 
    return
10745 
 
10746 
 
2591 chandransh 10747 
  def __repr__(self):
10748 
    L = ['%s=%r' % (key, value)
10749 
      for key, value in self.__dict__.iteritems()]
10750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10751 
 
10752 
  def __eq__(self, other):
10753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10754 
 
10755 
  def __ne__(self, other):
10756 
    return not (self == other)
10757 
 
10758 
class validateDoa_result:
10759 
  """
10760 
  Attributes:
10761 
   - success
10762 
   - ex
10763 
  """
10764 
 
10765 
  thrift_spec = (
10766 
    (0, TType.BOOL, 'success', None, None, ), # 0
10767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10768 
  )
10769 
 
10770 
  def __init__(self, success=None, ex=None,):
10771 
    self.success = success
10772 
    self.ex = ex
10773 
 
10774 
  def read(self, iprot):
10775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10777 
      return
10778 
    iprot.readStructBegin()
10779 
    while True:
10780 
      (fname, ftype, fid) = iprot.readFieldBegin()
10781 
      if ftype == TType.STOP:
10782 
        break
10783 
      if fid == 0:
10784 
        if ftype == TType.BOOL:
10785 
          self.success = iprot.readBool();
10786 
        else:
10787 
          iprot.skip(ftype)
10788 
      elif fid == 1:
10789 
        if ftype == TType.STRUCT:
10790 
          self.ex = TransactionServiceException()
10791 
          self.ex.read(iprot)
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      else:
10795 
        iprot.skip(ftype)
10796 
      iprot.readFieldEnd()
10797 
    iprot.readStructEnd()
10798 
 
10799 
  def write(self, oprot):
10800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10802 
      return
10803 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10804 
    if self.success is not None:
2591 chandransh 10805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10806 
      oprot.writeBool(self.success)
10807 
      oprot.writeFieldEnd()
3431 rajveer 10808 
    if self.ex is not None:
2591 chandransh 10809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10810 
      self.ex.write(oprot)
10811 
      oprot.writeFieldEnd()
10812 
    oprot.writeFieldStop()
10813 
    oprot.writeStructEnd()
10814 
 
3431 rajveer 10815 
  def validate(self):
10816 
    return
10817 
 
10818 
 
2591 chandransh 10819 
  def __repr__(self):
10820 
    L = ['%s=%r' % (key, value)
10821 
      for key, value in self.__dict__.iteritems()]
10822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10823 
 
10824 
  def __eq__(self, other):
10825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10826 
 
10827 
  def __ne__(self, other):
10828 
    return not (self == other)
10829 
 
2616 chandransh 10830 
class reshipOrder_args:
10831 
  """
10832 
  Attributes:
10833 
   - orderId
10834 
  """
2591 chandransh 10835 
 
2616 chandransh 10836 
  thrift_spec = (
10837 
    None, # 0
10838 
    (1, TType.I64, 'orderId', None, None, ), # 1
10839 
  )
10840 
 
10841 
  def __init__(self, orderId=None,):
10842 
    self.orderId = orderId
10843 
 
10844 
  def read(self, iprot):
10845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10847 
      return
10848 
    iprot.readStructBegin()
10849 
    while True:
10850 
      (fname, ftype, fid) = iprot.readFieldBegin()
10851 
      if ftype == TType.STOP:
10852 
        break
10853 
      if fid == 1:
10854 
        if ftype == TType.I64:
10855 
          self.orderId = iprot.readI64();
10856 
        else:
10857 
          iprot.skip(ftype)
10858 
      else:
10859 
        iprot.skip(ftype)
10860 
      iprot.readFieldEnd()
10861 
    iprot.readStructEnd()
10862 
 
10863 
  def write(self, oprot):
10864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10866 
      return
10867 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10868 
    if self.orderId is not None:
2616 chandransh 10869 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10870 
      oprot.writeI64(self.orderId)
10871 
      oprot.writeFieldEnd()
10872 
    oprot.writeFieldStop()
10873 
    oprot.writeStructEnd()
10874 
 
3431 rajveer 10875 
  def validate(self):
10876 
    return
10877 
 
10878 
 
2616 chandransh 10879 
  def __repr__(self):
10880 
    L = ['%s=%r' % (key, value)
10881 
      for key, value in self.__dict__.iteritems()]
10882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10883 
 
10884 
  def __eq__(self, other):
10885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10886 
 
10887 
  def __ne__(self, other):
10888 
    return not (self == other)
10889 
 
10890 
class reshipOrder_result:
10891 
  """
10892 
  Attributes:
10893 
   - success
10894 
   - ex
10895 
  """
10896 
 
10897 
  thrift_spec = (
10898 
    (0, TType.I64, 'success', None, None, ), # 0
10899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10900 
  )
10901 
 
10902 
  def __init__(self, success=None, ex=None,):
10903 
    self.success = success
10904 
    self.ex = ex
10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 0:
10916 
        if ftype == TType.I64:
10917 
          self.success = iprot.readI64();
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      elif fid == 1:
10921 
        if ftype == TType.STRUCT:
10922 
          self.ex = TransactionServiceException()
10923 
          self.ex.read(iprot)
10924 
        else:
10925 
          iprot.skip(ftype)
10926 
      else:
10927 
        iprot.skip(ftype)
10928 
      iprot.readFieldEnd()
10929 
    iprot.readStructEnd()
10930 
 
10931 
  def write(self, oprot):
10932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10934 
      return
10935 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10936 
    if self.success is not None:
2616 chandransh 10937 
      oprot.writeFieldBegin('success', TType.I64, 0)
10938 
      oprot.writeI64(self.success)
10939 
      oprot.writeFieldEnd()
3431 rajveer 10940 
    if self.ex is not None:
2616 chandransh 10941 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10942 
      self.ex.write(oprot)
10943 
      oprot.writeFieldEnd()
10944 
    oprot.writeFieldStop()
10945 
    oprot.writeStructEnd()
10946 
 
3431 rajveer 10947 
  def validate(self):
10948 
    return
10949 
 
10950 
 
2616 chandransh 10951 
  def __repr__(self):
10952 
    L = ['%s=%r' % (key, value)
10953 
      for key, value in self.__dict__.iteritems()]
10954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10955 
 
10956 
  def __eq__(self, other):
10957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10958 
 
10959 
  def __ne__(self, other):
10960 
    return not (self == other)
10961 
 
10962 
class refundOrder_args:
10963 
  """
10964 
  Attributes:
10965 
   - orderId
3226 chandransh 10966 
   - refundedBy
10967 
   - reason
2616 chandransh 10968 
  """
10969 
 
10970 
  thrift_spec = (
10971 
    None, # 0
10972 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10973 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10974 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10975 
  )
10976 
 
3226 chandransh 10977 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10978 
    self.orderId = orderId
3226 chandransh 10979 
    self.refundedBy = refundedBy
10980 
    self.reason = reason
2616 chandransh 10981 
 
10982 
  def read(self, iprot):
10983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10985 
      return
10986 
    iprot.readStructBegin()
10987 
    while True:
10988 
      (fname, ftype, fid) = iprot.readFieldBegin()
10989 
      if ftype == TType.STOP:
10990 
        break
10991 
      if fid == 1:
10992 
        if ftype == TType.I64:
10993 
          self.orderId = iprot.readI64();
10994 
        else:
10995 
          iprot.skip(ftype)
3226 chandransh 10996 
      elif fid == 2:
10997 
        if ftype == TType.STRING:
10998 
          self.refundedBy = iprot.readString();
10999 
        else:
11000 
          iprot.skip(ftype)
11001 
      elif fid == 3:
11002 
        if ftype == TType.STRING:
11003 
          self.reason = iprot.readString();
11004 
        else:
11005 
          iprot.skip(ftype)
2616 chandransh 11006 
      else:
11007 
        iprot.skip(ftype)
11008 
      iprot.readFieldEnd()
11009 
    iprot.readStructEnd()
11010 
 
11011 
  def write(self, oprot):
11012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11014 
      return
11015 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 11016 
    if self.orderId is not None:
2616 chandransh 11017 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11018 
      oprot.writeI64(self.orderId)
11019 
      oprot.writeFieldEnd()
3431 rajveer 11020 
    if self.refundedBy is not None:
3226 chandransh 11021 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11022 
      oprot.writeString(self.refundedBy)
11023 
      oprot.writeFieldEnd()
3431 rajveer 11024 
    if self.reason is not None:
3226 chandransh 11025 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11026 
      oprot.writeString(self.reason)
11027 
      oprot.writeFieldEnd()
2616 chandransh 11028 
    oprot.writeFieldStop()
11029 
    oprot.writeStructEnd()
11030 
 
3431 rajveer 11031 
  def validate(self):
11032 
    return
11033 
 
11034 
 
2616 chandransh 11035 
  def __repr__(self):
11036 
    L = ['%s=%r' % (key, value)
11037 
      for key, value in self.__dict__.iteritems()]
11038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11039 
 
11040 
  def __eq__(self, other):
11041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11042 
 
11043 
  def __ne__(self, other):
11044 
    return not (self == other)
11045 
 
11046 
class refundOrder_result:
11047 
  """
11048 
  Attributes:
11049 
   - success
11050 
   - ex
11051 
  """
11052 
 
11053 
  thrift_spec = (
11054 
    (0, TType.BOOL, 'success', None, None, ), # 0
11055 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11056 
  )
11057 
 
11058 
  def __init__(self, success=None, ex=None,):
11059 
    self.success = success
11060 
    self.ex = ex
11061 
 
11062 
  def read(self, iprot):
11063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11065 
      return
11066 
    iprot.readStructBegin()
11067 
    while True:
11068 
      (fname, ftype, fid) = iprot.readFieldBegin()
11069 
      if ftype == TType.STOP:
11070 
        break
11071 
      if fid == 0:
11072 
        if ftype == TType.BOOL:
11073 
          self.success = iprot.readBool();
11074 
        else:
11075 
          iprot.skip(ftype)
11076 
      elif fid == 1:
11077 
        if ftype == TType.STRUCT:
11078 
          self.ex = TransactionServiceException()
11079 
          self.ex.read(iprot)
11080 
        else:
11081 
          iprot.skip(ftype)
11082 
      else:
11083 
        iprot.skip(ftype)
11084 
      iprot.readFieldEnd()
11085 
    iprot.readStructEnd()
11086 
 
11087 
  def write(self, oprot):
11088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11090 
      return
11091 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11092 
    if self.success is not None:
2616 chandransh 11093 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11094 
      oprot.writeBool(self.success)
11095 
      oprot.writeFieldEnd()
3431 rajveer 11096 
    if self.ex is not None:
2616 chandransh 11097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11098 
      self.ex.write(oprot)
11099 
      oprot.writeFieldEnd()
11100 
    oprot.writeFieldStop()
11101 
    oprot.writeStructEnd()
11102 
 
3431 rajveer 11103 
  def validate(self):
11104 
    return
11105 
 
11106 
 
2616 chandransh 11107 
  def __repr__(self):
11108 
    L = ['%s=%r' % (key, value)
11109 
      for key, value in self.__dict__.iteritems()]
11110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11111 
 
11112 
  def __eq__(self, other):
11113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11114 
 
11115 
  def __ne__(self, other):
11116 
    return not (self == other)
11117 
 
2690 chandransh 11118 
class getReturnOrders_args:
11119 
  """
11120 
  Attributes:
11121 
   - warehouseId
11122 
   - fromDate
11123 
   - toDate
11124 
  """
2616 chandransh 11125 
 
2690 chandransh 11126 
  thrift_spec = (
11127 
    None, # 0
11128 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11129 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11130 
    (3, TType.I64, 'toDate', None, None, ), # 3
11131 
  )
11132 
 
11133 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11134 
    self.warehouseId = warehouseId
11135 
    self.fromDate = fromDate
11136 
    self.toDate = toDate
11137 
 
11138 
  def read(self, iprot):
11139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11141 
      return
11142 
    iprot.readStructBegin()
11143 
    while True:
11144 
      (fname, ftype, fid) = iprot.readFieldBegin()
11145 
      if ftype == TType.STOP:
11146 
        break
11147 
      if fid == 1:
11148 
        if ftype == TType.I64:
11149 
          self.warehouseId = iprot.readI64();
11150 
        else:
11151 
          iprot.skip(ftype)
11152 
      elif fid == 2:
11153 
        if ftype == TType.I64:
11154 
          self.fromDate = iprot.readI64();
11155 
        else:
11156 
          iprot.skip(ftype)
11157 
      elif fid == 3:
11158 
        if ftype == TType.I64:
11159 
          self.toDate = iprot.readI64();
11160 
        else:
11161 
          iprot.skip(ftype)
11162 
      else:
11163 
        iprot.skip(ftype)
11164 
      iprot.readFieldEnd()
11165 
    iprot.readStructEnd()
11166 
 
11167 
  def write(self, oprot):
11168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11170 
      return
11171 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11172 
    if self.warehouseId is not None:
2690 chandransh 11173 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11174 
      oprot.writeI64(self.warehouseId)
11175 
      oprot.writeFieldEnd()
3431 rajveer 11176 
    if self.fromDate is not None:
2690 chandransh 11177 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11178 
      oprot.writeI64(self.fromDate)
11179 
      oprot.writeFieldEnd()
3431 rajveer 11180 
    if self.toDate is not None:
2690 chandransh 11181 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11182 
      oprot.writeI64(self.toDate)
11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
3431 rajveer 11187 
  def validate(self):
11188 
    return
11189 
 
11190 
 
2690 chandransh 11191 
  def __repr__(self):
11192 
    L = ['%s=%r' % (key, value)
11193 
      for key, value in self.__dict__.iteritems()]
11194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11195 
 
11196 
  def __eq__(self, other):
11197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11198 
 
11199 
  def __ne__(self, other):
11200 
    return not (self == other)
11201 
 
11202 
class getReturnOrders_result:
11203 
  """
11204 
  Attributes:
11205 
   - success
11206 
  """
11207 
 
11208 
  thrift_spec = (
11209 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11210 
  )
11211 
 
11212 
  def __init__(self, success=None,):
11213 
    self.success = success
11214 
 
11215 
  def read(self, iprot):
11216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11218 
      return
11219 
    iprot.readStructBegin()
11220 
    while True:
11221 
      (fname, ftype, fid) = iprot.readFieldBegin()
11222 
      if ftype == TType.STOP:
11223 
        break
11224 
      if fid == 0:
11225 
        if ftype == TType.LIST:
11226 
          self.success = []
4133 chandransh 11227 
          (_etype209, _size206) = iprot.readListBegin()
11228 
          for _i210 in xrange(_size206):
11229 
            _elem211 = ReturnOrder()
11230 
            _elem211.read(iprot)
11231 
            self.success.append(_elem211)
2690 chandransh 11232 
          iprot.readListEnd()
11233 
        else:
11234 
          iprot.skip(ftype)
11235 
      else:
11236 
        iprot.skip(ftype)
11237 
      iprot.readFieldEnd()
11238 
    iprot.readStructEnd()
11239 
 
11240 
  def write(self, oprot):
11241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11243 
      return
11244 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11245 
    if self.success is not None:
2690 chandransh 11246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11248 
      for iter212 in self.success:
11249 
        iter212.write(oprot)
2690 chandransh 11250 
      oprot.writeListEnd()
11251 
      oprot.writeFieldEnd()
11252 
    oprot.writeFieldStop()
11253 
    oprot.writeStructEnd()
11254 
 
3431 rajveer 11255 
  def validate(self):
11256 
    return
11257 
 
11258 
 
2690 chandransh 11259 
  def __repr__(self):
11260 
    L = ['%s=%r' % (key, value)
11261 
      for key, value in self.__dict__.iteritems()]
11262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11263 
 
11264 
  def __eq__(self, other):
11265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11266 
 
11267 
  def __ne__(self, other):
11268 
    return not (self == other)
11269 
 
2700 chandransh 11270 
class getReturnOrder_args:
11271 
  """
11272 
  Attributes:
11273 
   - id
11274 
  """
11275 
 
11276 
  thrift_spec = (
11277 
    None, # 0
11278 
    (1, TType.I64, 'id', None, None, ), # 1
11279 
  )
11280 
 
11281 
  def __init__(self, id=None,):
11282 
    self.id = id
11283 
 
11284 
  def read(self, iprot):
11285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11287 
      return
11288 
    iprot.readStructBegin()
11289 
    while True:
11290 
      (fname, ftype, fid) = iprot.readFieldBegin()
11291 
      if ftype == TType.STOP:
11292 
        break
11293 
      if fid == 1:
11294 
        if ftype == TType.I64:
11295 
          self.id = iprot.readI64();
11296 
        else:
11297 
          iprot.skip(ftype)
11298 
      else:
11299 
        iprot.skip(ftype)
11300 
      iprot.readFieldEnd()
11301 
    iprot.readStructEnd()
11302 
 
11303 
  def write(self, oprot):
11304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11306 
      return
11307 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11308 
    if self.id is not None:
2700 chandransh 11309 
      oprot.writeFieldBegin('id', TType.I64, 1)
11310 
      oprot.writeI64(self.id)
11311 
      oprot.writeFieldEnd()
11312 
    oprot.writeFieldStop()
11313 
    oprot.writeStructEnd()
11314 
 
3431 rajveer 11315 
  def validate(self):
11316 
    return
11317 
 
11318 
 
2700 chandransh 11319 
  def __repr__(self):
11320 
    L = ['%s=%r' % (key, value)
11321 
      for key, value in self.__dict__.iteritems()]
11322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11323 
 
11324 
  def __eq__(self, other):
11325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11326 
 
11327 
  def __ne__(self, other):
11328 
    return not (self == other)
11329 
 
11330 
class getReturnOrder_result:
11331 
  """
11332 
  Attributes:
11333 
   - success
11334 
   - ex
11335 
  """
11336 
 
11337 
  thrift_spec = (
11338 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11340 
  )
11341 
 
11342 
  def __init__(self, success=None, ex=None,):
11343 
    self.success = success
11344 
    self.ex = ex
11345 
 
11346 
  def read(self, iprot):
11347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11349 
      return
11350 
    iprot.readStructBegin()
11351 
    while True:
11352 
      (fname, ftype, fid) = iprot.readFieldBegin()
11353 
      if ftype == TType.STOP:
11354 
        break
11355 
      if fid == 0:
11356 
        if ftype == TType.STRUCT:
11357 
          self.success = ReturnOrder()
11358 
          self.success.read(iprot)
11359 
        else:
11360 
          iprot.skip(ftype)
11361 
      elif fid == 1:
11362 
        if ftype == TType.STRUCT:
11363 
          self.ex = TransactionServiceException()
11364 
          self.ex.read(iprot)
11365 
        else:
11366 
          iprot.skip(ftype)
11367 
      else:
11368 
        iprot.skip(ftype)
11369 
      iprot.readFieldEnd()
11370 
    iprot.readStructEnd()
11371 
 
11372 
  def write(self, oprot):
11373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11375 
      return
11376 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11377 
    if self.success is not None:
2700 chandransh 11378 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11379 
      self.success.write(oprot)
11380 
      oprot.writeFieldEnd()
3431 rajveer 11381 
    if self.ex is not None:
2700 chandransh 11382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11383 
      self.ex.write(oprot)
11384 
      oprot.writeFieldEnd()
11385 
    oprot.writeFieldStop()
11386 
    oprot.writeStructEnd()
11387 
 
3431 rajveer 11388 
  def validate(self):
11389 
    return
11390 
 
11391 
 
2700 chandransh 11392 
  def __repr__(self):
11393 
    L = ['%s=%r' % (key, value)
11394 
      for key, value in self.__dict__.iteritems()]
11395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11396 
 
11397 
  def __eq__(self, other):
11398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11399 
 
11400 
  def __ne__(self, other):
11401 
    return not (self == other)
11402 
 
2690 chandransh 11403 
class processReturn_args:
11404 
  """
11405 
  Attributes:
11406 
   - returnOrderId
11407 
  """
11408 
 
11409 
  thrift_spec = (
11410 
    None, # 0
11411 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11412 
  )
11413 
 
11414 
  def __init__(self, returnOrderId=None,):
11415 
    self.returnOrderId = returnOrderId
11416 
 
11417 
  def read(self, iprot):
11418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11420 
      return
11421 
    iprot.readStructBegin()
11422 
    while True:
11423 
      (fname, ftype, fid) = iprot.readFieldBegin()
11424 
      if ftype == TType.STOP:
11425 
        break
11426 
      if fid == 1:
11427 
        if ftype == TType.I64:
11428 
          self.returnOrderId = iprot.readI64();
11429 
        else:
11430 
          iprot.skip(ftype)
11431 
      else:
11432 
        iprot.skip(ftype)
11433 
      iprot.readFieldEnd()
11434 
    iprot.readStructEnd()
11435 
 
11436 
  def write(self, oprot):
11437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11439 
      return
11440 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11441 
    if self.returnOrderId is not None:
2690 chandransh 11442 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11443 
      oprot.writeI64(self.returnOrderId)
11444 
      oprot.writeFieldEnd()
11445 
    oprot.writeFieldStop()
11446 
    oprot.writeStructEnd()
11447 
 
3431 rajveer 11448 
  def validate(self):
11449 
    return
11450 
 
11451 
 
2690 chandransh 11452 
  def __repr__(self):
11453 
    L = ['%s=%r' % (key, value)
11454 
      for key, value in self.__dict__.iteritems()]
11455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11456 
 
11457 
  def __eq__(self, other):
11458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11459 
 
11460 
  def __ne__(self, other):
11461 
    return not (self == other)
11462 
 
11463 
class processReturn_result:
11464 
  """
11465 
  Attributes:
11466 
   - ex
11467 
  """
11468 
 
11469 
  thrift_spec = (
11470 
    None, # 0
11471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11472 
  )
11473 
 
11474 
  def __init__(self, ex=None,):
11475 
    self.ex = ex
11476 
 
11477 
  def read(self, iprot):
11478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11480 
      return
11481 
    iprot.readStructBegin()
11482 
    while True:
11483 
      (fname, ftype, fid) = iprot.readFieldBegin()
11484 
      if ftype == TType.STOP:
11485 
        break
11486 
      if fid == 1:
11487 
        if ftype == TType.STRUCT:
11488 
          self.ex = TransactionServiceException()
11489 
          self.ex.read(iprot)
11490 
        else:
11491 
          iprot.skip(ftype)
11492 
      else:
11493 
        iprot.skip(ftype)
11494 
      iprot.readFieldEnd()
11495 
    iprot.readStructEnd()
11496 
 
11497 
  def write(self, oprot):
11498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11500 
      return
11501 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11502 
    if self.ex is not None:
2690 chandransh 11503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11504 
      self.ex.write(oprot)
11505 
      oprot.writeFieldEnd()
11506 
    oprot.writeFieldStop()
11507 
    oprot.writeStructEnd()
11508 
 
3431 rajveer 11509 
  def validate(self):
11510 
    return
11511 
 
11512 
 
2690 chandransh 11513 
  def __repr__(self):
11514 
    L = ['%s=%r' % (key, value)
11515 
      for key, value in self.__dict__.iteritems()]
11516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11517 
 
11518 
  def __eq__(self, other):
11519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11520 
 
11521 
  def __ne__(self, other):
11522 
    return not (self == other)
11523 
 
2819 chandransh 11524 
class createPurchaseOrder_args:
11525 
  """
11526 
  Attributes:
11527 
   - warehouseId
11528 
  """
2690 chandransh 11529 
 
2819 chandransh 11530 
  thrift_spec = (
11531 
    None, # 0
11532 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11533 
  )
11534 
 
11535 
  def __init__(self, warehouseId=None,):
11536 
    self.warehouseId = warehouseId
11537 
 
11538 
  def read(self, iprot):
11539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11541 
      return
11542 
    iprot.readStructBegin()
11543 
    while True:
11544 
      (fname, ftype, fid) = iprot.readFieldBegin()
11545 
      if ftype == TType.STOP:
11546 
        break
11547 
      if fid == 1:
11548 
        if ftype == TType.I64:
11549 
          self.warehouseId = iprot.readI64();
11550 
        else:
11551 
          iprot.skip(ftype)
11552 
      else:
11553 
        iprot.skip(ftype)
11554 
      iprot.readFieldEnd()
11555 
    iprot.readStructEnd()
11556 
 
11557 
  def write(self, oprot):
11558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11560 
      return
11561 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11562 
    if self.warehouseId is not None:
2819 chandransh 11563 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11564 
      oprot.writeI64(self.warehouseId)
11565 
      oprot.writeFieldEnd()
11566 
    oprot.writeFieldStop()
11567 
    oprot.writeStructEnd()
11568 
 
3431 rajveer 11569 
  def validate(self):
11570 
    return
11571 
 
11572 
 
2819 chandransh 11573 
  def __repr__(self):
11574 
    L = ['%s=%r' % (key, value)
11575 
      for key, value in self.__dict__.iteritems()]
11576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11577 
 
11578 
  def __eq__(self, other):
11579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11580 
 
11581 
  def __ne__(self, other):
11582 
    return not (self == other)
11583 
 
11584 
class createPurchaseOrder_result:
11585 
  """
11586 
  Attributes:
11587 
   - success
11588 
   - ex
11589 
  """
11590 
 
11591 
  thrift_spec = (
11592 
    (0, TType.I64, 'success', None, None, ), # 0
11593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11594 
  )
11595 
 
11596 
  def __init__(self, success=None, ex=None,):
11597 
    self.success = success
11598 
    self.ex = ex
11599 
 
11600 
  def read(self, iprot):
11601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11603 
      return
11604 
    iprot.readStructBegin()
11605 
    while True:
11606 
      (fname, ftype, fid) = iprot.readFieldBegin()
11607 
      if ftype == TType.STOP:
11608 
        break
11609 
      if fid == 0:
11610 
        if ftype == TType.I64:
11611 
          self.success = iprot.readI64();
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      elif fid == 1:
11615 
        if ftype == TType.STRUCT:
11616 
          self.ex = TransactionServiceException()
11617 
          self.ex.read(iprot)
11618 
        else:
11619 
          iprot.skip(ftype)
11620 
      else:
11621 
        iprot.skip(ftype)
11622 
      iprot.readFieldEnd()
11623 
    iprot.readStructEnd()
11624 
 
11625 
  def write(self, oprot):
11626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11628 
      return
11629 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11630 
    if self.success is not None:
2819 chandransh 11631 
      oprot.writeFieldBegin('success', TType.I64, 0)
11632 
      oprot.writeI64(self.success)
11633 
      oprot.writeFieldEnd()
3431 rajveer 11634 
    if self.ex is not None:
2819 chandransh 11635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11636 
      self.ex.write(oprot)
11637 
      oprot.writeFieldEnd()
11638 
    oprot.writeFieldStop()
11639 
    oprot.writeStructEnd()
11640 
 
3431 rajveer 11641 
  def validate(self):
11642 
    return
11643 
 
11644 
 
2819 chandransh 11645 
  def __repr__(self):
11646 
    L = ['%s=%r' % (key, value)
11647 
      for key, value in self.__dict__.iteritems()]
11648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11649 
 
11650 
  def __eq__(self, other):
11651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11652 
 
11653 
  def __ne__(self, other):
11654 
    return not (self == other)
3451 chandransh 11655 
 
11656 
class updateWeight_args:
11657 
  """
11658 
  Attributes:
11659 
   - orderId
11660 
   - weight
11661 
  """
11662 
 
11663 
  thrift_spec = (
11664 
    None, # 0
11665 
    (1, TType.I64, 'orderId', None, None, ), # 1
11666 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11667 
  )
11668 
 
11669 
  def __init__(self, orderId=None, weight=None,):
11670 
    self.orderId = orderId
11671 
    self.weight = weight
11672 
 
11673 
  def read(self, iprot):
11674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11676 
      return
11677 
    iprot.readStructBegin()
11678 
    while True:
11679 
      (fname, ftype, fid) = iprot.readFieldBegin()
11680 
      if ftype == TType.STOP:
11681 
        break
11682 
      if fid == 1:
11683 
        if ftype == TType.I64:
11684 
          self.orderId = iprot.readI64();
11685 
        else:
11686 
          iprot.skip(ftype)
11687 
      elif fid == 2:
11688 
        if ftype == TType.DOUBLE:
11689 
          self.weight = iprot.readDouble();
11690 
        else:
11691 
          iprot.skip(ftype)
11692 
      else:
11693 
        iprot.skip(ftype)
11694 
      iprot.readFieldEnd()
11695 
    iprot.readStructEnd()
11696 
 
11697 
  def write(self, oprot):
11698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11700 
      return
11701 
    oprot.writeStructBegin('updateWeight_args')
11702 
    if self.orderId is not None:
11703 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11704 
      oprot.writeI64(self.orderId)
11705 
      oprot.writeFieldEnd()
11706 
    if self.weight is not None:
11707 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11708 
      oprot.writeDouble(self.weight)
11709 
      oprot.writeFieldEnd()
11710 
    oprot.writeFieldStop()
11711 
    oprot.writeStructEnd()
11712 
 
11713 
  def validate(self):
11714 
    return
11715 
 
11716 
 
11717 
  def __repr__(self):
11718 
    L = ['%s=%r' % (key, value)
11719 
      for key, value in self.__dict__.iteritems()]
11720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11721 
 
11722 
  def __eq__(self, other):
11723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11724 
 
11725 
  def __ne__(self, other):
11726 
    return not (self == other)
11727 
 
11728 
class updateWeight_result:
11729 
  """
11730 
  Attributes:
11731 
   - success
11732 
   - ex
11733 
  """
11734 
 
11735 
  thrift_spec = (
11736 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11738 
  )
11739 
 
11740 
  def __init__(self, success=None, ex=None,):
11741 
    self.success = success
11742 
    self.ex = ex
11743 
 
11744 
  def read(self, iprot):
11745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11747 
      return
11748 
    iprot.readStructBegin()
11749 
    while True:
11750 
      (fname, ftype, fid) = iprot.readFieldBegin()
11751 
      if ftype == TType.STOP:
11752 
        break
11753 
      if fid == 0:
11754 
        if ftype == TType.STRUCT:
11755 
          self.success = Order()
11756 
          self.success.read(iprot)
11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      elif fid == 1:
11760 
        if ftype == TType.STRUCT:
11761 
          self.ex = TransactionServiceException()
11762 
          self.ex.read(iprot)
11763 
        else:
11764 
          iprot.skip(ftype)
11765 
      else:
11766 
        iprot.skip(ftype)
11767 
      iprot.readFieldEnd()
11768 
    iprot.readStructEnd()
11769 
 
11770 
  def write(self, oprot):
11771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11773 
      return
11774 
    oprot.writeStructBegin('updateWeight_result')
11775 
    if self.success is not None:
11776 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11777 
      self.success.write(oprot)
11778 
      oprot.writeFieldEnd()
11779 
    if self.ex is not None:
11780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11781 
      self.ex.write(oprot)
11782 
      oprot.writeFieldEnd()
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
3469 chandransh 11800 
 
11801 
class changeItem_args:
11802 
  """
11803 
  Attributes:
11804 
   - orderId
11805 
   - itemId
11806 
  """
11807 
 
11808 
  thrift_spec = (
11809 
    None, # 0
11810 
    (1, TType.I64, 'orderId', None, None, ), # 1
11811 
    (2, TType.I64, 'itemId', None, None, ), # 2
11812 
  )
11813 
 
11814 
  def __init__(self, orderId=None, itemId=None,):
11815 
    self.orderId = orderId
11816 
    self.itemId = itemId
11817 
 
11818 
  def read(self, iprot):
11819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11821 
      return
11822 
    iprot.readStructBegin()
11823 
    while True:
11824 
      (fname, ftype, fid) = iprot.readFieldBegin()
11825 
      if ftype == TType.STOP:
11826 
        break
11827 
      if fid == 1:
11828 
        if ftype == TType.I64:
11829 
          self.orderId = iprot.readI64();
11830 
        else:
11831 
          iprot.skip(ftype)
11832 
      elif fid == 2:
11833 
        if ftype == TType.I64:
11834 
          self.itemId = iprot.readI64();
11835 
        else:
11836 
          iprot.skip(ftype)
11837 
      else:
11838 
        iprot.skip(ftype)
11839 
      iprot.readFieldEnd()
11840 
    iprot.readStructEnd()
11841 
 
11842 
  def write(self, oprot):
11843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11845 
      return
11846 
    oprot.writeStructBegin('changeItem_args')
11847 
    if self.orderId is not None:
11848 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11849 
      oprot.writeI64(self.orderId)
11850 
      oprot.writeFieldEnd()
11851 
    if self.itemId is not None:
11852 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11853 
      oprot.writeI64(self.itemId)
11854 
      oprot.writeFieldEnd()
11855 
    oprot.writeFieldStop()
11856 
    oprot.writeStructEnd()
11857 
 
11858 
  def validate(self):
11859 
    return
11860 
 
11861 
 
11862 
  def __repr__(self):
11863 
    L = ['%s=%r' % (key, value)
11864 
      for key, value in self.__dict__.iteritems()]
11865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11866 
 
11867 
  def __eq__(self, other):
11868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11869 
 
11870 
  def __ne__(self, other):
11871 
    return not (self == other)
11872 
 
11873 
class changeItem_result:
11874 
  """
11875 
  Attributes:
11876 
   - success
11877 
   - ex
11878 
  """
11879 
 
11880 
  thrift_spec = (
11881 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11883 
  )
11884 
 
11885 
  def __init__(self, success=None, ex=None,):
11886 
    self.success = success
11887 
    self.ex = ex
11888 
 
11889 
  def read(self, iprot):
11890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11892 
      return
11893 
    iprot.readStructBegin()
11894 
    while True:
11895 
      (fname, ftype, fid) = iprot.readFieldBegin()
11896 
      if ftype == TType.STOP:
11897 
        break
11898 
      if fid == 0:
11899 
        if ftype == TType.STRUCT:
11900 
          self.success = Order()
11901 
          self.success.read(iprot)
11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      elif fid == 1:
11905 
        if ftype == TType.STRUCT:
11906 
          self.ex = TransactionServiceException()
11907 
          self.ex.read(iprot)
11908 
        else:
11909 
          iprot.skip(ftype)
11910 
      else:
11911 
        iprot.skip(ftype)
11912 
      iprot.readFieldEnd()
11913 
    iprot.readStructEnd()
11914 
 
11915 
  def write(self, oprot):
11916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11918 
      return
11919 
    oprot.writeStructBegin('changeItem_result')
11920 
    if self.success is not None:
11921 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11922 
      self.success.write(oprot)
11923 
      oprot.writeFieldEnd()
11924 
    if self.ex is not None:
11925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11926 
      self.ex.write(oprot)
11927 
      oprot.writeFieldEnd()
11928 
    oprot.writeFieldStop()
11929 
    oprot.writeStructEnd()
11930 
 
11931 
  def validate(self):
11932 
    return
11933 
 
11934 
 
11935 
  def __repr__(self):
11936 
    L = ['%s=%r' % (key, value)
11937 
      for key, value in self.__dict__.iteritems()]
11938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11939 
 
11940 
  def __eq__(self, other):
11941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11942 
 
11943 
  def __ne__(self, other):
11944 
    return not (self == other)
11945 
 
11946 
class shiftToWarehouse_args:
11947 
  """
11948 
  Attributes:
11949 
   - orderId
11950 
   - warehouseId
11951 
  """
11952 
 
11953 
  thrift_spec = (
11954 
    None, # 0
11955 
    (1, TType.I64, 'orderId', None, None, ), # 1
11956 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11957 
  )
11958 
 
11959 
  def __init__(self, orderId=None, warehouseId=None,):
11960 
    self.orderId = orderId
11961 
    self.warehouseId = warehouseId
11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      if fid == 1:
11973 
        if ftype == TType.I64:
11974 
          self.orderId = iprot.readI64();
11975 
        else:
11976 
          iprot.skip(ftype)
11977 
      elif fid == 2:
11978 
        if ftype == TType.I64:
11979 
          self.warehouseId = iprot.readI64();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      else:
11983 
        iprot.skip(ftype)
11984 
      iprot.readFieldEnd()
11985 
    iprot.readStructEnd()
11986 
 
11987 
  def write(self, oprot):
11988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11990 
      return
11991 
    oprot.writeStructBegin('shiftToWarehouse_args')
11992 
    if self.orderId is not None:
11993 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11994 
      oprot.writeI64(self.orderId)
11995 
      oprot.writeFieldEnd()
11996 
    if self.warehouseId is not None:
11997 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11998 
      oprot.writeI64(self.warehouseId)
11999 
      oprot.writeFieldEnd()
12000 
    oprot.writeFieldStop()
12001 
    oprot.writeStructEnd()
12002 
 
12003 
  def validate(self):
12004 
    return
12005 
 
12006 
 
12007 
  def __repr__(self):
12008 
    L = ['%s=%r' % (key, value)
12009 
      for key, value in self.__dict__.iteritems()]
12010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12011 
 
12012 
  def __eq__(self, other):
12013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12014 
 
12015 
  def __ne__(self, other):
12016 
    return not (self == other)
12017 
 
12018 
class shiftToWarehouse_result:
12019 
  """
12020 
  Attributes:
12021 
   - success
12022 
   - ex
12023 
  """
12024 
 
12025 
  thrift_spec = (
12026 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12028 
  )
12029 
 
12030 
  def __init__(self, success=None, ex=None,):
12031 
    self.success = success
12032 
    self.ex = ex
12033 
 
12034 
  def read(self, iprot):
12035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12037 
      return
12038 
    iprot.readStructBegin()
12039 
    while True:
12040 
      (fname, ftype, fid) = iprot.readFieldBegin()
12041 
      if ftype == TType.STOP:
12042 
        break
12043 
      if fid == 0:
12044 
        if ftype == TType.STRUCT:
12045 
          self.success = Order()
12046 
          self.success.read(iprot)
12047 
        else:
12048 
          iprot.skip(ftype)
12049 
      elif fid == 1:
12050 
        if ftype == TType.STRUCT:
12051 
          self.ex = TransactionServiceException()
12052 
          self.ex.read(iprot)
12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      else:
12056 
        iprot.skip(ftype)
12057 
      iprot.readFieldEnd()
12058 
    iprot.readStructEnd()
12059 
 
12060 
  def write(self, oprot):
12061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12063 
      return
12064 
    oprot.writeStructBegin('shiftToWarehouse_result')
12065 
    if self.success is not None:
12066 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12067 
      self.success.write(oprot)
12068 
      oprot.writeFieldEnd()
12069 
    if self.ex is not None:
12070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12071 
      self.ex.write(oprot)
12072 
      oprot.writeFieldEnd()
12073 
    oprot.writeFieldStop()
12074 
    oprot.writeStructEnd()
12075 
 
12076 
  def validate(self):
12077 
    return
12078 
 
12079 
 
12080 
  def __repr__(self):
12081 
    L = ['%s=%r' % (key, value)
12082 
      for key, value in self.__dict__.iteritems()]
12083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12084 
 
12085 
  def __eq__(self, other):
12086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12087 
 
12088 
  def __ne__(self, other):
12089 
    return not (self == other)
3553 chandransh 12090 
 
12091 
class addDelayReason_args:
12092 
  """
12093 
  Attributes:
12094 
   - orderId
12095 
   - delayReason
3986 chandransh 12096 
   - furtherDelay
3553 chandransh 12097 
  """
12098 
 
12099 
  thrift_spec = (
12100 
    None, # 0
12101 
    (1, TType.I64, 'orderId', None, None, ), # 1
12102 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12103 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12104 
  )
12105 
 
3986 chandransh 12106 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12107 
    self.orderId = orderId
12108 
    self.delayReason = delayReason
3986 chandransh 12109 
    self.furtherDelay = furtherDelay
3553 chandransh 12110 
 
12111 
  def read(self, iprot):
12112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12114 
      return
12115 
    iprot.readStructBegin()
12116 
    while True:
12117 
      (fname, ftype, fid) = iprot.readFieldBegin()
12118 
      if ftype == TType.STOP:
12119 
        break
12120 
      if fid == 1:
12121 
        if ftype == TType.I64:
12122 
          self.orderId = iprot.readI64();
12123 
        else:
12124 
          iprot.skip(ftype)
12125 
      elif fid == 2:
12126 
        if ftype == TType.I32:
12127 
          self.delayReason = iprot.readI32();
12128 
        else:
12129 
          iprot.skip(ftype)
3986 chandransh 12130 
      elif fid == 3:
12131 
        if ftype == TType.I64:
12132 
          self.furtherDelay = iprot.readI64();
12133 
        else:
12134 
          iprot.skip(ftype)
3553 chandransh 12135 
      else:
12136 
        iprot.skip(ftype)
12137 
      iprot.readFieldEnd()
12138 
    iprot.readStructEnd()
12139 
 
12140 
  def write(self, oprot):
12141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12143 
      return
12144 
    oprot.writeStructBegin('addDelayReason_args')
12145 
    if self.orderId is not None:
12146 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12147 
      oprot.writeI64(self.orderId)
12148 
      oprot.writeFieldEnd()
12149 
    if self.delayReason is not None:
12150 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12151 
      oprot.writeI32(self.delayReason)
12152 
      oprot.writeFieldEnd()
3986 chandransh 12153 
    if self.furtherDelay is not None:
12154 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12155 
      oprot.writeI64(self.furtherDelay)
12156 
      oprot.writeFieldEnd()
3553 chandransh 12157 
    oprot.writeFieldStop()
12158 
    oprot.writeStructEnd()
12159 
 
12160 
  def validate(self):
12161 
    return
12162 
 
12163 
 
12164 
  def __repr__(self):
12165 
    L = ['%s=%r' % (key, value)
12166 
      for key, value in self.__dict__.iteritems()]
12167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12168 
 
12169 
  def __eq__(self, other):
12170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12171 
 
12172 
  def __ne__(self, other):
12173 
    return not (self == other)
12174 
 
12175 
class addDelayReason_result:
12176 
  """
12177 
  Attributes:
12178 
   - success
12179 
   - ex
12180 
  """
12181 
 
12182 
  thrift_spec = (
12183 
    (0, TType.BOOL, 'success', None, None, ), # 0
12184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12185 
  )
12186 
 
12187 
  def __init__(self, success=None, ex=None,):
12188 
    self.success = success
12189 
    self.ex = ex
12190 
 
12191 
  def read(self, iprot):
12192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12194 
      return
12195 
    iprot.readStructBegin()
12196 
    while True:
12197 
      (fname, ftype, fid) = iprot.readFieldBegin()
12198 
      if ftype == TType.STOP:
12199 
        break
12200 
      if fid == 0:
12201 
        if ftype == TType.BOOL:
12202 
          self.success = iprot.readBool();
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      elif fid == 1:
12206 
        if ftype == TType.STRUCT:
12207 
          self.ex = TransactionServiceException()
12208 
          self.ex.read(iprot)
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      else:
12212 
        iprot.skip(ftype)
12213 
      iprot.readFieldEnd()
12214 
    iprot.readStructEnd()
12215 
 
12216 
  def write(self, oprot):
12217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12219 
      return
12220 
    oprot.writeStructBegin('addDelayReason_result')
12221 
    if self.success is not None:
12222 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12223 
      oprot.writeBool(self.success)
12224 
      oprot.writeFieldEnd()
12225 
    if self.ex is not None:
12226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12227 
      self.ex.write(oprot)
12228 
      oprot.writeFieldEnd()
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
3956 chandransh 12246 
 
12247 
class reconcileCodCollection_args:
12248 
  """
12249 
  Attributes:
12250 
   - collectedAmountMap
12251 
   - xferBy
12252 
   - xferTxnId
12253 
   - xferDate
12254 
  """
12255 
 
12256 
  thrift_spec = (
12257 
    None, # 0
12258 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12259 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12260 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12261 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12262 
  )
12263 
 
12264 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12265 
    self.collectedAmountMap = collectedAmountMap
12266 
    self.xferBy = xferBy
12267 
    self.xferTxnId = xferTxnId
12268 
    self.xferDate = xferDate
12269 
 
12270 
  def read(self, iprot):
12271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12273 
      return
12274 
    iprot.readStructBegin()
12275 
    while True:
12276 
      (fname, ftype, fid) = iprot.readFieldBegin()
12277 
      if ftype == TType.STOP:
12278 
        break
12279 
      if fid == 1:
12280 
        if ftype == TType.MAP:
12281 
          self.collectedAmountMap = {}
4133 chandransh 12282 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12283 
          for _i217 in xrange(_size213):
12284 
            _key218 = iprot.readString();
12285 
            _val219 = iprot.readDouble();
12286 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12287 
          iprot.readMapEnd()
12288 
        else:
12289 
          iprot.skip(ftype)
12290 
      elif fid == 2:
12291 
        if ftype == TType.STRING:
12292 
          self.xferBy = iprot.readString();
12293 
        else:
12294 
          iprot.skip(ftype)
12295 
      elif fid == 3:
12296 
        if ftype == TType.STRING:
12297 
          self.xferTxnId = iprot.readString();
12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      elif fid == 4:
12301 
        if ftype == TType.I64:
12302 
          self.xferDate = iprot.readI64();
12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      else:
12306 
        iprot.skip(ftype)
12307 
      iprot.readFieldEnd()
12308 
    iprot.readStructEnd()
12309 
 
12310 
  def write(self, oprot):
12311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12313 
      return
12314 
    oprot.writeStructBegin('reconcileCodCollection_args')
12315 
    if self.collectedAmountMap is not None:
12316 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12317 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12318 
      for kiter220,viter221 in self.collectedAmountMap.items():
12319 
        oprot.writeString(kiter220)
12320 
        oprot.writeDouble(viter221)
3956 chandransh 12321 
      oprot.writeMapEnd()
12322 
      oprot.writeFieldEnd()
12323 
    if self.xferBy is not None:
12324 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12325 
      oprot.writeString(self.xferBy)
12326 
      oprot.writeFieldEnd()
12327 
    if self.xferTxnId is not None:
12328 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12329 
      oprot.writeString(self.xferTxnId)
12330 
      oprot.writeFieldEnd()
12331 
    if self.xferDate is not None:
12332 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12333 
      oprot.writeI64(self.xferDate)
12334 
      oprot.writeFieldEnd()
12335 
    oprot.writeFieldStop()
12336 
    oprot.writeStructEnd()
12337 
 
12338 
  def validate(self):
12339 
    return
12340 
 
12341 
 
12342 
  def __repr__(self):
12343 
    L = ['%s=%r' % (key, value)
12344 
      for key, value in self.__dict__.iteritems()]
12345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12346 
 
12347 
  def __eq__(self, other):
12348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12349 
 
12350 
  def __ne__(self, other):
12351 
    return not (self == other)
12352 
 
12353 
class reconcileCodCollection_result:
12354 
  """
12355 
  Attributes:
12356 
   - success
12357 
   - ex
12358 
  """
12359 
 
12360 
  thrift_spec = (
12361 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12363 
  )
12364 
 
12365 
  def __init__(self, success=None, ex=None,):
12366 
    self.success = success
12367 
    self.ex = ex
12368 
 
12369 
  def read(self, iprot):
12370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12372 
      return
12373 
    iprot.readStructBegin()
12374 
    while True:
12375 
      (fname, ftype, fid) = iprot.readFieldBegin()
12376 
      if ftype == TType.STOP:
12377 
        break
12378 
      if fid == 0:
12379 
        if ftype == TType.MAP:
12380 
          self.success = {}
4133 chandransh 12381 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12382 
          for _i226 in xrange(_size222):
12383 
            _key227 = iprot.readString();
12384 
            _val228 = iprot.readString();
12385 
            self.success[_key227] = _val228
3956 chandransh 12386 
          iprot.readMapEnd()
12387 
        else:
12388 
          iprot.skip(ftype)
12389 
      elif fid == 1:
12390 
        if ftype == TType.STRUCT:
12391 
          self.ex = TransactionServiceException()
12392 
          self.ex.read(iprot)
12393 
        else:
12394 
          iprot.skip(ftype)
12395 
      else:
12396 
        iprot.skip(ftype)
12397 
      iprot.readFieldEnd()
12398 
    iprot.readStructEnd()
12399 
 
12400 
  def write(self, oprot):
12401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12403 
      return
12404 
    oprot.writeStructBegin('reconcileCodCollection_result')
12405 
    if self.success is not None:
12406 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12407 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12408 
      for kiter229,viter230 in self.success.items():
12409 
        oprot.writeString(kiter229)
12410 
        oprot.writeString(viter230)
3956 chandransh 12411 
      oprot.writeMapEnd()
12412 
      oprot.writeFieldEnd()
12413 
    if self.ex is not None:
12414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12415 
      self.ex.write(oprot)
12416 
      oprot.writeFieldEnd()
12417 
    oprot.writeFieldStop()
12418 
    oprot.writeStructEnd()
12419 
 
12420 
  def validate(self):
12421 
    return
12422 
 
12423 
 
12424 
  def __repr__(self):
12425 
    L = ['%s=%r' % (key, value)
12426 
      for key, value in self.__dict__.iteritems()]
12427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12428 
 
12429 
  def __eq__(self, other):
12430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12431 
 
12432 
  def __ne__(self, other):
12433 
    return not (self == other)
4008 mandeep.dh 12434 
 
12435 
class getTransactionsRequiringExtraProcessing_args:
12436 
  """
12437 
  Attributes:
12438 
   - category
12439 
  """
12440 
 
12441 
  thrift_spec = (
12442 
    None, # 0
12443 
    (1, TType.I32, 'category', None, None, ), # 1
12444 
  )
12445 
 
12446 
  def __init__(self, category=None,):
12447 
    self.category = category
12448 
 
12449 
  def read(self, iprot):
12450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12452 
      return
12453 
    iprot.readStructBegin()
12454 
    while True:
12455 
      (fname, ftype, fid) = iprot.readFieldBegin()
12456 
      if ftype == TType.STOP:
12457 
        break
12458 
      if fid == 1:
12459 
        if ftype == TType.I32:
12460 
          self.category = iprot.readI32();
12461 
        else:
12462 
          iprot.skip(ftype)
12463 
      else:
12464 
        iprot.skip(ftype)
12465 
      iprot.readFieldEnd()
12466 
    iprot.readStructEnd()
12467 
 
12468 
  def write(self, oprot):
12469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12471 
      return
12472 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12473 
    if self.category is not None:
12474 
      oprot.writeFieldBegin('category', TType.I32, 1)
12475 
      oprot.writeI32(self.category)
12476 
      oprot.writeFieldEnd()
12477 
    oprot.writeFieldStop()
12478 
    oprot.writeStructEnd()
12479 
 
12480 
  def validate(self):
12481 
    return
12482 
 
12483 
 
12484 
  def __repr__(self):
12485 
    L = ['%s=%r' % (key, value)
12486 
      for key, value in self.__dict__.iteritems()]
12487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12488 
 
12489 
  def __eq__(self, other):
12490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12491 
 
12492 
  def __ne__(self, other):
12493 
    return not (self == other)
12494 
 
12495 
class getTransactionsRequiringExtraProcessing_result:
12496 
  """
12497 
  Attributes:
12498 
   - success
12499 
  """
12500 
 
12501 
  thrift_spec = (
12502 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12503 
  )
12504 
 
12505 
  def __init__(self, success=None,):
12506 
    self.success = success
12507 
 
12508 
  def read(self, iprot):
12509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12511 
      return
12512 
    iprot.readStructBegin()
12513 
    while True:
12514 
      (fname, ftype, fid) = iprot.readFieldBegin()
12515 
      if ftype == TType.STOP:
12516 
        break
12517 
      if fid == 0:
12518 
        if ftype == TType.LIST:
12519 
          self.success = []
4133 chandransh 12520 
          (_etype234, _size231) = iprot.readListBegin()
12521 
          for _i235 in xrange(_size231):
12522 
            _elem236 = iprot.readI64();
12523 
            self.success.append(_elem236)
4008 mandeep.dh 12524 
          iprot.readListEnd()
12525 
        else:
12526 
          iprot.skip(ftype)
12527 
      else:
12528 
        iprot.skip(ftype)
12529 
      iprot.readFieldEnd()
12530 
    iprot.readStructEnd()
12531 
 
12532 
  def write(self, oprot):
12533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12535 
      return
12536 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12537 
    if self.success is not None:
12538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12539 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12540 
      for iter237 in self.success:
12541 
        oprot.writeI64(iter237)
4008 mandeep.dh 12542 
      oprot.writeListEnd()
12543 
      oprot.writeFieldEnd()
12544 
    oprot.writeFieldStop()
12545 
    oprot.writeStructEnd()
12546 
 
12547 
  def validate(self):
12548 
    return
12549 
 
12550 
 
12551 
  def __repr__(self):
12552 
    L = ['%s=%r' % (key, value)
12553 
      for key, value in self.__dict__.iteritems()]
12554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12555 
 
12556 
  def __eq__(self, other):
12557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12558 
 
12559 
  def __ne__(self, other):
12560 
    return not (self == other)
12561 
 
12562 
class markTransactionAsProcessed_args:
12563 
  """
12564 
  Attributes:
12565 
   - transactionId
12566 
   - category
12567 
  """
12568 
 
12569 
  thrift_spec = (
12570 
    None, # 0
12571 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12572 
    (2, TType.I32, 'category', None, None, ), # 2
12573 
  )
12574 
 
12575 
  def __init__(self, transactionId=None, category=None,):
12576 
    self.transactionId = transactionId
12577 
    self.category = category
12578 
 
12579 
  def read(self, iprot):
12580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12582 
      return
12583 
    iprot.readStructBegin()
12584 
    while True:
12585 
      (fname, ftype, fid) = iprot.readFieldBegin()
12586 
      if ftype == TType.STOP:
12587 
        break
12588 
      if fid == 1:
12589 
        if ftype == TType.I64:
12590 
          self.transactionId = iprot.readI64();
12591 
        else:
12592 
          iprot.skip(ftype)
12593 
      elif fid == 2:
12594 
        if ftype == TType.I32:
12595 
          self.category = iprot.readI32();
12596 
        else:
12597 
          iprot.skip(ftype)
12598 
      else:
12599 
        iprot.skip(ftype)
12600 
      iprot.readFieldEnd()
12601 
    iprot.readStructEnd()
12602 
 
12603 
  def write(self, oprot):
12604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12606 
      return
12607 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12608 
    if self.transactionId is not None:
12609 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12610 
      oprot.writeI64(self.transactionId)
12611 
      oprot.writeFieldEnd()
12612 
    if self.category is not None:
12613 
      oprot.writeFieldBegin('category', TType.I32, 2)
12614 
      oprot.writeI32(self.category)
12615 
      oprot.writeFieldEnd()
12616 
    oprot.writeFieldStop()
12617 
    oprot.writeStructEnd()
12618 
 
12619 
  def validate(self):
12620 
    return
12621 
 
12622 
 
12623 
  def __repr__(self):
12624 
    L = ['%s=%r' % (key, value)
12625 
      for key, value in self.__dict__.iteritems()]
12626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12627 
 
12628 
  def __eq__(self, other):
12629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12630 
 
12631 
  def __ne__(self, other):
12632 
    return not (self == other)
12633 
 
12634 
class markTransactionAsProcessed_result:
12635 
 
12636 
  thrift_spec = (
12637 
  )
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      else:
12649 
        iprot.skip(ftype)
12650 
      iprot.readFieldEnd()
12651 
    iprot.readStructEnd()
12652 
 
12653 
  def write(self, oprot):
12654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12656 
      return
12657 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
4018 chandransh 12675 
 
12676 
class getItemWiseRiskyOrdersCount_args:
12677 
 
12678 
  thrift_spec = (
12679 
  )
12680 
 
12681 
  def read(self, iprot):
12682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12684 
      return
12685 
    iprot.readStructBegin()
12686 
    while True:
12687 
      (fname, ftype, fid) = iprot.readFieldBegin()
12688 
      if ftype == TType.STOP:
12689 
        break
12690 
      else:
12691 
        iprot.skip(ftype)
12692 
      iprot.readFieldEnd()
12693 
    iprot.readStructEnd()
12694 
 
12695 
  def write(self, oprot):
12696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12698 
      return
12699 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12700 
    oprot.writeFieldStop()
12701 
    oprot.writeStructEnd()
12702 
 
12703 
  def validate(self):
12704 
    return
12705 
 
12706 
 
12707 
  def __repr__(self):
12708 
    L = ['%s=%r' % (key, value)
12709 
      for key, value in self.__dict__.iteritems()]
12710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12711 
 
12712 
  def __eq__(self, other):
12713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12714 
 
12715 
  def __ne__(self, other):
12716 
    return not (self == other)
12717 
 
12718 
class getItemWiseRiskyOrdersCount_result:
12719 
  """
12720 
  Attributes:
12721 
   - success
12722 
  """
12723 
 
12724 
  thrift_spec = (
12725 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12726 
  )
12727 
 
12728 
  def __init__(self, success=None,):
12729 
    self.success = success
12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
12740 
      if fid == 0:
12741 
        if ftype == TType.MAP:
12742 
          self.success = {}
4133 chandransh 12743 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12744 
          for _i242 in xrange(_size238):
12745 
            _key243 = iprot.readI64();
12746 
            _val244 = iprot.readI64();
12747 
            self.success[_key243] = _val244
4018 chandransh 12748 
          iprot.readMapEnd()
12749 
        else:
12750 
          iprot.skip(ftype)
12751 
      else:
12752 
        iprot.skip(ftype)
12753 
      iprot.readFieldEnd()
12754 
    iprot.readStructEnd()
12755 
 
12756 
  def write(self, oprot):
12757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12759 
      return
12760 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12761 
    if self.success is not None:
12762 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12763 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12764 
      for kiter245,viter246 in self.success.items():
12765 
        oprot.writeI64(kiter245)
12766 
        oprot.writeI64(viter246)
4018 chandransh 12767 
      oprot.writeMapEnd()
12768 
      oprot.writeFieldEnd()
12769 
    oprot.writeFieldStop()
12770 
    oprot.writeStructEnd()
12771 
 
12772 
  def validate(self):
12773 
    return
12774 
 
12775 
 
12776 
  def __repr__(self):
12777 
    L = ['%s=%r' % (key, value)
12778 
      for key, value in self.__dict__.iteritems()]
12779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12780 
 
12781 
  def __eq__(self, other):
12782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12783 
 
12784 
  def __ne__(self, other):
12785 
    return not (self == other)
4247 rajveer 12786 
 
4295 varun.gupt 12787 
class getOrdersForItemIds_args:
12788 
  """
12789 
  Attributes:
12790 
   - itemIds
12791 
  """
12792 
 
12793 
  thrift_spec = (
12794 
    None, # 0
12795 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12796 
  )
12797 
 
12798 
  def __init__(self, itemIds=None,):
12799 
    self.itemIds = itemIds
12800 
 
12801 
  def read(self, iprot):
12802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12804 
      return
12805 
    iprot.readStructBegin()
12806 
    while True:
12807 
      (fname, ftype, fid) = iprot.readFieldBegin()
12808 
      if ftype == TType.STOP:
12809 
        break
12810 
      if fid == 1:
12811 
        if ftype == TType.LIST:
12812 
          self.itemIds = []
12813 
          (_etype250, _size247) = iprot.readListBegin()
12814 
          for _i251 in xrange(_size247):
12815 
            _elem252 = iprot.readI64();
12816 
            self.itemIds.append(_elem252)
12817 
          iprot.readListEnd()
12818 
        else:
12819 
          iprot.skip(ftype)
12820 
      else:
12821 
        iprot.skip(ftype)
12822 
      iprot.readFieldEnd()
12823 
    iprot.readStructEnd()
12824 
 
12825 
  def write(self, oprot):
12826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12828 
      return
12829 
    oprot.writeStructBegin('getOrdersForItemIds_args')
12830 
    if self.itemIds is not None:
12831 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12832 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12833 
      for iter253 in self.itemIds:
12834 
        oprot.writeI64(iter253)
12835 
      oprot.writeListEnd()
12836 
      oprot.writeFieldEnd()
12837 
    oprot.writeFieldStop()
12838 
    oprot.writeStructEnd()
12839 
 
12840 
  def validate(self):
12841 
    return
12842 
 
12843 
 
12844 
  def __repr__(self):
12845 
    L = ['%s=%r' % (key, value)
12846 
      for key, value in self.__dict__.iteritems()]
12847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12848 
 
12849 
  def __eq__(self, other):
12850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12851 
 
12852 
  def __ne__(self, other):
12853 
    return not (self == other)
12854 
 
12855 
class getOrdersForItemIds_result:
12856 
  """
12857 
  Attributes:
12858 
   - success
12859 
  """
12860 
 
12861 
  thrift_spec = (
12862 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12863 
  )
12864 
 
12865 
  def __init__(self, success=None,):
12866 
    self.success = success
12867 
 
12868 
  def read(self, iprot):
12869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12871 
      return
12872 
    iprot.readStructBegin()
12873 
    while True:
12874 
      (fname, ftype, fid) = iprot.readFieldBegin()
12875 
      if ftype == TType.STOP:
12876 
        break
12877 
      if fid == 0:
12878 
        if ftype == TType.LIST:
12879 
          self.success = []
12880 
          (_etype257, _size254) = iprot.readListBegin()
12881 
          for _i258 in xrange(_size254):
12882 
            _elem259 = Order()
12883 
            _elem259.read(iprot)
12884 
            self.success.append(_elem259)
12885 
          iprot.readListEnd()
12886 
        else:
12887 
          iprot.skip(ftype)
12888 
      else:
12889 
        iprot.skip(ftype)
12890 
      iprot.readFieldEnd()
12891 
    iprot.readStructEnd()
12892 
 
12893 
  def write(self, oprot):
12894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12896 
      return
12897 
    oprot.writeStructBegin('getOrdersForItemIds_result')
12898 
    if self.success is not None:
12899 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12900 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12901 
      for iter260 in self.success:
12902 
        iter260.write(oprot)
12903 
      oprot.writeListEnd()
12904 
      oprot.writeFieldEnd()
12905 
    oprot.writeFieldStop()
12906 
    oprot.writeStructEnd()
12907 
 
12908 
  def validate(self):
12909 
    return
12910 
 
12911 
 
12912 
  def __repr__(self):
12913 
    L = ['%s=%r' % (key, value)
12914 
      for key, value in self.__dict__.iteritems()]
12915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12916 
 
12917 
  def __eq__(self, other):
12918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12919 
 
12920 
  def __ne__(self, other):
12921 
    return not (self == other)
12922 
 
4247 rajveer 12923 
class markOrderCancellationRequestReceived_args:
12924 
  """
12925 
  Attributes:
12926 
   - orderId
12927 
  """
12928 
 
12929 
  thrift_spec = (
12930 
    None, # 0
12931 
    (1, TType.I64, 'orderId', None, None, ), # 1
12932 
  )
12933 
 
12934 
  def __init__(self, orderId=None,):
12935 
    self.orderId = orderId
12936 
 
12937 
  def read(self, iprot):
12938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12940 
      return
12941 
    iprot.readStructBegin()
12942 
    while True:
12943 
      (fname, ftype, fid) = iprot.readFieldBegin()
12944 
      if ftype == TType.STOP:
12945 
        break
12946 
      if fid == 1:
12947 
        if ftype == TType.I64:
12948 
          self.orderId = iprot.readI64();
12949 
        else:
12950 
          iprot.skip(ftype)
12951 
      else:
12952 
        iprot.skip(ftype)
12953 
      iprot.readFieldEnd()
12954 
    iprot.readStructEnd()
12955 
 
12956 
  def write(self, oprot):
12957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12959 
      return
12960 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12961 
    if self.orderId is not None:
12962 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12963 
      oprot.writeI64(self.orderId)
12964 
      oprot.writeFieldEnd()
12965 
    oprot.writeFieldStop()
12966 
    oprot.writeStructEnd()
12967 
 
12968 
  def validate(self):
12969 
    return
12970 
 
12971 
 
12972 
  def __repr__(self):
12973 
    L = ['%s=%r' % (key, value)
12974 
      for key, value in self.__dict__.iteritems()]
12975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12976 
 
12977 
  def __eq__(self, other):
12978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12979 
 
12980 
  def __ne__(self, other):
12981 
    return not (self == other)
12982 
 
12983 
class markOrderCancellationRequestReceived_result:
12984 
  """
12985 
  Attributes:
12986 
   - ex
12987 
  """
12988 
 
12989 
  thrift_spec = (
12990 
    None, # 0
12991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12992 
  )
12993 
 
12994 
  def __init__(self, ex=None,):
12995 
    self.ex = ex
12996 
 
12997 
  def read(self, iprot):
12998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13000 
      return
13001 
    iprot.readStructBegin()
13002 
    while True:
13003 
      (fname, ftype, fid) = iprot.readFieldBegin()
13004 
      if ftype == TType.STOP:
13005 
        break
13006 
      if fid == 1:
13007 
        if ftype == TType.STRUCT:
13008 
          self.ex = TransactionServiceException()
13009 
          self.ex.read(iprot)
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      else:
13013 
        iprot.skip(ftype)
13014 
      iprot.readFieldEnd()
13015 
    iprot.readStructEnd()
13016 
 
13017 
  def write(self, oprot):
13018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13020 
      return
13021 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13022 
    if self.ex is not None:
13023 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13024 
      self.ex.write(oprot)
13025 
      oprot.writeFieldEnd()
13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
13044 
class markOrderCancellationRequestConfirmed_args:
13045 
  """
13046 
  Attributes:
13047 
   - orderId
13048 
  """
13049 
 
13050 
  thrift_spec = (
13051 
    None, # 0
13052 
    (1, TType.I64, 'orderId', None, None, ), # 1
13053 
  )
13054 
 
13055 
  def __init__(self, orderId=None,):
13056 
    self.orderId = orderId
13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
13067 
      if fid == 1:
13068 
        if ftype == TType.I64:
13069 
          self.orderId = iprot.readI64();
13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
13081 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13082 
    if self.orderId is not None:
13083 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13084 
      oprot.writeI64(self.orderId)
13085 
      oprot.writeFieldEnd()
13086 
    oprot.writeFieldStop()
13087 
    oprot.writeStructEnd()
13088 
 
13089 
  def validate(self):
13090 
    return
13091 
 
13092 
 
13093 
  def __repr__(self):
13094 
    L = ['%s=%r' % (key, value)
13095 
      for key, value in self.__dict__.iteritems()]
13096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13097 
 
13098 
  def __eq__(self, other):
13099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13100 
 
13101 
  def __ne__(self, other):
13102 
    return not (self == other)
13103 
 
13104 
class markOrderCancellationRequestConfirmed_result:
13105 
  """
13106 
  Attributes:
13107 
   - ex
13108 
  """
13109 
 
13110 
  thrift_spec = (
13111 
    None, # 0
13112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13113 
  )
13114 
 
13115 
  def __init__(self, ex=None,):
13116 
    self.ex = ex
13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 1:
13128 
        if ftype == TType.STRUCT:
13129 
          self.ex = TransactionServiceException()
13130 
          self.ex.read(iprot)
13131 
        else:
13132 
          iprot.skip(ftype)
13133 
      else:
13134 
        iprot.skip(ftype)
13135 
      iprot.readFieldEnd()
13136 
    iprot.readStructEnd()
13137 
 
13138 
  def write(self, oprot):
13139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13141 
      return
13142 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13143 
    if self.ex is not None:
13144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13145 
      self.ex.write(oprot)
13146 
      oprot.writeFieldEnd()
13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
13165 
class markOrderCancellationRequestDenied_args:
13166 
  """
13167 
  Attributes:
13168 
   - orderId
13169 
  """
13170 
 
13171 
  thrift_spec = (
13172 
    None, # 0
13173 
    (1, TType.I64, 'orderId', None, None, ), # 1
13174 
  )
13175 
 
13176 
  def __init__(self, orderId=None,):
13177 
    self.orderId = orderId
13178 
 
13179 
  def read(self, iprot):
13180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13182 
      return
13183 
    iprot.readStructBegin()
13184 
    while True:
13185 
      (fname, ftype, fid) = iprot.readFieldBegin()
13186 
      if ftype == TType.STOP:
13187 
        break
13188 
      if fid == 1:
13189 
        if ftype == TType.I64:
13190 
          self.orderId = iprot.readI64();
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      else:
13194 
        iprot.skip(ftype)
13195 
      iprot.readFieldEnd()
13196 
    iprot.readStructEnd()
13197 
 
13198 
  def write(self, oprot):
13199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13201 
      return
13202 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13203 
    if self.orderId is not None:
13204 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13205 
      oprot.writeI64(self.orderId)
13206 
      oprot.writeFieldEnd()
13207 
    oprot.writeFieldStop()
13208 
    oprot.writeStructEnd()
13209 
 
13210 
  def validate(self):
13211 
    return
13212 
 
13213 
 
13214 
  def __repr__(self):
13215 
    L = ['%s=%r' % (key, value)
13216 
      for key, value in self.__dict__.iteritems()]
13217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13218 
 
13219 
  def __eq__(self, other):
13220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13221 
 
13222 
  def __ne__(self, other):
13223 
    return not (self == other)
13224 
 
13225 
class markOrderCancellationRequestDenied_result:
13226 
  """
13227 
  Attributes:
13228 
   - ex
13229 
  """
13230 
 
13231 
  thrift_spec = (
13232 
    None, # 0
13233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13234 
  )
13235 
 
13236 
  def __init__(self, ex=None,):
13237 
    self.ex = ex
13238 
 
13239 
  def read(self, iprot):
13240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13242 
      return
13243 
    iprot.readStructBegin()
13244 
    while True:
13245 
      (fname, ftype, fid) = iprot.readFieldBegin()
13246 
      if ftype == TType.STOP:
13247 
        break
13248 
      if fid == 1:
13249 
        if ftype == TType.STRUCT:
13250 
          self.ex = TransactionServiceException()
13251 
          self.ex.read(iprot)
13252 
        else:
13253 
          iprot.skip(ftype)
13254 
      else:
13255 
        iprot.skip(ftype)
13256 
      iprot.readFieldEnd()
13257 
    iprot.readStructEnd()
13258 
 
13259 
  def write(self, oprot):
13260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13262 
      return
13263 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13264 
    if self.ex is not None:
13265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13266 
      self.ex.write(oprot)
13267 
      oprot.writeFieldEnd()
13268 
    oprot.writeFieldStop()
13269 
    oprot.writeStructEnd()
13270 
 
13271 
  def validate(self):
13272 
    return
13273 
 
13274 
 
13275 
  def __repr__(self):
13276 
    L = ['%s=%r' % (key, value)
13277 
      for key, value in self.__dict__.iteritems()]
13278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13279 
 
13280 
  def __eq__(self, other):
13281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13282 
 
13283 
  def __ne__(self, other):
13284 
    return not (self == other)
13285 
 
4258 rajveer 13286 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13287 
  """
13288 
  Attributes:
4258 rajveer 13289 
   - transactionId
4247 rajveer 13290 
  """
13291 
 
13292 
  thrift_spec = (
13293 
    None, # 0
4258 rajveer 13294 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13295 
  )
13296 
 
4258 rajveer 13297 
  def __init__(self, transactionId=None,):
13298 
    self.transactionId = transactionId
4247 rajveer 13299 
 
13300 
  def read(self, iprot):
13301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13303 
      return
13304 
    iprot.readStructBegin()
13305 
    while True:
13306 
      (fname, ftype, fid) = iprot.readFieldBegin()
13307 
      if ftype == TType.STOP:
13308 
        break
13309 
      if fid == 1:
13310 
        if ftype == TType.I64:
4258 rajveer 13311 
          self.transactionId = iprot.readI64();
4247 rajveer 13312 
        else:
13313 
          iprot.skip(ftype)
13314 
      else:
13315 
        iprot.skip(ftype)
13316 
      iprot.readFieldEnd()
13317 
    iprot.readStructEnd()
13318 
 
13319 
  def write(self, oprot):
13320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13322 
      return
4258 rajveer 13323 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13324 
    if self.transactionId is not None:
13325 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13326 
      oprot.writeI64(self.transactionId)
4247 rajveer 13327 
      oprot.writeFieldEnd()
13328 
    oprot.writeFieldStop()
13329 
    oprot.writeStructEnd()
13330 
 
13331 
  def validate(self):
13332 
    return
13333 
 
13334 
 
13335 
  def __repr__(self):
13336 
    L = ['%s=%r' % (key, value)
13337 
      for key, value in self.__dict__.iteritems()]
13338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13339 
 
13340 
  def __eq__(self, other):
13341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13342 
 
13343 
  def __ne__(self, other):
13344 
    return not (self == other)
13345 
 
4258 rajveer 13346 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13347 
  """
13348 
  Attributes:
13349 
   - ex
13350 
  """
13351 
 
13352 
  thrift_spec = (
13353 
    None, # 0
13354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13355 
  )
13356 
 
13357 
  def __init__(self, ex=None,):
13358 
    self.ex = ex
13359 
 
13360 
  def read(self, iprot):
13361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13363 
      return
13364 
    iprot.readStructBegin()
13365 
    while True:
13366 
      (fname, ftype, fid) = iprot.readFieldBegin()
13367 
      if ftype == TType.STOP:
13368 
        break
13369 
      if fid == 1:
13370 
        if ftype == TType.STRUCT:
13371 
          self.ex = TransactionServiceException()
13372 
          self.ex.read(iprot)
13373 
        else:
13374 
          iprot.skip(ftype)
13375 
      else:
13376 
        iprot.skip(ftype)
13377 
      iprot.readFieldEnd()
13378 
    iprot.readStructEnd()
13379 
 
13380 
  def write(self, oprot):
13381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13383 
      return
4258 rajveer 13384 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13385 
    if self.ex is not None:
13386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13387 
      self.ex.write(oprot)
13388 
      oprot.writeFieldEnd()
13389 
    oprot.writeFieldStop()
13390 
    oprot.writeStructEnd()
13391 
 
13392 
  def validate(self):
13393 
    return
13394 
 
13395 
 
13396 
  def __repr__(self):
13397 
    L = ['%s=%r' % (key, value)
13398 
      for key, value in self.__dict__.iteritems()]
13399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13400 
 
13401 
  def __eq__(self, other):
13402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13403 
 
13404 
  def __ne__(self, other):
13405 
    return not (self == other)
4259 anupam.sin 13406 
 
13407 
class refundTransaction_args:
13408 
  """
13409 
  Attributes:
13410 
   - transactionId
13411 
   - refundedBy
13412 
   - reason
13413 
  """
13414 
 
13415 
  thrift_spec = (
13416 
    None, # 0
13417 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13418 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13419 
    (3, TType.STRING, 'reason', None, None, ), # 3
13420 
  )
13421 
 
13422 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13423 
    self.transactionId = transactionId
13424 
    self.refundedBy = refundedBy
13425 
    self.reason = reason
13426 
 
13427 
  def read(self, iprot):
13428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13430 
      return
13431 
    iprot.readStructBegin()
13432 
    while True:
13433 
      (fname, ftype, fid) = iprot.readFieldBegin()
13434 
      if ftype == TType.STOP:
13435 
        break
13436 
      if fid == 1:
13437 
        if ftype == TType.I64:
13438 
          self.transactionId = iprot.readI64();
13439 
        else:
13440 
          iprot.skip(ftype)
13441 
      elif fid == 2:
13442 
        if ftype == TType.STRING:
13443 
          self.refundedBy = iprot.readString();
13444 
        else:
13445 
          iprot.skip(ftype)
13446 
      elif fid == 3:
13447 
        if ftype == TType.STRING:
13448 
          self.reason = iprot.readString();
13449 
        else:
13450 
          iprot.skip(ftype)
13451 
      else:
13452 
        iprot.skip(ftype)
13453 
      iprot.readFieldEnd()
13454 
    iprot.readStructEnd()
13455 
 
13456 
  def write(self, oprot):
13457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13459 
      return
13460 
    oprot.writeStructBegin('refundTransaction_args')
13461 
    if self.transactionId is not None:
13462 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13463 
      oprot.writeI64(self.transactionId)
13464 
      oprot.writeFieldEnd()
13465 
    if self.refundedBy is not None:
13466 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13467 
      oprot.writeString(self.refundedBy)
13468 
      oprot.writeFieldEnd()
13469 
    if self.reason is not None:
13470 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13471 
      oprot.writeString(self.reason)
13472 
      oprot.writeFieldEnd()
13473 
    oprot.writeFieldStop()
13474 
    oprot.writeStructEnd()
13475 
 
13476 
  def validate(self):
13477 
    return
13478 
 
13479 
 
13480 
  def __repr__(self):
13481 
    L = ['%s=%r' % (key, value)
13482 
      for key, value in self.__dict__.iteritems()]
13483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13484 
 
13485 
  def __eq__(self, other):
13486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13487 
 
13488 
  def __ne__(self, other):
13489 
    return not (self == other)
13490 
 
13491 
class refundTransaction_result:
13492 
  """
13493 
  Attributes:
13494 
   - ex
13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    None, # 0
13499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13500 
  )
13501 
 
13502 
  def __init__(self, ex=None,):
13503 
    self.ex = ex
13504 
 
13505 
  def read(self, iprot):
13506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13508 
      return
13509 
    iprot.readStructBegin()
13510 
    while True:
13511 
      (fname, ftype, fid) = iprot.readFieldBegin()
13512 
      if ftype == TType.STOP:
13513 
        break
13514 
      if fid == 1:
13515 
        if ftype == TType.STRUCT:
13516 
          self.ex = TransactionServiceException()
13517 
          self.ex.read(iprot)
13518 
        else:
13519 
          iprot.skip(ftype)
13520 
      else:
13521 
        iprot.skip(ftype)
13522 
      iprot.readFieldEnd()
13523 
    iprot.readStructEnd()
13524 
 
13525 
  def write(self, oprot):
13526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13528 
      return
13529 
    oprot.writeStructBegin('refundTransaction_result')
13530 
    if self.ex is not None:
13531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13532 
      self.ex.write(oprot)
13533 
      oprot.writeFieldEnd()
13534 
    oprot.writeFieldStop()
13535 
    oprot.writeStructEnd()
13536 
 
13537 
  def validate(self):
13538 
    return
13539 
 
13540 
 
13541 
  def __repr__(self):
13542 
    L = ['%s=%r' % (key, value)
13543 
      for key, value in self.__dict__.iteritems()]
13544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13545 
 
13546 
  def __eq__(self, other):
13547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13548 
 
13549 
  def __ne__(self, other):
13550 
    return not (self == other)
4285 rajveer 13551 
 
4324 mandeep.dh 13552 
class updateShipmentAddress_args:
13553 
  """
13554 
  Attributes:
13555 
   - orderId
13556 
   - addressId
13557 
  """
13558 
 
13559 
  thrift_spec = (
13560 
    None, # 0
13561 
    (1, TType.I64, 'orderId', None, None, ), # 1
13562 
    (2, TType.I64, 'addressId', None, None, ), # 2
13563 
  )
13564 
 
13565 
  def __init__(self, orderId=None, addressId=None,):
13566 
    self.orderId = orderId
13567 
    self.addressId = addressId
13568 
 
13569 
  def read(self, iprot):
13570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13572 
      return
13573 
    iprot.readStructBegin()
13574 
    while True:
13575 
      (fname, ftype, fid) = iprot.readFieldBegin()
13576 
      if ftype == TType.STOP:
13577 
        break
13578 
      if fid == 1:
13579 
        if ftype == TType.I64:
13580 
          self.orderId = iprot.readI64();
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      elif fid == 2:
13584 
        if ftype == TType.I64:
13585 
          self.addressId = iprot.readI64();
13586 
        else:
13587 
          iprot.skip(ftype)
13588 
      else:
13589 
        iprot.skip(ftype)
13590 
      iprot.readFieldEnd()
13591 
    iprot.readStructEnd()
13592 
 
13593 
  def write(self, oprot):
13594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13596 
      return
13597 
    oprot.writeStructBegin('updateShipmentAddress_args')
13598 
    if self.orderId is not None:
13599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13600 
      oprot.writeI64(self.orderId)
13601 
      oprot.writeFieldEnd()
13602 
    if self.addressId is not None:
13603 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
13604 
      oprot.writeI64(self.addressId)
13605 
      oprot.writeFieldEnd()
13606 
    oprot.writeFieldStop()
13607 
    oprot.writeStructEnd()
13608 
 
13609 
  def validate(self):
13610 
    return
13611 
 
13612 
 
13613 
  def __repr__(self):
13614 
    L = ['%s=%r' % (key, value)
13615 
      for key, value in self.__dict__.iteritems()]
13616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13617 
 
13618 
  def __eq__(self, other):
13619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13620 
 
13621 
  def __ne__(self, other):
13622 
    return not (self == other)
13623 
 
13624 
class updateShipmentAddress_result:
13625 
  """
13626 
  Attributes:
13627 
   - ex
13628 
  """
13629 
 
13630 
  thrift_spec = (
13631 
    None, # 0
13632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13633 
  )
13634 
 
13635 
  def __init__(self, ex=None,):
13636 
    self.ex = ex
13637 
 
13638 
  def read(self, iprot):
13639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13641 
      return
13642 
    iprot.readStructBegin()
13643 
    while True:
13644 
      (fname, ftype, fid) = iprot.readFieldBegin()
13645 
      if ftype == TType.STOP:
13646 
        break
13647 
      if fid == 1:
13648 
        if ftype == TType.STRUCT:
13649 
          self.ex = TransactionServiceException()
13650 
          self.ex.read(iprot)
13651 
        else:
13652 
          iprot.skip(ftype)
13653 
      else:
13654 
        iprot.skip(ftype)
13655 
      iprot.readFieldEnd()
13656 
    iprot.readStructEnd()
13657 
 
13658 
  def write(self, oprot):
13659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13661 
      return
13662 
    oprot.writeStructBegin('updateShipmentAddress_result')
13663 
    if self.ex is not None:
13664 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13665 
      self.ex.write(oprot)
13666 
      oprot.writeFieldEnd()
13667 
    oprot.writeFieldStop()
13668 
    oprot.writeStructEnd()
13669 
 
13670 
  def validate(self):
13671 
    return
13672 
 
13673 
 
13674 
  def __repr__(self):
13675 
    L = ['%s=%r' % (key, value)
13676 
      for key, value in self.__dict__.iteritems()]
13677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13678 
 
13679 
  def __eq__(self, other):
13680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13681 
 
13682 
  def __ne__(self, other):
13683 
    return not (self == other)
13684 
 
4285 rajveer 13685 
class acceptOrdersForItemId_args:
13686 
  """
13687 
  Attributes:
13688 
   - itemId
13689 
   - inventory
13690 
  """
13691 
 
13692 
  thrift_spec = (
13693 
    None, # 0
13694 
    (1, TType.I64, 'itemId', None, None, ), # 1
13695 
    (2, TType.I64, 'inventory', None, None, ), # 2
13696 
  )
13697 
 
13698 
  def __init__(self, itemId=None, inventory=None,):
13699 
    self.itemId = itemId
13700 
    self.inventory = inventory
13701 
 
13702 
  def read(self, iprot):
13703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13705 
      return
13706 
    iprot.readStructBegin()
13707 
    while True:
13708 
      (fname, ftype, fid) = iprot.readFieldBegin()
13709 
      if ftype == TType.STOP:
13710 
        break
13711 
      if fid == 1:
13712 
        if ftype == TType.I64:
13713 
          self.itemId = iprot.readI64();
13714 
        else:
13715 
          iprot.skip(ftype)
13716 
      elif fid == 2:
13717 
        if ftype == TType.I64:
13718 
          self.inventory = iprot.readI64();
13719 
        else:
13720 
          iprot.skip(ftype)
13721 
      else:
13722 
        iprot.skip(ftype)
13723 
      iprot.readFieldEnd()
13724 
    iprot.readStructEnd()
13725 
 
13726 
  def write(self, oprot):
13727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13729 
      return
13730 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13731 
    if self.itemId is not None:
13732 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13733 
      oprot.writeI64(self.itemId)
13734 
      oprot.writeFieldEnd()
13735 
    if self.inventory is not None:
13736 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13737 
      oprot.writeI64(self.inventory)
13738 
      oprot.writeFieldEnd()
13739 
    oprot.writeFieldStop()
13740 
    oprot.writeStructEnd()
13741 
 
13742 
  def validate(self):
13743 
    return
13744 
 
13745 
 
13746 
  def __repr__(self):
13747 
    L = ['%s=%r' % (key, value)
13748 
      for key, value in self.__dict__.iteritems()]
13749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13750 
 
13751 
  def __eq__(self, other):
13752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13753 
 
13754 
  def __ne__(self, other):
13755 
    return not (self == other)
13756 
 
13757 
class acceptOrdersForItemId_result:
13758 
  """
13759 
  Attributes:
13760 
   - success
13761 
   - ex
13762 
  """
13763 
 
13764 
  thrift_spec = (
13765 
    (0, TType.BOOL, 'success', None, None, ), # 0
13766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13767 
  )
13768 
 
13769 
  def __init__(self, success=None, ex=None,):
13770 
    self.success = success
13771 
    self.ex = ex
13772 
 
13773 
  def read(self, iprot):
13774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13776 
      return
13777 
    iprot.readStructBegin()
13778 
    while True:
13779 
      (fname, ftype, fid) = iprot.readFieldBegin()
13780 
      if ftype == TType.STOP:
13781 
        break
13782 
      if fid == 0:
13783 
        if ftype == TType.BOOL:
13784 
          self.success = iprot.readBool();
13785 
        else:
13786 
          iprot.skip(ftype)
13787 
      elif fid == 1:
13788 
        if ftype == TType.STRUCT:
13789 
          self.ex = TransactionServiceException()
13790 
          self.ex.read(iprot)
13791 
        else:
13792 
          iprot.skip(ftype)
13793 
      else:
13794 
        iprot.skip(ftype)
13795 
      iprot.readFieldEnd()
13796 
    iprot.readStructEnd()
13797 
 
13798 
  def write(self, oprot):
13799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13801 
      return
13802 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13803 
    if self.success is not None:
13804 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13805 
      oprot.writeBool(self.success)
13806 
      oprot.writeFieldEnd()
13807 
    if self.ex is not None:
13808 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13809 
      self.ex.write(oprot)
13810 
      oprot.writeFieldEnd()
13811 
    oprot.writeFieldStop()
13812 
    oprot.writeStructEnd()
13813 
 
13814 
  def validate(self):
13815 
    return
13816 
 
13817 
 
13818 
  def __repr__(self):
13819 
    L = ['%s=%r' % (key, value)
13820 
      for key, value in self.__dict__.iteritems()]
13821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13822 
 
13823 
  def __eq__(self, other):
13824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13825 
 
13826 
  def __ne__(self, other):
13827 
    return not (self == other)
4303 rajveer 13828 
 
13829 
class markOrdersAsPORaised_args:
13830 
  """
13831 
  Attributes:
13832 
   - vendorId
13833 
   - itemId
13834 
   - quantity
13835 
   - estimate
4369 rajveer 13836 
   - isReminder
4303 rajveer 13837 
  """
13838 
 
13839 
  thrift_spec = (
13840 
    None, # 0
13841 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13842 
    (2, TType.I64, 'itemId', None, None, ), # 2
13843 
    (3, TType.I64, 'quantity', None, None, ), # 3
13844 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 13845 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 13846 
  )
13847 
 
4369 rajveer 13848 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 13849 
    self.vendorId = vendorId
13850 
    self.itemId = itemId
13851 
    self.quantity = quantity
13852 
    self.estimate = estimate
4369 rajveer 13853 
    self.isReminder = isReminder
4303 rajveer 13854 
 
13855 
  def read(self, iprot):
13856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13858 
      return
13859 
    iprot.readStructBegin()
13860 
    while True:
13861 
      (fname, ftype, fid) = iprot.readFieldBegin()
13862 
      if ftype == TType.STOP:
13863 
        break
13864 
      if fid == 1:
13865 
        if ftype == TType.I64:
13866 
          self.vendorId = iprot.readI64();
13867 
        else:
13868 
          iprot.skip(ftype)
13869 
      elif fid == 2:
13870 
        if ftype == TType.I64:
13871 
          self.itemId = iprot.readI64();
13872 
        else:
13873 
          iprot.skip(ftype)
13874 
      elif fid == 3:
13875 
        if ftype == TType.I64:
13876 
          self.quantity = iprot.readI64();
13877 
        else:
13878 
          iprot.skip(ftype)
13879 
      elif fid == 4:
13880 
        if ftype == TType.I64:
13881 
          self.estimate = iprot.readI64();
13882 
        else:
13883 
          iprot.skip(ftype)
4369 rajveer 13884 
      elif fid == 5:
13885 
        if ftype == TType.BOOL:
13886 
          self.isReminder = iprot.readBool();
13887 
        else:
13888 
          iprot.skip(ftype)
4303 rajveer 13889 
      else:
13890 
        iprot.skip(ftype)
13891 
      iprot.readFieldEnd()
13892 
    iprot.readStructEnd()
13893 
 
13894 
  def write(self, oprot):
13895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13897 
      return
13898 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
13899 
    if self.vendorId is not None:
13900 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13901 
      oprot.writeI64(self.vendorId)
13902 
      oprot.writeFieldEnd()
13903 
    if self.itemId is not None:
13904 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13905 
      oprot.writeI64(self.itemId)
13906 
      oprot.writeFieldEnd()
13907 
    if self.quantity is not None:
13908 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13909 
      oprot.writeI64(self.quantity)
13910 
      oprot.writeFieldEnd()
13911 
    if self.estimate is not None:
13912 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13913 
      oprot.writeI64(self.estimate)
13914 
      oprot.writeFieldEnd()
4369 rajveer 13915 
    if self.isReminder is not None:
13916 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
13917 
      oprot.writeBool(self.isReminder)
13918 
      oprot.writeFieldEnd()
4303 rajveer 13919 
    oprot.writeFieldStop()
13920 
    oprot.writeStructEnd()
13921 
 
13922 
  def validate(self):
13923 
    return
13924 
 
13925 
 
13926 
  def __repr__(self):
13927 
    L = ['%s=%r' % (key, value)
13928 
      for key, value in self.__dict__.iteritems()]
13929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13930 
 
13931 
  def __eq__(self, other):
13932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13933 
 
13934 
  def __ne__(self, other):
13935 
    return not (self == other)
13936 
 
13937 
class markOrdersAsPORaised_result:
13938 
  """
13939 
  Attributes:
13940 
   - ex
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    None, # 0
13945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13946 
  )
13947 
 
13948 
  def __init__(self, ex=None,):
13949 
    self.ex = ex
13950 
 
13951 
  def read(self, iprot):
13952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13954 
      return
13955 
    iprot.readStructBegin()
13956 
    while True:
13957 
      (fname, ftype, fid) = iprot.readFieldBegin()
13958 
      if ftype == TType.STOP:
13959 
        break
13960 
      if fid == 1:
13961 
        if ftype == TType.STRUCT:
13962 
          self.ex = TransactionServiceException()
13963 
          self.ex.read(iprot)
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      else:
13967 
        iprot.skip(ftype)
13968 
      iprot.readFieldEnd()
13969 
    iprot.readStructEnd()
13970 
 
13971 
  def write(self, oprot):
13972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13974 
      return
13975 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
13976 
    if self.ex is not None:
13977 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13978 
      self.ex.write(oprot)
13979 
      oprot.writeFieldEnd()
13980 
    oprot.writeFieldStop()
13981 
    oprot.writeStructEnd()
13982 
 
13983 
  def validate(self):
13984 
    return
13985 
 
13986 
 
13987 
  def __repr__(self):
13988 
    L = ['%s=%r' % (key, value)
13989 
      for key, value in self.__dict__.iteritems()]
13990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13991 
 
13992 
  def __eq__(self, other):
13993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13994 
 
13995 
  def __ne__(self, other):
13996 
    return not (self == other)
13997 
 
13998 
class markOrdersAsReversalInitiated_args:
13999 
  """
14000 
  Attributes:
14001 
   - vendorId
14002 
   - itemId
14003 
   - quantity
14004 
   - estimate
4369 rajveer 14005 
   - isReminder
4303 rajveer 14006 
  """
14007 
 
14008 
  thrift_spec = (
14009 
    None, # 0
14010 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14011 
    (2, TType.I64, 'itemId', None, None, ), # 2
14012 
    (3, TType.I64, 'quantity', None, None, ), # 3
14013 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14014 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14015 
  )
14016 
 
4369 rajveer 14017 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14018 
    self.vendorId = vendorId
14019 
    self.itemId = itemId
14020 
    self.quantity = quantity
14021 
    self.estimate = estimate
4369 rajveer 14022 
    self.isReminder = isReminder
4303 rajveer 14023 
 
14024 
  def read(self, iprot):
14025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14027 
      return
14028 
    iprot.readStructBegin()
14029 
    while True:
14030 
      (fname, ftype, fid) = iprot.readFieldBegin()
14031 
      if ftype == TType.STOP:
14032 
        break
14033 
      if fid == 1:
14034 
        if ftype == TType.I64:
14035 
          self.vendorId = iprot.readI64();
14036 
        else:
14037 
          iprot.skip(ftype)
14038 
      elif fid == 2:
14039 
        if ftype == TType.I64:
14040 
          self.itemId = iprot.readI64();
14041 
        else:
14042 
          iprot.skip(ftype)
14043 
      elif fid == 3:
14044 
        if ftype == TType.I64:
14045 
          self.quantity = iprot.readI64();
14046 
        else:
14047 
          iprot.skip(ftype)
14048 
      elif fid == 4:
14049 
        if ftype == TType.I64:
14050 
          self.estimate = iprot.readI64();
14051 
        else:
14052 
          iprot.skip(ftype)
4369 rajveer 14053 
      elif fid == 5:
14054 
        if ftype == TType.BOOL:
14055 
          self.isReminder = iprot.readBool();
14056 
        else:
14057 
          iprot.skip(ftype)
4303 rajveer 14058 
      else:
14059 
        iprot.skip(ftype)
14060 
      iprot.readFieldEnd()
14061 
    iprot.readStructEnd()
14062 
 
14063 
  def write(self, oprot):
14064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14066 
      return
14067 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14068 
    if self.vendorId is not None:
14069 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14070 
      oprot.writeI64(self.vendorId)
14071 
      oprot.writeFieldEnd()
14072 
    if self.itemId is not None:
14073 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14074 
      oprot.writeI64(self.itemId)
14075 
      oprot.writeFieldEnd()
14076 
    if self.quantity is not None:
14077 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14078 
      oprot.writeI64(self.quantity)
14079 
      oprot.writeFieldEnd()
14080 
    if self.estimate is not None:
14081 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14082 
      oprot.writeI64(self.estimate)
14083 
      oprot.writeFieldEnd()
4369 rajveer 14084 
    if self.isReminder is not None:
14085 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14086 
      oprot.writeBool(self.isReminder)
14087 
      oprot.writeFieldEnd()
4303 rajveer 14088 
    oprot.writeFieldStop()
14089 
    oprot.writeStructEnd()
14090 
 
14091 
  def validate(self):
14092 
    return
14093 
 
14094 
 
14095 
  def __repr__(self):
14096 
    L = ['%s=%r' % (key, value)
14097 
      for key, value in self.__dict__.iteritems()]
14098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14099 
 
14100 
  def __eq__(self, other):
14101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14102 
 
14103 
  def __ne__(self, other):
14104 
    return not (self == other)
14105 
 
14106 
class markOrdersAsReversalInitiated_result:
14107 
  """
14108 
  Attributes:
14109 
   - ex
14110 
  """
14111 
 
14112 
  thrift_spec = (
14113 
    None, # 0
14114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14115 
  )
14116 
 
14117 
  def __init__(self, ex=None,):
14118 
    self.ex = ex
14119 
 
14120 
  def read(self, iprot):
14121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14123 
      return
14124 
    iprot.readStructBegin()
14125 
    while True:
14126 
      (fname, ftype, fid) = iprot.readFieldBegin()
14127 
      if ftype == TType.STOP:
14128 
        break
14129 
      if fid == 1:
14130 
        if ftype == TType.STRUCT:
14131 
          self.ex = TransactionServiceException()
14132 
          self.ex.read(iprot)
14133 
        else:
14134 
          iprot.skip(ftype)
14135 
      else:
14136 
        iprot.skip(ftype)
14137 
      iprot.readFieldEnd()
14138 
    iprot.readStructEnd()
14139 
 
14140 
  def write(self, oprot):
14141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14143 
      return
14144 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14145 
    if self.ex is not None:
14146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14147 
      self.ex.write(oprot)
14148 
      oprot.writeFieldEnd()
14149 
    oprot.writeFieldStop()
14150 
    oprot.writeStructEnd()
14151 
 
14152 
  def validate(self):
14153 
    return
14154 
 
14155 
 
14156 
  def __repr__(self):
14157 
    L = ['%s=%r' % (key, value)
14158 
      for key, value in self.__dict__.iteritems()]
14159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14160 
 
14161 
  def __eq__(self, other):
14162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14163 
 
14164 
  def __ne__(self, other):
14165 
    return not (self == other)
14166 
 
14167 
class markOrdersAsNotAvailabke_args:
14168 
  """
14169 
  Attributes:
14170 
   - vendorId
14171 
   - itemId
14172 
   - quantity
14173 
   - estimate
4369 rajveer 14174 
   - isReminder
4303 rajveer 14175 
  """
14176 
 
14177 
  thrift_spec = (
14178 
    None, # 0
14179 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14180 
    (2, TType.I64, 'itemId', None, None, ), # 2
14181 
    (3, TType.I64, 'quantity', None, None, ), # 3
14182 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14183 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14184 
  )
14185 
 
4369 rajveer 14186 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14187 
    self.vendorId = vendorId
14188 
    self.itemId = itemId
14189 
    self.quantity = quantity
14190 
    self.estimate = estimate
4369 rajveer 14191 
    self.isReminder = isReminder
4303 rajveer 14192 
 
14193 
  def read(self, iprot):
14194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14196 
      return
14197 
    iprot.readStructBegin()
14198 
    while True:
14199 
      (fname, ftype, fid) = iprot.readFieldBegin()
14200 
      if ftype == TType.STOP:
14201 
        break
14202 
      if fid == 1:
14203 
        if ftype == TType.I64:
14204 
          self.vendorId = iprot.readI64();
14205 
        else:
14206 
          iprot.skip(ftype)
14207 
      elif fid == 2:
14208 
        if ftype == TType.I64:
14209 
          self.itemId = iprot.readI64();
14210 
        else:
14211 
          iprot.skip(ftype)
14212 
      elif fid == 3:
14213 
        if ftype == TType.I64:
14214 
          self.quantity = iprot.readI64();
14215 
        else:
14216 
          iprot.skip(ftype)
14217 
      elif fid == 4:
14218 
        if ftype == TType.I64:
14219 
          self.estimate = iprot.readI64();
14220 
        else:
14221 
          iprot.skip(ftype)
4369 rajveer 14222 
      elif fid == 5:
14223 
        if ftype == TType.BOOL:
14224 
          self.isReminder = iprot.readBool();
14225 
        else:
14226 
          iprot.skip(ftype)
4303 rajveer 14227 
      else:
14228 
        iprot.skip(ftype)
14229 
      iprot.readFieldEnd()
14230 
    iprot.readStructEnd()
14231 
 
14232 
  def write(self, oprot):
14233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14235 
      return
14236 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14237 
    if self.vendorId is not None:
14238 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14239 
      oprot.writeI64(self.vendorId)
14240 
      oprot.writeFieldEnd()
14241 
    if self.itemId is not None:
14242 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14243 
      oprot.writeI64(self.itemId)
14244 
      oprot.writeFieldEnd()
14245 
    if self.quantity is not None:
14246 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14247 
      oprot.writeI64(self.quantity)
14248 
      oprot.writeFieldEnd()
14249 
    if self.estimate is not None:
14250 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14251 
      oprot.writeI64(self.estimate)
14252 
      oprot.writeFieldEnd()
4369 rajveer 14253 
    if self.isReminder is not None:
14254 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14255 
      oprot.writeBool(self.isReminder)
14256 
      oprot.writeFieldEnd()
4303 rajveer 14257 
    oprot.writeFieldStop()
14258 
    oprot.writeStructEnd()
14259 
 
14260 
  def validate(self):
14261 
    return
14262 
 
14263 
 
14264 
  def __repr__(self):
14265 
    L = ['%s=%r' % (key, value)
14266 
      for key, value in self.__dict__.iteritems()]
14267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14268 
 
14269 
  def __eq__(self, other):
14270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14271 
 
14272 
  def __ne__(self, other):
14273 
    return not (self == other)
14274 
 
14275 
class markOrdersAsNotAvailabke_result:
14276 
  """
14277 
  Attributes:
14278 
   - ex
14279 
  """
14280 
 
14281 
  thrift_spec = (
14282 
    None, # 0
14283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14284 
  )
14285 
 
14286 
  def __init__(self, ex=None,):
14287 
    self.ex = ex
14288 
 
14289 
  def read(self, iprot):
14290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14292 
      return
14293 
    iprot.readStructBegin()
14294 
    while True:
14295 
      (fname, ftype, fid) = iprot.readFieldBegin()
14296 
      if ftype == TType.STOP:
14297 
        break
14298 
      if fid == 1:
14299 
        if ftype == TType.STRUCT:
14300 
          self.ex = TransactionServiceException()
14301 
          self.ex.read(iprot)
14302 
        else:
14303 
          iprot.skip(ftype)
14304 
      else:
14305 
        iprot.skip(ftype)
14306 
      iprot.readFieldEnd()
14307 
    iprot.readStructEnd()
14308 
 
14309 
  def write(self, oprot):
14310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14312 
      return
14313 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14314 
    if self.ex is not None:
14315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14316 
      self.ex.write(oprot)
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
4369 rajveer 14335 
 
14336 
class markOrdersAsTimeout_args:
14337 
  """
14338 
  Attributes:
14339 
   - vendorId
14340 
  """
14341 
 
14342 
  thrift_spec = (
14343 
    None, # 0
14344 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14345 
  )
14346 
 
14347 
  def __init__(self, vendorId=None,):
14348 
    self.vendorId = vendorId
14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 1:
14360 
        if ftype == TType.I64:
14361 
          self.vendorId = iprot.readI64();
14362 
        else:
14363 
          iprot.skip(ftype)
14364 
      else:
14365 
        iprot.skip(ftype)
14366 
      iprot.readFieldEnd()
14367 
    iprot.readStructEnd()
14368 
 
14369 
  def write(self, oprot):
14370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14372 
      return
14373 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
14374 
    if self.vendorId is not None:
14375 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14376 
      oprot.writeI64(self.vendorId)
14377 
      oprot.writeFieldEnd()
14378 
    oprot.writeFieldStop()
14379 
    oprot.writeStructEnd()
14380 
 
14381 
  def validate(self):
14382 
    return
14383 
 
14384 
 
14385 
  def __repr__(self):
14386 
    L = ['%s=%r' % (key, value)
14387 
      for key, value in self.__dict__.iteritems()]
14388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14389 
 
14390 
  def __eq__(self, other):
14391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14392 
 
14393 
  def __ne__(self, other):
14394 
    return not (self == other)
14395 
 
14396 
class markOrdersAsTimeout_result:
14397 
  """
14398 
  Attributes:
14399 
   - success
14400 
   - ex
14401 
  """
14402 
 
14403 
  thrift_spec = (
14404 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
14405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14406 
  )
14407 
 
14408 
  def __init__(self, success=None, ex=None,):
14409 
    self.success = success
14410 
    self.ex = ex
14411 
 
14412 
  def read(self, iprot):
14413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14415 
      return
14416 
    iprot.readStructBegin()
14417 
    while True:
14418 
      (fname, ftype, fid) = iprot.readFieldBegin()
14419 
      if ftype == TType.STOP:
14420 
        break
14421 
      if fid == 0:
14422 
        if ftype == TType.MAP:
14423 
          self.success = {}
14424 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
14425 
          for _i265 in xrange(_size261):
14426 
            _key266 = iprot.readI32();
14427 
            _val267 = TimeoutSummary()
14428 
            _val267.read(iprot)
14429 
            self.success[_key266] = _val267
14430 
          iprot.readMapEnd()
14431 
        else:
14432 
          iprot.skip(ftype)
14433 
      elif fid == 1:
14434 
        if ftype == TType.STRUCT:
14435 
          self.ex = TransactionServiceException()
14436 
          self.ex.read(iprot)
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      else:
14440 
        iprot.skip(ftype)
14441 
      iprot.readFieldEnd()
14442 
    iprot.readStructEnd()
14443 
 
14444 
  def write(self, oprot):
14445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14447 
      return
14448 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
14449 
    if self.success is not None:
14450 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14451 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
14452 
      for kiter268,viter269 in self.success.items():
14453 
        oprot.writeI32(kiter268)
14454 
        viter269.write(oprot)
14455 
      oprot.writeMapEnd()
14456 
      oprot.writeFieldEnd()
14457 
    if self.ex is not None:
14458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14459 
      self.ex.write(oprot)
14460 
      oprot.writeFieldEnd()
14461 
    oprot.writeFieldStop()
14462 
    oprot.writeStructEnd()
14463 
 
14464 
  def validate(self):
14465 
    return
14466 
 
14467 
 
14468 
  def __repr__(self):
14469 
    L = ['%s=%r' % (key, value)
14470 
      for key, value in self.__dict__.iteritems()]
14471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14472 
 
14473 
  def __eq__(self, other):
14474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14475 
 
14476 
  def __ne__(self, other):
14477 
    return not (self == other)
4386 anupam.sin 14478 
 
14479 
class getOrderForAwb_args:
14480 
  """
14481 
  Attributes:
14482 
   - awb
14483 
  """
14484 
 
14485 
  thrift_spec = (
14486 
    None, # 0
14487 
    (1, TType.STRING, 'awb', None, None, ), # 1
14488 
  )
14489 
 
14490 
  def __init__(self, awb=None,):
14491 
    self.awb = awb
14492 
 
14493 
  def read(self, iprot):
14494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14496 
      return
14497 
    iprot.readStructBegin()
14498 
    while True:
14499 
      (fname, ftype, fid) = iprot.readFieldBegin()
14500 
      if ftype == TType.STOP:
14501 
        break
14502 
      if fid == 1:
14503 
        if ftype == TType.STRING:
14504 
          self.awb = iprot.readString();
14505 
        else:
14506 
          iprot.skip(ftype)
14507 
      else:
14508 
        iprot.skip(ftype)
14509 
      iprot.readFieldEnd()
14510 
    iprot.readStructEnd()
14511 
 
14512 
  def write(self, oprot):
14513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14515 
      return
14516 
    oprot.writeStructBegin('getOrderForAwb_args')
14517 
    if self.awb is not None:
14518 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
14519 
      oprot.writeString(self.awb)
14520 
      oprot.writeFieldEnd()
14521 
    oprot.writeFieldStop()
14522 
    oprot.writeStructEnd()
14523 
 
14524 
  def validate(self):
14525 
    return
14526 
 
14527 
 
14528 
  def __repr__(self):
14529 
    L = ['%s=%r' % (key, value)
14530 
      for key, value in self.__dict__.iteritems()]
14531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14532 
 
14533 
  def __eq__(self, other):
14534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14535 
 
14536 
  def __ne__(self, other):
14537 
    return not (self == other)
14538 
 
14539 
class getOrderForAwb_result:
14540 
  """
14541 
  Attributes:
14542 
   - success
14543 
   - ex
14544 
  """
14545 
 
14546 
  thrift_spec = (
14547 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14549 
  )
14550 
 
14551 
  def __init__(self, success=None, ex=None,):
14552 
    self.success = success
14553 
    self.ex = ex
14554 
 
14555 
  def read(self, iprot):
14556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14558 
      return
14559 
    iprot.readStructBegin()
14560 
    while True:
14561 
      (fname, ftype, fid) = iprot.readFieldBegin()
14562 
      if ftype == TType.STOP:
14563 
        break
14564 
      if fid == 0:
14565 
        if ftype == TType.STRUCT:
14566 
          self.success = Order()
14567 
          self.success.read(iprot)
14568 
        else:
14569 
          iprot.skip(ftype)
14570 
      elif fid == 1:
14571 
        if ftype == TType.STRUCT:
14572 
          self.ex = TransactionServiceException()
14573 
          self.ex.read(iprot)
14574 
        else:
14575 
          iprot.skip(ftype)
14576 
      else:
14577 
        iprot.skip(ftype)
14578 
      iprot.readFieldEnd()
14579 
    iprot.readStructEnd()
14580 
 
14581 
  def write(self, oprot):
14582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14584 
      return
14585 
    oprot.writeStructBegin('getOrderForAwb_result')
14586 
    if self.success is not None:
14587 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14588 
      self.success.write(oprot)
14589 
      oprot.writeFieldEnd()
14590 
    if self.ex is not None:
14591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14592 
      self.ex.write(oprot)
14593 
      oprot.writeFieldEnd()
14594 
    oprot.writeFieldStop()
14595 
    oprot.writeStructEnd()
14596 
 
14597 
  def validate(self):
14598 
    return
14599 
 
14600 
 
14601 
  def __repr__(self):
14602 
    L = ['%s=%r' % (key, value)
14603 
      for key, value in self.__dict__.iteritems()]
14604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14605 
 
14606 
  def __eq__(self, other):
14607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14608 
 
14609 
  def __ne__(self, other):
14610 
    return not (self == other)