Subversion Repositories SmartDukaan

Rev

Rev 4394 | Rev 4444 | 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
4410 rajveer 333 
    given warehouse and were picked up by the given provider as MANIFESTED.
334 
 
335 
    Parameters:
336 
     - warehouseId
337 
     - providerId
338 
     - cod
339 
    """
340 
    pass
341 
 
342 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
343 
    """
344 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 345 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 346 
 
3064 chandransh 347 
    Parameters:
759 chandransh 348 
     - warehouseId
349 
     - providerId
3064 chandransh 350 
     - cod
759 chandransh 351 
    """
352 
    pass
353 
 
1113 chandransh 354 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
355 
    """
356 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
357 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
358 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 359 
 
1113 chandransh 360 
    Parameters:
361 
     - providerId
362 
     - pickupDetails
363 
    """
364 
    pass
365 
 
1132 chandransh 366 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
367 
    """
368 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
369 
    the name of the receiver.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1132 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - deliveredOrders
375 
    """
376 
    pass
377 
 
1135 chandransh 378 
  def markOrdersAsFailed(self, providerId, returnedOrders):
379 
    """
380 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
381 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 382 
 
1135 chandransh 383 
    Parameters:
384 
     - providerId
385 
     - returnedOrders
386 
    """
387 
    pass
388 
 
1246 chandransh 389 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
390 
    """
391 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 392 
 
1246 chandransh 393 
    Parameters:
394 
     - providerId
395 
     - undeliveredOrders
396 
    """
397 
    pass
398 
 
1408 ankur.sing 399 
  def getUndeliveredOrders(self, providerId, warehouseId):
400 
    """
401 
    Returns the list of orders whose delivery time has passed but have not been
402 
    delivered yet for the given provider and warehouse. To get a complete list of
403 
    undelivered orders, pass them as -1.
404 
    Returns an empty list if no such orders exist.
3431 rajveer 405 
 
1408 ankur.sing 406 
    Parameters:
407 
     - providerId
408 
     - warehouseId
409 
    """
410 
    pass
411 
 
2536 chandransh 412 
  def toggleDOAFlag(self, orderId):
413 
    """
414 
    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.
415 
    Returns the final flag status.
416 
    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 417 
 
2536 chandransh 418 
    Parameters:
419 
     - orderId
420 
    """
421 
    pass
1886 ankur.sing 422 
 
2536 chandransh 423 
  def requestPickupNumber(self, orderId):
424 
    """
425 
    Sends out an email to the account manager of the original courier provider used to ship the order.
426 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
427 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
428 
    For any other status, it returns false.
429 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 430 
 
2536 chandransh 431 
    Parameters:
432 
     - orderId
433 
    """
434 
    pass
435 
 
436 
  def authorizePickup(self, orderId, pickupNumber):
437 
    """
438 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
439 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
440 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
441 
    	3. Returns true
2591 chandransh 442 
    If the order is in any other status, it returns false.
2536 chandransh 443 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 444 
 
2536 chandransh 445 
    Parameters:
446 
     - orderId
447 
     - pickupNumber
448 
    """
449 
    pass
450 
 
2764 chandransh 451 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
452 
    """
453 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
454 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 455 
 
2764 chandransh 456 
    Parameters:
457 
     - providerId
458 
     - pickupDetails
459 
    """
460 
    pass
461 
 
2616 chandransh 462 
  def receiveReturn(self, orderId):
2591 chandransh 463 
    """
2599 chandransh 464 
    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 465 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
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 
    """
472 
    pass
2536 chandransh 473 
 
2591 chandransh 474 
  def validateDoa(self, orderId, isValid):
475 
    """
2599 chandransh 476 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 477 
    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 478 
    If the order is in any other state, it returns false.
479 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 480 
 
2591 chandransh 481 
    Parameters:
482 
     - orderId
483 
     - isValid
484 
    """
485 
    pass
486 
 
2616 chandransh 487 
  def reshipOrder(self, orderId):
488 
    """
489 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
490 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
491 
    	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.
492 
 
493 
    If the order is in DOA_CERT_VALID state, it does the following:
494 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
495 
    	2. Creates a return order for the warehouse executive to return the DOA material.
496 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 497 
 
2616 chandransh 498 
    Returns the id of the newly created order.
3431 rajveer 499 
 
2616 chandransh 500 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 501 
 
2616 chandransh 502 
    Parameters:
503 
     - orderId
504 
    """
505 
    pass
2591 chandransh 506 
 
3226 chandransh 507 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 508 
    """
509 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
510 
    	1. Creates a refund request for batch processing.
511 
    	2. Creates a return order for the warehouse executive to return the shipped material.
512 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 513 
 
2616 chandransh 514 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
515 
    	1. Creates a refund request for batch processing.
3226 chandransh 516 
    	2. Cancels the reservation of the item in the warehouse.
517 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 518 
 
3226 chandransh 519 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
520 
    	1. Cancels the reservation of the item in the warehouse.
521 
    	2. Marks the current order as CANCELED.
522 
 
523 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
524 
 
2616 chandransh 525 
    Returns True if it is successful, False otherwise.
3431 rajveer 526 
 
2616 chandransh 527 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 528 
 
2616 chandransh 529 
    Parameters:
530 
     - orderId
3226 chandransh 531 
     - refundedBy
532 
     - reason
2616 chandransh 533 
    """
534 
    pass
535 
 
2690 chandransh 536 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
537 
    """
538 
    Get all return orders created between the from and to dates for the given warehouse.
539 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 540 
 
2690 chandransh 541 
    Parameters:
542 
     - warehouseId
543 
     - fromDate
544 
     - toDate
545 
    """
546 
    pass
2616 chandransh 547 
 
2700 chandransh 548 
  def getReturnOrder(self, id):
549 
    """
550 
    Returns the ReturnOrder corresponding to the given id.
551 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 552 
 
2700 chandransh 553 
    Parameters:
554 
     - id
555 
    """
556 
    pass
557 
 
2690 chandransh 558 
  def processReturn(self, returnOrderId):
559 
    """
560 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 561 
 
2690 chandransh 562 
    Parameters:
563 
     - returnOrderId
564 
    """
565 
    pass
566 
 
2819 chandransh 567 
  def createPurchaseOrder(self, warehouseId):
568 
    """
569 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 570 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 571 
 
2819 chandransh 572 
    Parameters:
573 
     - warehouseId
574 
    """
575 
    pass
2690 chandransh 576 
 
3451 chandransh 577 
  def updateWeight(self, orderId, weight):
578 
    """
579 
    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 580 
 
3451 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - weight
584 
    """
585 
    pass
586 
 
3469 chandransh 587 
  def changeItem(self, orderId, itemId):
588 
    """
589 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
590 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 591 
 
3469 chandransh 592 
    Parameters:
593 
     - orderId
594 
     - itemId
595 
    """
596 
    pass
597 
 
598 
  def shiftToWarehouse(self, orderId, warehouseId):
599 
    """
600 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
601 
 
602 
    Parameters:
603 
     - orderId
604 
     - warehouseId
605 
    """
606 
    pass
607 
 
3986 chandransh 608 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 609 
    """
610 
    Adds the given delay reason to the given order.
3986 chandransh 611 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 612 
    Raises an exception if no order with the given id can be found.
3469 chandransh 613 
 
3553 chandransh 614 
    Parameters:
615 
     - orderId
616 
     - delayReason
3986 chandransh 617 
     - furtherDelay
3553 chandransh 618 
    """
619 
    pass
620 
 
3956 chandransh 621 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
622 
    """
623 
    Marks the COD orders with given AWB nos. as having been processed.
624 
    Updates the captured amount for the corresponding payment.
3553 chandransh 625 
 
3956 chandransh 626 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
627 
    1. There is no order corresponding to an AWB number.
628 
    2. The captured amount for a payment exceeds the total payment.
629 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
630 
 
631 
    Parameters:
632 
     - collectedAmountMap
633 
     - xferBy
634 
     - xferTxnId
635 
     - xferDate
636 
    """
637 
    pass
638 
 
4008 mandeep.dh 639 
  def getTransactionsRequiringExtraProcessing(self, category):
640 
    """
4065 mandeep.dh 641 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 642 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 643 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 644 
 
4008 mandeep.dh 645 
    Parameters:
646 
     - category
647 
    """
648 
    pass
649 
 
650 
  def markTransactionAsProcessed(self, transactionId, category):
651 
    """
652 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 653 
    It essentially deletes the transaction id record for a particular
654 
    processing type category (if present) from DB.
655 
    This is currently used by CRM application.
4008 mandeep.dh 656 
 
657 
    Parameters:
658 
     - transactionId
659 
     - category
660 
    """
661 
    pass
662 
 
4018 chandransh 663 
  def getItemWiseRiskyOrdersCount(self, ):
664 
    """
665 
    Returns a map containing the number of risky orders keyed by item id. A risky order
666 
    is defined as one whose shipping date is about to expire.
667 
    """
668 
    pass
4008 mandeep.dh 669 
 
4295 varun.gupt 670 
  def getOrdersForItemIds(self, itemIds):
671 
    """
672 
    Returns a list of all orders which have items with given id
673 
 
674 
    Parameters:
675 
     - itemIds
676 
    """
677 
    pass
678 
 
4247 rajveer 679 
  def markOrderCancellationRequestReceived(self, orderId):
680 
    """
681 
    Mark order as cancellation request received. If customer sends request of cancellation of
682 
    a particular order, this method will be called. It will just change status of the order
683 
    depending on its current status. It also records the previous status, so that we can move
684 
    back to that status if cancellation request is denied.
4018 chandransh 685 
 
4247 rajveer 686 
    Parameters:
687 
     - orderId
688 
    """
689 
    pass
690 
 
691 
  def markOrderCancellationRequestConfirmed(self, orderId):
692 
    """
693 
    If we decide to to cancel order, CRM will call this method to move the status of order to
694 
    cancellation request confirmed. After this OM will be able to cancel the order.
695 
 
696 
    Parameters:
697 
     - orderId
698 
    """
699 
    pass
700 
 
701 
  def markOrderCancellationRequestDenied(self, orderId):
702 
    """
703 
    If we decide to not to cancel order, we will move the order ro previous status.
704 
 
705 
    Parameters:
706 
     - orderId
707 
    """
708 
    pass
709 
 
4258 rajveer 710 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 711 
    """
4258 rajveer 712 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
713 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 714 
 
715 
    Parameters:
4258 rajveer 716 
     - transactionId
4247 rajveer 717 
    """
718 
    pass
719 
 
4259 anupam.sin 720 
  def refundTransaction(self, transactionId, refundedBy, reason):
721 
    """
722 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
723 
    need to be cancelled
4247 rajveer 724 
 
4259 anupam.sin 725 
    Parameters:
726 
     - transactionId
727 
     - refundedBy
728 
     - reason
729 
    """
730 
    pass
731 
 
4324 mandeep.dh 732 
  def updateShipmentAddress(self, orderId, addressId):
733 
    """
734 
    Updates shipment address of an order. Delivery and shipping date estimates
735 
    etc. are also updated here.
736 
 
737 
    Throws TransactionServiceException in case address change is not
738 
    possible due to certain reasons such as new pincode in address is
739 
    not serviceable etc.
740 
 
741 
    Parameters:
742 
     - orderId
743 
     - addressId
744 
    """
745 
    pass
746 
 
4285 rajveer 747 
  def acceptOrdersForItemId(self, itemId, inventory):
748 
    """
749 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
750 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 751 
 
4285 rajveer 752 
    Parameters:
753 
     - itemId
754 
     - inventory
755 
    """
756 
    pass
757 
 
4369 rajveer 758 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 759 
    """
760 
    Parameters:
761 
     - vendorId
762 
     - itemId
763 
     - quantity
764 
     - estimate
4369 rajveer 765 
     - isReminder
4303 rajveer 766 
    """
767 
    pass
4285 rajveer 768 
 
4369 rajveer 769 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 770 
    """
771 
    Parameters:
772 
     - vendorId
773 
     - itemId
774 
     - quantity
775 
     - estimate
4369 rajveer 776 
     - isReminder
4303 rajveer 777 
    """
778 
    pass
779 
 
4369 rajveer 780 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 781 
    """
782 
    Parameters:
783 
     - vendorId
784 
     - itemId
785 
     - quantity
786 
     - estimate
4369 rajveer 787 
     - isReminder
4303 rajveer 788 
    """
789 
    pass
790 
 
4369 rajveer 791 
  def markOrdersAsTimeout(self, vendorId):
792 
    """
793 
    Parameters:
794 
     - vendorId
795 
    """
796 
    pass
4303 rajveer 797 
 
4386 anupam.sin 798 
  def getOrderForAwb(self, awb):
799 
    """
800 
    Returns the order corresponding to an AWB number
4369 rajveer 801 
 
4386 anupam.sin 802 
    Parameters:
803 
     - awb
804 
    """
805 
    pass
806 
 
807 
 
3376 rajveer 808 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 809 
  def __init__(self, iprot, oprot=None):
3376 rajveer 810 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 811 
 
812 
  def createTransaction(self, transaction):
813 
    """
814 
    Parameters:
815 
     - transaction
816 
    """
817 
    self.send_createTransaction(transaction)
132 ashish 818 
    return self.recv_createTransaction()
94 ashish 819 
 
820 
  def send_createTransaction(self, transaction):
821 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
822 
    args = createTransaction_args()
823 
    args.transaction = transaction
824 
    args.write(self._oprot)
825 
    self._oprot.writeMessageEnd()
826 
    self._oprot.trans.flush()
827 
 
828 
  def recv_createTransaction(self, ):
829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
830 
    if mtype == TMessageType.EXCEPTION:
831 
      x = TApplicationException()
832 
      x.read(self._iprot)
833 
      self._iprot.readMessageEnd()
834 
      raise x
835 
    result = createTransaction_result()
836 
    result.read(self._iprot)
837 
    self._iprot.readMessageEnd()
3431 rajveer 838 
    if result.success is not None:
132 ashish 839 
      return result.success
3431 rajveer 840 
    if result.ex is not None:
94 ashish 841 
      raise result.ex
132 ashish 842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 843 
 
844 
  def getTransaction(self, id):
845 
    """
846 
    Parameters:
847 
     - id
848 
    """
849 
    self.send_getTransaction(id)
850 
    return self.recv_getTransaction()
851 
 
852 
  def send_getTransaction(self, id):
853 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
854 
    args = getTransaction_args()
855 
    args.id = id
856 
    args.write(self._oprot)
857 
    self._oprot.writeMessageEnd()
858 
    self._oprot.trans.flush()
859 
 
860 
  def recv_getTransaction(self, ):
861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
862 
    if mtype == TMessageType.EXCEPTION:
863 
      x = TApplicationException()
864 
      x.read(self._iprot)
865 
      self._iprot.readMessageEnd()
866 
      raise x
867 
    result = getTransaction_result()
868 
    result.read(self._iprot)
869 
    self._iprot.readMessageEnd()
3431 rajveer 870 
    if result.success is not None:
94 ashish 871 
      return result.success
3431 rajveer 872 
    if result.ex is not None:
94 ashish 873 
      raise result.ex
874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
875 
 
876 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
877 
    """
878 
    Parameters:
879 
     - customerId
880 
     - from_date
881 
     - to_date
882 
     - status
883 
    """
884 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
885 
    return self.recv_getTransactionsForCustomer()
886 
 
887 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
888 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
889 
    args = getTransactionsForCustomer_args()
890 
    args.customerId = customerId
891 
    args.from_date = from_date
892 
    args.to_date = to_date
893 
    args.status = status
894 
    args.write(self._oprot)
895 
    self._oprot.writeMessageEnd()
896 
    self._oprot.trans.flush()
897 
 
898 
  def recv_getTransactionsForCustomer(self, ):
899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
900 
    if mtype == TMessageType.EXCEPTION:
901 
      x = TApplicationException()
902 
      x.read(self._iprot)
903 
      self._iprot.readMessageEnd()
904 
      raise x
905 
    result = getTransactionsForCustomer_result()
906 
    result.read(self._iprot)
907 
    self._iprot.readMessageEnd()
3431 rajveer 908 
    if result.success is not None:
94 ashish 909 
      return result.success
3431 rajveer 910 
    if result.ex is not None:
94 ashish 911 
      raise result.ex
912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
913 
 
132 ashish 914 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
915 
    """
916 
    Parameters:
917 
     - shoppingCartId
918 
    """
919 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
920 
    return self.recv_getTransactionsForShoppingCartId()
921 
 
922 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
923 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
924 
    args = getTransactionsForShoppingCartId_args()
925 
    args.shoppingCartId = shoppingCartId
926 
    args.write(self._oprot)
927 
    self._oprot.writeMessageEnd()
928 
    self._oprot.trans.flush()
929 
 
930 
  def recv_getTransactionsForShoppingCartId(self, ):
931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
932 
    if mtype == TMessageType.EXCEPTION:
933 
      x = TApplicationException()
934 
      x.read(self._iprot)
935 
      self._iprot.readMessageEnd()
936 
      raise x
937 
    result = getTransactionsForShoppingCartId_result()
938 
    result.read(self._iprot)
939 
    self._iprot.readMessageEnd()
3431 rajveer 940 
    if result.success is not None:
132 ashish 941 
      return result.success
3431 rajveer 942 
    if result.ex is not None:
132 ashish 943 
      raise result.ex
944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
945 
 
94 ashish 946 
  def getTransactionStatus(self, transactionId):
947 
    """
948 
    Parameters:
949 
     - transactionId
950 
    """
951 
    self.send_getTransactionStatus(transactionId)
952 
    return self.recv_getTransactionStatus()
953 
 
954 
  def send_getTransactionStatus(self, transactionId):
955 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
956 
    args = getTransactionStatus_args()
957 
    args.transactionId = transactionId
958 
    args.write(self._oprot)
959 
    self._oprot.writeMessageEnd()
960 
    self._oprot.trans.flush()
961 
 
962 
  def recv_getTransactionStatus(self, ):
963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
964 
    if mtype == TMessageType.EXCEPTION:
965 
      x = TApplicationException()
966 
      x.read(self._iprot)
967 
      self._iprot.readMessageEnd()
968 
      raise x
969 
    result = getTransactionStatus_result()
970 
    result.read(self._iprot)
971 
    self._iprot.readMessageEnd()
3431 rajveer 972 
    if result.success is not None:
94 ashish 973 
      return result.success
3431 rajveer 974 
    if result.ex is not None:
94 ashish 975 
      raise result.ex
976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
977 
 
978 
  def changeTransactionStatus(self, transactionId, status, description):
979 
    """
980 
    Parameters:
981 
     - transactionId
982 
     - status
983 
     - description
984 
    """
985 
    self.send_changeTransactionStatus(transactionId, status, description)
986 
    return self.recv_changeTransactionStatus()
987 
 
988 
  def send_changeTransactionStatus(self, transactionId, status, description):
989 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
990 
    args = changeTransactionStatus_args()
991 
    args.transactionId = transactionId
992 
    args.status = status
993 
    args.description = description
994 
    args.write(self._oprot)
995 
    self._oprot.writeMessageEnd()
996 
    self._oprot.trans.flush()
997 
 
998 
  def recv_changeTransactionStatus(self, ):
999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1000 
    if mtype == TMessageType.EXCEPTION:
1001 
      x = TApplicationException()
1002 
      x.read(self._iprot)
1003 
      self._iprot.readMessageEnd()
1004 
      raise x
1005 
    result = changeTransactionStatus_result()
1006 
    result.read(self._iprot)
1007 
    self._iprot.readMessageEnd()
3431 rajveer 1008 
    if result.success is not None:
94 ashish 1009 
      return result.success
3431 rajveer 1010 
    if result.ex is not None:
94 ashish 1011 
      raise result.ex
1012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1013 
 
1398 varun.gupt 1014 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1015 
    """
1016 
    Parameters:
1017 
     - transactionId
1018 
    """
1398 varun.gupt 1019 
    self.send_enqueueTransactionInfoEmail(transactionId)
1020 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1021 
 
1398 varun.gupt 1022 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1023 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1024 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1025 
    args.transactionId = transactionId
1026 
    args.write(self._oprot)
1027 
    self._oprot.writeMessageEnd()
1028 
    self._oprot.trans.flush()
1029 
 
1398 varun.gupt 1030 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1032 
    if mtype == TMessageType.EXCEPTION:
1033 
      x = TApplicationException()
1034 
      x.read(self._iprot)
1035 
      self._iprot.readMessageEnd()
1036 
      raise x
1398 varun.gupt 1037 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1038 
    result.read(self._iprot)
1039 
    self._iprot.readMessageEnd()
3431 rajveer 1040 
    if result.success is not None:
1382 varun.gupt 1041 
      return result.success
3431 rajveer 1042 
    if result.ex is not None:
1382 varun.gupt 1043 
      raise result.ex
1398 varun.gupt 1044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1045 
 
483 rajveer 1046 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1047 
    """
1048 
    Parameters:
483 rajveer 1049 
     - status
1050 
     - from_date
1051 
     - to_date
1052 
     - warehouse_id
94 ashish 1053 
    """
483 rajveer 1054 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1055 
    return self.recv_getAllOrders()
94 ashish 1056 
 
483 rajveer 1057 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1058 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1059 
    args = getAllOrders_args()
1060 
    args.status = status
1061 
    args.from_date = from_date
1062 
    args.to_date = to_date
1063 
    args.warehouse_id = warehouse_id
94 ashish 1064 
    args.write(self._oprot)
1065 
    self._oprot.writeMessageEnd()
1066 
    self._oprot.trans.flush()
1067 
 
483 rajveer 1068 
  def recv_getAllOrders(self, ):
94 ashish 1069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1070 
    if mtype == TMessageType.EXCEPTION:
1071 
      x = TApplicationException()
1072 
      x.read(self._iprot)
1073 
      self._iprot.readMessageEnd()
1074 
      raise x
483 rajveer 1075 
    result = getAllOrders_result()
94 ashish 1076 
    result.read(self._iprot)
1077 
    self._iprot.readMessageEnd()
3431 rajveer 1078 
    if result.success is not None:
94 ashish 1079 
      return result.success
3431 rajveer 1080 
    if result.ex is not None:
94 ashish 1081 
      raise result.ex
483 rajveer 1082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1083 
 
4133 chandransh 1084 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1085 
    """
1086 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1087 
    Pass the status as null and the limit as 0 to ignore them.
1088 
 
1089 
    Parameters:
1090 
     - statuses
1091 
     - offset
1092 
     - limit
1093 
     - warehouse_id
1094 
    """
1095 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1096 
    return self.recv_getOrdersInBatch()
1097 
 
1098 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1099 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1100 
    args = getOrdersInBatch_args()
1101 
    args.statuses = statuses
1102 
    args.offset = offset
1103 
    args.limit = limit
1104 
    args.warehouse_id = warehouse_id
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1109 
  def recv_getOrdersInBatch(self, ):
1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1116 
    result = getOrdersInBatch_result()
1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
1119 
    if result.success is not None:
1120 
      return result.success
1121 
    if result.ex is not None:
1122 
      raise result.ex
1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1124 
 
1125 
  def getOrderCount(self, statuses, warehouseId):
1126 
    """
1127 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1128 
 
1129 
    Parameters:
1130 
     - statuses
1131 
     - warehouseId
1132 
    """
1133 
    self.send_getOrderCount(statuses, warehouseId)
1134 
    return self.recv_getOrderCount()
1135 
 
1136 
  def send_getOrderCount(self, statuses, warehouseId):
1137 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1138 
    args = getOrderCount_args()
1139 
    args.statuses = statuses
1140 
    args.warehouseId = warehouseId
1141 
    args.write(self._oprot)
1142 
    self._oprot.writeMessageEnd()
1143 
    self._oprot.trans.flush()
1144 
 
1145 
  def recv_getOrderCount(self, ):
1146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1147 
    if mtype == TMessageType.EXCEPTION:
1148 
      x = TApplicationException()
1149 
      x.read(self._iprot)
1150 
      self._iprot.readMessageEnd()
1151 
      raise x
1152 
    result = getOrderCount_result()
1153 
    result.read(self._iprot)
1154 
    self._iprot.readMessageEnd()
1155 
    if result.success is not None:
1156 
      return result.success
1157 
    if result.ex is not None:
1158 
      raise result.ex
1159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1160 
 
999 varun.gupt 1161 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1162 
    """
1132 chandransh 1163 
    Returns orders within a range of their billing dates
3431 rajveer 1164 
 
999 varun.gupt 1165 
    Parameters:
1166 
     - status
1167 
     - start_billing_date
1168 
     - end_billing_date
1169 
     - warehouse_id
1170 
    """
1171 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1172 
    return self.recv_getOrdersByBillingDate()
1173 
 
1174 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1175 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1176 
    args = getOrdersByBillingDate_args()
1177 
    args.status = status
1178 
    args.start_billing_date = start_billing_date
1179 
    args.end_billing_date = end_billing_date
1180 
    args.warehouse_id = warehouse_id
1181 
    args.write(self._oprot)
1182 
    self._oprot.writeMessageEnd()
1183 
    self._oprot.trans.flush()
1184 
 
1185 
  def recv_getOrdersByBillingDate(self, ):
1186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1187 
    if mtype == TMessageType.EXCEPTION:
1188 
      x = TApplicationException()
1189 
      x.read(self._iprot)
1190 
      self._iprot.readMessageEnd()
1191 
      raise x
1192 
    result = getOrdersByBillingDate_result()
1193 
    result.read(self._iprot)
1194 
    self._iprot.readMessageEnd()
3431 rajveer 1195 
    if result.success is not None:
999 varun.gupt 1196 
      return result.success
3431 rajveer 1197 
    if result.ex is not None:
999 varun.gupt 1198 
      raise result.ex
1199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1200 
 
3451 chandransh 1201 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1202 
    """
1203 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1204 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1205 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1206 
 
3427 chandransh 1207 
    Parameters:
1208 
     - fromShippingDate
1209 
     - toShippingDate
1210 
     - providerId
1211 
     - warehouseId
3451 chandransh 1212 
     - cod
3427 chandransh 1213 
    """
3451 chandransh 1214 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1215 
    return self.recv_getOrdersByShippingDate()
1216 
 
3451 chandransh 1217 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1218 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1219 
    args = getOrdersByShippingDate_args()
1220 
    args.fromShippingDate = fromShippingDate
1221 
    args.toShippingDate = toShippingDate
1222 
    args.providerId = providerId
1223 
    args.warehouseId = warehouseId
3451 chandransh 1224 
    args.cod = cod
3427 chandransh 1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_getOrdersByShippingDate(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = getOrdersByShippingDate_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
3431 rajveer 1239 
    if result.success is not None:
3427 chandransh 1240 
      return result.success
3431 rajveer 1241 
    if result.ex is not None:
3427 chandransh 1242 
      raise result.ex
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1244 
 
1382 varun.gupt 1245 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1246 
    """
1247 
    Returns order ids for orders which can be returned
3431 rajveer 1248 
 
1382 varun.gupt 1249 
    Parameters:
1250 
     - customer_id
1251 
     - limit
1252 
    """
1253 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1254 
    return self.recv_getReturnableOrdersForCustomer()
1255 
 
1256 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1257 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1258 
    args = getReturnableOrdersForCustomer_args()
1259 
    args.customer_id = customer_id
1260 
    args.limit = limit
1261 
    args.write(self._oprot)
1262 
    self._oprot.writeMessageEnd()
1263 
    self._oprot.trans.flush()
1264 
 
1265 
  def recv_getReturnableOrdersForCustomer(self, ):
1266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1267 
    if mtype == TMessageType.EXCEPTION:
1268 
      x = TApplicationException()
1269 
      x.read(self._iprot)
1270 
      self._iprot.readMessageEnd()
1271 
      raise x
1272 
    result = getReturnableOrdersForCustomer_result()
1273 
    result.read(self._iprot)
1274 
    self._iprot.readMessageEnd()
3431 rajveer 1275 
    if result.success is not None:
1382 varun.gupt 1276 
      return result.success
3431 rajveer 1277 
    if result.ex is not None:
1382 varun.gupt 1278 
      raise result.ex
1279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1280 
 
1281 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1282 
    """
1283 
    Returns order ids for orders which can be cancelled
3431 rajveer 1284 
 
1382 varun.gupt 1285 
    Parameters:
1286 
     - customer_id
1287 
     - limit
1288 
    """
1289 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1290 
    return self.recv_getCancellableOrdersForCustomer()
1291 
 
1292 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1293 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1294 
    args = getCancellableOrdersForCustomer_args()
1295 
    args.customer_id = customer_id
1296 
    args.limit = limit
1297 
    args.write(self._oprot)
1298 
    self._oprot.writeMessageEnd()
1299 
    self._oprot.trans.flush()
1300 
 
1301 
  def recv_getCancellableOrdersForCustomer(self, ):
1302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1303 
    if mtype == TMessageType.EXCEPTION:
1304 
      x = TApplicationException()
1305 
      x.read(self._iprot)
1306 
      self._iprot.readMessageEnd()
1307 
      raise x
1308 
    result = getCancellableOrdersForCustomer_result()
1309 
    result.read(self._iprot)
1310 
    self._iprot.readMessageEnd()
3431 rajveer 1311 
    if result.success is not None:
1382 varun.gupt 1312 
      return result.success
3431 rajveer 1313 
    if result.ex is not None:
1382 varun.gupt 1314 
      raise result.ex
1315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1316 
 
483 rajveer 1317 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1318 
    """
1319 
    Parameters:
483 rajveer 1320 
     - orderId
1321 
     - status
1322 
     - description
94 ashish 1323 
    """
483 rajveer 1324 
    self.send_changeOrderStatus(orderId, status, description)
1325 
    return self.recv_changeOrderStatus()
94 ashish 1326 
 
483 rajveer 1327 
  def send_changeOrderStatus(self, orderId, status, description):
1328 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1329 
    args = changeOrderStatus_args()
1330 
    args.orderId = orderId
1331 
    args.status = status
1332 
    args.description = description
94 ashish 1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
483 rajveer 1337 
  def recv_changeOrderStatus(self, ):
94 ashish 1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
483 rajveer 1344 
    result = changeOrderStatus_result()
94 ashish 1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
3431 rajveer 1347 
    if result.success is not None:
94 ashish 1348 
      return result.success
3431 rajveer 1349 
    if result.ex is not None:
94 ashish 1350 
      raise result.ex
483 rajveer 1351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1352 
 
1528 ankur.sing 1353 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1354 
    """
1528 ankur.sing 1355 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1356 
    only user who owns the transaction can view its order details.
3431 rajveer 1357 
 
94 ashish 1358 
    Parameters:
1359 
     - transactionId
1528 ankur.sing 1360 
     - customerId
94 ashish 1361 
    """
1528 ankur.sing 1362 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1363 
    return self.recv_getOrdersForTransaction()
94 ashish 1364 
 
1528 ankur.sing 1365 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1366 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1367 
    args = getOrdersForTransaction_args()
94 ashish 1368 
    args.transactionId = transactionId
1528 ankur.sing 1369 
    args.customerId = customerId
94 ashish 1370 
    args.write(self._oprot)
1371 
    self._oprot.writeMessageEnd()
1372 
    self._oprot.trans.flush()
1373 
 
483 rajveer 1374 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1376 
    if mtype == TMessageType.EXCEPTION:
1377 
      x = TApplicationException()
1378 
      x.read(self._iprot)
1379 
      self._iprot.readMessageEnd()
1380 
      raise x
483 rajveer 1381 
    result = getOrdersForTransaction_result()
94 ashish 1382 
    result.read(self._iprot)
1383 
    self._iprot.readMessageEnd()
3431 rajveer 1384 
    if result.success is not None:
94 ashish 1385 
      return result.success
3431 rajveer 1386 
    if result.ex is not None:
94 ashish 1387 
      raise result.ex
483 rajveer 1388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1389 
 
3014 chandransh 1390 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1391 
    """
3014 chandransh 1392 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1393 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1394 
 
94 ashish 1395 
    Parameters:
483 rajveer 1396 
     - customerId
1397 
     - from_date
1398 
     - to_date
3014 chandransh 1399 
     - statuses
94 ashish 1400 
    """
3014 chandransh 1401 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1402 
    return self.recv_getOrdersForCustomer()
94 ashish 1403 
 
3014 chandransh 1404 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1405 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1406 
    args = getOrdersForCustomer_args()
1407 
    args.customerId = customerId
1408 
    args.from_date = from_date
1409 
    args.to_date = to_date
3014 chandransh 1410 
    args.statuses = statuses
94 ashish 1411 
    args.write(self._oprot)
1412 
    self._oprot.writeMessageEnd()
1413 
    self._oprot.trans.flush()
1414 
 
483 rajveer 1415 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1417 
    if mtype == TMessageType.EXCEPTION:
1418 
      x = TApplicationException()
1419 
      x.read(self._iprot)
1420 
      self._iprot.readMessageEnd()
1421 
      raise x
483 rajveer 1422 
    result = getOrdersForCustomer_result()
94 ashish 1423 
    result.read(self._iprot)
1424 
    self._iprot.readMessageEnd()
3431 rajveer 1425 
    if result.success is not None:
94 ashish 1426 
      return result.success
3431 rajveer 1427 
    if result.ex is not None:
94 ashish 1428 
      raise result.ex
483 rajveer 1429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1430 
 
483 rajveer 1431 
  def createOrder(self, order):
94 ashish 1432 
    """
1433 
    Parameters:
483 rajveer 1434 
     - order
94 ashish 1435 
    """
483 rajveer 1436 
    self.send_createOrder(order)
1437 
    return self.recv_createOrder()
94 ashish 1438 
 
483 rajveer 1439 
  def send_createOrder(self, order):
1440 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1441 
    args = createOrder_args()
1442 
    args.order = order
94 ashish 1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
483 rajveer 1447 
  def recv_createOrder(self, ):
94 ashish 1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
483 rajveer 1454 
    result = createOrder_result()
94 ashish 1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
94 ashish 1458 
      return result.success
3431 rajveer 1459 
    if result.ex is not None:
94 ashish 1460 
      raise result.ex
483 rajveer 1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1462 
 
483 rajveer 1463 
  def getOrder(self, id):
94 ashish 1464 
    """
1465 
    Parameters:
483 rajveer 1466 
     - id
94 ashish 1467 
    """
483 rajveer 1468 
    self.send_getOrder(id)
1469 
    return self.recv_getOrder()
94 ashish 1470 
 
483 rajveer 1471 
  def send_getOrder(self, id):
1472 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1473 
    args = getOrder_args()
1474 
    args.id = id
94 ashish 1475 
    args.write(self._oprot)
1476 
    self._oprot.writeMessageEnd()
1477 
    self._oprot.trans.flush()
1478 
 
483 rajveer 1479 
  def recv_getOrder(self, ):
94 ashish 1480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1481 
    if mtype == TMessageType.EXCEPTION:
1482 
      x = TApplicationException()
1483 
      x.read(self._iprot)
1484 
      self._iprot.readMessageEnd()
1485 
      raise x
483 rajveer 1486 
    result = getOrder_result()
94 ashish 1487 
    result.read(self._iprot)
1488 
    self._iprot.readMessageEnd()
3431 rajveer 1489 
    if result.success is not None:
94 ashish 1490 
      return result.success
3431 rajveer 1491 
    if result.ex is not None:
94 ashish 1492 
      raise result.ex
483 rajveer 1493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1494 
 
483 rajveer 1495 
  def getLineItemsForOrder(self, orderId):
94 ashish 1496 
    """
1497 
    Parameters:
483 rajveer 1498 
     - orderId
94 ashish 1499 
    """
483 rajveer 1500 
    self.send_getLineItemsForOrder(orderId)
1501 
    return self.recv_getLineItemsForOrder()
94 ashish 1502 
 
483 rajveer 1503 
  def send_getLineItemsForOrder(self, orderId):
1504 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1505 
    args = getLineItemsForOrder_args()
1506 
    args.orderId = orderId
94 ashish 1507 
    args.write(self._oprot)
1508 
    self._oprot.writeMessageEnd()
1509 
    self._oprot.trans.flush()
1510 
 
483 rajveer 1511 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1513 
    if mtype == TMessageType.EXCEPTION:
1514 
      x = TApplicationException()
1515 
      x.read(self._iprot)
1516 
      self._iprot.readMessageEnd()
1517 
      raise x
483 rajveer 1518 
    result = getLineItemsForOrder_result()
94 ashish 1519 
    result.read(self._iprot)
1520 
    self._iprot.readMessageEnd()
3431 rajveer 1521 
    if result.success is not None:
94 ashish 1522 
      return result.success
3431 rajveer 1523 
    if result.ex is not None:
94 ashish 1524 
      raise result.ex
483 rajveer 1525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1526 
 
1528 ankur.sing 1527 
  def getOrderForCustomer(self, orderId, customerId):
1528 
    """
1529 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1530 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1531 
 
1528 ankur.sing 1532 
    Parameters:
1533 
     - orderId
1534 
     - customerId
1535 
    """
1536 
    self.send_getOrderForCustomer(orderId, customerId)
1537 
    return self.recv_getOrderForCustomer()
1538 
 
1539 
  def send_getOrderForCustomer(self, orderId, customerId):
1540 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1541 
    args = getOrderForCustomer_args()
1542 
    args.orderId = orderId
1543 
    args.customerId = customerId
1544 
    args.write(self._oprot)
1545 
    self._oprot.writeMessageEnd()
1546 
    self._oprot.trans.flush()
1547 
 
1548 
  def recv_getOrderForCustomer(self, ):
1549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1550 
    if mtype == TMessageType.EXCEPTION:
1551 
      x = TApplicationException()
1552 
      x.read(self._iprot)
1553 
      self._iprot.readMessageEnd()
1554 
      raise x
1555 
    result = getOrderForCustomer_result()
1556 
    result.read(self._iprot)
1557 
    self._iprot.readMessageEnd()
3431 rajveer 1558 
    if result.success is not None:
1528 ankur.sing 1559 
      return result.success
3431 rajveer 1560 
    if result.ex is not None:
1528 ankur.sing 1561 
      raise result.ex
1562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1563 
 
4394 rajveer 1564 
  def getAlerts(self, type, status, timestamp):
3064 chandransh 1565 
    """
1566 
    Parameters:
4394 rajveer 1567 
     - type
1568 
     - status
1569 
     - timestamp
3064 chandransh 1570 
    """
4394 rajveer 1571 
    self.send_getAlerts(type, status, timestamp)
3064 chandransh 1572 
    return self.recv_getAlerts()
1573 
 
4394 rajveer 1574 
  def send_getAlerts(self, type, status, timestamp):
3064 chandransh 1575 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1576 
    args = getAlerts_args()
4394 rajveer 1577 
    args.type = type
1578 
    args.status = status
1579 
    args.timestamp = timestamp
3064 chandransh 1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getAlerts(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getAlerts_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
3431 rajveer 1594 
    if result.success is not None:
3064 chandransh 1595 
      return result.success
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1597 
 
4394 rajveer 1598 
  def addAlert(self, type, description):
3064 chandransh 1599 
    """
1600 
    Parameters:
1601 
     - type
4394 rajveer 1602 
     - description
3064 chandransh 1603 
    """
4394 rajveer 1604 
    self.send_addAlert(type, description)
1605 
    self.recv_addAlert()
3064 chandransh 1606 
 
4394 rajveer 1607 
  def send_addAlert(self, type, description):
1608 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1609 
    args = addAlert_args()
3064 chandransh 1610 
    args.type = type
4394 rajveer 1611 
    args.description = description
3064 chandransh 1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
4394 rajveer 1616 
  def recv_addAlert(self, ):
3064 chandransh 1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
4394 rajveer 1623 
    result = addAlert_result()
3064 chandransh 1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
1626 
    return
1627 
 
1628 
  def getValidOrderCount(self, ):
1629 
    """
1630 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1631 
    """
1632 
    self.send_getValidOrderCount()
1633 
    return self.recv_getValidOrderCount()
1634 
 
1635 
  def send_getValidOrderCount(self, ):
1636 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1637 
    args = getValidOrderCount_args()
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getValidOrderCount(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getValidOrderCount_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
3064 chandransh 1653 
      return result.success
1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1655 
 
1656 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1657 
    """
1658 
    Returns the number of distinct customers who have done successful transactions
1659 
    """
1660 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1661 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1662 
 
1663 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1664 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1665 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1666 
    args.write(self._oprot)
1667 
    self._oprot.writeMessageEnd()
1668 
    self._oprot.trans.flush()
1669 
 
1670 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1672 
    if mtype == TMessageType.EXCEPTION:
1673 
      x = TApplicationException()
1674 
      x.read(self._iprot)
1675 
      self._iprot.readMessageEnd()
1676 
      raise x
1677 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1678 
    result.read(self._iprot)
1679 
    self._iprot.readMessageEnd()
3431 rajveer 1680 
    if result.success is not None:
3064 chandransh 1681 
      return result.success
1682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1683 
 
1684 
  def getValidOrdersAmountRange(self, ):
1685 
    """
1686 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1687 
    List contains two values, first minimum amount and second maximum amount.
1688 
    """
1689 
    self.send_getValidOrdersAmountRange()
1690 
    return self.recv_getValidOrdersAmountRange()
1691 
 
1692 
  def send_getValidOrdersAmountRange(self, ):
1693 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1694 
    args = getValidOrdersAmountRange_args()
1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
1699 
  def recv_getValidOrdersAmountRange(self, ):
1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
1706 
    result = getValidOrdersAmountRange_result()
1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
3431 rajveer 1709 
    if result.success is not None:
3064 chandransh 1710 
      return result.success
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1712 
 
1713 
  def getValidOrders(self, limit):
1714 
    """
1715 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1716 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1717 
 
3064 chandransh 1718 
    Parameters:
1719 
     - limit
1720 
    """
1721 
    self.send_getValidOrders(limit)
1722 
    return self.recv_getValidOrders()
1723 
 
1724 
  def send_getValidOrders(self, limit):
1725 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1726 
    args = getValidOrders_args()
1727 
    args.limit = limit
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getValidOrders(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getValidOrders_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
3064 chandransh 1743 
      return result.success
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1745 
 
1220 chandransh 1746 
  def batchOrders(self, warehouseId):
1747 
    """
1748 
    Create a batch of all the pending orders for the given warehouse.
1749 
    The returned list is orderd by created_timestamp.
1750 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1751 
 
1220 chandransh 1752 
    Parameters:
1753 
     - warehouseId
1754 
    """
1755 
    self.send_batchOrders(warehouseId)
1756 
    return self.recv_batchOrders()
1757 
 
1758 
  def send_batchOrders(self, warehouseId):
1759 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1760 
    args = batchOrders_args()
1761 
    args.warehouseId = warehouseId
1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_batchOrders(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = batchOrders_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
1220 chandransh 1777 
      return result.success
3431 rajveer 1778 
    if result.ex is not None:
1220 chandransh 1779 
      raise result.ex
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1781 
 
1208 chandransh 1782 
  def markOrderAsOutOfStock(self, orderId):
1783 
    """
1784 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1785 
 
1208 chandransh 1786 
    Parameters:
1787 
     - orderId
1788 
    """
1789 
    self.send_markOrderAsOutOfStock(orderId)
1790 
    return self.recv_markOrderAsOutOfStock()
1791 
 
1792 
  def send_markOrderAsOutOfStock(self, orderId):
1793 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1794 
    args = markOrderAsOutOfStock_args()
1795 
    args.orderId = orderId
1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
1800 
  def recv_markOrderAsOutOfStock(self, ):
1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
1807 
    result = markOrderAsOutOfStock_result()
1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
3431 rajveer 1810 
    if result.success is not None:
1208 chandransh 1811 
      return result.success
3431 rajveer 1812 
    if result.ex is not None:
1208 chandransh 1813 
      raise result.ex
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1815 
 
3064 chandransh 1816 
  def verifyOrder(self, orderId):
759 chandransh 1817 
    """
3064 chandransh 1818 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1819 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1820 
    used for all other orders as well.
1821 
    Throws an exception if no such order exists.
3431 rajveer 1822 
 
759 chandransh 1823 
    Parameters:
3064 chandransh 1824 
     - orderId
759 chandransh 1825 
    """
3064 chandransh 1826 
    self.send_verifyOrder(orderId)
1827 
    return self.recv_verifyOrder()
759 chandransh 1828 
 
3064 chandransh 1829 
  def send_verifyOrder(self, orderId):
1830 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1831 
    args = verifyOrder_args()
1832 
    args.orderId = orderId
759 chandransh 1833 
    args.write(self._oprot)
1834 
    self._oprot.writeMessageEnd()
1835 
    self._oprot.trans.flush()
1836 
 
3064 chandransh 1837 
  def recv_verifyOrder(self, ):
759 chandransh 1838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1839 
    if mtype == TMessageType.EXCEPTION:
1840 
      x = TApplicationException()
1841 
      x.read(self._iprot)
1842 
      self._iprot.readMessageEnd()
1843 
      raise x
3064 chandransh 1844 
    result = verifyOrder_result()
759 chandransh 1845 
    result.read(self._iprot)
1846 
    self._iprot.readMessageEnd()
3431 rajveer 1847 
    if result.success is not None:
759 chandransh 1848 
      return result.success
3431 rajveer 1849 
    if result.ex is not None:
759 chandransh 1850 
      raise result.ex
3064 chandransh 1851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1852 
 
3064 chandransh 1853 
  def acceptOrder(self, orderId):
1113 chandransh 1854 
    """
3064 chandransh 1855 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1856 
    given order is not a COD order, it also captures the payment if the same has
1857 
    not been captured.
1858 
    Throws an exception if no such order exists.
3431 rajveer 1859 
 
1113 chandransh 1860 
    Parameters:
3064 chandransh 1861 
     - orderId
1113 chandransh 1862 
    """
3064 chandransh 1863 
    self.send_acceptOrder(orderId)
1864 
    return self.recv_acceptOrder()
1113 chandransh 1865 
 
3064 chandransh 1866 
  def send_acceptOrder(self, orderId):
1867 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1868 
    args = acceptOrder_args()
1869 
    args.orderId = orderId
1113 chandransh 1870 
    args.write(self._oprot)
1871 
    self._oprot.writeMessageEnd()
1872 
    self._oprot.trans.flush()
1873 
 
3064 chandransh 1874 
  def recv_acceptOrder(self, ):
1113 chandransh 1875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1876 
    if mtype == TMessageType.EXCEPTION:
1877 
      x = TApplicationException()
1878 
      x.read(self._iprot)
1879 
      self._iprot.readMessageEnd()
1880 
      raise x
3064 chandransh 1881 
    result = acceptOrder_result()
1113 chandransh 1882 
    result.read(self._iprot)
1883 
    self._iprot.readMessageEnd()
3431 rajveer 1884 
    if result.success is not None:
1113 chandransh 1885 
      return result.success
3431 rajveer 1886 
    if result.ex is not None:
1113 chandransh 1887 
      raise result.ex
3064 chandransh 1888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1889 
 
4283 anupam.sin 1890 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1891 
    """
3064 chandransh 1892 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1893 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1894 
    the IMEI no. if a -1 is supplied.
1895 
    Also, it generates an invoice number for the order, marks the order as
1896 
    BILLED and sets the billing timestamp.
1897 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1898 
 
1135 chandransh 1899 
    Parameters:
3064 chandransh 1900 
     - orderId
1901 
     - invoice_number
4283 anupam.sin 1902 
     - imeiNumber
1903 
     - itemNumber
3064 chandransh 1904 
     - billed_by
4264 rajveer 1905 
     - jacketNumber
4283 anupam.sin 1906 
     - billingType
1907 
     - vendorId
1135 chandransh 1908 
    """
4283 anupam.sin 1909 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1910 
    return self.recv_addBillingDetails()
1135 chandransh 1911 
 
4283 anupam.sin 1912 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1913 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1914 
    args = addBillingDetails_args()
1915 
    args.orderId = orderId
1916 
    args.invoice_number = invoice_number
4283 anupam.sin 1917 
    args.imeiNumber = imeiNumber
1918 
    args.itemNumber = itemNumber
3064 chandransh 1919 
    args.billed_by = billed_by
4264 rajveer 1920 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1921 
    args.billingType = billingType
1922 
    args.vendorId = vendorId
1135 chandransh 1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
3064 chandransh 1927 
  def recv_addBillingDetails(self, ):
1135 chandransh 1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
3064 chandransh 1934 
    result = addBillingDetails_result()
1135 chandransh 1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
3431 rajveer 1937 
    if result.success is not None:
3064 chandransh 1938 
      return result.success
3431 rajveer 1939 
    if result.ex is not None:
1135 chandransh 1940 
      raise result.ex
3064 chandransh 1941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1942 
 
3064 chandransh 1943 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1944 
    """
3064 chandransh 1945 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 1946 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 1947 
 
1408 ankur.sing 1948 
    Parameters:
3064 chandransh 1949 
     - warehouseId
1408 ankur.sing 1950 
     - providerId
3064 chandransh 1951 
     - cod
1408 ankur.sing 1952 
    """
3064 chandransh 1953 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1954 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1955 
 
3064 chandransh 1956 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1957 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1958 
    args = markOrdersAsManifested_args()
1959 
    args.warehouseId = warehouseId
1408 ankur.sing 1960 
    args.providerId = providerId
3064 chandransh 1961 
    args.cod = cod
1408 ankur.sing 1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
3064 chandransh 1966 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
3064 chandransh 1973 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
3431 rajveer 1976 
    if result.success is not None:
1408 ankur.sing 1977 
      return result.success
3431 rajveer 1978 
    if result.ex is not None:
3064 chandransh 1979 
      raise result.ex
1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1981 
 
4410 rajveer 1982 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
1983 
    """
1984 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
1985 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
1986 
 
1987 
    Parameters:
1988 
     - warehouseId
1989 
     - providerId
1990 
     - cod
1991 
    """
1992 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
1993 
    return self.recv_markOrdersAsShippedFromWarehouse()
1994 
 
1995 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
1996 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
1997 
    args = markOrdersAsShippedFromWarehouse_args()
1998 
    args.warehouseId = warehouseId
1999 
    args.providerId = providerId
2000 
    args.cod = cod
2001 
    args.write(self._oprot)
2002 
    self._oprot.writeMessageEnd()
2003 
    self._oprot.trans.flush()
2004 
 
2005 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2007 
    if mtype == TMessageType.EXCEPTION:
2008 
      x = TApplicationException()
2009 
      x.read(self._iprot)
2010 
      self._iprot.readMessageEnd()
2011 
      raise x
2012 
    result = markOrdersAsShippedFromWarehouse_result()
2013 
    result.read(self._iprot)
2014 
    self._iprot.readMessageEnd()
2015 
    if result.success is not None:
2016 
      return result.success
2017 
    if result.ex is not None:
2018 
      raise result.ex
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2020 
 
3064 chandransh 2021 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2022 
    """
3064 chandransh 2023 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2024 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2025 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2026 
 
94 ashish 2027 
    Parameters:
3064 chandransh 2028 
     - providerId
2029 
     - pickupDetails
304 ashish 2030 
    """
3064 chandransh 2031 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2032 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2033 
 
3064 chandransh 2034 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2035 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2036 
    args = markOrdersAsPickedUp_args()
2037 
    args.providerId = providerId
2038 
    args.pickupDetails = pickupDetails
304 ashish 2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
3064 chandransh 2043 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
3064 chandransh 2050 
    result = markOrdersAsPickedUp_result()
304 ashish 2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
3431 rajveer 2053 
    if result.success is not None:
304 ashish 2054 
      return result.success
3431 rajveer 2055 
    if result.ex is not None:
3064 chandransh 2056 
      raise result.ex
2057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2058 
 
3064 chandransh 2059 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2060 
    """
3064 chandransh 2061 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2062 
    the name of the receiver.
2063 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2064 
 
304 ashish 2065 
    Parameters:
3064 chandransh 2066 
     - providerId
2067 
     - deliveredOrders
304 ashish 2068 
    """
3064 chandransh 2069 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2070 
    self.recv_markOrdersAsDelivered()
304 ashish 2071 
 
3064 chandransh 2072 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2073 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2074 
    args = markOrdersAsDelivered_args()
2075 
    args.providerId = providerId
2076 
    args.deliveredOrders = deliveredOrders
304 ashish 2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
3064 chandransh 2081 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2083 
    if mtype == TMessageType.EXCEPTION:
2084 
      x = TApplicationException()
2085 
      x.read(self._iprot)
2086 
      self._iprot.readMessageEnd()
2087 
      raise x
3064 chandransh 2088 
    result = markOrdersAsDelivered_result()
304 ashish 2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
3431 rajveer 2091 
    if result.ex is not None:
3064 chandransh 2092 
      raise result.ex
304 ashish 2093 
    return
2094 
 
3064 chandransh 2095 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2096 
    """
3064 chandransh 2097 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2098 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2099 
 
3064 chandransh 2100 
    Parameters:
2101 
     - providerId
2102 
     - returnedOrders
1596 ankur.sing 2103 
    """
3064 chandransh 2104 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2105 
    self.recv_markOrdersAsFailed()
304 ashish 2106 
 
3064 chandransh 2107 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2108 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2109 
    args = markOrdersAsFailed_args()
2110 
    args.providerId = providerId
2111 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2112 
    args.write(self._oprot)
2113 
    self._oprot.writeMessageEnd()
2114 
    self._oprot.trans.flush()
2115 
 
3064 chandransh 2116 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2118 
    if mtype == TMessageType.EXCEPTION:
2119 
      x = TApplicationException()
2120 
      x.read(self._iprot)
2121 
      self._iprot.readMessageEnd()
2122 
      raise x
3064 chandransh 2123 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2124 
    result.read(self._iprot)
2125 
    self._iprot.readMessageEnd()
3431 rajveer 2126 
    if result.ex is not None:
3064 chandransh 2127 
      raise result.ex
2128 
    return
1596 ankur.sing 2129 
 
3064 chandransh 2130 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2131 
    """
3064 chandransh 2132 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2133 
 
3064 chandransh 2134 
    Parameters:
2135 
     - providerId
2136 
     - undeliveredOrders
1627 ankur.sing 2137 
    """
3064 chandransh 2138 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2139 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2140 
 
3064 chandransh 2141 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2142 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2143 
    args = updateNonDeliveryReason_args()
2144 
    args.providerId = providerId
2145 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2146 
    args.write(self._oprot)
2147 
    self._oprot.writeMessageEnd()
2148 
    self._oprot.trans.flush()
2149 
 
3064 chandransh 2150 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2152 
    if mtype == TMessageType.EXCEPTION:
2153 
      x = TApplicationException()
2154 
      x.read(self._iprot)
2155 
      self._iprot.readMessageEnd()
2156 
      raise x
3064 chandransh 2157 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2158 
    result.read(self._iprot)
2159 
    self._iprot.readMessageEnd()
3431 rajveer 2160 
    if result.ex is not None:
3064 chandransh 2161 
      raise result.ex
2162 
    return
1627 ankur.sing 2163 
 
3064 chandransh 2164 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2165 
    """
3064 chandransh 2166 
    Returns the list of orders whose delivery time has passed but have not been
2167 
    delivered yet for the given provider and warehouse. To get a complete list of
2168 
    undelivered orders, pass them as -1.
2169 
    Returns an empty list if no such orders exist.
3431 rajveer 2170 
 
1886 ankur.sing 2171 
    Parameters:
3064 chandransh 2172 
     - providerId
2173 
     - warehouseId
1886 ankur.sing 2174 
    """
3064 chandransh 2175 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2176 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2177 
 
3064 chandransh 2178 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2179 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2180 
    args = getUndeliveredOrders_args()
2181 
    args.providerId = providerId
2182 
    args.warehouseId = warehouseId
1886 ankur.sing 2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
3064 chandransh 2187 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
3064 chandransh 2194 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
3431 rajveer 2197 
    if result.success is not None:
1886 ankur.sing 2198 
      return result.success
3064 chandransh 2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2200 
 
2536 chandransh 2201 
  def toggleDOAFlag(self, orderId):
2202 
    """
2203 
    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.
2204 
    Returns the final flag status.
2205 
    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 2206 
 
2536 chandransh 2207 
    Parameters:
2208 
     - orderId
2209 
    """
2210 
    self.send_toggleDOAFlag(orderId)
2211 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2212 
 
2536 chandransh 2213 
  def send_toggleDOAFlag(self, orderId):
2214 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2215 
    args = toggleDOAFlag_args()
2216 
    args.orderId = orderId
2217 
    args.write(self._oprot)
2218 
    self._oprot.writeMessageEnd()
2219 
    self._oprot.trans.flush()
2220 
 
2221 
  def recv_toggleDOAFlag(self, ):
2222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2223 
    if mtype == TMessageType.EXCEPTION:
2224 
      x = TApplicationException()
2225 
      x.read(self._iprot)
2226 
      self._iprot.readMessageEnd()
2227 
      raise x
2228 
    result = toggleDOAFlag_result()
2229 
    result.read(self._iprot)
2230 
    self._iprot.readMessageEnd()
3431 rajveer 2231 
    if result.success is not None:
2536 chandransh 2232 
      return result.success
3431 rajveer 2233 
    if result.ex is not None:
2536 chandransh 2234 
      raise result.ex
2235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2236 
 
2237 
  def requestPickupNumber(self, orderId):
2238 
    """
2239 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2240 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2241 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2242 
    For any other status, it returns false.
2243 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2244 
 
2536 chandransh 2245 
    Parameters:
2246 
     - orderId
2247 
    """
2248 
    self.send_requestPickupNumber(orderId)
2249 
    return self.recv_requestPickupNumber()
2250 
 
2251 
  def send_requestPickupNumber(self, orderId):
2252 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2253 
    args = requestPickupNumber_args()
2254 
    args.orderId = orderId
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_requestPickupNumber(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = requestPickupNumber_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
3431 rajveer 2269 
    if result.success is not None:
2536 chandransh 2270 
      return result.success
3431 rajveer 2271 
    if result.ex is not None:
2536 chandransh 2272 
      raise result.ex
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2274 
 
2275 
  def authorizePickup(self, orderId, pickupNumber):
2276 
    """
2277 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2278 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2279 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2280 
    	3. Returns true
2591 chandransh 2281 
    If the order is in any other status, it returns false.
2536 chandransh 2282 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2283 
 
2536 chandransh 2284 
    Parameters:
2285 
     - orderId
2286 
     - pickupNumber
2287 
    """
2288 
    self.send_authorizePickup(orderId, pickupNumber)
2289 
    return self.recv_authorizePickup()
2290 
 
2291 
  def send_authorizePickup(self, orderId, pickupNumber):
2292 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2293 
    args = authorizePickup_args()
2294 
    args.orderId = orderId
2295 
    args.pickupNumber = pickupNumber
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_authorizePickup(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = authorizePickup_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
3431 rajveer 2310 
    if result.success is not None:
2536 chandransh 2311 
      return result.success
3431 rajveer 2312 
    if result.ex is not None:
2536 chandransh 2313 
      raise result.ex
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2315 
 
2764 chandransh 2316 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2317 
    """
2318 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2319 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2320 
 
2764 chandransh 2321 
    Parameters:
2322 
     - providerId
2323 
     - pickupDetails
2324 
    """
2325 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2326 
    return self.recv_markDoasAsPickedUp()
2327 
 
2328 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2329 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2330 
    args = markDoasAsPickedUp_args()
2331 
    args.providerId = providerId
2332 
    args.pickupDetails = pickupDetails
2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_markDoasAsPickedUp(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = markDoasAsPickedUp_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
3431 rajveer 2347 
    if result.success is not None:
2764 chandransh 2348 
      return result.success
2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2350 
 
2616 chandransh 2351 
  def receiveReturn(self, orderId):
2591 chandransh 2352 
    """
2599 chandransh 2353 
    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 2354 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2355 
    If the order is in any other state, it returns false.
2356 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2357 
 
2591 chandransh 2358 
    Parameters:
2359 
     - orderId
2360 
    """
2616 chandransh 2361 
    self.send_receiveReturn(orderId)
2362 
    return self.recv_receiveReturn()
2536 chandransh 2363 
 
2616 chandransh 2364 
  def send_receiveReturn(self, orderId):
2365 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2366 
    args = receiveReturn_args()
2591 chandransh 2367 
    args.orderId = orderId
2368 
    args.write(self._oprot)
2369 
    self._oprot.writeMessageEnd()
2370 
    self._oprot.trans.flush()
2371 
 
2616 chandransh 2372 
  def recv_receiveReturn(self, ):
2591 chandransh 2373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2374 
    if mtype == TMessageType.EXCEPTION:
2375 
      x = TApplicationException()
2376 
      x.read(self._iprot)
2377 
      self._iprot.readMessageEnd()
2378 
      raise x
2616 chandransh 2379 
    result = receiveReturn_result()
2591 chandransh 2380 
    result.read(self._iprot)
2381 
    self._iprot.readMessageEnd()
3431 rajveer 2382 
    if result.success is not None:
2591 chandransh 2383 
      return result.success
3431 rajveer 2384 
    if result.ex is not None:
2591 chandransh 2385 
      raise result.ex
2616 chandransh 2386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2387 
 
2388 
  def validateDoa(self, orderId, isValid):
2389 
    """
2599 chandransh 2390 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2391 
    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 2392 
    If the order is in any other state, it returns false.
2393 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2394 
 
2591 chandransh 2395 
    Parameters:
2396 
     - orderId
2397 
     - isValid
2398 
    """
2399 
    self.send_validateDoa(orderId, isValid)
2400 
    return self.recv_validateDoa()
2401 
 
2402 
  def send_validateDoa(self, orderId, isValid):
2403 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2404 
    args = validateDoa_args()
2405 
    args.orderId = orderId
2406 
    args.isValid = isValid
2407 
    args.write(self._oprot)
2408 
    self._oprot.writeMessageEnd()
2409 
    self._oprot.trans.flush()
2410 
 
2411 
  def recv_validateDoa(self, ):
2412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2413 
    if mtype == TMessageType.EXCEPTION:
2414 
      x = TApplicationException()
2415 
      x.read(self._iprot)
2416 
      self._iprot.readMessageEnd()
2417 
      raise x
2418 
    result = validateDoa_result()
2419 
    result.read(self._iprot)
2420 
    self._iprot.readMessageEnd()
3431 rajveer 2421 
    if result.success is not None:
2591 chandransh 2422 
      return result.success
3431 rajveer 2423 
    if result.ex is not None:
2591 chandransh 2424 
      raise result.ex
2425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2426 
 
2616 chandransh 2427 
  def reshipOrder(self, orderId):
2428 
    """
2429 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2430 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2431 
    	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.
2432 
 
2433 
    If the order is in DOA_CERT_VALID state, it does the following:
2434 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2435 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2436 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2437 
 
2616 chandransh 2438 
    Returns the id of the newly created order.
3431 rajveer 2439 
 
2616 chandransh 2440 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2441 
 
2616 chandransh 2442 
    Parameters:
2443 
     - orderId
2444 
    """
2445 
    self.send_reshipOrder(orderId)
2446 
    return self.recv_reshipOrder()
2591 chandransh 2447 
 
2616 chandransh 2448 
  def send_reshipOrder(self, orderId):
2449 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2450 
    args = reshipOrder_args()
2451 
    args.orderId = orderId
2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_reshipOrder(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = reshipOrder_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
3431 rajveer 2466 
    if result.success is not None:
2616 chandransh 2467 
      return result.success
3431 rajveer 2468 
    if result.ex is not None:
2616 chandransh 2469 
      raise result.ex
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2471 
 
3226 chandransh 2472 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2473 
    """
2474 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2475 
    	1. Creates a refund request for batch processing.
2476 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2477 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2478 
 
2616 chandransh 2479 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2480 
    	1. Creates a refund request for batch processing.
3226 chandransh 2481 
    	2. Cancels the reservation of the item in the warehouse.
2482 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2483 
 
3226 chandransh 2484 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2485 
    	1. Cancels the reservation of the item in the warehouse.
2486 
    	2. Marks the current order as CANCELED.
2487 
 
2488 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2489 
 
2616 chandransh 2490 
    Returns True if it is successful, False otherwise.
3431 rajveer 2491 
 
2616 chandransh 2492 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2493 
 
2616 chandransh 2494 
    Parameters:
2495 
     - orderId
3226 chandransh 2496 
     - refundedBy
2497 
     - reason
2616 chandransh 2498 
    """
3226 chandransh 2499 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2500 
    return self.recv_refundOrder()
2501 
 
3226 chandransh 2502 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2503 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2504 
    args = refundOrder_args()
2505 
    args.orderId = orderId
3226 chandransh 2506 
    args.refundedBy = refundedBy
2507 
    args.reason = reason
2616 chandransh 2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_refundOrder(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = refundOrder_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
3431 rajveer 2522 
    if result.success is not None:
2616 chandransh 2523 
      return result.success
3431 rajveer 2524 
    if result.ex is not None:
2616 chandransh 2525 
      raise result.ex
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2527 
 
2690 chandransh 2528 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2529 
    """
2530 
    Get all return orders created between the from and to dates for the given warehouse.
2531 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2532 
 
2690 chandransh 2533 
    Parameters:
2534 
     - warehouseId
2535 
     - fromDate
2536 
     - toDate
2537 
    """
2538 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2539 
    return self.recv_getReturnOrders()
2616 chandransh 2540 
 
2690 chandransh 2541 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2542 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2543 
    args = getReturnOrders_args()
2544 
    args.warehouseId = warehouseId
2545 
    args.fromDate = fromDate
2546 
    args.toDate = toDate
2547 
    args.write(self._oprot)
2548 
    self._oprot.writeMessageEnd()
2549 
    self._oprot.trans.flush()
2550 
 
2551 
  def recv_getReturnOrders(self, ):
2552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2553 
    if mtype == TMessageType.EXCEPTION:
2554 
      x = TApplicationException()
2555 
      x.read(self._iprot)
2556 
      self._iprot.readMessageEnd()
2557 
      raise x
2558 
    result = getReturnOrders_result()
2559 
    result.read(self._iprot)
2560 
    self._iprot.readMessageEnd()
3431 rajveer 2561 
    if result.success is not None:
2690 chandransh 2562 
      return result.success
2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2564 
 
2700 chandransh 2565 
  def getReturnOrder(self, id):
2566 
    """
2567 
    Returns the ReturnOrder corresponding to the given id.
2568 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2569 
 
2700 chandransh 2570 
    Parameters:
2571 
     - id
2572 
    """
2573 
    self.send_getReturnOrder(id)
2574 
    return self.recv_getReturnOrder()
2575 
 
2576 
  def send_getReturnOrder(self, id):
2577 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2578 
    args = getReturnOrder_args()
2579 
    args.id = id
2580 
    args.write(self._oprot)
2581 
    self._oprot.writeMessageEnd()
2582 
    self._oprot.trans.flush()
2583 
 
2584 
  def recv_getReturnOrder(self, ):
2585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2586 
    if mtype == TMessageType.EXCEPTION:
2587 
      x = TApplicationException()
2588 
      x.read(self._iprot)
2589 
      self._iprot.readMessageEnd()
2590 
      raise x
2591 
    result = getReturnOrder_result()
2592 
    result.read(self._iprot)
2593 
    self._iprot.readMessageEnd()
3431 rajveer 2594 
    if result.success is not None:
2700 chandransh 2595 
      return result.success
3431 rajveer 2596 
    if result.ex is not None:
2700 chandransh 2597 
      raise result.ex
2598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2599 
 
2690 chandransh 2600 
  def processReturn(self, returnOrderId):
2601 
    """
2602 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2603 
 
2690 chandransh 2604 
    Parameters:
2605 
     - returnOrderId
2606 
    """
2607 
    self.send_processReturn(returnOrderId)
2608 
    self.recv_processReturn()
2609 
 
2610 
  def send_processReturn(self, returnOrderId):
2611 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2612 
    args = processReturn_args()
2613 
    args.returnOrderId = returnOrderId
2614 
    args.write(self._oprot)
2615 
    self._oprot.writeMessageEnd()
2616 
    self._oprot.trans.flush()
2617 
 
2618 
  def recv_processReturn(self, ):
2619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2620 
    if mtype == TMessageType.EXCEPTION:
2621 
      x = TApplicationException()
2622 
      x.read(self._iprot)
2623 
      self._iprot.readMessageEnd()
2624 
      raise x
2625 
    result = processReturn_result()
2626 
    result.read(self._iprot)
2627 
    self._iprot.readMessageEnd()
3431 rajveer 2628 
    if result.ex is not None:
2690 chandransh 2629 
      raise result.ex
2630 
    return
2631 
 
2819 chandransh 2632 
  def createPurchaseOrder(self, warehouseId):
2633 
    """
2634 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2635 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2636 
 
2819 chandransh 2637 
    Parameters:
2638 
     - warehouseId
2639 
    """
2640 
    self.send_createPurchaseOrder(warehouseId)
2641 
    return self.recv_createPurchaseOrder()
2690 chandransh 2642 
 
2819 chandransh 2643 
  def send_createPurchaseOrder(self, warehouseId):
2644 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2645 
    args = createPurchaseOrder_args()
2646 
    args.warehouseId = warehouseId
2647 
    args.write(self._oprot)
2648 
    self._oprot.writeMessageEnd()
2649 
    self._oprot.trans.flush()
2650 
 
2651 
  def recv_createPurchaseOrder(self, ):
2652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2653 
    if mtype == TMessageType.EXCEPTION:
2654 
      x = TApplicationException()
2655 
      x.read(self._iprot)
2656 
      self._iprot.readMessageEnd()
2657 
      raise x
2658 
    result = createPurchaseOrder_result()
2659 
    result.read(self._iprot)
2660 
    self._iprot.readMessageEnd()
3431 rajveer 2661 
    if result.success is not None:
2819 chandransh 2662 
      return result.success
3431 rajveer 2663 
    if result.ex is not None:
2819 chandransh 2664 
      raise result.ex
2665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2666 
 
3451 chandransh 2667 
  def updateWeight(self, orderId, weight):
2668 
    """
2669 
    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 2670 
 
3451 chandransh 2671 
    Parameters:
2672 
     - orderId
2673 
     - weight
2674 
    """
2675 
    self.send_updateWeight(orderId, weight)
2676 
    return self.recv_updateWeight()
2677 
 
2678 
  def send_updateWeight(self, orderId, weight):
2679 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2680 
    args = updateWeight_args()
2681 
    args.orderId = orderId
2682 
    args.weight = weight
2683 
    args.write(self._oprot)
2684 
    self._oprot.writeMessageEnd()
2685 
    self._oprot.trans.flush()
2686 
 
2687 
  def recv_updateWeight(self, ):
2688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2689 
    if mtype == TMessageType.EXCEPTION:
2690 
      x = TApplicationException()
2691 
      x.read(self._iprot)
2692 
      self._iprot.readMessageEnd()
2693 
      raise x
2694 
    result = updateWeight_result()
2695 
    result.read(self._iprot)
2696 
    self._iprot.readMessageEnd()
2697 
    if result.success is not None:
2698 
      return result.success
2699 
    if result.ex is not None:
2700 
      raise result.ex
2701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2702 
 
3469 chandransh 2703 
  def changeItem(self, orderId, itemId):
2704 
    """
2705 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2706 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2707 
 
3469 chandransh 2708 
    Parameters:
2709 
     - orderId
2710 
     - itemId
2711 
    """
2712 
    self.send_changeItem(orderId, itemId)
2713 
    return self.recv_changeItem()
2714 
 
2715 
  def send_changeItem(self, orderId, itemId):
2716 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2717 
    args = changeItem_args()
2718 
    args.orderId = orderId
2719 
    args.itemId = itemId
2720 
    args.write(self._oprot)
2721 
    self._oprot.writeMessageEnd()
2722 
    self._oprot.trans.flush()
2723 
 
2724 
  def recv_changeItem(self, ):
2725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2726 
    if mtype == TMessageType.EXCEPTION:
2727 
      x = TApplicationException()
2728 
      x.read(self._iprot)
2729 
      self._iprot.readMessageEnd()
2730 
      raise x
2731 
    result = changeItem_result()
2732 
    result.read(self._iprot)
2733 
    self._iprot.readMessageEnd()
2734 
    if result.success is not None:
2735 
      return result.success
2736 
    if result.ex is not None:
2737 
      raise result.ex
2738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2739 
 
2740 
  def shiftToWarehouse(self, orderId, warehouseId):
2741 
    """
2742 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2743 
 
2744 
    Parameters:
2745 
     - orderId
2746 
     - warehouseId
2747 
    """
2748 
    self.send_shiftToWarehouse(orderId, warehouseId)
2749 
    return self.recv_shiftToWarehouse()
2750 
 
2751 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2752 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2753 
    args = shiftToWarehouse_args()
2754 
    args.orderId = orderId
2755 
    args.warehouseId = warehouseId
2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2760 
  def recv_shiftToWarehouse(self, ):
2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2767 
    result = shiftToWarehouse_result()
2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
2770 
    if result.success is not None:
2771 
      return result.success
2772 
    if result.ex is not None:
2773 
      raise result.ex
2774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2775 
 
3986 chandransh 2776 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2777 
    """
2778 
    Adds the given delay reason to the given order.
3986 chandransh 2779 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2780 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2781 
 
3553 chandransh 2782 
    Parameters:
2783 
     - orderId
2784 
     - delayReason
3986 chandransh 2785 
     - furtherDelay
3553 chandransh 2786 
    """
3986 chandransh 2787 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2788 
    return self.recv_addDelayReason()
2789 
 
3986 chandransh 2790 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2791 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2792 
    args = addDelayReason_args()
2793 
    args.orderId = orderId
2794 
    args.delayReason = delayReason
3986 chandransh 2795 
    args.furtherDelay = furtherDelay
3553 chandransh 2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
2800 
  def recv_addDelayReason(self, ):
2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
2807 
    result = addDelayReason_result()
2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
2810 
    if result.success is not None:
2811 
      return result.success
2812 
    if result.ex is not None:
2813 
      raise result.ex
2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2815 
 
3956 chandransh 2816 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2817 
    """
2818 
    Marks the COD orders with given AWB nos. as having been processed.
2819 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2820 
 
3956 chandransh 2821 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2822 
    1. There is no order corresponding to an AWB number.
2823 
    2. The captured amount for a payment exceeds the total payment.
2824 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2825 
 
2826 
    Parameters:
2827 
     - collectedAmountMap
2828 
     - xferBy
2829 
     - xferTxnId
2830 
     - xferDate
2831 
    """
2832 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2833 
    return self.recv_reconcileCodCollection()
2834 
 
2835 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2836 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2837 
    args = reconcileCodCollection_args()
2838 
    args.collectedAmountMap = collectedAmountMap
2839 
    args.xferBy = xferBy
2840 
    args.xferTxnId = xferTxnId
2841 
    args.xferDate = xferDate
2842 
    args.write(self._oprot)
2843 
    self._oprot.writeMessageEnd()
2844 
    self._oprot.trans.flush()
2845 
 
2846 
  def recv_reconcileCodCollection(self, ):
2847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2848 
    if mtype == TMessageType.EXCEPTION:
2849 
      x = TApplicationException()
2850 
      x.read(self._iprot)
2851 
      self._iprot.readMessageEnd()
2852 
      raise x
2853 
    result = reconcileCodCollection_result()
2854 
    result.read(self._iprot)
2855 
    self._iprot.readMessageEnd()
2856 
    if result.success is not None:
2857 
      return result.success
2858 
    if result.ex is not None:
2859 
      raise result.ex
2860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2861 
 
4008 mandeep.dh 2862 
  def getTransactionsRequiringExtraProcessing(self, category):
2863 
    """
4065 mandeep.dh 2864 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2865 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2866 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2867 
 
4008 mandeep.dh 2868 
    Parameters:
2869 
     - category
2870 
    """
2871 
    self.send_getTransactionsRequiringExtraProcessing(category)
2872 
    return self.recv_getTransactionsRequiringExtraProcessing()
2873 
 
2874 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2875 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2876 
    args = getTransactionsRequiringExtraProcessing_args()
2877 
    args.category = category
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = getTransactionsRequiringExtraProcessing_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    if result.success is not None:
2893 
      return result.success
2894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2895 
 
2896 
  def markTransactionAsProcessed(self, transactionId, category):
2897 
    """
2898 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2899 
    It essentially deletes the transaction id record for a particular
2900 
    processing type category (if present) from DB.
2901 
    This is currently used by CRM application.
4008 mandeep.dh 2902 
 
2903 
    Parameters:
2904 
     - transactionId
2905 
     - category
2906 
    """
2907 
    self.send_markTransactionAsProcessed(transactionId, category)
2908 
    self.recv_markTransactionAsProcessed()
2909 
 
2910 
  def send_markTransactionAsProcessed(self, transactionId, category):
2911 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2912 
    args = markTransactionAsProcessed_args()
2913 
    args.transactionId = transactionId
2914 
    args.category = category
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_markTransactionAsProcessed(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = markTransactionAsProcessed_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
2929 
    return
2930 
 
4018 chandransh 2931 
  def getItemWiseRiskyOrdersCount(self, ):
2932 
    """
2933 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2934 
    is defined as one whose shipping date is about to expire.
2935 
    """
2936 
    self.send_getItemWiseRiskyOrdersCount()
2937 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2938 
 
4018 chandransh 2939 
  def send_getItemWiseRiskyOrdersCount(self, ):
2940 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2941 
    args = getItemWiseRiskyOrdersCount_args()
2942 
    args.write(self._oprot)
2943 
    self._oprot.writeMessageEnd()
2944 
    self._oprot.trans.flush()
2945 
 
2946 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2948 
    if mtype == TMessageType.EXCEPTION:
2949 
      x = TApplicationException()
2950 
      x.read(self._iprot)
2951 
      self._iprot.readMessageEnd()
2952 
      raise x
2953 
    result = getItemWiseRiskyOrdersCount_result()
2954 
    result.read(self._iprot)
2955 
    self._iprot.readMessageEnd()
2956 
    if result.success is not None:
2957 
      return result.success
2958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2959 
 
4295 varun.gupt 2960 
  def getOrdersForItemIds(self, itemIds):
2961 
    """
2962 
    Returns a list of all orders which have items with given id
2963 
 
2964 
    Parameters:
2965 
     - itemIds
2966 
    """
2967 
    self.send_getOrdersForItemIds(itemIds)
2968 
    return self.recv_getOrdersForItemIds()
2969 
 
2970 
  def send_getOrdersForItemIds(self, itemIds):
2971 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2972 
    args = getOrdersForItemIds_args()
2973 
    args.itemIds = itemIds
2974 
    args.write(self._oprot)
2975 
    self._oprot.writeMessageEnd()
2976 
    self._oprot.trans.flush()
2977 
 
2978 
  def recv_getOrdersForItemIds(self, ):
2979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2980 
    if mtype == TMessageType.EXCEPTION:
2981 
      x = TApplicationException()
2982 
      x.read(self._iprot)
2983 
      self._iprot.readMessageEnd()
2984 
      raise x
2985 
    result = getOrdersForItemIds_result()
2986 
    result.read(self._iprot)
2987 
    self._iprot.readMessageEnd()
2988 
    if result.success is not None:
2989 
      return result.success
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2991 
 
4247 rajveer 2992 
  def markOrderCancellationRequestReceived(self, orderId):
2993 
    """
2994 
    Mark order as cancellation request received. If customer sends request of cancellation of
2995 
    a particular order, this method will be called. It will just change status of the order
2996 
    depending on its current status. It also records the previous status, so that we can move
2997 
    back to that status if cancellation request is denied.
4018 chandransh 2998 
 
4247 rajveer 2999 
    Parameters:
3000 
     - orderId
3001 
    """
3002 
    self.send_markOrderCancellationRequestReceived(orderId)
3003 
    self.recv_markOrderCancellationRequestReceived()
3004 
 
3005 
  def send_markOrderCancellationRequestReceived(self, orderId):
3006 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3007 
    args = markOrderCancellationRequestReceived_args()
3008 
    args.orderId = orderId
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_markOrderCancellationRequestReceived(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = markOrderCancellationRequestReceived_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3023 
    if result.ex is not None:
3024 
      raise result.ex
3025 
    return
3026 
 
3027 
  def markOrderCancellationRequestConfirmed(self, orderId):
3028 
    """
3029 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3030 
    cancellation request confirmed. After this OM will be able to cancel the order.
3031 
 
3032 
    Parameters:
3033 
     - orderId
3034 
    """
3035 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3036 
    self.recv_markOrderCancellationRequestConfirmed()
3037 
 
3038 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3039 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3040 
    args = markOrderCancellationRequestConfirmed_args()
3041 
    args.orderId = orderId
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = markOrderCancellationRequestConfirmed_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    if result.ex is not None:
3057 
      raise result.ex
3058 
    return
3059 
 
3060 
  def markOrderCancellationRequestDenied(self, orderId):
3061 
    """
3062 
    If we decide to not to cancel order, we will move the order ro previous status.
3063 
 
3064 
    Parameters:
3065 
     - orderId
3066 
    """
3067 
    self.send_markOrderCancellationRequestDenied(orderId)
3068 
    self.recv_markOrderCancellationRequestDenied()
3069 
 
3070 
  def send_markOrderCancellationRequestDenied(self, orderId):
3071 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3072 
    args = markOrderCancellationRequestDenied_args()
3073 
    args.orderId = orderId
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_markOrderCancellationRequestDenied(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = markOrderCancellationRequestDenied_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.ex is not None:
3089 
      raise result.ex
3090 
    return
3091 
 
4258 rajveer 3092 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3093 
    """
4258 rajveer 3094 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3095 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3096 
 
3097 
    Parameters:
4258 rajveer 3098 
     - transactionId
4247 rajveer 3099 
    """
4258 rajveer 3100 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3101 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3102 
 
4258 rajveer 3103 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3104 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3105 
    args = markTransactionAsPaymentFlagRemoved_args()
3106 
    args.transactionId = transactionId
4247 rajveer 3107 
    args.write(self._oprot)
3108 
    self._oprot.writeMessageEnd()
3109 
    self._oprot.trans.flush()
3110 
 
4258 rajveer 3111 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3113 
    if mtype == TMessageType.EXCEPTION:
3114 
      x = TApplicationException()
3115 
      x.read(self._iprot)
3116 
      self._iprot.readMessageEnd()
3117 
      raise x
4258 rajveer 3118 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3119 
    result.read(self._iprot)
3120 
    self._iprot.readMessageEnd()
3121 
    if result.ex is not None:
3122 
      raise result.ex
3123 
    return
3124 
 
4259 anupam.sin 3125 
  def refundTransaction(self, transactionId, refundedBy, reason):
3126 
    """
3127 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3128 
    need to be cancelled
4247 rajveer 3129 
 
4259 anupam.sin 3130 
    Parameters:
3131 
     - transactionId
3132 
     - refundedBy
3133 
     - reason
3134 
    """
3135 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3136 
    self.recv_refundTransaction()
3137 
 
3138 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3139 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3140 
    args = refundTransaction_args()
3141 
    args.transactionId = transactionId
3142 
    args.refundedBy = refundedBy
3143 
    args.reason = reason
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_refundTransaction(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = refundTransaction_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.ex is not None:
3159 
      raise result.ex
3160 
    return
3161 
 
4324 mandeep.dh 3162 
  def updateShipmentAddress(self, orderId, addressId):
3163 
    """
3164 
    Updates shipment address of an order. Delivery and shipping date estimates
3165 
    etc. are also updated here.
3166 
 
3167 
    Throws TransactionServiceException in case address change is not
3168 
    possible due to certain reasons such as new pincode in address is
3169 
    not serviceable etc.
3170 
 
3171 
    Parameters:
3172 
     - orderId
3173 
     - addressId
3174 
    """
3175 
    self.send_updateShipmentAddress(orderId, addressId)
3176 
    self.recv_updateShipmentAddress()
3177 
 
3178 
  def send_updateShipmentAddress(self, orderId, addressId):
3179 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3180 
    args = updateShipmentAddress_args()
3181 
    args.orderId = orderId
3182 
    args.addressId = addressId
3183 
    args.write(self._oprot)
3184 
    self._oprot.writeMessageEnd()
3185 
    self._oprot.trans.flush()
3186 
 
3187 
  def recv_updateShipmentAddress(self, ):
3188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3189 
    if mtype == TMessageType.EXCEPTION:
3190 
      x = TApplicationException()
3191 
      x.read(self._iprot)
3192 
      self._iprot.readMessageEnd()
3193 
      raise x
3194 
    result = updateShipmentAddress_result()
3195 
    result.read(self._iprot)
3196 
    self._iprot.readMessageEnd()
3197 
    if result.ex is not None:
3198 
      raise result.ex
3199 
    return
3200 
 
4285 rajveer 3201 
  def acceptOrdersForItemId(self, itemId, inventory):
3202 
    """
3203 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3204 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3205 
 
4285 rajveer 3206 
    Parameters:
3207 
     - itemId
3208 
     - inventory
3209 
    """
3210 
    self.send_acceptOrdersForItemId(itemId, inventory)
3211 
    return self.recv_acceptOrdersForItemId()
3212 
 
3213 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3214 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3215 
    args = acceptOrdersForItemId_args()
3216 
    args.itemId = itemId
3217 
    args.inventory = inventory
3218 
    args.write(self._oprot)
3219 
    self._oprot.writeMessageEnd()
3220 
    self._oprot.trans.flush()
3221 
 
3222 
  def recv_acceptOrdersForItemId(self, ):
3223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3224 
    if mtype == TMessageType.EXCEPTION:
3225 
      x = TApplicationException()
3226 
      x.read(self._iprot)
3227 
      self._iprot.readMessageEnd()
3228 
      raise x
3229 
    result = acceptOrdersForItemId_result()
3230 
    result.read(self._iprot)
3231 
    self._iprot.readMessageEnd()
3232 
    if result.success is not None:
3233 
      return result.success
3234 
    if result.ex is not None:
3235 
      raise result.ex
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3237 
 
4369 rajveer 3238 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3239 
    """
3240 
    Parameters:
3241 
     - vendorId
3242 
     - itemId
3243 
     - quantity
3244 
     - estimate
4369 rajveer 3245 
     - isReminder
4303 rajveer 3246 
    """
4369 rajveer 3247 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3248 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3249 
 
4369 rajveer 3250 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3251 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3252 
    args = markOrdersAsPORaised_args()
3253 
    args.vendorId = vendorId
3254 
    args.itemId = itemId
3255 
    args.quantity = quantity
3256 
    args.estimate = estimate
4369 rajveer 3257 
    args.isReminder = isReminder
4303 rajveer 3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_markOrdersAsPORaised(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = markOrdersAsPORaised_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3272 
    if result.ex is not None:
3273 
      raise result.ex
3274 
    return
3275 
 
4369 rajveer 3276 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3277 
    """
3278 
    Parameters:
3279 
     - vendorId
3280 
     - itemId
3281 
     - quantity
3282 
     - estimate
4369 rajveer 3283 
     - isReminder
4303 rajveer 3284 
    """
4369 rajveer 3285 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3286 
    self.recv_markOrdersAsReversalInitiated()
3287 
 
4369 rajveer 3288 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3289 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3290 
    args = markOrdersAsReversalInitiated_args()
3291 
    args.vendorId = vendorId
3292 
    args.itemId = itemId
3293 
    args.quantity = quantity
3294 
    args.estimate = estimate
4369 rajveer 3295 
    args.isReminder = isReminder
4303 rajveer 3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3300 
  def recv_markOrdersAsReversalInitiated(self, ):
3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3307 
    result = markOrdersAsReversalInitiated_result()
3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3310 
    if result.ex is not None:
3311 
      raise result.ex
3312 
    return
3313 
 
4369 rajveer 3314 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3315 
    """
3316 
    Parameters:
3317 
     - vendorId
3318 
     - itemId
3319 
     - quantity
3320 
     - estimate
4369 rajveer 3321 
     - isReminder
4303 rajveer 3322 
    """
4369 rajveer 3323 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3324 
    self.recv_markOrdersAsNotAvailabke()
3325 
 
4369 rajveer 3326 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3327 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3328 
    args = markOrdersAsNotAvailabke_args()
3329 
    args.vendorId = vendorId
3330 
    args.itemId = itemId
3331 
    args.quantity = quantity
3332 
    args.estimate = estimate
4369 rajveer 3333 
    args.isReminder = isReminder
4303 rajveer 3334 
    args.write(self._oprot)
3335 
    self._oprot.writeMessageEnd()
3336 
    self._oprot.trans.flush()
3337 
 
3338 
  def recv_markOrdersAsNotAvailabke(self, ):
3339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3340 
    if mtype == TMessageType.EXCEPTION:
3341 
      x = TApplicationException()
3342 
      x.read(self._iprot)
3343 
      self._iprot.readMessageEnd()
3344 
      raise x
3345 
    result = markOrdersAsNotAvailabke_result()
3346 
    result.read(self._iprot)
3347 
    self._iprot.readMessageEnd()
3348 
    if result.ex is not None:
3349 
      raise result.ex
3350 
    return
3351 
 
4369 rajveer 3352 
  def markOrdersAsTimeout(self, vendorId):
3353 
    """
3354 
    Parameters:
3355 
     - vendorId
3356 
    """
3357 
    self.send_markOrdersAsTimeout(vendorId)
3358 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3359 
 
4369 rajveer 3360 
  def send_markOrdersAsTimeout(self, vendorId):
3361 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3362 
    args = markOrdersAsTimeout_args()
3363 
    args.vendorId = vendorId
3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_markOrdersAsTimeout(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = markOrdersAsTimeout_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    if result.ex is not None:
3381 
      raise result.ex
3382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3383 
 
4386 anupam.sin 3384 
  def getOrderForAwb(self, awb):
3385 
    """
3386 
    Returns the order corresponding to an AWB number
4369 rajveer 3387 
 
4386 anupam.sin 3388 
    Parameters:
3389 
     - awb
3390 
    """
3391 
    self.send_getOrderForAwb(awb)
3392 
    return self.recv_getOrderForAwb()
3393 
 
3394 
  def send_getOrderForAwb(self, awb):
3395 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3396 
    args = getOrderForAwb_args()
3397 
    args.awb = awb
3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_getOrderForAwb(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = getOrderForAwb_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3412 
    if result.success is not None:
3413 
      return result.success
3414 
    if result.ex is not None:
3415 
      raise result.ex
3416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3417 
 
3418 
 
3376 rajveer 3419 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3420 
  def __init__(self, handler):
3376 rajveer 3421 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3422 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3423 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3424 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3425 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3426 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3427 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3428 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3429 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3430 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3431 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3432 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3433 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3434 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3435 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3436 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3437 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3438 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3439 
    self._processMap["createOrder"] = Processor.process_createOrder
3440 
    self._processMap["getOrder"] = Processor.process_getOrder
3441 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3442 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3443 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3444 
    self._processMap["addAlert"] = Processor.process_addAlert
3064 chandransh 3445 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3446 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3447 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3448 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3449 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3450 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3451 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3452 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3453 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3454 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3455 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3456 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3457 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3458 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3459 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3460 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3461 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3462 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3463 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3464 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3465 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3466 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3467 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3468 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3469 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3470 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3471 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3472 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3473 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3474 
    self._processMap["changeItem"] = Processor.process_changeItem
3475 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3476 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3477 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3478 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3479 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3480 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3481 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3482 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3483 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3484 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3485 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3486 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3487 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3488 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3489 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3490 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3491 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3492 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3493 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3494 
 
3495 
  def process(self, iprot, oprot):
3496 
    (name, type, seqid) = iprot.readMessageBegin()
3497 
    if name not in self._processMap:
3498 
      iprot.skip(TType.STRUCT)
3499 
      iprot.readMessageEnd()
3500 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3501 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3502 
      x.write(oprot)
3503 
      oprot.writeMessageEnd()
3504 
      oprot.trans.flush()
3505 
      return
3506 
    else:
3507 
      self._processMap[name](self, seqid, iprot, oprot)
3508 
    return True
3509 
 
3510 
  def process_createTransaction(self, seqid, iprot, oprot):
3511 
    args = createTransaction_args()
3512 
    args.read(iprot)
3513 
    iprot.readMessageEnd()
3514 
    result = createTransaction_result()
3515 
    try:
132 ashish 3516 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3517 
    except TransactionServiceException, ex:
3518 
      result.ex = ex
3519 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3520 
    result.write(oprot)
3521 
    oprot.writeMessageEnd()
3522 
    oprot.trans.flush()
3523 
 
3524 
  def process_getTransaction(self, seqid, iprot, oprot):
3525 
    args = getTransaction_args()
3526 
    args.read(iprot)
3527 
    iprot.readMessageEnd()
3528 
    result = getTransaction_result()
3529 
    try:
3530 
      result.success = self._handler.getTransaction(args.id)
3531 
    except TransactionServiceException, ex:
3532 
      result.ex = ex
3533 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3534 
    result.write(oprot)
3535 
    oprot.writeMessageEnd()
3536 
    oprot.trans.flush()
3537 
 
3538 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3539 
    args = getTransactionsForCustomer_args()
3540 
    args.read(iprot)
3541 
    iprot.readMessageEnd()
3542 
    result = getTransactionsForCustomer_result()
3543 
    try:
3544 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3545 
    except TransactionServiceException, ex:
3546 
      result.ex = ex
3547 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3548 
    result.write(oprot)
3549 
    oprot.writeMessageEnd()
3550 
    oprot.trans.flush()
3551 
 
132 ashish 3552 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3553 
    args = getTransactionsForShoppingCartId_args()
3554 
    args.read(iprot)
3555 
    iprot.readMessageEnd()
3556 
    result = getTransactionsForShoppingCartId_result()
3557 
    try:
3558 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3559 
    except TransactionServiceException, ex:
3560 
      result.ex = ex
3561 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3562 
    result.write(oprot)
3563 
    oprot.writeMessageEnd()
3564 
    oprot.trans.flush()
3565 
 
94 ashish 3566 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3567 
    args = getTransactionStatus_args()
3568 
    args.read(iprot)
3569 
    iprot.readMessageEnd()
3570 
    result = getTransactionStatus_result()
3571 
    try:
3572 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3573 
    except TransactionServiceException, ex:
3574 
      result.ex = ex
3575 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3576 
    result.write(oprot)
3577 
    oprot.writeMessageEnd()
3578 
    oprot.trans.flush()
3579 
 
3580 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3581 
    args = changeTransactionStatus_args()
3582 
    args.read(iprot)
3583 
    iprot.readMessageEnd()
3584 
    result = changeTransactionStatus_result()
3585 
    try:
3586 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3587 
    except TransactionServiceException, ex:
3588 
      result.ex = ex
3589 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3590 
    result.write(oprot)
3591 
    oprot.writeMessageEnd()
3592 
    oprot.trans.flush()
3593 
 
1398 varun.gupt 3594 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3595 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3596 
    args.read(iprot)
3597 
    iprot.readMessageEnd()
1398 varun.gupt 3598 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3599 
    try:
1398 varun.gupt 3600 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3601 
    except TransactionServiceException, ex:
3602 
      result.ex = ex
1398 varun.gupt 3603 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3604 
    result.write(oprot)
3605 
    oprot.writeMessageEnd()
3606 
    oprot.trans.flush()
3607 
 
483 rajveer 3608 
  def process_getAllOrders(self, seqid, iprot, oprot):
3609 
    args = getAllOrders_args()
94 ashish 3610 
    args.read(iprot)
3611 
    iprot.readMessageEnd()
483 rajveer 3612 
    result = getAllOrders_result()
94 ashish 3613 
    try:
483 rajveer 3614 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3615 
    except TransactionServiceException, ex:
3616 
      result.ex = ex
483 rajveer 3617 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3618 
    result.write(oprot)
3619 
    oprot.writeMessageEnd()
3620 
    oprot.trans.flush()
3621 
 
4133 chandransh 3622 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3623 
    args = getOrdersInBatch_args()
3624 
    args.read(iprot)
3625 
    iprot.readMessageEnd()
3626 
    result = getOrdersInBatch_result()
3627 
    try:
3628 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3629 
    except TransactionServiceException, ex:
3630 
      result.ex = ex
3631 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3632 
    result.write(oprot)
3633 
    oprot.writeMessageEnd()
3634 
    oprot.trans.flush()
3635 
 
3636 
  def process_getOrderCount(self, seqid, iprot, oprot):
3637 
    args = getOrderCount_args()
3638 
    args.read(iprot)
3639 
    iprot.readMessageEnd()
3640 
    result = getOrderCount_result()
3641 
    try:
3642 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3643 
    except TransactionServiceException, ex:
3644 
      result.ex = ex
3645 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3646 
    result.write(oprot)
3647 
    oprot.writeMessageEnd()
3648 
    oprot.trans.flush()
3649 
 
999 varun.gupt 3650 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3651 
    args = getOrdersByBillingDate_args()
3652 
    args.read(iprot)
3653 
    iprot.readMessageEnd()
3654 
    result = getOrdersByBillingDate_result()
3655 
    try:
3656 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3657 
    except TransactionServiceException, ex:
3658 
      result.ex = ex
3659 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3660 
    result.write(oprot)
3661 
    oprot.writeMessageEnd()
3662 
    oprot.trans.flush()
3663 
 
3427 chandransh 3664 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3665 
    args = getOrdersByShippingDate_args()
3666 
    args.read(iprot)
3667 
    iprot.readMessageEnd()
3668 
    result = getOrdersByShippingDate_result()
3669 
    try:
3451 chandransh 3670 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3671 
    except TransactionServiceException, ex:
3672 
      result.ex = ex
3673 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3674 
    result.write(oprot)
3675 
    oprot.writeMessageEnd()
3676 
    oprot.trans.flush()
3677 
 
1382 varun.gupt 3678 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3679 
    args = getReturnableOrdersForCustomer_args()
3680 
    args.read(iprot)
3681 
    iprot.readMessageEnd()
3682 
    result = getReturnableOrdersForCustomer_result()
3683 
    try:
3684 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3685 
    except TransactionServiceException, ex:
3686 
      result.ex = ex
3687 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3688 
    result.write(oprot)
3689 
    oprot.writeMessageEnd()
3690 
    oprot.trans.flush()
3691 
 
3692 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3693 
    args = getCancellableOrdersForCustomer_args()
3694 
    args.read(iprot)
3695 
    iprot.readMessageEnd()
3696 
    result = getCancellableOrdersForCustomer_result()
3697 
    try:
3698 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3699 
    except TransactionServiceException, ex:
3700 
      result.ex = ex
3701 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3702 
    result.write(oprot)
3703 
    oprot.writeMessageEnd()
3704 
    oprot.trans.flush()
3705 
 
483 rajveer 3706 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3707 
    args = changeOrderStatus_args()
94 ashish 3708 
    args.read(iprot)
3709 
    iprot.readMessageEnd()
483 rajveer 3710 
    result = changeOrderStatus_result()
94 ashish 3711 
    try:
483 rajveer 3712 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3713 
    except TransactionServiceException, ex:
3714 
      result.ex = ex
483 rajveer 3715 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3716 
    result.write(oprot)
3717 
    oprot.writeMessageEnd()
3718 
    oprot.trans.flush()
3719 
 
483 rajveer 3720 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3721 
    args = getOrdersForTransaction_args()
94 ashish 3722 
    args.read(iprot)
3723 
    iprot.readMessageEnd()
483 rajveer 3724 
    result = getOrdersForTransaction_result()
94 ashish 3725 
    try:
1528 ankur.sing 3726 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3727 
    except TransactionServiceException, ex:
3728 
      result.ex = ex
483 rajveer 3729 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3730 
    result.write(oprot)
3731 
    oprot.writeMessageEnd()
3732 
    oprot.trans.flush()
3733 
 
483 rajveer 3734 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3735 
    args = getOrdersForCustomer_args()
94 ashish 3736 
    args.read(iprot)
3737 
    iprot.readMessageEnd()
483 rajveer 3738 
    result = getOrdersForCustomer_result()
94 ashish 3739 
    try:
3014 chandransh 3740 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3741 
    except TransactionServiceException, ex:
3742 
      result.ex = ex
483 rajveer 3743 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3744 
    result.write(oprot)
3745 
    oprot.writeMessageEnd()
3746 
    oprot.trans.flush()
3747 
 
483 rajveer 3748 
  def process_createOrder(self, seqid, iprot, oprot):
3749 
    args = createOrder_args()
94 ashish 3750 
    args.read(iprot)
3751 
    iprot.readMessageEnd()
483 rajveer 3752 
    result = createOrder_result()
94 ashish 3753 
    try:
483 rajveer 3754 
      result.success = self._handler.createOrder(args.order)
94 ashish 3755 
    except TransactionServiceException, ex:
3756 
      result.ex = ex
483 rajveer 3757 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3758 
    result.write(oprot)
3759 
    oprot.writeMessageEnd()
3760 
    oprot.trans.flush()
3761 
 
483 rajveer 3762 
  def process_getOrder(self, seqid, iprot, oprot):
3763 
    args = getOrder_args()
94 ashish 3764 
    args.read(iprot)
3765 
    iprot.readMessageEnd()
483 rajveer 3766 
    result = getOrder_result()
94 ashish 3767 
    try:
483 rajveer 3768 
      result.success = self._handler.getOrder(args.id)
94 ashish 3769 
    except TransactionServiceException, ex:
3770 
      result.ex = ex
483 rajveer 3771 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3772 
    result.write(oprot)
3773 
    oprot.writeMessageEnd()
3774 
    oprot.trans.flush()
3775 
 
483 rajveer 3776 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3777 
    args = getLineItemsForOrder_args()
94 ashish 3778 
    args.read(iprot)
3779 
    iprot.readMessageEnd()
483 rajveer 3780 
    result = getLineItemsForOrder_result()
94 ashish 3781 
    try:
483 rajveer 3782 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3783 
    except TransactionServiceException, ex:
3784 
      result.ex = ex
483 rajveer 3785 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
1528 ankur.sing 3790 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3791 
    args = getOrderForCustomer_args()
3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
3794 
    result = getOrderForCustomer_result()
3795 
    try:
3796 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3797 
    except TransactionServiceException, ex:
3798 
      result.ex = ex
3799 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3800 
    result.write(oprot)
3801 
    oprot.writeMessageEnd()
3802 
    oprot.trans.flush()
3803 
 
3064 chandransh 3804 
  def process_getAlerts(self, seqid, iprot, oprot):
3805 
    args = getAlerts_args()
3806 
    args.read(iprot)
3807 
    iprot.readMessageEnd()
3808 
    result = getAlerts_result()
4394 rajveer 3809 
    result.success = self._handler.getAlerts(args.type, args.status, args.timestamp)
3064 chandransh 3810 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3811 
    result.write(oprot)
3812 
    oprot.writeMessageEnd()
3813 
    oprot.trans.flush()
3814 
 
4394 rajveer 3815 
  def process_addAlert(self, seqid, iprot, oprot):
3816 
    args = addAlert_args()
3064 chandransh 3817 
    args.read(iprot)
3818 
    iprot.readMessageEnd()
4394 rajveer 3819 
    result = addAlert_result()
3820 
    self._handler.addAlert(args.type, args.description)
3821 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 3822 
    result.write(oprot)
3823 
    oprot.writeMessageEnd()
3824 
    oprot.trans.flush()
3825 
 
3826 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3827 
    args = getValidOrderCount_args()
3828 
    args.read(iprot)
3829 
    iprot.readMessageEnd()
3830 
    result = getValidOrderCount_result()
3831 
    result.success = self._handler.getValidOrderCount()
3832 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3833 
    result.write(oprot)
3834 
    oprot.writeMessageEnd()
3835 
    oprot.trans.flush()
3836 
 
3837 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3838 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3839 
    args.read(iprot)
3840 
    iprot.readMessageEnd()
3841 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3842 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3843 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3844 
    result.write(oprot)
3845 
    oprot.writeMessageEnd()
3846 
    oprot.trans.flush()
3847 
 
3848 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3849 
    args = getValidOrdersAmountRange_args()
3850 
    args.read(iprot)
3851 
    iprot.readMessageEnd()
3852 
    result = getValidOrdersAmountRange_result()
3853 
    result.success = self._handler.getValidOrdersAmountRange()
3854 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
3858 
 
3859 
  def process_getValidOrders(self, seqid, iprot, oprot):
3860 
    args = getValidOrders_args()
3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
3863 
    result = getValidOrders_result()
3864 
    result.success = self._handler.getValidOrders(args.limit)
3865 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3866 
    result.write(oprot)
3867 
    oprot.writeMessageEnd()
3868 
    oprot.trans.flush()
3869 
 
1220 chandransh 3870 
  def process_batchOrders(self, seqid, iprot, oprot):
3871 
    args = batchOrders_args()
3872 
    args.read(iprot)
3873 
    iprot.readMessageEnd()
3874 
    result = batchOrders_result()
3875 
    try:
3876 
      result.success = self._handler.batchOrders(args.warehouseId)
3877 
    except TransactionServiceException, ex:
3878 
      result.ex = ex
3879 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3880 
    result.write(oprot)
3881 
    oprot.writeMessageEnd()
3882 
    oprot.trans.flush()
3883 
 
1208 chandransh 3884 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3885 
    args = markOrderAsOutOfStock_args()
3886 
    args.read(iprot)
3887 
    iprot.readMessageEnd()
3888 
    result = markOrderAsOutOfStock_result()
3889 
    try:
3890 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3891 
    except TransactionServiceException, ex:
3892 
      result.ex = ex
3893 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3894 
    result.write(oprot)
3895 
    oprot.writeMessageEnd()
3896 
    oprot.trans.flush()
3897 
 
3064 chandransh 3898 
  def process_verifyOrder(self, seqid, iprot, oprot):
3899 
    args = verifyOrder_args()
759 chandransh 3900 
    args.read(iprot)
3901 
    iprot.readMessageEnd()
3064 chandransh 3902 
    result = verifyOrder_result()
759 chandransh 3903 
    try:
3064 chandransh 3904 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3905 
    except TransactionServiceException, ex:
3906 
      result.ex = ex
3064 chandransh 3907 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3908 
    result.write(oprot)
3909 
    oprot.writeMessageEnd()
3910 
    oprot.trans.flush()
3911 
 
3064 chandransh 3912 
  def process_acceptOrder(self, seqid, iprot, oprot):
3913 
    args = acceptOrder_args()
1113 chandransh 3914 
    args.read(iprot)
3915 
    iprot.readMessageEnd()
3064 chandransh 3916 
    result = acceptOrder_result()
1113 chandransh 3917 
    try:
3064 chandransh 3918 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3919 
    except TransactionServiceException, ex:
3920 
      result.ex = ex
3064 chandransh 3921 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3922 
    result.write(oprot)
3923 
    oprot.writeMessageEnd()
3924 
    oprot.trans.flush()
3925 
 
3064 chandransh 3926 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3927 
    args = addBillingDetails_args()
1135 chandransh 3928 
    args.read(iprot)
3929 
    iprot.readMessageEnd()
3064 chandransh 3930 
    result = addBillingDetails_result()
1135 chandransh 3931 
    try:
4283 anupam.sin 3932 
      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 3933 
    except TransactionServiceException, ex:
3934 
      result.ex = ex
3064 chandransh 3935 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3936 
    result.write(oprot)
3937 
    oprot.writeMessageEnd()
3938 
    oprot.trans.flush()
3939 
 
3064 chandransh 3940 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3941 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3942 
    args.read(iprot)
3943 
    iprot.readMessageEnd()
3064 chandransh 3944 
    result = markOrdersAsManifested_result()
3945 
    try:
3946 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3947 
    except TransactionServiceException, ex:
3948 
      result.ex = ex
3949 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3950 
    result.write(oprot)
3951 
    oprot.writeMessageEnd()
3952 
    oprot.trans.flush()
3953 
 
4410 rajveer 3954 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
3955 
    args = markOrdersAsShippedFromWarehouse_args()
3956 
    args.read(iprot)
3957 
    iprot.readMessageEnd()
3958 
    result = markOrdersAsShippedFromWarehouse_result()
3959 
    try:
3960 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
3961 
    except TransactionServiceException, ex:
3962 
      result.ex = ex
3963 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
3964 
    result.write(oprot)
3965 
    oprot.writeMessageEnd()
3966 
    oprot.trans.flush()
3967 
 
3064 chandransh 3968 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3969 
    args = markOrdersAsPickedUp_args()
304 ashish 3970 
    args.read(iprot)
3971 
    iprot.readMessageEnd()
3064 chandransh 3972 
    result = markOrdersAsPickedUp_result()
3973 
    try:
3974 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3975 
    except TransactionServiceException, ex:
3976 
      result.ex = ex
3977 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3978 
    result.write(oprot)
3979 
    oprot.writeMessageEnd()
3980 
    oprot.trans.flush()
94 ashish 3981 
 
3064 chandransh 3982 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3983 
    args = markOrdersAsDelivered_args()
304 ashish 3984 
    args.read(iprot)
3985 
    iprot.readMessageEnd()
3064 chandransh 3986 
    result = markOrdersAsDelivered_result()
3987 
    try:
3988 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3989 
    except TransactionServiceException, ex:
3990 
      result.ex = ex
3991 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3992 
    result.write(oprot)
3993 
    oprot.writeMessageEnd()
3994 
    oprot.trans.flush()
3995 
 
3064 chandransh 3996 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3997 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3998 
    args.read(iprot)
3999 
    iprot.readMessageEnd()
3064 chandransh 4000 
    result = markOrdersAsFailed_result()
4001 
    try:
4002 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4003 
    except TransactionServiceException, ex:
4004 
      result.ex = ex
4005 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4006 
    result.write(oprot)
4007 
    oprot.writeMessageEnd()
4008 
    oprot.trans.flush()
304 ashish 4009 
 
3064 chandransh 4010 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4011 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4012 
    args.read(iprot)
4013 
    iprot.readMessageEnd()
3064 chandransh 4014 
    result = updateNonDeliveryReason_result()
4015 
    try:
4016 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4017 
    except TransactionServiceException, ex:
4018 
      result.ex = ex
4019 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4020 
    result.write(oprot)
4021 
    oprot.writeMessageEnd()
4022 
    oprot.trans.flush()
1596 ankur.sing 4023 
 
3064 chandransh 4024 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4025 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4026 
    args.read(iprot)
4027 
    iprot.readMessageEnd()
3064 chandransh 4028 
    result = getUndeliveredOrders_result()
4029 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4030 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4031 
    result.write(oprot)
4032 
    oprot.writeMessageEnd()
4033 
    oprot.trans.flush()
4034 
 
2536 chandransh 4035 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4036 
    args = toggleDOAFlag_args()
4037 
    args.read(iprot)
4038 
    iprot.readMessageEnd()
4039 
    result = toggleDOAFlag_result()
4040 
    try:
4041 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4042 
    except TransactionServiceException, ex:
4043 
      result.ex = ex
4044 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4045 
    result.write(oprot)
4046 
    oprot.writeMessageEnd()
4047 
    oprot.trans.flush()
1886 ankur.sing 4048 
 
2536 chandransh 4049 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4050 
    args = requestPickupNumber_args()
4051 
    args.read(iprot)
4052 
    iprot.readMessageEnd()
4053 
    result = requestPickupNumber_result()
4054 
    try:
4055 
      result.success = self._handler.requestPickupNumber(args.orderId)
4056 
    except TransactionServiceException, ex:
4057 
      result.ex = ex
4058 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4059 
    result.write(oprot)
4060 
    oprot.writeMessageEnd()
4061 
    oprot.trans.flush()
4062 
 
4063 
  def process_authorizePickup(self, seqid, iprot, oprot):
4064 
    args = authorizePickup_args()
4065 
    args.read(iprot)
4066 
    iprot.readMessageEnd()
4067 
    result = authorizePickup_result()
4068 
    try:
4069 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4070 
    except TransactionServiceException, ex:
4071 
      result.ex = ex
4072 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4073 
    result.write(oprot)
4074 
    oprot.writeMessageEnd()
4075 
    oprot.trans.flush()
4076 
 
2764 chandransh 4077 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4078 
    args = markDoasAsPickedUp_args()
4079 
    args.read(iprot)
4080 
    iprot.readMessageEnd()
4081 
    result = markDoasAsPickedUp_result()
4082 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4083 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4084 
    result.write(oprot)
4085 
    oprot.writeMessageEnd()
4086 
    oprot.trans.flush()
4087 
 
2616 chandransh 4088 
  def process_receiveReturn(self, seqid, iprot, oprot):
4089 
    args = receiveReturn_args()
2591 chandransh 4090 
    args.read(iprot)
4091 
    iprot.readMessageEnd()
2616 chandransh 4092 
    result = receiveReturn_result()
2591 chandransh 4093 
    try:
2616 chandransh 4094 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 4095 
    except TransactionServiceException, ex:
4096 
      result.ex = ex
2616 chandransh 4097 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4098 
    result.write(oprot)
4099 
    oprot.writeMessageEnd()
4100 
    oprot.trans.flush()
2536 chandransh 4101 
 
2591 chandransh 4102 
  def process_validateDoa(self, seqid, iprot, oprot):
4103 
    args = validateDoa_args()
4104 
    args.read(iprot)
4105 
    iprot.readMessageEnd()
4106 
    result = validateDoa_result()
4107 
    try:
4108 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4109 
    except TransactionServiceException, ex:
4110 
      result.ex = ex
4111 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4112 
    result.write(oprot)
4113 
    oprot.writeMessageEnd()
4114 
    oprot.trans.flush()
4115 
 
2616 chandransh 4116 
  def process_reshipOrder(self, seqid, iprot, oprot):
4117 
    args = reshipOrder_args()
4118 
    args.read(iprot)
4119 
    iprot.readMessageEnd()
4120 
    result = reshipOrder_result()
4121 
    try:
4122 
      result.success = self._handler.reshipOrder(args.orderId)
4123 
    except TransactionServiceException, ex:
4124 
      result.ex = ex
4125 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4126 
    result.write(oprot)
4127 
    oprot.writeMessageEnd()
4128 
    oprot.trans.flush()
2591 chandransh 4129 
 
2616 chandransh 4130 
  def process_refundOrder(self, seqid, iprot, oprot):
4131 
    args = refundOrder_args()
4132 
    args.read(iprot)
4133 
    iprot.readMessageEnd()
4134 
    result = refundOrder_result()
4135 
    try:
3226 chandransh 4136 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4137 
    except TransactionServiceException, ex:
4138 
      result.ex = ex
4139 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4140 
    result.write(oprot)
4141 
    oprot.writeMessageEnd()
4142 
    oprot.trans.flush()
4143 
 
2690 chandransh 4144 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4145 
    args = getReturnOrders_args()
4146 
    args.read(iprot)
4147 
    iprot.readMessageEnd()
4148 
    result = getReturnOrders_result()
4149 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4150 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
2616 chandransh 4154 
 
2700 chandransh 4155 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4156 
    args = getReturnOrder_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = getReturnOrder_result()
4160 
    try:
4161 
      result.success = self._handler.getReturnOrder(args.id)
4162 
    except TransactionServiceException, ex:
4163 
      result.ex = ex
4164 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
2690 chandransh 4169 
  def process_processReturn(self, seqid, iprot, oprot):
4170 
    args = processReturn_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = processReturn_result()
4174 
    try:
4175 
      self._handler.processReturn(args.returnOrderId)
4176 
    except TransactionServiceException, ex:
4177 
      result.ex = ex
4178 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
2819 chandransh 4183 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4184 
    args = createPurchaseOrder_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = createPurchaseOrder_result()
4188 
    try:
4189 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4190 
    except TransactionServiceException, ex:
4191 
      result.ex = ex
4192 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
2690 chandransh 4196 
 
3451 chandransh 4197 
  def process_updateWeight(self, seqid, iprot, oprot):
4198 
    args = updateWeight_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = updateWeight_result()
4202 
    try:
4203 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4204 
    except TransactionServiceException, ex:
4205 
      result.ex = ex
4206 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
2819 chandransh 4210 
 
3469 chandransh 4211 
  def process_changeItem(self, seqid, iprot, oprot):
4212 
    args = changeItem_args()
4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
4215 
    result = changeItem_result()
4216 
    try:
4217 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4218 
    except TransactionServiceException, ex:
4219 
      result.ex = ex
4220 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
3451 chandransh 4224 
 
3469 chandransh 4225 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4226 
    args = shiftToWarehouse_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = shiftToWarehouse_result()
4230 
    try:
4231 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4232 
    except TransactionServiceException, ex:
4233 
      result.ex = ex
4234 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
3553 chandransh 4239 
  def process_addDelayReason(self, seqid, iprot, oprot):
4240 
    args = addDelayReason_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = addDelayReason_result()
4244 
    try:
3986 chandransh 4245 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4246 
    except TransactionServiceException, ex:
4247 
      result.ex = ex
4248 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
3469 chandransh 4252 
 
3956 chandransh 4253 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4254 
    args = reconcileCodCollection_args()
4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
4257 
    result = reconcileCodCollection_result()
4258 
    try:
4259 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4260 
    except TransactionServiceException, ex:
4261 
      result.ex = ex
4262 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
3553 chandransh 4266 
 
4008 mandeep.dh 4267 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4268 
    args = getTransactionsRequiringExtraProcessing_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = getTransactionsRequiringExtraProcessing_result()
4272 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4273 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
3956 chandransh 4277 
 
4008 mandeep.dh 4278 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4279 
    args = markTransactionAsProcessed_args()
4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
4282 
    result = markTransactionAsProcessed_result()
4283 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4284 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
4288 
 
4018 chandransh 4289 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4290 
    args = getItemWiseRiskyOrdersCount_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = getItemWiseRiskyOrdersCount_result()
4294 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4295 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4296 
    result.write(oprot)
4297 
    oprot.writeMessageEnd()
4298 
    oprot.trans.flush()
4008 mandeep.dh 4299 
 
4295 varun.gupt 4300 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4301 
    args = getOrdersForItemIds_args()
4302 
    args.read(iprot)
4303 
    iprot.readMessageEnd()
4304 
    result = getOrdersForItemIds_result()
4305 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4306 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4307 
    result.write(oprot)
4308 
    oprot.writeMessageEnd()
4309 
    oprot.trans.flush()
4310 
 
4247 rajveer 4311 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4312 
    args = markOrderCancellationRequestReceived_args()
4313 
    args.read(iprot)
4314 
    iprot.readMessageEnd()
4315 
    result = markOrderCancellationRequestReceived_result()
4316 
    try:
4317 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4318 
    except TransactionServiceException, ex:
4319 
      result.ex = ex
4320 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4321 
    result.write(oprot)
4322 
    oprot.writeMessageEnd()
4323 
    oprot.trans.flush()
4018 chandransh 4324 
 
4247 rajveer 4325 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4326 
    args = markOrderCancellationRequestConfirmed_args()
4327 
    args.read(iprot)
4328 
    iprot.readMessageEnd()
4329 
    result = markOrderCancellationRequestConfirmed_result()
4330 
    try:
4331 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4332 
    except TransactionServiceException, ex:
4333 
      result.ex = ex
4334 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4335 
    result.write(oprot)
4336 
    oprot.writeMessageEnd()
4337 
    oprot.trans.flush()
4338 
 
4339 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4340 
    args = markOrderCancellationRequestDenied_args()
4341 
    args.read(iprot)
4342 
    iprot.readMessageEnd()
4343 
    result = markOrderCancellationRequestDenied_result()
4344 
    try:
4345 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4346 
    except TransactionServiceException, ex:
4347 
      result.ex = ex
4348 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4349 
    result.write(oprot)
4350 
    oprot.writeMessageEnd()
4351 
    oprot.trans.flush()
4352 
 
4258 rajveer 4353 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4354 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4355 
    args.read(iprot)
4356 
    iprot.readMessageEnd()
4258 rajveer 4357 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4358 
    try:
4258 rajveer 4359 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4360 
    except TransactionServiceException, ex:
4361 
      result.ex = ex
4258 rajveer 4362 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
4259 anupam.sin 4367 
  def process_refundTransaction(self, seqid, iprot, oprot):
4368 
    args = refundTransaction_args()
4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
4371 
    result = refundTransaction_result()
4372 
    try:
4373 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4374 
    except TransactionServiceException, ex:
4375 
      result.ex = ex
4376 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4377 
    result.write(oprot)
4378 
    oprot.writeMessageEnd()
4379 
    oprot.trans.flush()
4247 rajveer 4380 
 
4324 mandeep.dh 4381 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4382 
    args = updateShipmentAddress_args()
4383 
    args.read(iprot)
4384 
    iprot.readMessageEnd()
4385 
    result = updateShipmentAddress_result()
4386 
    try:
4387 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4388 
    except TransactionServiceException, ex:
4389 
      result.ex = ex
4390 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4391 
    result.write(oprot)
4392 
    oprot.writeMessageEnd()
4393 
    oprot.trans.flush()
4394 
 
4285 rajveer 4395 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4396 
    args = acceptOrdersForItemId_args()
4397 
    args.read(iprot)
4398 
    iprot.readMessageEnd()
4399 
    result = acceptOrdersForItemId_result()
4400 
    try:
4401 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4402 
    except TransactionServiceException, ex:
4403 
      result.ex = ex
4404 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4405 
    result.write(oprot)
4406 
    oprot.writeMessageEnd()
4407 
    oprot.trans.flush()
4259 anupam.sin 4408 
 
4303 rajveer 4409 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4410 
    args = markOrdersAsPORaised_args()
4411 
    args.read(iprot)
4412 
    iprot.readMessageEnd()
4413 
    result = markOrdersAsPORaised_result()
4414 
    try:
4369 rajveer 4415 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4416 
    except TransactionServiceException, ex:
4417 
      result.ex = ex
4418 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4419 
    result.write(oprot)
4420 
    oprot.writeMessageEnd()
4421 
    oprot.trans.flush()
4285 rajveer 4422 
 
4303 rajveer 4423 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4424 
    args = markOrdersAsReversalInitiated_args()
4425 
    args.read(iprot)
4426 
    iprot.readMessageEnd()
4427 
    result = markOrdersAsReversalInitiated_result()
4428 
    try:
4369 rajveer 4429 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4430 
    except TransactionServiceException, ex:
4431 
      result.ex = ex
4432 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4433 
    result.write(oprot)
4434 
    oprot.writeMessageEnd()
4435 
    oprot.trans.flush()
4436 
 
4437 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4438 
    args = markOrdersAsNotAvailabke_args()
4439 
    args.read(iprot)
4440 
    iprot.readMessageEnd()
4441 
    result = markOrdersAsNotAvailabke_result()
4442 
    try:
4369 rajveer 4443 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4444 
    except TransactionServiceException, ex:
4445 
      result.ex = ex
4446 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
4369 rajveer 4451 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4452 
    args = markOrdersAsTimeout_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = markOrdersAsTimeout_result()
4456 
    try:
4457 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4458 
    except TransactionServiceException, ex:
4459 
      result.ex = ex
4460 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4303 rajveer 4464 
 
4386 anupam.sin 4465 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4466 
    args = getOrderForAwb_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = getOrderForAwb_result()
4470 
    try:
4471 
      result.success = self._handler.getOrderForAwb(args.awb)
4472 
    except TransactionServiceException, ex:
4473 
      result.ex = ex
4474 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4475 
    result.write(oprot)
4476 
    oprot.writeMessageEnd()
4477 
    oprot.trans.flush()
4369 rajveer 4478 
 
4386 anupam.sin 4479 
 
94 ashish 4480 
# HELPER FUNCTIONS AND STRUCTURES
4481 
 
4482 
class createTransaction_args:
4483 
  """
4484 
  Attributes:
4485 
   - transaction
4486 
  """
4487 
 
4488 
  thrift_spec = (
4489 
    None, # 0
4490 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4491 
  )
4492 
 
4493 
  def __init__(self, transaction=None,):
4494 
    self.transaction = transaction
4495 
 
4496 
  def read(self, iprot):
4497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4499 
      return
4500 
    iprot.readStructBegin()
4501 
    while True:
4502 
      (fname, ftype, fid) = iprot.readFieldBegin()
4503 
      if ftype == TType.STOP:
4504 
        break
4505 
      if fid == 1:
4506 
        if ftype == TType.STRUCT:
4507 
          self.transaction = Transaction()
4508 
          self.transaction.read(iprot)
4509 
        else:
4510 
          iprot.skip(ftype)
4511 
      else:
4512 
        iprot.skip(ftype)
4513 
      iprot.readFieldEnd()
4514 
    iprot.readStructEnd()
4515 
 
4516 
  def write(self, oprot):
4517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4519 
      return
4520 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4521 
    if self.transaction is not None:
94 ashish 4522 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4523 
      self.transaction.write(oprot)
4524 
      oprot.writeFieldEnd()
4525 
    oprot.writeFieldStop()
4526 
    oprot.writeStructEnd()
4527 
 
3431 rajveer 4528 
  def validate(self):
4529 
    return
4530 
 
4531 
 
94 ashish 4532 
  def __repr__(self):
4533 
    L = ['%s=%r' % (key, value)
4534 
      for key, value in self.__dict__.iteritems()]
4535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4536 
 
4537 
  def __eq__(self, other):
4538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4539 
 
4540 
  def __ne__(self, other):
4541 
    return not (self == other)
4542 
 
4543 
class createTransaction_result:
4544 
  """
4545 
  Attributes:
132 ashish 4546 
   - success
94 ashish 4547 
   - ex
4548 
  """
4549 
 
4550 
  thrift_spec = (
132 ashish 4551 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4553 
  )
4554 
 
132 ashish 4555 
  def __init__(self, success=None, ex=None,):
4556 
    self.success = success
94 ashish 4557 
    self.ex = ex
4558 
 
4559 
  def read(self, iprot):
4560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4562 
      return
4563 
    iprot.readStructBegin()
4564 
    while True:
4565 
      (fname, ftype, fid) = iprot.readFieldBegin()
4566 
      if ftype == TType.STOP:
4567 
        break
132 ashish 4568 
      if fid == 0:
4569 
        if ftype == TType.I64:
4570 
          self.success = iprot.readI64();
4571 
        else:
4572 
          iprot.skip(ftype)
4573 
      elif fid == 1:
94 ashish 4574 
        if ftype == TType.STRUCT:
4575 
          self.ex = TransactionServiceException()
4576 
          self.ex.read(iprot)
4577 
        else:
4578 
          iprot.skip(ftype)
4579 
      else:
4580 
        iprot.skip(ftype)
4581 
      iprot.readFieldEnd()
4582 
    iprot.readStructEnd()
4583 
 
4584 
  def write(self, oprot):
4585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4587 
      return
4588 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4589 
    if self.success is not None:
132 ashish 4590 
      oprot.writeFieldBegin('success', TType.I64, 0)
4591 
      oprot.writeI64(self.success)
4592 
      oprot.writeFieldEnd()
3431 rajveer 4593 
    if self.ex is not None:
94 ashish 4594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4595 
      self.ex.write(oprot)
4596 
      oprot.writeFieldEnd()
4597 
    oprot.writeFieldStop()
4598 
    oprot.writeStructEnd()
4599 
 
3431 rajveer 4600 
  def validate(self):
4601 
    return
4602 
 
4603 
 
94 ashish 4604 
  def __repr__(self):
4605 
    L = ['%s=%r' % (key, value)
4606 
      for key, value in self.__dict__.iteritems()]
4607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4608 
 
4609 
  def __eq__(self, other):
4610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4611 
 
4612 
  def __ne__(self, other):
4613 
    return not (self == other)
4614 
 
4615 
class getTransaction_args:
4616 
  """
4617 
  Attributes:
4618 
   - id
4619 
  """
4620 
 
4621 
  thrift_spec = (
4622 
    None, # 0
4623 
    (1, TType.I64, 'id', None, None, ), # 1
4624 
  )
4625 
 
4626 
  def __init__(self, id=None,):
4627 
    self.id = id
4628 
 
4629 
  def read(self, iprot):
4630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4632 
      return
4633 
    iprot.readStructBegin()
4634 
    while True:
4635 
      (fname, ftype, fid) = iprot.readFieldBegin()
4636 
      if ftype == TType.STOP:
4637 
        break
4638 
      if fid == 1:
4639 
        if ftype == TType.I64:
4640 
          self.id = iprot.readI64();
4641 
        else:
4642 
          iprot.skip(ftype)
4643 
      else:
4644 
        iprot.skip(ftype)
4645 
      iprot.readFieldEnd()
4646 
    iprot.readStructEnd()
4647 
 
4648 
  def write(self, oprot):
4649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4651 
      return
4652 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4653 
    if self.id is not None:
94 ashish 4654 
      oprot.writeFieldBegin('id', TType.I64, 1)
4655 
      oprot.writeI64(self.id)
4656 
      oprot.writeFieldEnd()
4657 
    oprot.writeFieldStop()
4658 
    oprot.writeStructEnd()
4659 
 
3431 rajveer 4660 
  def validate(self):
4661 
    return
4662 
 
4663 
 
94 ashish 4664 
  def __repr__(self):
4665 
    L = ['%s=%r' % (key, value)
4666 
      for key, value in self.__dict__.iteritems()]
4667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4668 
 
4669 
  def __eq__(self, other):
4670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4671 
 
4672 
  def __ne__(self, other):
4673 
    return not (self == other)
4674 
 
4675 
class getTransaction_result:
4676 
  """
4677 
  Attributes:
4678 
   - success
4679 
   - ex
4680 
  """
4681 
 
4682 
  thrift_spec = (
4683 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4685 
  )
4686 
 
4687 
  def __init__(self, success=None, ex=None,):
4688 
    self.success = success
4689 
    self.ex = ex
4690 
 
4691 
  def read(self, iprot):
4692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4694 
      return
4695 
    iprot.readStructBegin()
4696 
    while True:
4697 
      (fname, ftype, fid) = iprot.readFieldBegin()
4698 
      if ftype == TType.STOP:
4699 
        break
4700 
      if fid == 0:
4701 
        if ftype == TType.STRUCT:
4702 
          self.success = Transaction()
4703 
          self.success.read(iprot)
4704 
        else:
4705 
          iprot.skip(ftype)
4706 
      elif fid == 1:
4707 
        if ftype == TType.STRUCT:
4708 
          self.ex = TransactionServiceException()
4709 
          self.ex.read(iprot)
4710 
        else:
4711 
          iprot.skip(ftype)
4712 
      else:
4713 
        iprot.skip(ftype)
4714 
      iprot.readFieldEnd()
4715 
    iprot.readStructEnd()
4716 
 
4717 
  def write(self, oprot):
4718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4720 
      return
4721 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4722 
    if self.success is not None:
94 ashish 4723 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4724 
      self.success.write(oprot)
4725 
      oprot.writeFieldEnd()
3431 rajveer 4726 
    if self.ex is not None:
94 ashish 4727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4728 
      self.ex.write(oprot)
4729 
      oprot.writeFieldEnd()
4730 
    oprot.writeFieldStop()
4731 
    oprot.writeStructEnd()
4732 
 
3431 rajveer 4733 
  def validate(self):
4734 
    return
4735 
 
4736 
 
94 ashish 4737 
  def __repr__(self):
4738 
    L = ['%s=%r' % (key, value)
4739 
      for key, value in self.__dict__.iteritems()]
4740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4741 
 
4742 
  def __eq__(self, other):
4743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4744 
 
4745 
  def __ne__(self, other):
4746 
    return not (self == other)
4747 
 
4748 
class getTransactionsForCustomer_args:
4749 
  """
4750 
  Attributes:
4751 
   - customerId
4752 
   - from_date
4753 
   - to_date
4754 
   - status
4755 
  """
4756 
 
4757 
  thrift_spec = (
4758 
    None, # 0
4759 
    (1, TType.I64, 'customerId', None, None, ), # 1
4760 
    (2, TType.I64, 'from_date', None, None, ), # 2
4761 
    (3, TType.I64, 'to_date', None, None, ), # 3
4762 
    (4, TType.I32, 'status', None, None, ), # 4
4763 
  )
4764 
 
4765 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4766 
    self.customerId = customerId
4767 
    self.from_date = from_date
4768 
    self.to_date = to_date
4769 
    self.status = status
4770 
 
4771 
  def read(self, iprot):
4772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4774 
      return
4775 
    iprot.readStructBegin()
4776 
    while True:
4777 
      (fname, ftype, fid) = iprot.readFieldBegin()
4778 
      if ftype == TType.STOP:
4779 
        break
4780 
      if fid == 1:
4781 
        if ftype == TType.I64:
4782 
          self.customerId = iprot.readI64();
4783 
        else:
4784 
          iprot.skip(ftype)
4785 
      elif fid == 2:
4786 
        if ftype == TType.I64:
4787 
          self.from_date = iprot.readI64();
4788 
        else:
4789 
          iprot.skip(ftype)
4790 
      elif fid == 3:
4791 
        if ftype == TType.I64:
4792 
          self.to_date = iprot.readI64();
4793 
        else:
4794 
          iprot.skip(ftype)
4795 
      elif fid == 4:
4796 
        if ftype == TType.I32:
4797 
          self.status = iprot.readI32();
4798 
        else:
4799 
          iprot.skip(ftype)
4800 
      else:
4801 
        iprot.skip(ftype)
4802 
      iprot.readFieldEnd()
4803 
    iprot.readStructEnd()
4804 
 
4805 
  def write(self, oprot):
4806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4808 
      return
4809 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4810 
    if self.customerId is not None:
94 ashish 4811 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4812 
      oprot.writeI64(self.customerId)
4813 
      oprot.writeFieldEnd()
3431 rajveer 4814 
    if self.from_date is not None:
94 ashish 4815 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4816 
      oprot.writeI64(self.from_date)
4817 
      oprot.writeFieldEnd()
3431 rajveer 4818 
    if self.to_date is not None:
94 ashish 4819 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4820 
      oprot.writeI64(self.to_date)
4821 
      oprot.writeFieldEnd()
3431 rajveer 4822 
    if self.status is not None:
94 ashish 4823 
      oprot.writeFieldBegin('status', TType.I32, 4)
4824 
      oprot.writeI32(self.status)
4825 
      oprot.writeFieldEnd()
4826 
    oprot.writeFieldStop()
4827 
    oprot.writeStructEnd()
4828 
 
3431 rajveer 4829 
  def validate(self):
4830 
    return
4831 
 
4832 
 
94 ashish 4833 
  def __repr__(self):
4834 
    L = ['%s=%r' % (key, value)
4835 
      for key, value in self.__dict__.iteritems()]
4836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4837 
 
4838 
  def __eq__(self, other):
4839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4840 
 
4841 
  def __ne__(self, other):
4842 
    return not (self == other)
4843 
 
4844 
class getTransactionsForCustomer_result:
4845 
  """
4846 
  Attributes:
4847 
   - success
4848 
   - ex
4849 
  """
4850 
 
4851 
  thrift_spec = (
4852 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4854 
  )
4855 
 
4856 
  def __init__(self, success=None, ex=None,):
4857 
    self.success = success
4858 
    self.ex = ex
4859 
 
4860 
  def read(self, iprot):
4861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4863 
      return
4864 
    iprot.readStructBegin()
4865 
    while True:
4866 
      (fname, ftype, fid) = iprot.readFieldBegin()
4867 
      if ftype == TType.STOP:
4868 
        break
4869 
      if fid == 0:
4870 
        if ftype == TType.LIST:
4871 
          self.success = []
685 chandransh 4872 
          (_etype17, _size14) = iprot.readListBegin()
4873 
          for _i18 in xrange(_size14):
4874 
            _elem19 = Transaction()
4875 
            _elem19.read(iprot)
4876 
            self.success.append(_elem19)
94 ashish 4877 
          iprot.readListEnd()
4878 
        else:
4879 
          iprot.skip(ftype)
4880 
      elif fid == 1:
4881 
        if ftype == TType.STRUCT:
4882 
          self.ex = TransactionServiceException()
4883 
          self.ex.read(iprot)
4884 
        else:
4885 
          iprot.skip(ftype)
4886 
      else:
4887 
        iprot.skip(ftype)
4888 
      iprot.readFieldEnd()
4889 
    iprot.readStructEnd()
4890 
 
4891 
  def write(self, oprot):
4892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4894 
      return
4895 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4896 
    if self.success is not None:
94 ashish 4897 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4898 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4899 
      for iter20 in self.success:
4900 
        iter20.write(oprot)
94 ashish 4901 
      oprot.writeListEnd()
4902 
      oprot.writeFieldEnd()
3431 rajveer 4903 
    if self.ex is not None:
94 ashish 4904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4905 
      self.ex.write(oprot)
4906 
      oprot.writeFieldEnd()
4907 
    oprot.writeFieldStop()
4908 
    oprot.writeStructEnd()
4909 
 
3431 rajveer 4910 
  def validate(self):
4911 
    return
4912 
 
4913 
 
94 ashish 4914 
  def __repr__(self):
4915 
    L = ['%s=%r' % (key, value)
4916 
      for key, value in self.__dict__.iteritems()]
4917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4918 
 
4919 
  def __eq__(self, other):
4920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4921 
 
4922 
  def __ne__(self, other):
4923 
    return not (self == other)
4924 
 
132 ashish 4925 
class getTransactionsForShoppingCartId_args:
4926 
  """
4927 
  Attributes:
4928 
   - shoppingCartId
4929 
  """
4930 
 
4931 
  thrift_spec = (
4932 
    None, # 0
4933 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4934 
  )
4935 
 
4936 
  def __init__(self, shoppingCartId=None,):
4937 
    self.shoppingCartId = shoppingCartId
4938 
 
4939 
  def read(self, iprot):
4940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4942 
      return
4943 
    iprot.readStructBegin()
4944 
    while True:
4945 
      (fname, ftype, fid) = iprot.readFieldBegin()
4946 
      if ftype == TType.STOP:
4947 
        break
4948 
      if fid == 1:
4949 
        if ftype == TType.I64:
4950 
          self.shoppingCartId = iprot.readI64();
4951 
        else:
4952 
          iprot.skip(ftype)
4953 
      else:
4954 
        iprot.skip(ftype)
4955 
      iprot.readFieldEnd()
4956 
    iprot.readStructEnd()
4957 
 
4958 
  def write(self, oprot):
4959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4961 
      return
4962 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4963 
    if self.shoppingCartId is not None:
132 ashish 4964 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4965 
      oprot.writeI64(self.shoppingCartId)
4966 
      oprot.writeFieldEnd()
4967 
    oprot.writeFieldStop()
4968 
    oprot.writeStructEnd()
4969 
 
3431 rajveer 4970 
  def validate(self):
4971 
    return
4972 
 
4973 
 
132 ashish 4974 
  def __repr__(self):
4975 
    L = ['%s=%r' % (key, value)
4976 
      for key, value in self.__dict__.iteritems()]
4977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4978 
 
4979 
  def __eq__(self, other):
4980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4981 
 
4982 
  def __ne__(self, other):
4983 
    return not (self == other)
4984 
 
4985 
class getTransactionsForShoppingCartId_result:
4986 
  """
4987 
  Attributes:
4988 
   - success
4989 
   - ex
4990 
  """
4991 
 
4992 
  thrift_spec = (
4993 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4995 
  )
4996 
 
4997 
  def __init__(self, success=None, ex=None,):
4998 
    self.success = success
4999 
    self.ex = ex
5000 
 
5001 
  def read(self, iprot):
5002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5004 
      return
5005 
    iprot.readStructBegin()
5006 
    while True:
5007 
      (fname, ftype, fid) = iprot.readFieldBegin()
5008 
      if ftype == TType.STOP:
5009 
        break
5010 
      if fid == 0:
5011 
        if ftype == TType.LIST:
5012 
          self.success = []
685 chandransh 5013 
          (_etype24, _size21) = iprot.readListBegin()
5014 
          for _i25 in xrange(_size21):
5015 
            _elem26 = Transaction()
5016 
            _elem26.read(iprot)
5017 
            self.success.append(_elem26)
132 ashish 5018 
          iprot.readListEnd()
5019 
        else:
5020 
          iprot.skip(ftype)
5021 
      elif fid == 1:
5022 
        if ftype == TType.STRUCT:
5023 
          self.ex = TransactionServiceException()
5024 
          self.ex.read(iprot)
5025 
        else:
5026 
          iprot.skip(ftype)
5027 
      else:
5028 
        iprot.skip(ftype)
5029 
      iprot.readFieldEnd()
5030 
    iprot.readStructEnd()
5031 
 
5032 
  def write(self, oprot):
5033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5035 
      return
5036 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5037 
    if self.success is not None:
132 ashish 5038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5040 
      for iter27 in self.success:
5041 
        iter27.write(oprot)
132 ashish 5042 
      oprot.writeListEnd()
5043 
      oprot.writeFieldEnd()
3431 rajveer 5044 
    if self.ex is not None:
132 ashish 5045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5046 
      self.ex.write(oprot)
5047 
      oprot.writeFieldEnd()
5048 
    oprot.writeFieldStop()
5049 
    oprot.writeStructEnd()
5050 
 
3431 rajveer 5051 
  def validate(self):
5052 
    return
5053 
 
5054 
 
132 ashish 5055 
  def __repr__(self):
5056 
    L = ['%s=%r' % (key, value)
5057 
      for key, value in self.__dict__.iteritems()]
5058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5059 
 
5060 
  def __eq__(self, other):
5061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5062 
 
5063 
  def __ne__(self, other):
5064 
    return not (self == other)
5065 
 
94 ashish 5066 
class getTransactionStatus_args:
5067 
  """
5068 
  Attributes:
5069 
   - transactionId
5070 
  """
5071 
 
5072 
  thrift_spec = (
5073 
    None, # 0
5074 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5075 
  )
5076 
 
5077 
  def __init__(self, transactionId=None,):
5078 
    self.transactionId = transactionId
5079 
 
5080 
  def read(self, iprot):
5081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5083 
      return
5084 
    iprot.readStructBegin()
5085 
    while True:
5086 
      (fname, ftype, fid) = iprot.readFieldBegin()
5087 
      if ftype == TType.STOP:
5088 
        break
5089 
      if fid == 1:
5090 
        if ftype == TType.I64:
5091 
          self.transactionId = iprot.readI64();
5092 
        else:
5093 
          iprot.skip(ftype)
5094 
      else:
5095 
        iprot.skip(ftype)
5096 
      iprot.readFieldEnd()
5097 
    iprot.readStructEnd()
5098 
 
5099 
  def write(self, oprot):
5100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5102 
      return
5103 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5104 
    if self.transactionId is not None:
94 ashish 5105 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5106 
      oprot.writeI64(self.transactionId)
5107 
      oprot.writeFieldEnd()
5108 
    oprot.writeFieldStop()
5109 
    oprot.writeStructEnd()
5110 
 
3431 rajveer 5111 
  def validate(self):
5112 
    return
5113 
 
5114 
 
94 ashish 5115 
  def __repr__(self):
5116 
    L = ['%s=%r' % (key, value)
5117 
      for key, value in self.__dict__.iteritems()]
5118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5119 
 
5120 
  def __eq__(self, other):
5121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5122 
 
5123 
  def __ne__(self, other):
5124 
    return not (self == other)
5125 
 
5126 
class getTransactionStatus_result:
5127 
  """
5128 
  Attributes:
5129 
   - success
5130 
   - ex
5131 
  """
5132 
 
5133 
  thrift_spec = (
5134 
    (0, TType.I32, 'success', None, None, ), # 0
5135 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5136 
  )
5137 
 
5138 
  def __init__(self, success=None, ex=None,):
5139 
    self.success = success
5140 
    self.ex = ex
5141 
 
5142 
  def read(self, iprot):
5143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5145 
      return
5146 
    iprot.readStructBegin()
5147 
    while True:
5148 
      (fname, ftype, fid) = iprot.readFieldBegin()
5149 
      if ftype == TType.STOP:
5150 
        break
5151 
      if fid == 0:
5152 
        if ftype == TType.I32:
5153 
          self.success = iprot.readI32();
5154 
        else:
5155 
          iprot.skip(ftype)
5156 
      elif fid == 1:
5157 
        if ftype == TType.STRUCT:
5158 
          self.ex = TransactionServiceException()
5159 
          self.ex.read(iprot)
5160 
        else:
5161 
          iprot.skip(ftype)
5162 
      else:
5163 
        iprot.skip(ftype)
5164 
      iprot.readFieldEnd()
5165 
    iprot.readStructEnd()
5166 
 
5167 
  def write(self, oprot):
5168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5170 
      return
5171 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5172 
    if self.success is not None:
94 ashish 5173 
      oprot.writeFieldBegin('success', TType.I32, 0)
5174 
      oprot.writeI32(self.success)
5175 
      oprot.writeFieldEnd()
3431 rajveer 5176 
    if self.ex is not None:
94 ashish 5177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5178 
      self.ex.write(oprot)
5179 
      oprot.writeFieldEnd()
5180 
    oprot.writeFieldStop()
5181 
    oprot.writeStructEnd()
5182 
 
3431 rajveer 5183 
  def validate(self):
5184 
    return
5185 
 
5186 
 
94 ashish 5187 
  def __repr__(self):
5188 
    L = ['%s=%r' % (key, value)
5189 
      for key, value in self.__dict__.iteritems()]
5190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5191 
 
5192 
  def __eq__(self, other):
5193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5194 
 
5195 
  def __ne__(self, other):
5196 
    return not (self == other)
5197 
 
5198 
class changeTransactionStatus_args:
5199 
  """
5200 
  Attributes:
5201 
   - transactionId
5202 
   - status
5203 
   - description
5204 
  """
5205 
 
5206 
  thrift_spec = (
5207 
    None, # 0
5208 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5209 
    (2, TType.I32, 'status', None, None, ), # 2
5210 
    (3, TType.STRING, 'description', None, None, ), # 3
5211 
  )
5212 
 
5213 
  def __init__(self, transactionId=None, status=None, description=None,):
5214 
    self.transactionId = transactionId
5215 
    self.status = status
5216 
    self.description = description
5217 
 
5218 
  def read(self, iprot):
5219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5221 
      return
5222 
    iprot.readStructBegin()
5223 
    while True:
5224 
      (fname, ftype, fid) = iprot.readFieldBegin()
5225 
      if ftype == TType.STOP:
5226 
        break
5227 
      if fid == 1:
5228 
        if ftype == TType.I64:
5229 
          self.transactionId = iprot.readI64();
5230 
        else:
5231 
          iprot.skip(ftype)
5232 
      elif fid == 2:
5233 
        if ftype == TType.I32:
5234 
          self.status = iprot.readI32();
5235 
        else:
5236 
          iprot.skip(ftype)
5237 
      elif fid == 3:
5238 
        if ftype == TType.STRING:
5239 
          self.description = iprot.readString();
5240 
        else:
5241 
          iprot.skip(ftype)
5242 
      else:
5243 
        iprot.skip(ftype)
5244 
      iprot.readFieldEnd()
5245 
    iprot.readStructEnd()
5246 
 
5247 
  def write(self, oprot):
5248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5250 
      return
5251 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5252 
    if self.transactionId is not None:
94 ashish 5253 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5254 
      oprot.writeI64(self.transactionId)
5255 
      oprot.writeFieldEnd()
3431 rajveer 5256 
    if self.status is not None:
94 ashish 5257 
      oprot.writeFieldBegin('status', TType.I32, 2)
5258 
      oprot.writeI32(self.status)
5259 
      oprot.writeFieldEnd()
3431 rajveer 5260 
    if self.description is not None:
94 ashish 5261 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5262 
      oprot.writeString(self.description)
5263 
      oprot.writeFieldEnd()
5264 
    oprot.writeFieldStop()
5265 
    oprot.writeStructEnd()
5266 
 
3431 rajveer 5267 
  def validate(self):
5268 
    return
5269 
 
5270 
 
94 ashish 5271 
  def __repr__(self):
5272 
    L = ['%s=%r' % (key, value)
5273 
      for key, value in self.__dict__.iteritems()]
5274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5275 
 
5276 
  def __eq__(self, other):
5277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5278 
 
5279 
  def __ne__(self, other):
5280 
    return not (self == other)
5281 
 
5282 
class changeTransactionStatus_result:
5283 
  """
5284 
  Attributes:
5285 
   - success
5286 
   - ex
5287 
  """
5288 
 
5289 
  thrift_spec = (
5290 
    (0, TType.BOOL, 'success', None, None, ), # 0
5291 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5292 
  )
5293 
 
5294 
  def __init__(self, success=None, ex=None,):
5295 
    self.success = success
5296 
    self.ex = ex
5297 
 
5298 
  def read(self, iprot):
5299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5301 
      return
5302 
    iprot.readStructBegin()
5303 
    while True:
5304 
      (fname, ftype, fid) = iprot.readFieldBegin()
5305 
      if ftype == TType.STOP:
5306 
        break
5307 
      if fid == 0:
5308 
        if ftype == TType.BOOL:
5309 
          self.success = iprot.readBool();
5310 
        else:
5311 
          iprot.skip(ftype)
5312 
      elif fid == 1:
5313 
        if ftype == TType.STRUCT:
5314 
          self.ex = TransactionServiceException()
5315 
          self.ex.read(iprot)
5316 
        else:
5317 
          iprot.skip(ftype)
5318 
      else:
5319 
        iprot.skip(ftype)
5320 
      iprot.readFieldEnd()
5321 
    iprot.readStructEnd()
5322 
 
5323 
  def write(self, oprot):
5324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5326 
      return
5327 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5328 
    if self.success is not None:
94 ashish 5329 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5330 
      oprot.writeBool(self.success)
5331 
      oprot.writeFieldEnd()
3431 rajveer 5332 
    if self.ex is not None:
94 ashish 5333 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5334 
      self.ex.write(oprot)
5335 
      oprot.writeFieldEnd()
5336 
    oprot.writeFieldStop()
5337 
    oprot.writeStructEnd()
5338 
 
3431 rajveer 5339 
  def validate(self):
5340 
    return
5341 
 
5342 
 
94 ashish 5343 
  def __repr__(self):
5344 
    L = ['%s=%r' % (key, value)
5345 
      for key, value in self.__dict__.iteritems()]
5346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5347 
 
5348 
  def __eq__(self, other):
5349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5350 
 
5351 
  def __ne__(self, other):
5352 
    return not (self == other)
5353 
 
1398 varun.gupt 5354 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5355 
  """
5356 
  Attributes:
5357 
   - transactionId
5358 
  """
5359 
 
5360 
  thrift_spec = (
5361 
    None, # 0
5362 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5363 
  )
5364 
 
5365 
  def __init__(self, transactionId=None,):
5366 
    self.transactionId = transactionId
5367 
 
5368 
  def read(self, iprot):
5369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5371 
      return
5372 
    iprot.readStructBegin()
5373 
    while True:
5374 
      (fname, ftype, fid) = iprot.readFieldBegin()
5375 
      if ftype == TType.STOP:
5376 
        break
5377 
      if fid == 1:
5378 
        if ftype == TType.I64:
5379 
          self.transactionId = iprot.readI64();
5380 
        else:
5381 
          iprot.skip(ftype)
5382 
      else:
5383 
        iprot.skip(ftype)
5384 
      iprot.readFieldEnd()
5385 
    iprot.readStructEnd()
5386 
 
5387 
  def write(self, oprot):
5388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5390 
      return
1398 varun.gupt 5391 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5392 
    if self.transactionId is not None:
1382 varun.gupt 5393 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5394 
      oprot.writeI64(self.transactionId)
5395 
      oprot.writeFieldEnd()
5396 
    oprot.writeFieldStop()
5397 
    oprot.writeStructEnd()
5398 
 
3431 rajveer 5399 
  def validate(self):
5400 
    return
5401 
 
5402 
 
1382 varun.gupt 5403 
  def __repr__(self):
5404 
    L = ['%s=%r' % (key, value)
5405 
      for key, value in self.__dict__.iteritems()]
5406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5407 
 
5408 
  def __eq__(self, other):
5409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5410 
 
5411 
  def __ne__(self, other):
5412 
    return not (self == other)
5413 
 
1398 varun.gupt 5414 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5415 
  """
5416 
  Attributes:
5417 
   - success
5418 
   - ex
5419 
  """
5420 
 
5421 
  thrift_spec = (
5422 
    (0, TType.BOOL, 'success', None, None, ), # 0
5423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5424 
  )
5425 
 
5426 
  def __init__(self, success=None, ex=None,):
5427 
    self.success = success
5428 
    self.ex = ex
5429 
 
5430 
  def read(self, iprot):
5431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5433 
      return
5434 
    iprot.readStructBegin()
5435 
    while True:
5436 
      (fname, ftype, fid) = iprot.readFieldBegin()
5437 
      if ftype == TType.STOP:
5438 
        break
5439 
      if fid == 0:
5440 
        if ftype == TType.BOOL:
5441 
          self.success = iprot.readBool();
5442 
        else:
5443 
          iprot.skip(ftype)
5444 
      elif fid == 1:
5445 
        if ftype == TType.STRUCT:
5446 
          self.ex = TransactionServiceException()
5447 
          self.ex.read(iprot)
5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      else:
5451 
        iprot.skip(ftype)
5452 
      iprot.readFieldEnd()
5453 
    iprot.readStructEnd()
5454 
 
5455 
  def write(self, oprot):
5456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5458 
      return
1398 varun.gupt 5459 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5460 
    if self.success is not None:
1382 varun.gupt 5461 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5462 
      oprot.writeBool(self.success)
5463 
      oprot.writeFieldEnd()
3431 rajveer 5464 
    if self.ex is not None:
1382 varun.gupt 5465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5466 
      self.ex.write(oprot)
5467 
      oprot.writeFieldEnd()
5468 
    oprot.writeFieldStop()
5469 
    oprot.writeStructEnd()
5470 
 
3431 rajveer 5471 
  def validate(self):
5472 
    return
5473 
 
5474 
 
1382 varun.gupt 5475 
  def __repr__(self):
5476 
    L = ['%s=%r' % (key, value)
5477 
      for key, value in self.__dict__.iteritems()]
5478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5479 
 
5480 
  def __eq__(self, other):
5481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5482 
 
5483 
  def __ne__(self, other):
5484 
    return not (self == other)
5485 
 
483 rajveer 5486 
class getAllOrders_args:
94 ashish 5487 
  """
5488 
  Attributes:
483 rajveer 5489 
   - status
5490 
   - from_date
5491 
   - to_date
5492 
   - warehouse_id
94 ashish 5493 
  """
5494 
 
5495 
  thrift_spec = (
5496 
    None, # 0
483 rajveer 5497 
    (1, TType.I32, 'status', None, None, ), # 1
5498 
    (2, TType.I64, 'from_date', None, None, ), # 2
5499 
    (3, TType.I64, 'to_date', None, None, ), # 3
5500 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5501 
  )
5502 
 
483 rajveer 5503 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5504 
    self.status = status
5505 
    self.from_date = from_date
5506 
    self.to_date = to_date
5507 
    self.warehouse_id = warehouse_id
94 ashish 5508 
 
5509 
  def read(self, iprot):
5510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5512 
      return
5513 
    iprot.readStructBegin()
5514 
    while True:
5515 
      (fname, ftype, fid) = iprot.readFieldBegin()
5516 
      if ftype == TType.STOP:
5517 
        break
5518 
      if fid == 1:
483 rajveer 5519 
        if ftype == TType.I32:
5520 
          self.status = iprot.readI32();
94 ashish 5521 
        else:
5522 
          iprot.skip(ftype)
483 rajveer 5523 
      elif fid == 2:
5524 
        if ftype == TType.I64:
5525 
          self.from_date = iprot.readI64();
94 ashish 5526 
        else:
5527 
          iprot.skip(ftype)
483 rajveer 5528 
      elif fid == 3:
5529 
        if ftype == TType.I64:
5530 
          self.to_date = iprot.readI64();
94 ashish 5531 
        else:
5532 
          iprot.skip(ftype)
483 rajveer 5533 
      elif fid == 4:
94 ashish 5534 
        if ftype == TType.I64:
483 rajveer 5535 
          self.warehouse_id = iprot.readI64();
94 ashish 5536 
        else:
5537 
          iprot.skip(ftype)
5538 
      else:
5539 
        iprot.skip(ftype)
5540 
      iprot.readFieldEnd()
5541 
    iprot.readStructEnd()
5542 
 
5543 
  def write(self, oprot):
5544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5546 
      return
483 rajveer 5547 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5548 
    if self.status is not None:
483 rajveer 5549 
      oprot.writeFieldBegin('status', TType.I32, 1)
5550 
      oprot.writeI32(self.status)
94 ashish 5551 
      oprot.writeFieldEnd()
3431 rajveer 5552 
    if self.from_date is not None:
483 rajveer 5553 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5554 
      oprot.writeI64(self.from_date)
94 ashish 5555 
      oprot.writeFieldEnd()
3431 rajveer 5556 
    if self.to_date is not None:
483 rajveer 5557 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5558 
      oprot.writeI64(self.to_date)
94 ashish 5559 
      oprot.writeFieldEnd()
3431 rajveer 5560 
    if self.warehouse_id is not None:
483 rajveer 5561 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5562 
      oprot.writeI64(self.warehouse_id)
94 ashish 5563 
      oprot.writeFieldEnd()
5564 
    oprot.writeFieldStop()
5565 
    oprot.writeStructEnd()
5566 
 
3431 rajveer 5567 
  def validate(self):
5568 
    return
5569 
 
5570 
 
94 ashish 5571 
  def __repr__(self):
5572 
    L = ['%s=%r' % (key, value)
5573 
      for key, value in self.__dict__.iteritems()]
5574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5575 
 
5576 
  def __eq__(self, other):
5577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5578 
 
5579 
  def __ne__(self, other):
5580 
    return not (self == other)
5581 
 
483 rajveer 5582 
class getAllOrders_result:
94 ashish 5583 
  """
5584 
  Attributes:
5585 
   - success
5586 
   - ex
5587 
  """
5588 
 
5589 
  thrift_spec = (
483 rajveer 5590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5592 
  )
5593 
 
5594 
  def __init__(self, success=None, ex=None,):
5595 
    self.success = success
5596 
    self.ex = ex
5597 
 
5598 
  def read(self, iprot):
5599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5601 
      return
5602 
    iprot.readStructBegin()
5603 
    while True:
5604 
      (fname, ftype, fid) = iprot.readFieldBegin()
5605 
      if ftype == TType.STOP:
5606 
        break
5607 
      if fid == 0:
483 rajveer 5608 
        if ftype == TType.LIST:
5609 
          self.success = []
685 chandransh 5610 
          (_etype31, _size28) = iprot.readListBegin()
5611 
          for _i32 in xrange(_size28):
5612 
            _elem33 = Order()
5613 
            _elem33.read(iprot)
5614 
            self.success.append(_elem33)
483 rajveer 5615 
          iprot.readListEnd()
94 ashish 5616 
        else:
5617 
          iprot.skip(ftype)
5618 
      elif fid == 1:
5619 
        if ftype == TType.STRUCT:
5620 
          self.ex = TransactionServiceException()
5621 
          self.ex.read(iprot)
5622 
        else:
5623 
          iprot.skip(ftype)
5624 
      else:
5625 
        iprot.skip(ftype)
5626 
      iprot.readFieldEnd()
5627 
    iprot.readStructEnd()
5628 
 
5629 
  def write(self, oprot):
5630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5632 
      return
483 rajveer 5633 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5634 
    if self.success is not None:
483 rajveer 5635 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5636 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5637 
      for iter34 in self.success:
5638 
        iter34.write(oprot)
483 rajveer 5639 
      oprot.writeListEnd()
94 ashish 5640 
      oprot.writeFieldEnd()
3431 rajveer 5641 
    if self.ex is not None:
94 ashish 5642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5643 
      self.ex.write(oprot)
5644 
      oprot.writeFieldEnd()
5645 
    oprot.writeFieldStop()
5646 
    oprot.writeStructEnd()
5647 
 
3431 rajveer 5648 
  def validate(self):
5649 
    return
5650 
 
5651 
 
94 ashish 5652 
  def __repr__(self):
5653 
    L = ['%s=%r' % (key, value)
5654 
      for key, value in self.__dict__.iteritems()]
5655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5656 
 
5657 
  def __eq__(self, other):
5658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5659 
 
5660 
  def __ne__(self, other):
5661 
    return not (self == other)
5662 
 
4133 chandransh 5663 
class getOrdersInBatch_args:
5664 
  """
5665 
  Attributes:
5666 
   - statuses
5667 
   - offset
5668 
   - limit
5669 
   - warehouse_id
5670 
  """
5671 
 
5672 
  thrift_spec = (
5673 
    None, # 0
5674 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5675 
    (2, TType.I64, 'offset', None, None, ), # 2
5676 
    (3, TType.I64, 'limit', None, None, ), # 3
5677 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5678 
  )
5679 
 
5680 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5681 
    self.statuses = statuses
5682 
    self.offset = offset
5683 
    self.limit = limit
5684 
    self.warehouse_id = warehouse_id
5685 
 
5686 
  def read(self, iprot):
5687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5689 
      return
5690 
    iprot.readStructBegin()
5691 
    while True:
5692 
      (fname, ftype, fid) = iprot.readFieldBegin()
5693 
      if ftype == TType.STOP:
5694 
        break
5695 
      if fid == 1:
5696 
        if ftype == TType.LIST:
5697 
          self.statuses = []
5698 
          (_etype38, _size35) = iprot.readListBegin()
5699 
          for _i39 in xrange(_size35):
5700 
            _elem40 = iprot.readI32();
5701 
            self.statuses.append(_elem40)
5702 
          iprot.readListEnd()
5703 
        else:
5704 
          iprot.skip(ftype)
5705 
      elif fid == 2:
5706 
        if ftype == TType.I64:
5707 
          self.offset = iprot.readI64();
5708 
        else:
5709 
          iprot.skip(ftype)
5710 
      elif fid == 3:
5711 
        if ftype == TType.I64:
5712 
          self.limit = iprot.readI64();
5713 
        else:
5714 
          iprot.skip(ftype)
5715 
      elif fid == 4:
5716 
        if ftype == TType.I64:
5717 
          self.warehouse_id = iprot.readI64();
5718 
        else:
5719 
          iprot.skip(ftype)
5720 
      else:
5721 
        iprot.skip(ftype)
5722 
      iprot.readFieldEnd()
5723 
    iprot.readStructEnd()
5724 
 
5725 
  def write(self, oprot):
5726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5728 
      return
5729 
    oprot.writeStructBegin('getOrdersInBatch_args')
5730 
    if self.statuses is not None:
5731 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5732 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5733 
      for iter41 in self.statuses:
5734 
        oprot.writeI32(iter41)
5735 
      oprot.writeListEnd()
5736 
      oprot.writeFieldEnd()
5737 
    if self.offset is not None:
5738 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5739 
      oprot.writeI64(self.offset)
5740 
      oprot.writeFieldEnd()
5741 
    if self.limit is not None:
5742 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5743 
      oprot.writeI64(self.limit)
5744 
      oprot.writeFieldEnd()
5745 
    if self.warehouse_id is not None:
5746 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5747 
      oprot.writeI64(self.warehouse_id)
5748 
      oprot.writeFieldEnd()
5749 
    oprot.writeFieldStop()
5750 
    oprot.writeStructEnd()
5751 
 
5752 
  def validate(self):
5753 
    return
5754 
 
5755 
 
5756 
  def __repr__(self):
5757 
    L = ['%s=%r' % (key, value)
5758 
      for key, value in self.__dict__.iteritems()]
5759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5760 
 
5761 
  def __eq__(self, other):
5762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5763 
 
5764 
  def __ne__(self, other):
5765 
    return not (self == other)
5766 
 
5767 
class getOrdersInBatch_result:
5768 
  """
5769 
  Attributes:
5770 
   - success
5771 
   - ex
5772 
  """
5773 
 
5774 
  thrift_spec = (
5775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5777 
  )
5778 
 
5779 
  def __init__(self, success=None, ex=None,):
5780 
    self.success = success
5781 
    self.ex = ex
5782 
 
5783 
  def read(self, iprot):
5784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5786 
      return
5787 
    iprot.readStructBegin()
5788 
    while True:
5789 
      (fname, ftype, fid) = iprot.readFieldBegin()
5790 
      if ftype == TType.STOP:
5791 
        break
5792 
      if fid == 0:
5793 
        if ftype == TType.LIST:
5794 
          self.success = []
5795 
          (_etype45, _size42) = iprot.readListBegin()
5796 
          for _i46 in xrange(_size42):
5797 
            _elem47 = Order()
5798 
            _elem47.read(iprot)
5799 
            self.success.append(_elem47)
5800 
          iprot.readListEnd()
5801 
        else:
5802 
          iprot.skip(ftype)
5803 
      elif fid == 1:
5804 
        if ftype == TType.STRUCT:
5805 
          self.ex = TransactionServiceException()
5806 
          self.ex.read(iprot)
5807 
        else:
5808 
          iprot.skip(ftype)
5809 
      else:
5810 
        iprot.skip(ftype)
5811 
      iprot.readFieldEnd()
5812 
    iprot.readStructEnd()
5813 
 
5814 
  def write(self, oprot):
5815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5817 
      return
5818 
    oprot.writeStructBegin('getOrdersInBatch_result')
5819 
    if self.success is not None:
5820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5822 
      for iter48 in self.success:
5823 
        iter48.write(oprot)
5824 
      oprot.writeListEnd()
5825 
      oprot.writeFieldEnd()
5826 
    if self.ex is not None:
5827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5828 
      self.ex.write(oprot)
5829 
      oprot.writeFieldEnd()
5830 
    oprot.writeFieldStop()
5831 
    oprot.writeStructEnd()
5832 
 
5833 
  def validate(self):
5834 
    return
5835 
 
5836 
 
5837 
  def __repr__(self):
5838 
    L = ['%s=%r' % (key, value)
5839 
      for key, value in self.__dict__.iteritems()]
5840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5841 
 
5842 
  def __eq__(self, other):
5843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5844 
 
5845 
  def __ne__(self, other):
5846 
    return not (self == other)
5847 
 
5848 
class getOrderCount_args:
5849 
  """
5850 
  Attributes:
5851 
   - statuses
5852 
   - warehouseId
5853 
  """
5854 
 
5855 
  thrift_spec = (
5856 
    None, # 0
5857 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5858 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5859 
  )
5860 
 
5861 
  def __init__(self, statuses=None, warehouseId=None,):
5862 
    self.statuses = statuses
5863 
    self.warehouseId = warehouseId
5864 
 
5865 
  def read(self, iprot):
5866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5868 
      return
5869 
    iprot.readStructBegin()
5870 
    while True:
5871 
      (fname, ftype, fid) = iprot.readFieldBegin()
5872 
      if ftype == TType.STOP:
5873 
        break
5874 
      if fid == 1:
5875 
        if ftype == TType.LIST:
5876 
          self.statuses = []
5877 
          (_etype52, _size49) = iprot.readListBegin()
5878 
          for _i53 in xrange(_size49):
5879 
            _elem54 = iprot.readI32();
5880 
            self.statuses.append(_elem54)
5881 
          iprot.readListEnd()
5882 
        else:
5883 
          iprot.skip(ftype)
5884 
      elif fid == 2:
5885 
        if ftype == TType.I64:
5886 
          self.warehouseId = iprot.readI64();
5887 
        else:
5888 
          iprot.skip(ftype)
5889 
      else:
5890 
        iprot.skip(ftype)
5891 
      iprot.readFieldEnd()
5892 
    iprot.readStructEnd()
5893 
 
5894 
  def write(self, oprot):
5895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5897 
      return
5898 
    oprot.writeStructBegin('getOrderCount_args')
5899 
    if self.statuses is not None:
5900 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5901 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5902 
      for iter55 in self.statuses:
5903 
        oprot.writeI32(iter55)
5904 
      oprot.writeListEnd()
5905 
      oprot.writeFieldEnd()
5906 
    if self.warehouseId is not None:
5907 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5908 
      oprot.writeI64(self.warehouseId)
5909 
      oprot.writeFieldEnd()
5910 
    oprot.writeFieldStop()
5911 
    oprot.writeStructEnd()
5912 
 
5913 
  def validate(self):
5914 
    return
5915 
 
5916 
 
5917 
  def __repr__(self):
5918 
    L = ['%s=%r' % (key, value)
5919 
      for key, value in self.__dict__.iteritems()]
5920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5921 
 
5922 
  def __eq__(self, other):
5923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5924 
 
5925 
  def __ne__(self, other):
5926 
    return not (self == other)
5927 
 
5928 
class getOrderCount_result:
5929 
  """
5930 
  Attributes:
5931 
   - success
5932 
   - ex
5933 
  """
5934 
 
5935 
  thrift_spec = (
5936 
    (0, TType.I32, 'success', None, None, ), # 0
5937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5938 
  )
5939 
 
5940 
  def __init__(self, success=None, ex=None,):
5941 
    self.success = success
5942 
    self.ex = ex
5943 
 
5944 
  def read(self, iprot):
5945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5947 
      return
5948 
    iprot.readStructBegin()
5949 
    while True:
5950 
      (fname, ftype, fid) = iprot.readFieldBegin()
5951 
      if ftype == TType.STOP:
5952 
        break
5953 
      if fid == 0:
5954 
        if ftype == TType.I32:
5955 
          self.success = iprot.readI32();
5956 
        else:
5957 
          iprot.skip(ftype)
5958 
      elif fid == 1:
5959 
        if ftype == TType.STRUCT:
5960 
          self.ex = TransactionServiceException()
5961 
          self.ex.read(iprot)
5962 
        else:
5963 
          iprot.skip(ftype)
5964 
      else:
5965 
        iprot.skip(ftype)
5966 
      iprot.readFieldEnd()
5967 
    iprot.readStructEnd()
5968 
 
5969 
  def write(self, oprot):
5970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5972 
      return
5973 
    oprot.writeStructBegin('getOrderCount_result')
5974 
    if self.success is not None:
5975 
      oprot.writeFieldBegin('success', TType.I32, 0)
5976 
      oprot.writeI32(self.success)
5977 
      oprot.writeFieldEnd()
5978 
    if self.ex is not None:
5979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5980 
      self.ex.write(oprot)
5981 
      oprot.writeFieldEnd()
5982 
    oprot.writeFieldStop()
5983 
    oprot.writeStructEnd()
5984 
 
5985 
  def validate(self):
5986 
    return
5987 
 
5988 
 
5989 
  def __repr__(self):
5990 
    L = ['%s=%r' % (key, value)
5991 
      for key, value in self.__dict__.iteritems()]
5992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5993 
 
5994 
  def __eq__(self, other):
5995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5996 
 
5997 
  def __ne__(self, other):
5998 
    return not (self == other)
5999 
 
999 varun.gupt 6000 
class getOrdersByBillingDate_args:
6001 
  """
6002 
  Attributes:
6003 
   - status
6004 
   - start_billing_date
6005 
   - end_billing_date
6006 
   - warehouse_id
6007 
  """
6008 
 
6009 
  thrift_spec = (
6010 
    None, # 0
6011 
    (1, TType.I32, 'status', None, None, ), # 1
6012 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6013 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6014 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6015 
  )
6016 
 
6017 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6018 
    self.status = status
6019 
    self.start_billing_date = start_billing_date
6020 
    self.end_billing_date = end_billing_date
6021 
    self.warehouse_id = warehouse_id
6022 
 
6023 
  def read(self, iprot):
6024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6026 
      return
6027 
    iprot.readStructBegin()
6028 
    while True:
6029 
      (fname, ftype, fid) = iprot.readFieldBegin()
6030 
      if ftype == TType.STOP:
6031 
        break
6032 
      if fid == 1:
6033 
        if ftype == TType.I32:
6034 
          self.status = iprot.readI32();
6035 
        else:
6036 
          iprot.skip(ftype)
6037 
      elif fid == 2:
6038 
        if ftype == TType.I64:
6039 
          self.start_billing_date = iprot.readI64();
6040 
        else:
6041 
          iprot.skip(ftype)
6042 
      elif fid == 3:
6043 
        if ftype == TType.I64:
6044 
          self.end_billing_date = iprot.readI64();
6045 
        else:
6046 
          iprot.skip(ftype)
6047 
      elif fid == 4:
6048 
        if ftype == TType.I64:
6049 
          self.warehouse_id = iprot.readI64();
6050 
        else:
6051 
          iprot.skip(ftype)
6052 
      else:
6053 
        iprot.skip(ftype)
6054 
      iprot.readFieldEnd()
6055 
    iprot.readStructEnd()
6056 
 
6057 
  def write(self, oprot):
6058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6060 
      return
6061 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6062 
    if self.status is not None:
999 varun.gupt 6063 
      oprot.writeFieldBegin('status', TType.I32, 1)
6064 
      oprot.writeI32(self.status)
6065 
      oprot.writeFieldEnd()
3431 rajveer 6066 
    if self.start_billing_date is not None:
999 varun.gupt 6067 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6068 
      oprot.writeI64(self.start_billing_date)
6069 
      oprot.writeFieldEnd()
3431 rajveer 6070 
    if self.end_billing_date is not None:
999 varun.gupt 6071 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6072 
      oprot.writeI64(self.end_billing_date)
6073 
      oprot.writeFieldEnd()
3431 rajveer 6074 
    if self.warehouse_id is not None:
999 varun.gupt 6075 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6076 
      oprot.writeI64(self.warehouse_id)
6077 
      oprot.writeFieldEnd()
6078 
    oprot.writeFieldStop()
6079 
    oprot.writeStructEnd()
6080 
 
3431 rajveer 6081 
  def validate(self):
6082 
    return
6083 
 
6084 
 
999 varun.gupt 6085 
  def __repr__(self):
6086 
    L = ['%s=%r' % (key, value)
6087 
      for key, value in self.__dict__.iteritems()]
6088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6089 
 
6090 
  def __eq__(self, other):
6091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6092 
 
6093 
  def __ne__(self, other):
6094 
    return not (self == other)
6095 
 
6096 
class getOrdersByBillingDate_result:
6097 
  """
6098 
  Attributes:
6099 
   - success
6100 
   - ex
6101 
  """
6102 
 
6103 
  thrift_spec = (
6104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6106 
  )
6107 
 
6108 
  def __init__(self, success=None, ex=None,):
6109 
    self.success = success
6110 
    self.ex = ex
6111 
 
6112 
  def read(self, iprot):
6113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6115 
      return
6116 
    iprot.readStructBegin()
6117 
    while True:
6118 
      (fname, ftype, fid) = iprot.readFieldBegin()
6119 
      if ftype == TType.STOP:
6120 
        break
6121 
      if fid == 0:
6122 
        if ftype == TType.LIST:
6123 
          self.success = []
4133 chandransh 6124 
          (_etype59, _size56) = iprot.readListBegin()
6125 
          for _i60 in xrange(_size56):
6126 
            _elem61 = Order()
6127 
            _elem61.read(iprot)
6128 
            self.success.append(_elem61)
999 varun.gupt 6129 
          iprot.readListEnd()
6130 
        else:
6131 
          iprot.skip(ftype)
6132 
      elif fid == 1:
6133 
        if ftype == TType.STRUCT:
6134 
          self.ex = TransactionServiceException()
6135 
          self.ex.read(iprot)
6136 
        else:
6137 
          iprot.skip(ftype)
6138 
      else:
6139 
        iprot.skip(ftype)
6140 
      iprot.readFieldEnd()
6141 
    iprot.readStructEnd()
6142 
 
6143 
  def write(self, oprot):
6144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6146 
      return
6147 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6148 
    if self.success is not None:
999 varun.gupt 6149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6151 
      for iter62 in self.success:
6152 
        iter62.write(oprot)
999 varun.gupt 6153 
      oprot.writeListEnd()
6154 
      oprot.writeFieldEnd()
3431 rajveer 6155 
    if self.ex is not None:
999 varun.gupt 6156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6157 
      self.ex.write(oprot)
6158 
      oprot.writeFieldEnd()
6159 
    oprot.writeFieldStop()
6160 
    oprot.writeStructEnd()
6161 
 
3431 rajveer 6162 
  def validate(self):
6163 
    return
6164 
 
6165 
 
999 varun.gupt 6166 
  def __repr__(self):
6167 
    L = ['%s=%r' % (key, value)
6168 
      for key, value in self.__dict__.iteritems()]
6169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6170 
 
6171 
  def __eq__(self, other):
6172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6173 
 
6174 
  def __ne__(self, other):
6175 
    return not (self == other)
6176 
 
3427 chandransh 6177 
class getOrdersByShippingDate_args:
6178 
  """
6179 
  Attributes:
6180 
   - fromShippingDate
6181 
   - toShippingDate
6182 
   - providerId
6183 
   - warehouseId
3451 chandransh 6184 
   - cod
3427 chandransh 6185 
  """
6186 
 
6187 
  thrift_spec = (
6188 
    None, # 0
6189 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6190 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6191 
    (3, TType.I64, 'providerId', None, None, ), # 3
6192 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6193 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6194 
  )
6195 
 
3451 chandransh 6196 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6197 
    self.fromShippingDate = fromShippingDate
6198 
    self.toShippingDate = toShippingDate
6199 
    self.providerId = providerId
6200 
    self.warehouseId = warehouseId
3451 chandransh 6201 
    self.cod = cod
3427 chandransh 6202 
 
6203 
  def read(self, iprot):
6204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6206 
      return
6207 
    iprot.readStructBegin()
6208 
    while True:
6209 
      (fname, ftype, fid) = iprot.readFieldBegin()
6210 
      if ftype == TType.STOP:
6211 
        break
6212 
      if fid == 1:
6213 
        if ftype == TType.I64:
6214 
          self.fromShippingDate = iprot.readI64();
6215 
        else:
6216 
          iprot.skip(ftype)
6217 
      elif fid == 2:
6218 
        if ftype == TType.I64:
6219 
          self.toShippingDate = iprot.readI64();
6220 
        else:
6221 
          iprot.skip(ftype)
6222 
      elif fid == 3:
6223 
        if ftype == TType.I64:
6224 
          self.providerId = iprot.readI64();
6225 
        else:
6226 
          iprot.skip(ftype)
6227 
      elif fid == 4:
6228 
        if ftype == TType.I64:
6229 
          self.warehouseId = iprot.readI64();
6230 
        else:
6231 
          iprot.skip(ftype)
3451 chandransh 6232 
      elif fid == 5:
6233 
        if ftype == TType.BOOL:
6234 
          self.cod = iprot.readBool();
6235 
        else:
6236 
          iprot.skip(ftype)
3427 chandransh 6237 
      else:
6238 
        iprot.skip(ftype)
6239 
      iprot.readFieldEnd()
6240 
    iprot.readStructEnd()
6241 
 
6242 
  def write(self, oprot):
6243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6245 
      return
6246 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6247 
    if self.fromShippingDate is not None:
3427 chandransh 6248 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6249 
      oprot.writeI64(self.fromShippingDate)
6250 
      oprot.writeFieldEnd()
3431 rajveer 6251 
    if self.toShippingDate is not None:
3427 chandransh 6252 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6253 
      oprot.writeI64(self.toShippingDate)
6254 
      oprot.writeFieldEnd()
3431 rajveer 6255 
    if self.providerId is not None:
3427 chandransh 6256 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6257 
      oprot.writeI64(self.providerId)
6258 
      oprot.writeFieldEnd()
3431 rajveer 6259 
    if self.warehouseId is not None:
3427 chandransh 6260 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6261 
      oprot.writeI64(self.warehouseId)
6262 
      oprot.writeFieldEnd()
3451 chandransh 6263 
    if self.cod is not None:
6264 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6265 
      oprot.writeBool(self.cod)
6266 
      oprot.writeFieldEnd()
3427 chandransh 6267 
    oprot.writeFieldStop()
6268 
    oprot.writeStructEnd()
6269 
 
3431 rajveer 6270 
  def validate(self):
6271 
    return
6272 
 
6273 
 
3427 chandransh 6274 
  def __repr__(self):
6275 
    L = ['%s=%r' % (key, value)
6276 
      for key, value in self.__dict__.iteritems()]
6277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6278 
 
6279 
  def __eq__(self, other):
6280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6281 
 
6282 
  def __ne__(self, other):
6283 
    return not (self == other)
6284 
 
6285 
class getOrdersByShippingDate_result:
6286 
  """
6287 
  Attributes:
6288 
   - success
6289 
   - ex
6290 
  """
6291 
 
6292 
  thrift_spec = (
6293 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6294 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6295 
  )
6296 
 
6297 
  def __init__(self, success=None, ex=None,):
6298 
    self.success = success
6299 
    self.ex = ex
6300 
 
6301 
  def read(self, iprot):
6302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6304 
      return
6305 
    iprot.readStructBegin()
6306 
    while True:
6307 
      (fname, ftype, fid) = iprot.readFieldBegin()
6308 
      if ftype == TType.STOP:
6309 
        break
6310 
      if fid == 0:
6311 
        if ftype == TType.LIST:
6312 
          self.success = []
4133 chandransh 6313 
          (_etype66, _size63) = iprot.readListBegin()
6314 
          for _i67 in xrange(_size63):
6315 
            _elem68 = Order()
6316 
            _elem68.read(iprot)
6317 
            self.success.append(_elem68)
3427 chandransh 6318 
          iprot.readListEnd()
6319 
        else:
6320 
          iprot.skip(ftype)
6321 
      elif fid == 1:
6322 
        if ftype == TType.STRUCT:
6323 
          self.ex = TransactionServiceException()
6324 
          self.ex.read(iprot)
6325 
        else:
6326 
          iprot.skip(ftype)
6327 
      else:
6328 
        iprot.skip(ftype)
6329 
      iprot.readFieldEnd()
6330 
    iprot.readStructEnd()
6331 
 
6332 
  def write(self, oprot):
6333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6335 
      return
6336 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6337 
    if self.success is not None:
3427 chandransh 6338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6340 
      for iter69 in self.success:
6341 
        iter69.write(oprot)
3427 chandransh 6342 
      oprot.writeListEnd()
6343 
      oprot.writeFieldEnd()
3431 rajveer 6344 
    if self.ex is not None:
3427 chandransh 6345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6346 
      self.ex.write(oprot)
6347 
      oprot.writeFieldEnd()
6348 
    oprot.writeFieldStop()
6349 
    oprot.writeStructEnd()
6350 
 
3431 rajveer 6351 
  def validate(self):
6352 
    return
6353 
 
6354 
 
3427 chandransh 6355 
  def __repr__(self):
6356 
    L = ['%s=%r' % (key, value)
6357 
      for key, value in self.__dict__.iteritems()]
6358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6359 
 
6360 
  def __eq__(self, other):
6361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6362 
 
6363 
  def __ne__(self, other):
6364 
    return not (self == other)
6365 
 
1382 varun.gupt 6366 
class getReturnableOrdersForCustomer_args:
6367 
  """
6368 
  Attributes:
6369 
   - customer_id
6370 
   - limit
6371 
  """
6372 
 
6373 
  thrift_spec = (
6374 
    None, # 0
6375 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6376 
    (2, TType.I64, 'limit', None, None, ), # 2
6377 
  )
6378 
 
6379 
  def __init__(self, customer_id=None, limit=None,):
6380 
    self.customer_id = customer_id
6381 
    self.limit = limit
6382 
 
6383 
  def read(self, iprot):
6384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6386 
      return
6387 
    iprot.readStructBegin()
6388 
    while True:
6389 
      (fname, ftype, fid) = iprot.readFieldBegin()
6390 
      if ftype == TType.STOP:
6391 
        break
6392 
      if fid == 1:
6393 
        if ftype == TType.I64:
6394 
          self.customer_id = iprot.readI64();
6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      elif fid == 2:
6398 
        if ftype == TType.I64:
6399 
          self.limit = iprot.readI64();
6400 
        else:
6401 
          iprot.skip(ftype)
6402 
      else:
6403 
        iprot.skip(ftype)
6404 
      iprot.readFieldEnd()
6405 
    iprot.readStructEnd()
6406 
 
6407 
  def write(self, oprot):
6408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6410 
      return
6411 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6412 
    if self.customer_id is not None:
1382 varun.gupt 6413 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6414 
      oprot.writeI64(self.customer_id)
6415 
      oprot.writeFieldEnd()
3431 rajveer 6416 
    if self.limit is not None:
1382 varun.gupt 6417 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6418 
      oprot.writeI64(self.limit)
6419 
      oprot.writeFieldEnd()
6420 
    oprot.writeFieldStop()
6421 
    oprot.writeStructEnd()
6422 
 
3431 rajveer 6423 
  def validate(self):
6424 
    return
6425 
 
6426 
 
1382 varun.gupt 6427 
  def __repr__(self):
6428 
    L = ['%s=%r' % (key, value)
6429 
      for key, value in self.__dict__.iteritems()]
6430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6431 
 
6432 
  def __eq__(self, other):
6433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6434 
 
6435 
  def __ne__(self, other):
6436 
    return not (self == other)
6437 
 
6438 
class getReturnableOrdersForCustomer_result:
6439 
  """
6440 
  Attributes:
6441 
   - success
6442 
   - ex
6443 
  """
6444 
 
6445 
  thrift_spec = (
6446 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6448 
  )
6449 
 
6450 
  def __init__(self, success=None, ex=None,):
6451 
    self.success = success
6452 
    self.ex = ex
6453 
 
6454 
  def read(self, iprot):
6455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6457 
      return
6458 
    iprot.readStructBegin()
6459 
    while True:
6460 
      (fname, ftype, fid) = iprot.readFieldBegin()
6461 
      if ftype == TType.STOP:
6462 
        break
6463 
      if fid == 0:
6464 
        if ftype == TType.LIST:
6465 
          self.success = []
4133 chandransh 6466 
          (_etype73, _size70) = iprot.readListBegin()
6467 
          for _i74 in xrange(_size70):
6468 
            _elem75 = iprot.readI64();
6469 
            self.success.append(_elem75)
1382 varun.gupt 6470 
          iprot.readListEnd()
6471 
        else:
6472 
          iprot.skip(ftype)
6473 
      elif fid == 1:
6474 
        if ftype == TType.STRUCT:
6475 
          self.ex = TransactionServiceException()
6476 
          self.ex.read(iprot)
6477 
        else:
6478 
          iprot.skip(ftype)
6479 
      else:
6480 
        iprot.skip(ftype)
6481 
      iprot.readFieldEnd()
6482 
    iprot.readStructEnd()
6483 
 
6484 
  def write(self, oprot):
6485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6487 
      return
6488 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6489 
    if self.success is not None:
1382 varun.gupt 6490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6491 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6492 
      for iter76 in self.success:
6493 
        oprot.writeI64(iter76)
1382 varun.gupt 6494 
      oprot.writeListEnd()
6495 
      oprot.writeFieldEnd()
3431 rajveer 6496 
    if self.ex is not None:
1382 varun.gupt 6497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6498 
      self.ex.write(oprot)
6499 
      oprot.writeFieldEnd()
6500 
    oprot.writeFieldStop()
6501 
    oprot.writeStructEnd()
6502 
 
3431 rajveer 6503 
  def validate(self):
6504 
    return
6505 
 
6506 
 
1382 varun.gupt 6507 
  def __repr__(self):
6508 
    L = ['%s=%r' % (key, value)
6509 
      for key, value in self.__dict__.iteritems()]
6510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6511 
 
6512 
  def __eq__(self, other):
6513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6514 
 
6515 
  def __ne__(self, other):
6516 
    return not (self == other)
6517 
 
6518 
class getCancellableOrdersForCustomer_args:
6519 
  """
6520 
  Attributes:
6521 
   - customer_id
6522 
   - limit
6523 
  """
6524 
 
6525 
  thrift_spec = (
6526 
    None, # 0
6527 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6528 
    (2, TType.I64, 'limit', None, None, ), # 2
6529 
  )
6530 
 
6531 
  def __init__(self, customer_id=None, limit=None,):
6532 
    self.customer_id = customer_id
6533 
    self.limit = limit
6534 
 
6535 
  def read(self, iprot):
6536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6538 
      return
6539 
    iprot.readStructBegin()
6540 
    while True:
6541 
      (fname, ftype, fid) = iprot.readFieldBegin()
6542 
      if ftype == TType.STOP:
6543 
        break
6544 
      if fid == 1:
6545 
        if ftype == TType.I64:
6546 
          self.customer_id = iprot.readI64();
6547 
        else:
6548 
          iprot.skip(ftype)
6549 
      elif fid == 2:
6550 
        if ftype == TType.I64:
6551 
          self.limit = iprot.readI64();
6552 
        else:
6553 
          iprot.skip(ftype)
6554 
      else:
6555 
        iprot.skip(ftype)
6556 
      iprot.readFieldEnd()
6557 
    iprot.readStructEnd()
6558 
 
6559 
  def write(self, oprot):
6560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6562 
      return
6563 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6564 
    if self.customer_id is not None:
1382 varun.gupt 6565 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6566 
      oprot.writeI64(self.customer_id)
6567 
      oprot.writeFieldEnd()
3431 rajveer 6568 
    if self.limit is not None:
1382 varun.gupt 6569 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6570 
      oprot.writeI64(self.limit)
6571 
      oprot.writeFieldEnd()
6572 
    oprot.writeFieldStop()
6573 
    oprot.writeStructEnd()
6574 
 
3431 rajveer 6575 
  def validate(self):
6576 
    return
6577 
 
6578 
 
1382 varun.gupt 6579 
  def __repr__(self):
6580 
    L = ['%s=%r' % (key, value)
6581 
      for key, value in self.__dict__.iteritems()]
6582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6583 
 
6584 
  def __eq__(self, other):
6585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6586 
 
6587 
  def __ne__(self, other):
6588 
    return not (self == other)
6589 
 
6590 
class getCancellableOrdersForCustomer_result:
6591 
  """
6592 
  Attributes:
6593 
   - success
6594 
   - ex
6595 
  """
6596 
 
6597 
  thrift_spec = (
6598 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6600 
  )
6601 
 
6602 
  def __init__(self, success=None, ex=None,):
6603 
    self.success = success
6604 
    self.ex = ex
6605 
 
6606 
  def read(self, iprot):
6607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6609 
      return
6610 
    iprot.readStructBegin()
6611 
    while True:
6612 
      (fname, ftype, fid) = iprot.readFieldBegin()
6613 
      if ftype == TType.STOP:
6614 
        break
6615 
      if fid == 0:
6616 
        if ftype == TType.LIST:
6617 
          self.success = []
4133 chandransh 6618 
          (_etype80, _size77) = iprot.readListBegin()
6619 
          for _i81 in xrange(_size77):
6620 
            _elem82 = iprot.readI64();
6621 
            self.success.append(_elem82)
1382 varun.gupt 6622 
          iprot.readListEnd()
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      elif fid == 1:
6626 
        if ftype == TType.STRUCT:
6627 
          self.ex = TransactionServiceException()
6628 
          self.ex.read(iprot)
6629 
        else:
6630 
          iprot.skip(ftype)
6631 
      else:
6632 
        iprot.skip(ftype)
6633 
      iprot.readFieldEnd()
6634 
    iprot.readStructEnd()
6635 
 
6636 
  def write(self, oprot):
6637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6639 
      return
6640 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6641 
    if self.success is not None:
1382 varun.gupt 6642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6643 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6644 
      for iter83 in self.success:
6645 
        oprot.writeI64(iter83)
1382 varun.gupt 6646 
      oprot.writeListEnd()
6647 
      oprot.writeFieldEnd()
3431 rajveer 6648 
    if self.ex is not None:
1382 varun.gupt 6649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6650 
      self.ex.write(oprot)
6651 
      oprot.writeFieldEnd()
6652 
    oprot.writeFieldStop()
6653 
    oprot.writeStructEnd()
6654 
 
3431 rajveer 6655 
  def validate(self):
6656 
    return
6657 
 
6658 
 
1382 varun.gupt 6659 
  def __repr__(self):
6660 
    L = ['%s=%r' % (key, value)
6661 
      for key, value in self.__dict__.iteritems()]
6662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6663 
 
6664 
  def __eq__(self, other):
6665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6666 
 
6667 
  def __ne__(self, other):
6668 
    return not (self == other)
6669 
 
483 rajveer 6670 
class changeOrderStatus_args:
94 ashish 6671 
  """
6672 
  Attributes:
483 rajveer 6673 
   - orderId
6674 
   - status
6675 
   - description
94 ashish 6676 
  """
6677 
 
6678 
  thrift_spec = (
6679 
    None, # 0
483 rajveer 6680 
    (1, TType.I64, 'orderId', None, None, ), # 1
6681 
    (2, TType.I32, 'status', None, None, ), # 2
6682 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6683 
  )
6684 
 
483 rajveer 6685 
  def __init__(self, orderId=None, status=None, description=None,):
6686 
    self.orderId = orderId
6687 
    self.status = status
6688 
    self.description = description
94 ashish 6689 
 
6690 
  def read(self, iprot):
6691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6693 
      return
6694 
    iprot.readStructBegin()
6695 
    while True:
6696 
      (fname, ftype, fid) = iprot.readFieldBegin()
6697 
      if ftype == TType.STOP:
6698 
        break
6699 
      if fid == 1:
6700 
        if ftype == TType.I64:
483 rajveer 6701 
          self.orderId = iprot.readI64();
94 ashish 6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      elif fid == 2:
483 rajveer 6705 
        if ftype == TType.I32:
6706 
          self.status = iprot.readI32();
94 ashish 6707 
        else:
6708 
          iprot.skip(ftype)
483 rajveer 6709 
      elif fid == 3:
6710 
        if ftype == TType.STRING:
6711 
          self.description = iprot.readString();
6712 
        else:
6713 
          iprot.skip(ftype)
94 ashish 6714 
      else:
6715 
        iprot.skip(ftype)
6716 
      iprot.readFieldEnd()
6717 
    iprot.readStructEnd()
6718 
 
6719 
  def write(self, oprot):
6720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6722 
      return
483 rajveer 6723 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6724 
    if self.orderId is not None:
483 rajveer 6725 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6726 
      oprot.writeI64(self.orderId)
94 ashish 6727 
      oprot.writeFieldEnd()
3431 rajveer 6728 
    if self.status is not None:
483 rajveer 6729 
      oprot.writeFieldBegin('status', TType.I32, 2)
6730 
      oprot.writeI32(self.status)
94 ashish 6731 
      oprot.writeFieldEnd()
3431 rajveer 6732 
    if self.description is not None:
483 rajveer 6733 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6734 
      oprot.writeString(self.description)
6735 
      oprot.writeFieldEnd()
94 ashish 6736 
    oprot.writeFieldStop()
6737 
    oprot.writeStructEnd()
6738 
 
3431 rajveer 6739 
  def validate(self):
6740 
    return
6741 
 
6742 
 
94 ashish 6743 
  def __repr__(self):
6744 
    L = ['%s=%r' % (key, value)
6745 
      for key, value in self.__dict__.iteritems()]
6746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6747 
 
6748 
  def __eq__(self, other):
6749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6750 
 
6751 
  def __ne__(self, other):
6752 
    return not (self == other)
6753 
 
483 rajveer 6754 
class changeOrderStatus_result:
94 ashish 6755 
  """
6756 
  Attributes:
6757 
   - success
6758 
   - ex
6759 
  """
6760 
 
6761 
  thrift_spec = (
6762 
    (0, TType.BOOL, 'success', None, None, ), # 0
6763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6764 
  )
6765 
 
6766 
  def __init__(self, success=None, ex=None,):
6767 
    self.success = success
6768 
    self.ex = ex
6769 
 
6770 
  def read(self, iprot):
6771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6773 
      return
6774 
    iprot.readStructBegin()
6775 
    while True:
6776 
      (fname, ftype, fid) = iprot.readFieldBegin()
6777 
      if ftype == TType.STOP:
6778 
        break
6779 
      if fid == 0:
6780 
        if ftype == TType.BOOL:
6781 
          self.success = iprot.readBool();
6782 
        else:
6783 
          iprot.skip(ftype)
6784 
      elif fid == 1:
6785 
        if ftype == TType.STRUCT:
6786 
          self.ex = TransactionServiceException()
6787 
          self.ex.read(iprot)
6788 
        else:
6789 
          iprot.skip(ftype)
6790 
      else:
6791 
        iprot.skip(ftype)
6792 
      iprot.readFieldEnd()
6793 
    iprot.readStructEnd()
6794 
 
6795 
  def write(self, oprot):
6796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6798 
      return
483 rajveer 6799 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6800 
    if self.success is not None:
94 ashish 6801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6802 
      oprot.writeBool(self.success)
6803 
      oprot.writeFieldEnd()
3431 rajveer 6804 
    if self.ex is not None:
94 ashish 6805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6806 
      self.ex.write(oprot)
6807 
      oprot.writeFieldEnd()
6808 
    oprot.writeFieldStop()
6809 
    oprot.writeStructEnd()
6810 
 
3431 rajveer 6811 
  def validate(self):
6812 
    return
6813 
 
6814 
 
94 ashish 6815 
  def __repr__(self):
6816 
    L = ['%s=%r' % (key, value)
6817 
      for key, value in self.__dict__.iteritems()]
6818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6819 
 
6820 
  def __eq__(self, other):
6821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6822 
 
6823 
  def __ne__(self, other):
6824 
    return not (self == other)
6825 
 
3064 chandransh 6826 
class getOrdersForTransaction_args:
494 rajveer 6827 
  """
6828 
  Attributes:
3064 chandransh 6829 
   - transactionId
6830 
   - customerId
494 rajveer 6831 
  """
6832 
 
6833 
  thrift_spec = (
6834 
    None, # 0
3064 chandransh 6835 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6836 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6837 
  )
6838 
 
3064 chandransh 6839 
  def __init__(self, transactionId=None, customerId=None,):
6840 
    self.transactionId = transactionId
6841 
    self.customerId = customerId
494 rajveer 6842 
 
6843 
  def read(self, iprot):
6844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6846 
      return
6847 
    iprot.readStructBegin()
6848 
    while True:
6849 
      (fname, ftype, fid) = iprot.readFieldBegin()
6850 
      if ftype == TType.STOP:
6851 
        break
6852 
      if fid == 1:
6853 
        if ftype == TType.I64:
3064 chandransh 6854 
          self.transactionId = iprot.readI64();
494 rajveer 6855 
        else:
6856 
          iprot.skip(ftype)
6857 
      elif fid == 2:
3064 chandransh 6858 
        if ftype == TType.I64:
6859 
          self.customerId = iprot.readI64();
494 rajveer 6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      else:
6863 
        iprot.skip(ftype)
6864 
      iprot.readFieldEnd()
6865 
    iprot.readStructEnd()
6866 
 
6867 
  def write(self, oprot):
6868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6870 
      return
3064 chandransh 6871 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6872 
    if self.transactionId is not None:
3064 chandransh 6873 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6874 
      oprot.writeI64(self.transactionId)
494 rajveer 6875 
      oprot.writeFieldEnd()
3431 rajveer 6876 
    if self.customerId is not None:
3064 chandransh 6877 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6878 
      oprot.writeI64(self.customerId)
494 rajveer 6879 
      oprot.writeFieldEnd()
6880 
    oprot.writeFieldStop()
6881 
    oprot.writeStructEnd()
6882 
 
3431 rajveer 6883 
  def validate(self):
6884 
    return
6885 
 
6886 
 
494 rajveer 6887 
  def __repr__(self):
6888 
    L = ['%s=%r' % (key, value)
6889 
      for key, value in self.__dict__.iteritems()]
6890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6891 
 
6892 
  def __eq__(self, other):
6893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6894 
 
6895 
  def __ne__(self, other):
6896 
    return not (self == other)
6897 
 
3064 chandransh 6898 
class getOrdersForTransaction_result:
494 rajveer 6899 
  """
6900 
  Attributes:
6901 
   - success
6902 
   - ex
6903 
  """
6904 
 
6905 
  thrift_spec = (
3064 chandransh 6906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6908 
  )
6909 
 
6910 
  def __init__(self, success=None, ex=None,):
6911 
    self.success = success
6912 
    self.ex = ex
6913 
 
6914 
  def read(self, iprot):
6915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6917 
      return
6918 
    iprot.readStructBegin()
6919 
    while True:
6920 
      (fname, ftype, fid) = iprot.readFieldBegin()
6921 
      if ftype == TType.STOP:
6922 
        break
6923 
      if fid == 0:
3064 chandransh 6924 
        if ftype == TType.LIST:
6925 
          self.success = []
4133 chandransh 6926 
          (_etype87, _size84) = iprot.readListBegin()
6927 
          for _i88 in xrange(_size84):
6928 
            _elem89 = Order()
6929 
            _elem89.read(iprot)
6930 
            self.success.append(_elem89)
3064 chandransh 6931 
          iprot.readListEnd()
494 rajveer 6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      elif fid == 1:
6935 
        if ftype == TType.STRUCT:
6936 
          self.ex = TransactionServiceException()
6937 
          self.ex.read(iprot)
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
3064 chandransh 6949 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6950 
    if self.success is not None:
3064 chandransh 6951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6953 
      for iter90 in self.success:
6954 
        iter90.write(oprot)
3064 chandransh 6955 
      oprot.writeListEnd()
494 rajveer 6956 
      oprot.writeFieldEnd()
3431 rajveer 6957 
    if self.ex is not None:
494 rajveer 6958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6959 
      self.ex.write(oprot)
6960 
      oprot.writeFieldEnd()
6961 
    oprot.writeFieldStop()
6962 
    oprot.writeStructEnd()
6963 
 
3431 rajveer 6964 
  def validate(self):
6965 
    return
6966 
 
6967 
 
494 rajveer 6968 
  def __repr__(self):
6969 
    L = ['%s=%r' % (key, value)
6970 
      for key, value in self.__dict__.iteritems()]
6971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6972 
 
6973 
  def __eq__(self, other):
6974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6975 
 
6976 
  def __ne__(self, other):
6977 
    return not (self == other)
6978 
 
3064 chandransh 6979 
class getOrdersForCustomer_args:
1149 chandransh 6980 
  """
6981 
  Attributes:
3064 chandransh 6982 
   - customerId
6983 
   - from_date
6984 
   - to_date
6985 
   - statuses
1149 chandransh 6986 
  """
6987 
 
6988 
  thrift_spec = (
6989 
    None, # 0
3064 chandransh 6990 
    (1, TType.I64, 'customerId', None, None, ), # 1
6991 
    (2, TType.I64, 'from_date', None, None, ), # 2
6992 
    (3, TType.I64, 'to_date', None, None, ), # 3
6993 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6994 
  )
6995 
 
3064 chandransh 6996 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6997 
    self.customerId = customerId
6998 
    self.from_date = from_date
6999 
    self.to_date = to_date
7000 
    self.statuses = statuses
1149 chandransh 7001 
 
7002 
  def read(self, iprot):
7003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7005 
      return
7006 
    iprot.readStructBegin()
7007 
    while True:
7008 
      (fname, ftype, fid) = iprot.readFieldBegin()
7009 
      if ftype == TType.STOP:
7010 
        break
7011 
      if fid == 1:
7012 
        if ftype == TType.I64:
3064 chandransh 7013 
          self.customerId = iprot.readI64();
1149 chandransh 7014 
        else:
7015 
          iprot.skip(ftype)
7016 
      elif fid == 2:
7017 
        if ftype == TType.I64:
3064 chandransh 7018 
          self.from_date = iprot.readI64();
1149 chandransh 7019 
        else:
7020 
          iprot.skip(ftype)
2783 chandransh 7021 
      elif fid == 3:
7022 
        if ftype == TType.I64:
3064 chandransh 7023 
          self.to_date = iprot.readI64();
2783 chandransh 7024 
        else:
7025 
          iprot.skip(ftype)
7026 
      elif fid == 4:
3064 chandransh 7027 
        if ftype == TType.LIST:
7028 
          self.statuses = []
4133 chandransh 7029 
          (_etype94, _size91) = iprot.readListBegin()
7030 
          for _i95 in xrange(_size91):
7031 
            _elem96 = iprot.readI32();
7032 
            self.statuses.append(_elem96)
3064 chandransh 7033 
          iprot.readListEnd()
2783 chandransh 7034 
        else:
7035 
          iprot.skip(ftype)
1149 chandransh 7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
3064 chandransh 7045 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7046 
    if self.customerId is not None:
3064 chandransh 7047 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7048 
      oprot.writeI64(self.customerId)
1149 chandransh 7049 
      oprot.writeFieldEnd()
3431 rajveer 7050 
    if self.from_date is not None:
3064 chandransh 7051 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7052 
      oprot.writeI64(self.from_date)
1149 chandransh 7053 
      oprot.writeFieldEnd()
3431 rajveer 7054 
    if self.to_date is not None:
3064 chandransh 7055 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7056 
      oprot.writeI64(self.to_date)
2783 chandransh 7057 
      oprot.writeFieldEnd()
3431 rajveer 7058 
    if self.statuses is not None:
3064 chandransh 7059 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7060 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7061 
      for iter97 in self.statuses:
7062 
        oprot.writeI32(iter97)
3064 chandransh 7063 
      oprot.writeListEnd()
2783 chandransh 7064 
      oprot.writeFieldEnd()
1149 chandransh 7065 
    oprot.writeFieldStop()
7066 
    oprot.writeStructEnd()
7067 
 
3431 rajveer 7068 
  def validate(self):
7069 
    return
7070 
 
7071 
 
1149 chandransh 7072 
  def __repr__(self):
7073 
    L = ['%s=%r' % (key, value)
7074 
      for key, value in self.__dict__.iteritems()]
7075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7076 
 
7077 
  def __eq__(self, other):
7078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7079 
 
7080 
  def __ne__(self, other):
7081 
    return not (self == other)
7082 
 
3064 chandransh 7083 
class getOrdersForCustomer_result:
1149 chandransh 7084 
  """
7085 
  Attributes:
7086 
   - success
7087 
   - ex
7088 
  """
7089 
 
7090 
  thrift_spec = (
3064 chandransh 7091 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7093 
  )
7094 
 
7095 
  def __init__(self, success=None, ex=None,):
7096 
    self.success = success
7097 
    self.ex = ex
7098 
 
7099 
  def read(self, iprot):
7100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7102 
      return
7103 
    iprot.readStructBegin()
7104 
    while True:
7105 
      (fname, ftype, fid) = iprot.readFieldBegin()
7106 
      if ftype == TType.STOP:
7107 
        break
7108 
      if fid == 0:
3064 chandransh 7109 
        if ftype == TType.LIST:
7110 
          self.success = []
4133 chandransh 7111 
          (_etype101, _size98) = iprot.readListBegin()
7112 
          for _i102 in xrange(_size98):
7113 
            _elem103 = Order()
7114 
            _elem103.read(iprot)
7115 
            self.success.append(_elem103)
3064 chandransh 7116 
          iprot.readListEnd()
1149 chandransh 7117 
        else:
7118 
          iprot.skip(ftype)
7119 
      elif fid == 1:
7120 
        if ftype == TType.STRUCT:
7121 
          self.ex = TransactionServiceException()
7122 
          self.ex.read(iprot)
7123 
        else:
7124 
          iprot.skip(ftype)
7125 
      else:
7126 
        iprot.skip(ftype)
7127 
      iprot.readFieldEnd()
7128 
    iprot.readStructEnd()
7129 
 
7130 
  def write(self, oprot):
7131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7133 
      return
3064 chandransh 7134 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7135 
    if self.success is not None:
3064 chandransh 7136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7138 
      for iter104 in self.success:
7139 
        iter104.write(oprot)
3064 chandransh 7140 
      oprot.writeListEnd()
1149 chandransh 7141 
      oprot.writeFieldEnd()
3431 rajveer 7142 
    if self.ex is not None:
1149 chandransh 7143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7144 
      self.ex.write(oprot)
7145 
      oprot.writeFieldEnd()
7146 
    oprot.writeFieldStop()
7147 
    oprot.writeStructEnd()
7148 
 
3431 rajveer 7149 
  def validate(self):
7150 
    return
7151 
 
7152 
 
1149 chandransh 7153 
  def __repr__(self):
7154 
    L = ['%s=%r' % (key, value)
7155 
      for key, value in self.__dict__.iteritems()]
7156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7157 
 
7158 
  def __eq__(self, other):
7159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7160 
 
7161 
  def __ne__(self, other):
7162 
    return not (self == other)
7163 
 
3064 chandransh 7164 
class createOrder_args:
921 rajveer 7165 
  """
7166 
  Attributes:
3064 chandransh 7167 
   - order
921 rajveer 7168 
  """
7169 
 
7170 
  thrift_spec = (
7171 
    None, # 0
3064 chandransh 7172 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7173 
  )
7174 
 
3064 chandransh 7175 
  def __init__(self, order=None,):
7176 
    self.order = order
921 rajveer 7177 
 
7178 
  def read(self, iprot):
7179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7181 
      return
7182 
    iprot.readStructBegin()
7183 
    while True:
7184 
      (fname, ftype, fid) = iprot.readFieldBegin()
7185 
      if ftype == TType.STOP:
7186 
        break
7187 
      if fid == 1:
3064 chandransh 7188 
        if ftype == TType.STRUCT:
7189 
          self.order = Order()
7190 
          self.order.read(iprot)
921 rajveer 7191 
        else:
7192 
          iprot.skip(ftype)
7193 
      else:
7194 
        iprot.skip(ftype)
7195 
      iprot.readFieldEnd()
7196 
    iprot.readStructEnd()
7197 
 
7198 
  def write(self, oprot):
7199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7201 
      return
3064 chandransh 7202 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7203 
    if self.order is not None:
3064 chandransh 7204 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7205 
      self.order.write(oprot)
921 rajveer 7206 
      oprot.writeFieldEnd()
7207 
    oprot.writeFieldStop()
7208 
    oprot.writeStructEnd()
7209 
 
3431 rajveer 7210 
  def validate(self):
7211 
    return
7212 
 
7213 
 
921 rajveer 7214 
  def __repr__(self):
7215 
    L = ['%s=%r' % (key, value)
7216 
      for key, value in self.__dict__.iteritems()]
7217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7218 
 
7219 
  def __eq__(self, other):
7220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7221 
 
7222 
  def __ne__(self, other):
7223 
    return not (self == other)
7224 
 
3064 chandransh 7225 
class createOrder_result:
921 rajveer 7226 
  """
7227 
  Attributes:
7228 
   - success
7229 
   - ex
7230 
  """
7231 
 
7232 
  thrift_spec = (
3064 chandransh 7233 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7235 
  )
7236 
 
7237 
  def __init__(self, success=None, ex=None,):
7238 
    self.success = success
7239 
    self.ex = ex
7240 
 
7241 
  def read(self, iprot):
7242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7244 
      return
7245 
    iprot.readStructBegin()
7246 
    while True:
7247 
      (fname, ftype, fid) = iprot.readFieldBegin()
7248 
      if ftype == TType.STOP:
7249 
        break
7250 
      if fid == 0:
3064 chandransh 7251 
        if ftype == TType.I64:
7252 
          self.success = iprot.readI64();
921 rajveer 7253 
        else:
7254 
          iprot.skip(ftype)
7255 
      elif fid == 1:
7256 
        if ftype == TType.STRUCT:
7257 
          self.ex = TransactionServiceException()
7258 
          self.ex.read(iprot)
7259 
        else:
7260 
          iprot.skip(ftype)
7261 
      else:
7262 
        iprot.skip(ftype)
7263 
      iprot.readFieldEnd()
7264 
    iprot.readStructEnd()
7265 
 
7266 
  def write(self, oprot):
7267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7269 
      return
3064 chandransh 7270 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7271 
    if self.success is not None:
3064 chandransh 7272 
      oprot.writeFieldBegin('success', TType.I64, 0)
7273 
      oprot.writeI64(self.success)
921 rajveer 7274 
      oprot.writeFieldEnd()
3431 rajveer 7275 
    if self.ex is not None:
921 rajveer 7276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7277 
      self.ex.write(oprot)
7278 
      oprot.writeFieldEnd()
7279 
    oprot.writeFieldStop()
7280 
    oprot.writeStructEnd()
7281 
 
3431 rajveer 7282 
  def validate(self):
7283 
    return
7284 
 
7285 
 
921 rajveer 7286 
  def __repr__(self):
7287 
    L = ['%s=%r' % (key, value)
7288 
      for key, value in self.__dict__.iteritems()]
7289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7290 
 
7291 
  def __eq__(self, other):
7292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7293 
 
7294 
  def __ne__(self, other):
7295 
    return not (self == other)
7296 
 
3064 chandransh 7297 
class getOrder_args:
921 rajveer 7298 
  """
7299 
  Attributes:
3064 chandransh 7300 
   - id
921 rajveer 7301 
  """
7302 
 
7303 
  thrift_spec = (
7304 
    None, # 0
3064 chandransh 7305 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7306 
  )
7307 
 
3064 chandransh 7308 
  def __init__(self, id=None,):
7309 
    self.id = id
921 rajveer 7310 
 
7311 
  def read(self, iprot):
7312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7314 
      return
7315 
    iprot.readStructBegin()
7316 
    while True:
7317 
      (fname, ftype, fid) = iprot.readFieldBegin()
7318 
      if ftype == TType.STOP:
7319 
        break
7320 
      if fid == 1:
7321 
        if ftype == TType.I64:
3064 chandransh 7322 
          self.id = iprot.readI64();
921 rajveer 7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      else:
7326 
        iprot.skip(ftype)
7327 
      iprot.readFieldEnd()
7328 
    iprot.readStructEnd()
7329 
 
7330 
  def write(self, oprot):
7331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7333 
      return
3064 chandransh 7334 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7335 
    if self.id is not None:
3064 chandransh 7336 
      oprot.writeFieldBegin('id', TType.I64, 1)
7337 
      oprot.writeI64(self.id)
921 rajveer 7338 
      oprot.writeFieldEnd()
7339 
    oprot.writeFieldStop()
7340 
    oprot.writeStructEnd()
7341 
 
3431 rajveer 7342 
  def validate(self):
7343 
    return
7344 
 
7345 
 
921 rajveer 7346 
  def __repr__(self):
7347 
    L = ['%s=%r' % (key, value)
7348 
      for key, value in self.__dict__.iteritems()]
7349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7350 
 
7351 
  def __eq__(self, other):
7352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7353 
 
7354 
  def __ne__(self, other):
7355 
    return not (self == other)
7356 
 
3064 chandransh 7357 
class getOrder_result:
921 rajveer 7358 
  """
7359 
  Attributes:
7360 
   - success
7361 
   - ex
7362 
  """
7363 
 
7364 
  thrift_spec = (
3064 chandransh 7365 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7367 
  )
7368 
 
7369 
  def __init__(self, success=None, ex=None,):
7370 
    self.success = success
7371 
    self.ex = ex
7372 
 
7373 
  def read(self, iprot):
7374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7376 
      return
7377 
    iprot.readStructBegin()
7378 
    while True:
7379 
      (fname, ftype, fid) = iprot.readFieldBegin()
7380 
      if ftype == TType.STOP:
7381 
        break
7382 
      if fid == 0:
3064 chandransh 7383 
        if ftype == TType.STRUCT:
7384 
          self.success = Order()
7385 
          self.success.read(iprot)
921 rajveer 7386 
        else:
7387 
          iprot.skip(ftype)
7388 
      elif fid == 1:
7389 
        if ftype == TType.STRUCT:
7390 
          self.ex = TransactionServiceException()
7391 
          self.ex.read(iprot)
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      else:
7395 
        iprot.skip(ftype)
7396 
      iprot.readFieldEnd()
7397 
    iprot.readStructEnd()
7398 
 
7399 
  def write(self, oprot):
7400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7402 
      return
3064 chandransh 7403 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7404 
    if self.success is not None:
3064 chandransh 7405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7406 
      self.success.write(oprot)
921 rajveer 7407 
      oprot.writeFieldEnd()
3431 rajveer 7408 
    if self.ex is not None:
921 rajveer 7409 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7410 
      self.ex.write(oprot)
7411 
      oprot.writeFieldEnd()
7412 
    oprot.writeFieldStop()
7413 
    oprot.writeStructEnd()
7414 
 
3431 rajveer 7415 
  def validate(self):
7416 
    return
7417 
 
7418 
 
921 rajveer 7419 
  def __repr__(self):
7420 
    L = ['%s=%r' % (key, value)
7421 
      for key, value in self.__dict__.iteritems()]
7422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7423 
 
7424 
  def __eq__(self, other):
7425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7426 
 
7427 
  def __ne__(self, other):
7428 
    return not (self == other)
7429 
 
3064 chandransh 7430 
class getLineItemsForOrder_args:
94 ashish 7431 
  """
7432 
  Attributes:
3064 chandransh 7433 
   - orderId
94 ashish 7434 
  """
7435 
 
7436 
  thrift_spec = (
7437 
    None, # 0
3064 chandransh 7438 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7439 
  )
7440 
 
3064 chandransh 7441 
  def __init__(self, orderId=None,):
7442 
    self.orderId = orderId
94 ashish 7443 
 
7444 
  def read(self, iprot):
7445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7447 
      return
7448 
    iprot.readStructBegin()
7449 
    while True:
7450 
      (fname, ftype, fid) = iprot.readFieldBegin()
7451 
      if ftype == TType.STOP:
7452 
        break
7453 
      if fid == 1:
7454 
        if ftype == TType.I64:
3064 chandransh 7455 
          self.orderId = iprot.readI64();
94 ashish 7456 
        else:
7457 
          iprot.skip(ftype)
7458 
      else:
7459 
        iprot.skip(ftype)
7460 
      iprot.readFieldEnd()
7461 
    iprot.readStructEnd()
7462 
 
7463 
  def write(self, oprot):
7464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7466 
      return
3064 chandransh 7467 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7468 
    if self.orderId is not None:
3064 chandransh 7469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7470 
      oprot.writeI64(self.orderId)
94 ashish 7471 
      oprot.writeFieldEnd()
7472 
    oprot.writeFieldStop()
7473 
    oprot.writeStructEnd()
7474 
 
3431 rajveer 7475 
  def validate(self):
7476 
    return
7477 
 
7478 
 
94 ashish 7479 
  def __repr__(self):
7480 
    L = ['%s=%r' % (key, value)
7481 
      for key, value in self.__dict__.iteritems()]
7482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7483 
 
7484 
  def __eq__(self, other):
7485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7486 
 
7487 
  def __ne__(self, other):
7488 
    return not (self == other)
7489 
 
3064 chandransh 7490 
class getLineItemsForOrder_result:
94 ashish 7491 
  """
7492 
  Attributes:
7493 
   - success
7494 
   - ex
7495 
  """
7496 
 
7497 
  thrift_spec = (
3064 chandransh 7498 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7500 
  )
7501 
 
7502 
  def __init__(self, success=None, ex=None,):
7503 
    self.success = success
7504 
    self.ex = ex
7505 
 
7506 
  def read(self, iprot):
7507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7509 
      return
7510 
    iprot.readStructBegin()
7511 
    while True:
7512 
      (fname, ftype, fid) = iprot.readFieldBegin()
7513 
      if ftype == TType.STOP:
7514 
        break
7515 
      if fid == 0:
483 rajveer 7516 
        if ftype == TType.LIST:
7517 
          self.success = []
4133 chandransh 7518 
          (_etype108, _size105) = iprot.readListBegin()
7519 
          for _i109 in xrange(_size105):
7520 
            _elem110 = LineItem()
7521 
            _elem110.read(iprot)
7522 
            self.success.append(_elem110)
483 rajveer 7523 
          iprot.readListEnd()
94 ashish 7524 
        else:
7525 
          iprot.skip(ftype)
7526 
      elif fid == 1:
7527 
        if ftype == TType.STRUCT:
7528 
          self.ex = TransactionServiceException()
7529 
          self.ex.read(iprot)
7530 
        else:
7531 
          iprot.skip(ftype)
7532 
      else:
7533 
        iprot.skip(ftype)
7534 
      iprot.readFieldEnd()
7535 
    iprot.readStructEnd()
7536 
 
7537 
  def write(self, oprot):
7538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7540 
      return
3064 chandransh 7541 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7542 
    if self.success is not None:
483 rajveer 7543 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7544 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7545 
      for iter111 in self.success:
7546 
        iter111.write(oprot)
483 rajveer 7547 
      oprot.writeListEnd()
94 ashish 7548 
      oprot.writeFieldEnd()
3431 rajveer 7549 
    if self.ex is not None:
94 ashish 7550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7551 
      self.ex.write(oprot)
7552 
      oprot.writeFieldEnd()
7553 
    oprot.writeFieldStop()
7554 
    oprot.writeStructEnd()
7555 
 
3431 rajveer 7556 
  def validate(self):
7557 
    return
7558 
 
7559 
 
94 ashish 7560 
  def __repr__(self):
7561 
    L = ['%s=%r' % (key, value)
7562 
      for key, value in self.__dict__.iteritems()]
7563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7564 
 
7565 
  def __eq__(self, other):
7566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7567 
 
7568 
  def __ne__(self, other):
7569 
    return not (self == other)
7570 
 
3064 chandransh 7571 
class getOrderForCustomer_args:
94 ashish 7572 
  """
7573 
  Attributes:
3064 chandransh 7574 
   - orderId
483 rajveer 7575 
   - customerId
94 ashish 7576 
  """
7577 
 
7578 
  thrift_spec = (
7579 
    None, # 0
3064 chandransh 7580 
    (1, TType.I64, 'orderId', None, None, ), # 1
7581 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7582 
  )
7583 
 
3064 chandransh 7584 
  def __init__(self, orderId=None, customerId=None,):
7585 
    self.orderId = orderId
483 rajveer 7586 
    self.customerId = customerId
94 ashish 7587 
 
7588 
  def read(self, iprot):
7589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7591 
      return
7592 
    iprot.readStructBegin()
7593 
    while True:
7594 
      (fname, ftype, fid) = iprot.readFieldBegin()
7595 
      if ftype == TType.STOP:
7596 
        break
7597 
      if fid == 1:
7598 
        if ftype == TType.I64:
3064 chandransh 7599 
          self.orderId = iprot.readI64();
94 ashish 7600 
        else:
7601 
          iprot.skip(ftype)
7602 
      elif fid == 2:
7603 
        if ftype == TType.I64:
3064 chandransh 7604 
          self.customerId = iprot.readI64();
94 ashish 7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      else:
7608 
        iprot.skip(ftype)
7609 
      iprot.readFieldEnd()
7610 
    iprot.readStructEnd()
7611 
 
7612 
  def write(self, oprot):
7613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7615 
      return
3064 chandransh 7616 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7617 
    if self.orderId is not None:
3064 chandransh 7618 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7619 
      oprot.writeI64(self.orderId)
7620 
      oprot.writeFieldEnd()
3431 rajveer 7621 
    if self.customerId is not None:
3064 chandransh 7622 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7623 
      oprot.writeI64(self.customerId)
94 ashish 7624 
      oprot.writeFieldEnd()
7625 
    oprot.writeFieldStop()
7626 
    oprot.writeStructEnd()
7627 
 
3431 rajveer 7628 
  def validate(self):
7629 
    return
7630 
 
7631 
 
94 ashish 7632 
  def __repr__(self):
7633 
    L = ['%s=%r' % (key, value)
7634 
      for key, value in self.__dict__.iteritems()]
7635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7636 
 
7637 
  def __eq__(self, other):
7638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7639 
 
7640 
  def __ne__(self, other):
7641 
    return not (self == other)
7642 
 
3064 chandransh 7643 
class getOrderForCustomer_result:
94 ashish 7644 
  """
7645 
  Attributes:
7646 
   - success
7647 
   - ex
7648 
  """
7649 
 
7650 
  thrift_spec = (
3064 chandransh 7651 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7653 
  )
7654 
 
7655 
  def __init__(self, success=None, ex=None,):
7656 
    self.success = success
7657 
    self.ex = ex
7658 
 
7659 
  def read(self, iprot):
7660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7662 
      return
7663 
    iprot.readStructBegin()
7664 
    while True:
7665 
      (fname, ftype, fid) = iprot.readFieldBegin()
7666 
      if ftype == TType.STOP:
7667 
        break
7668 
      if fid == 0:
3064 chandransh 7669 
        if ftype == TType.STRUCT:
7670 
          self.success = Order()
7671 
          self.success.read(iprot)
94 ashish 7672 
        else:
7673 
          iprot.skip(ftype)
7674 
      elif fid == 1:
7675 
        if ftype == TType.STRUCT:
7676 
          self.ex = TransactionServiceException()
7677 
          self.ex.read(iprot)
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      else:
7681 
        iprot.skip(ftype)
7682 
      iprot.readFieldEnd()
7683 
    iprot.readStructEnd()
7684 
 
7685 
  def write(self, oprot):
7686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7688 
      return
3064 chandransh 7689 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7690 
    if self.success is not None:
3064 chandransh 7691 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7692 
      self.success.write(oprot)
94 ashish 7693 
      oprot.writeFieldEnd()
3431 rajveer 7694 
    if self.ex is not None:
94 ashish 7695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7696 
      self.ex.write(oprot)
7697 
      oprot.writeFieldEnd()
7698 
    oprot.writeFieldStop()
7699 
    oprot.writeStructEnd()
7700 
 
3431 rajveer 7701 
  def validate(self):
7702 
    return
7703 
 
7704 
 
94 ashish 7705 
  def __repr__(self):
7706 
    L = ['%s=%r' % (key, value)
7707 
      for key, value in self.__dict__.iteritems()]
7708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7709 
 
7710 
  def __eq__(self, other):
7711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7712 
 
7713 
  def __ne__(self, other):
7714 
    return not (self == other)
7715 
 
3064 chandransh 7716 
class getAlerts_args:
94 ashish 7717 
  """
7718 
  Attributes:
4394 rajveer 7719 
   - type
7720 
   - status
7721 
   - timestamp
94 ashish 7722 
  """
7723 
 
7724 
  thrift_spec = (
7725 
    None, # 0
4394 rajveer 7726 
    (1, TType.I64, 'type', None, None, ), # 1
7727 
    (2, TType.I64, 'status', None, None, ), # 2
7728 
    (3, TType.I64, 'timestamp', None, None, ), # 3
94 ashish 7729 
  )
7730 
 
4394 rajveer 7731 
  def __init__(self, type=None, status=None, timestamp=None,):
7732 
    self.type = type
7733 
    self.status = status
7734 
    self.timestamp = timestamp
94 ashish 7735 
 
7736 
  def read(self, iprot):
7737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7739 
      return
7740 
    iprot.readStructBegin()
7741 
    while True:
7742 
      (fname, ftype, fid) = iprot.readFieldBegin()
7743 
      if ftype == TType.STOP:
7744 
        break
7745 
      if fid == 1:
3064 chandransh 7746 
        if ftype == TType.I64:
4394 rajveer 7747 
          self.type = iprot.readI64();
94 ashish 7748 
        else:
7749 
          iprot.skip(ftype)
3064 chandransh 7750 
      elif fid == 2:
4394 rajveer 7751 
        if ftype == TType.I64:
7752 
          self.status = iprot.readI64();
3064 chandransh 7753 
        else:
7754 
          iprot.skip(ftype)
4394 rajveer 7755 
      elif fid == 3:
7756 
        if ftype == TType.I64:
7757 
          self.timestamp = iprot.readI64();
7758 
        else:
7759 
          iprot.skip(ftype)
94 ashish 7760 
      else:
7761 
        iprot.skip(ftype)
7762 
      iprot.readFieldEnd()
7763 
    iprot.readStructEnd()
7764 
 
7765 
  def write(self, oprot):
7766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7768 
      return
3064 chandransh 7769 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 7770 
    if self.type is not None:
7771 
      oprot.writeFieldBegin('type', TType.I64, 1)
7772 
      oprot.writeI64(self.type)
94 ashish 7773 
      oprot.writeFieldEnd()
4394 rajveer 7774 
    if self.status is not None:
7775 
      oprot.writeFieldBegin('status', TType.I64, 2)
7776 
      oprot.writeI64(self.status)
3064 chandransh 7777 
      oprot.writeFieldEnd()
4394 rajveer 7778 
    if self.timestamp is not None:
7779 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
7780 
      oprot.writeI64(self.timestamp)
7781 
      oprot.writeFieldEnd()
94 ashish 7782 
    oprot.writeFieldStop()
7783 
    oprot.writeStructEnd()
7784 
 
3431 rajveer 7785 
  def validate(self):
7786 
    return
7787 
 
7788 
 
94 ashish 7789 
  def __repr__(self):
7790 
    L = ['%s=%r' % (key, value)
7791 
      for key, value in self.__dict__.iteritems()]
7792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7793 
 
7794 
  def __eq__(self, other):
7795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7796 
 
7797 
  def __ne__(self, other):
7798 
    return not (self == other)
7799 
 
3064 chandransh 7800 
class getAlerts_result:
94 ashish 7801 
  """
7802 
  Attributes:
7803 
   - success
7804 
  """
7805 
 
7806 
  thrift_spec = (
3064 chandransh 7807 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7808 
  )
7809 
 
3064 chandransh 7810 
  def __init__(self, success=None,):
94 ashish 7811 
    self.success = success
7812 
 
7813 
  def read(self, iprot):
7814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7816 
      return
7817 
    iprot.readStructBegin()
7818 
    while True:
7819 
      (fname, ftype, fid) = iprot.readFieldBegin()
7820 
      if ftype == TType.STOP:
7821 
        break
7822 
      if fid == 0:
3064 chandransh 7823 
        if ftype == TType.LIST:
7824 
          self.success = []
4133 chandransh 7825 
          (_etype115, _size112) = iprot.readListBegin()
7826 
          for _i116 in xrange(_size112):
7827 
            _elem117 = Alert()
7828 
            _elem117.read(iprot)
7829 
            self.success.append(_elem117)
3064 chandransh 7830 
          iprot.readListEnd()
94 ashish 7831 
        else:
7832 
          iprot.skip(ftype)
7833 
      else:
7834 
        iprot.skip(ftype)
7835 
      iprot.readFieldEnd()
7836 
    iprot.readStructEnd()
7837 
 
7838 
  def write(self, oprot):
7839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7841 
      return
3064 chandransh 7842 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7843 
    if self.success is not None:
3064 chandransh 7844 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7845 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7846 
      for iter118 in self.success:
7847 
        iter118.write(oprot)
3064 chandransh 7848 
      oprot.writeListEnd()
94 ashish 7849 
      oprot.writeFieldEnd()
7850 
    oprot.writeFieldStop()
7851 
    oprot.writeStructEnd()
7852 
 
3431 rajveer 7853 
  def validate(self):
7854 
    return
7855 
 
7856 
 
94 ashish 7857 
  def __repr__(self):
7858 
    L = ['%s=%r' % (key, value)
7859 
      for key, value in self.__dict__.iteritems()]
7860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7861 
 
7862 
  def __eq__(self, other):
7863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7864 
 
7865 
  def __ne__(self, other):
7866 
    return not (self == other)
7867 
 
4394 rajveer 7868 
class addAlert_args:
94 ashish 7869 
  """
7870 
  Attributes:
3064 chandransh 7871 
   - type
4394 rajveer 7872 
   - description
94 ashish 7873 
  """
7874 
 
7875 
  thrift_spec = (
7876 
    None, # 0
4394 rajveer 7877 
    (1, TType.I64, 'type', None, None, ), # 1
7878 
    (2, TType.STRING, 'description', None, None, ), # 2
94 ashish 7879 
  )
7880 
 
4394 rajveer 7881 
  def __init__(self, type=None, description=None,):
3064 chandransh 7882 
    self.type = type
4394 rajveer 7883 
    self.description = description
94 ashish 7884 
 
7885 
  def read(self, iprot):
7886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7888 
      return
7889 
    iprot.readStructBegin()
7890 
    while True:
7891 
      (fname, ftype, fid) = iprot.readFieldBegin()
7892 
      if ftype == TType.STOP:
7893 
        break
7894 
      if fid == 1:
7895 
        if ftype == TType.I64:
4394 rajveer 7896 
          self.type = iprot.readI64();
94 ashish 7897 
        else:
7898 
          iprot.skip(ftype)
3064 chandransh 7899 
      elif fid == 2:
7900 
        if ftype == TType.STRING:
4394 rajveer 7901 
          self.description = iprot.readString();
3064 chandransh 7902 
        else:
7903 
          iprot.skip(ftype)
94 ashish 7904 
      else:
7905 
        iprot.skip(ftype)
7906 
      iprot.readFieldEnd()
7907 
    iprot.readStructEnd()
7908 
 
7909 
  def write(self, oprot):
7910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7912 
      return
4394 rajveer 7913 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 7914 
    if self.type is not None:
4394 rajveer 7915 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 7916 
      oprot.writeI64(self.type)
7917 
      oprot.writeFieldEnd()
4394 rajveer 7918 
    if self.description is not None:
7919 
      oprot.writeFieldBegin('description', TType.STRING, 2)
7920 
      oprot.writeString(self.description)
3064 chandransh 7921 
      oprot.writeFieldEnd()
94 ashish 7922 
    oprot.writeFieldStop()
7923 
    oprot.writeStructEnd()
7924 
 
3431 rajveer 7925 
  def validate(self):
7926 
    return
7927 
 
7928 
 
94 ashish 7929 
  def __repr__(self):
7930 
    L = ['%s=%r' % (key, value)
7931 
      for key, value in self.__dict__.iteritems()]
7932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7933 
 
7934 
  def __eq__(self, other):
7935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7936 
 
7937 
  def __ne__(self, other):
7938 
    return not (self == other)
7939 
 
4394 rajveer 7940 
class addAlert_result:
3064 chandransh 7941 
 
7942 
  thrift_spec = (
7943 
  )
7944 
 
7945 
  def read(self, iprot):
7946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7948 
      return
7949 
    iprot.readStructBegin()
7950 
    while True:
7951 
      (fname, ftype, fid) = iprot.readFieldBegin()
7952 
      if ftype == TType.STOP:
7953 
        break
7954 
      else:
7955 
        iprot.skip(ftype)
7956 
      iprot.readFieldEnd()
7957 
    iprot.readStructEnd()
7958 
 
7959 
  def write(self, oprot):
7960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7962 
      return
4394 rajveer 7963 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 7964 
    oprot.writeFieldStop()
7965 
    oprot.writeStructEnd()
7966 
 
3431 rajveer 7967 
  def validate(self):
7968 
    return
7969 
 
7970 
 
3064 chandransh 7971 
  def __repr__(self):
7972 
    L = ['%s=%r' % (key, value)
7973 
      for key, value in self.__dict__.iteritems()]
7974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7975 
 
7976 
  def __eq__(self, other):
7977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7978 
 
7979 
  def __ne__(self, other):
7980 
    return not (self == other)
7981 
 
7982 
class getValidOrderCount_args:
7983 
 
7984 
  thrift_spec = (
7985 
  )
7986 
 
7987 
  def read(self, iprot):
7988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7990 
      return
7991 
    iprot.readStructBegin()
7992 
    while True:
7993 
      (fname, ftype, fid) = iprot.readFieldBegin()
7994 
      if ftype == TType.STOP:
7995 
        break
7996 
      else:
7997 
        iprot.skip(ftype)
7998 
      iprot.readFieldEnd()
7999 
    iprot.readStructEnd()
8000 
 
8001 
  def write(self, oprot):
8002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8004 
      return
8005 
    oprot.writeStructBegin('getValidOrderCount_args')
8006 
    oprot.writeFieldStop()
8007 
    oprot.writeStructEnd()
8008 
 
3431 rajveer 8009 
  def validate(self):
8010 
    return
8011 
 
8012 
 
3064 chandransh 8013 
  def __repr__(self):
8014 
    L = ['%s=%r' % (key, value)
8015 
      for key, value in self.__dict__.iteritems()]
8016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8017 
 
8018 
  def __eq__(self, other):
8019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8020 
 
8021 
  def __ne__(self, other):
8022 
    return not (self == other)
8023 
 
8024 
class getValidOrderCount_result:
94 ashish 8025 
  """
8026 
  Attributes:
8027 
   - success
8028 
  """
8029 
 
8030 
  thrift_spec = (
3064 chandransh 8031 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8032 
  )
8033 
 
3064 chandransh 8034 
  def __init__(self, success=None,):
94 ashish 8035 
    self.success = success
8036 
 
8037 
  def read(self, iprot):
8038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8040 
      return
8041 
    iprot.readStructBegin()
8042 
    while True:
8043 
      (fname, ftype, fid) = iprot.readFieldBegin()
8044 
      if ftype == TType.STOP:
8045 
        break
8046 
      if fid == 0:
3064 chandransh 8047 
        if ftype == TType.I64:
8048 
          self.success = iprot.readI64();
94 ashish 8049 
        else:
8050 
          iprot.skip(ftype)
8051 
      else:
8052 
        iprot.skip(ftype)
8053 
      iprot.readFieldEnd()
8054 
    iprot.readStructEnd()
8055 
 
8056 
  def write(self, oprot):
8057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8059 
      return
3064 chandransh 8060 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8061 
    if self.success is not None:
3064 chandransh 8062 
      oprot.writeFieldBegin('success', TType.I64, 0)
8063 
      oprot.writeI64(self.success)
94 ashish 8064 
      oprot.writeFieldEnd()
8065 
    oprot.writeFieldStop()
8066 
    oprot.writeStructEnd()
8067 
 
3431 rajveer 8068 
  def validate(self):
8069 
    return
8070 
 
8071 
 
94 ashish 8072 
  def __repr__(self):
8073 
    L = ['%s=%r' % (key, value)
8074 
      for key, value in self.__dict__.iteritems()]
8075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8076 
 
8077 
  def __eq__(self, other):
8078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8079 
 
8080 
  def __ne__(self, other):
8081 
    return not (self == other)
8082 
 
3064 chandransh 8083 
class getNoOfCustomersWithSuccessfulTransaction_args:
8084 
 
8085 
  thrift_spec = (
8086 
  )
8087 
 
8088 
  def read(self, iprot):
8089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8091 
      return
8092 
    iprot.readStructBegin()
8093 
    while True:
8094 
      (fname, ftype, fid) = iprot.readFieldBegin()
8095 
      if ftype == TType.STOP:
8096 
        break
8097 
      else:
8098 
        iprot.skip(ftype)
8099 
      iprot.readFieldEnd()
8100 
    iprot.readStructEnd()
8101 
 
8102 
  def write(self, oprot):
8103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8105 
      return
8106 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8107 
    oprot.writeFieldStop()
8108 
    oprot.writeStructEnd()
8109 
 
3431 rajveer 8110 
  def validate(self):
8111 
    return
8112 
 
8113 
 
3064 chandransh 8114 
  def __repr__(self):
8115 
    L = ['%s=%r' % (key, value)
8116 
      for key, value in self.__dict__.iteritems()]
8117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8118 
 
8119 
  def __eq__(self, other):
8120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8121 
 
8122 
  def __ne__(self, other):
8123 
    return not (self == other)
8124 
 
8125 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8126 
  """
8127 
  Attributes:
3064 chandransh 8128 
   - success
94 ashish 8129 
  """
8130 
 
8131 
  thrift_spec = (
3064 chandransh 8132 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8133 
  )
8134 
 
3064 chandransh 8135 
  def __init__(self, success=None,):
8136 
    self.success = success
94 ashish 8137 
 
8138 
  def read(self, iprot):
8139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8141 
      return
8142 
    iprot.readStructBegin()
8143 
    while True:
8144 
      (fname, ftype, fid) = iprot.readFieldBegin()
8145 
      if ftype == TType.STOP:
8146 
        break
3064 chandransh 8147 
      if fid == 0:
94 ashish 8148 
        if ftype == TType.I64:
3064 chandransh 8149 
          self.success = iprot.readI64();
94 ashish 8150 
        else:
8151 
          iprot.skip(ftype)
8152 
      else:
8153 
        iprot.skip(ftype)
8154 
      iprot.readFieldEnd()
8155 
    iprot.readStructEnd()
8156 
 
8157 
  def write(self, oprot):
8158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8160 
      return
3064 chandransh 8161 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8162 
    if self.success is not None:
3064 chandransh 8163 
      oprot.writeFieldBegin('success', TType.I64, 0)
8164 
      oprot.writeI64(self.success)
94 ashish 8165 
      oprot.writeFieldEnd()
8166 
    oprot.writeFieldStop()
8167 
    oprot.writeStructEnd()
8168 
 
3431 rajveer 8169 
  def validate(self):
8170 
    return
8171 
 
8172 
 
94 ashish 8173 
  def __repr__(self):
8174 
    L = ['%s=%r' % (key, value)
8175 
      for key, value in self.__dict__.iteritems()]
8176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8177 
 
8178 
  def __eq__(self, other):
8179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8180 
 
8181 
  def __ne__(self, other):
8182 
    return not (self == other)
8183 
 
3064 chandransh 8184 
class getValidOrdersAmountRange_args:
8185 
 
8186 
  thrift_spec = (
8187 
  )
8188 
 
8189 
  def read(self, iprot):
8190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8192 
      return
8193 
    iprot.readStructBegin()
8194 
    while True:
8195 
      (fname, ftype, fid) = iprot.readFieldBegin()
8196 
      if ftype == TType.STOP:
8197 
        break
8198 
      else:
8199 
        iprot.skip(ftype)
8200 
      iprot.readFieldEnd()
8201 
    iprot.readStructEnd()
8202 
 
8203 
  def write(self, oprot):
8204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8206 
      return
8207 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8208 
    oprot.writeFieldStop()
8209 
    oprot.writeStructEnd()
8210 
 
3431 rajveer 8211 
  def validate(self):
8212 
    return
8213 
 
8214 
 
3064 chandransh 8215 
  def __repr__(self):
8216 
    L = ['%s=%r' % (key, value)
8217 
      for key, value in self.__dict__.iteritems()]
8218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8219 
 
8220 
  def __eq__(self, other):
8221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8222 
 
8223 
  def __ne__(self, other):
8224 
    return not (self == other)
8225 
 
8226 
class getValidOrdersAmountRange_result:
94 ashish 8227 
  """
8228 
  Attributes:
8229 
   - success
8230 
  """
8231 
 
8232 
  thrift_spec = (
3064 chandransh 8233 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8234 
  )
8235 
 
3064 chandransh 8236 
  def __init__(self, success=None,):
94 ashish 8237 
    self.success = success
8238 
 
8239 
  def read(self, iprot):
8240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8242 
      return
8243 
    iprot.readStructBegin()
8244 
    while True:
8245 
      (fname, ftype, fid) = iprot.readFieldBegin()
8246 
      if ftype == TType.STOP:
8247 
        break
8248 
      if fid == 0:
483 rajveer 8249 
        if ftype == TType.LIST:
8250 
          self.success = []
4133 chandransh 8251 
          (_etype122, _size119) = iprot.readListBegin()
8252 
          for _i123 in xrange(_size119):
8253 
            _elem124 = iprot.readDouble();
8254 
            self.success.append(_elem124)
483 rajveer 8255 
          iprot.readListEnd()
94 ashish 8256 
        else:
8257 
          iprot.skip(ftype)
8258 
      else:
8259 
        iprot.skip(ftype)
8260 
      iprot.readFieldEnd()
8261 
    iprot.readStructEnd()
8262 
 
8263 
  def write(self, oprot):
8264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8266 
      return
3064 chandransh 8267 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8268 
    if self.success is not None:
483 rajveer 8269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8270 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8271 
      for iter125 in self.success:
8272 
        oprot.writeDouble(iter125)
483 rajveer 8273 
      oprot.writeListEnd()
94 ashish 8274 
      oprot.writeFieldEnd()
8275 
    oprot.writeFieldStop()
8276 
    oprot.writeStructEnd()
8277 
 
3431 rajveer 8278 
  def validate(self):
8279 
    return
8280 
 
8281 
 
94 ashish 8282 
  def __repr__(self):
8283 
    L = ['%s=%r' % (key, value)
8284 
      for key, value in self.__dict__.iteritems()]
8285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8286 
 
8287 
  def __eq__(self, other):
8288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8289 
 
8290 
  def __ne__(self, other):
8291 
    return not (self == other)
8292 
 
3064 chandransh 8293 
class getValidOrders_args:
1528 ankur.sing 8294 
  """
8295 
  Attributes:
3064 chandransh 8296 
   - limit
1528 ankur.sing 8297 
  """
8298 
 
8299 
  thrift_spec = (
8300 
    None, # 0
3064 chandransh 8301 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8302 
  )
8303 
 
3064 chandransh 8304 
  def __init__(self, limit=None,):
8305 
    self.limit = limit
1528 ankur.sing 8306 
 
8307 
  def read(self, iprot):
8308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8310 
      return
8311 
    iprot.readStructBegin()
8312 
    while True:
8313 
      (fname, ftype, fid) = iprot.readFieldBegin()
8314 
      if ftype == TType.STOP:
8315 
        break
8316 
      if fid == 1:
8317 
        if ftype == TType.I64:
3064 chandransh 8318 
          self.limit = iprot.readI64();
1528 ankur.sing 8319 
        else:
8320 
          iprot.skip(ftype)
8321 
      else:
8322 
        iprot.skip(ftype)
8323 
      iprot.readFieldEnd()
8324 
    iprot.readStructEnd()
8325 
 
8326 
  def write(self, oprot):
8327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8329 
      return
3064 chandransh 8330 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8331 
    if self.limit is not None:
3064 chandransh 8332 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8333 
      oprot.writeI64(self.limit)
1528 ankur.sing 8334 
      oprot.writeFieldEnd()
8335 
    oprot.writeFieldStop()
8336 
    oprot.writeStructEnd()
8337 
 
3431 rajveer 8338 
  def validate(self):
8339 
    return
8340 
 
8341 
 
1528 ankur.sing 8342 
  def __repr__(self):
8343 
    L = ['%s=%r' % (key, value)
8344 
      for key, value in self.__dict__.iteritems()]
8345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8346 
 
8347 
  def __eq__(self, other):
8348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8349 
 
8350 
  def __ne__(self, other):
8351 
    return not (self == other)
8352 
 
3064 chandransh 8353 
class getValidOrders_result:
1528 ankur.sing 8354 
  """
8355 
  Attributes:
8356 
   - success
8357 
  """
8358 
 
8359 
  thrift_spec = (
3064 chandransh 8360 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8361 
  )
8362 
 
3064 chandransh 8363 
  def __init__(self, success=None,):
1528 ankur.sing 8364 
    self.success = success
8365 
 
8366 
  def read(self, iprot):
8367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8369 
      return
8370 
    iprot.readStructBegin()
8371 
    while True:
8372 
      (fname, ftype, fid) = iprot.readFieldBegin()
8373 
      if ftype == TType.STOP:
8374 
        break
8375 
      if fid == 0:
3064 chandransh 8376 
        if ftype == TType.LIST:
8377 
          self.success = []
4133 chandransh 8378 
          (_etype129, _size126) = iprot.readListBegin()
8379 
          for _i130 in xrange(_size126):
8380 
            _elem131 = Order()
8381 
            _elem131.read(iprot)
8382 
            self.success.append(_elem131)
3064 chandransh 8383 
          iprot.readListEnd()
1528 ankur.sing 8384 
        else:
8385 
          iprot.skip(ftype)
8386 
      else:
8387 
        iprot.skip(ftype)
8388 
      iprot.readFieldEnd()
8389 
    iprot.readStructEnd()
8390 
 
8391 
  def write(self, oprot):
8392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8394 
      return
3064 chandransh 8395 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8396 
    if self.success is not None:
3064 chandransh 8397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8399 
      for iter132 in self.success:
8400 
        iter132.write(oprot)
3064 chandransh 8401 
      oprot.writeListEnd()
1528 ankur.sing 8402 
      oprot.writeFieldEnd()
8403 
    oprot.writeFieldStop()
8404 
    oprot.writeStructEnd()
8405 
 
3431 rajveer 8406 
  def validate(self):
8407 
    return
8408 
 
8409 
 
1528 ankur.sing 8410 
  def __repr__(self):
8411 
    L = ['%s=%r' % (key, value)
8412 
      for key, value in self.__dict__.iteritems()]
8413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8414 
 
8415 
  def __eq__(self, other):
8416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8417 
 
8418 
  def __ne__(self, other):
8419 
    return not (self == other)
8420 
 
1220 chandransh 8421 
class batchOrders_args:
8422 
  """
8423 
  Attributes:
8424 
   - warehouseId
8425 
  """
8426 
 
8427 
  thrift_spec = (
8428 
    None, # 0
8429 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8430 
  )
8431 
 
8432 
  def __init__(self, warehouseId=None,):
8433 
    self.warehouseId = warehouseId
8434 
 
8435 
  def read(self, iprot):
8436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8438 
      return
8439 
    iprot.readStructBegin()
8440 
    while True:
8441 
      (fname, ftype, fid) = iprot.readFieldBegin()
8442 
      if ftype == TType.STOP:
8443 
        break
8444 
      if fid == 1:
8445 
        if ftype == TType.I64:
8446 
          self.warehouseId = iprot.readI64();
8447 
        else:
8448 
          iprot.skip(ftype)
8449 
      else:
8450 
        iprot.skip(ftype)
8451 
      iprot.readFieldEnd()
8452 
    iprot.readStructEnd()
8453 
 
8454 
  def write(self, oprot):
8455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8457 
      return
8458 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8459 
    if self.warehouseId is not None:
1220 chandransh 8460 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8461 
      oprot.writeI64(self.warehouseId)
8462 
      oprot.writeFieldEnd()
8463 
    oprot.writeFieldStop()
8464 
    oprot.writeStructEnd()
8465 
 
3431 rajveer 8466 
  def validate(self):
8467 
    return
8468 
 
8469 
 
1220 chandransh 8470 
  def __repr__(self):
8471 
    L = ['%s=%r' % (key, value)
8472 
      for key, value in self.__dict__.iteritems()]
8473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8474 
 
8475 
  def __eq__(self, other):
8476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8477 
 
8478 
  def __ne__(self, other):
8479 
    return not (self == other)
8480 
 
8481 
class batchOrders_result:
8482 
  """
8483 
  Attributes:
8484 
   - success
8485 
   - ex
8486 
  """
8487 
 
8488 
  thrift_spec = (
8489 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8490 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8491 
  )
8492 
 
8493 
  def __init__(self, success=None, ex=None,):
8494 
    self.success = success
8495 
    self.ex = ex
8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      if fid == 0:
8507 
        if ftype == TType.LIST:
8508 
          self.success = []
4133 chandransh 8509 
          (_etype136, _size133) = iprot.readListBegin()
8510 
          for _i137 in xrange(_size133):
8511 
            _elem138 = Order()
8512 
            _elem138.read(iprot)
8513 
            self.success.append(_elem138)
1220 chandransh 8514 
          iprot.readListEnd()
8515 
        else:
8516 
          iprot.skip(ftype)
8517 
      elif fid == 1:
8518 
        if ftype == TType.STRUCT:
8519 
          self.ex = TransactionServiceException()
8520 
          self.ex.read(iprot)
8521 
        else:
8522 
          iprot.skip(ftype)
8523 
      else:
8524 
        iprot.skip(ftype)
8525 
      iprot.readFieldEnd()
8526 
    iprot.readStructEnd()
8527 
 
8528 
  def write(self, oprot):
8529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8531 
      return
8532 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8533 
    if self.success is not None:
1220 chandransh 8534 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8535 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8536 
      for iter139 in self.success:
8537 
        iter139.write(oprot)
1220 chandransh 8538 
      oprot.writeListEnd()
8539 
      oprot.writeFieldEnd()
3431 rajveer 8540 
    if self.ex is not None:
1220 chandransh 8541 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8542 
      self.ex.write(oprot)
8543 
      oprot.writeFieldEnd()
8544 
    oprot.writeFieldStop()
8545 
    oprot.writeStructEnd()
8546 
 
3431 rajveer 8547 
  def validate(self):
8548 
    return
8549 
 
8550 
 
1220 chandransh 8551 
  def __repr__(self):
8552 
    L = ['%s=%r' % (key, value)
8553 
      for key, value in self.__dict__.iteritems()]
8554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8555 
 
8556 
  def __eq__(self, other):
8557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8558 
 
8559 
  def __ne__(self, other):
8560 
    return not (self == other)
8561 
 
1208 chandransh 8562 
class markOrderAsOutOfStock_args:
8563 
  """
8564 
  Attributes:
8565 
   - orderId
8566 
  """
8567 
 
8568 
  thrift_spec = (
8569 
    None, # 0
8570 
    (1, TType.I64, 'orderId', None, None, ), # 1
8571 
  )
8572 
 
8573 
  def __init__(self, orderId=None,):
8574 
    self.orderId = orderId
8575 
 
8576 
  def read(self, iprot):
8577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8579 
      return
8580 
    iprot.readStructBegin()
8581 
    while True:
8582 
      (fname, ftype, fid) = iprot.readFieldBegin()
8583 
      if ftype == TType.STOP:
8584 
        break
8585 
      if fid == 1:
8586 
        if ftype == TType.I64:
8587 
          self.orderId = iprot.readI64();
8588 
        else:
8589 
          iprot.skip(ftype)
8590 
      else:
8591 
        iprot.skip(ftype)
8592 
      iprot.readFieldEnd()
8593 
    iprot.readStructEnd()
8594 
 
8595 
  def write(self, oprot):
8596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8598 
      return
8599 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8600 
    if self.orderId is not None:
1208 chandransh 8601 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8602 
      oprot.writeI64(self.orderId)
8603 
      oprot.writeFieldEnd()
8604 
    oprot.writeFieldStop()
8605 
    oprot.writeStructEnd()
8606 
 
3431 rajveer 8607 
  def validate(self):
8608 
    return
8609 
 
8610 
 
1208 chandransh 8611 
  def __repr__(self):
8612 
    L = ['%s=%r' % (key, value)
8613 
      for key, value in self.__dict__.iteritems()]
8614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8615 
 
8616 
  def __eq__(self, other):
8617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8618 
 
8619 
  def __ne__(self, other):
8620 
    return not (self == other)
8621 
 
8622 
class markOrderAsOutOfStock_result:
8623 
  """
8624 
  Attributes:
8625 
   - success
8626 
   - ex
8627 
  """
8628 
 
8629 
  thrift_spec = (
8630 
    (0, TType.BOOL, 'success', None, None, ), # 0
8631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8632 
  )
8633 
 
8634 
  def __init__(self, success=None, ex=None,):
8635 
    self.success = success
8636 
    self.ex = ex
8637 
 
8638 
  def read(self, iprot):
8639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8641 
      return
8642 
    iprot.readStructBegin()
8643 
    while True:
8644 
      (fname, ftype, fid) = iprot.readFieldBegin()
8645 
      if ftype == TType.STOP:
8646 
        break
8647 
      if fid == 0:
8648 
        if ftype == TType.BOOL:
8649 
          self.success = iprot.readBool();
8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      elif fid == 1:
8653 
        if ftype == TType.STRUCT:
8654 
          self.ex = TransactionServiceException()
8655 
          self.ex.read(iprot)
8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      else:
8659 
        iprot.skip(ftype)
8660 
      iprot.readFieldEnd()
8661 
    iprot.readStructEnd()
8662 
 
8663 
  def write(self, oprot):
8664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8666 
      return
8667 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8668 
    if self.success is not None:
1208 chandransh 8669 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8670 
      oprot.writeBool(self.success)
8671 
      oprot.writeFieldEnd()
3431 rajveer 8672 
    if self.ex is not None:
1208 chandransh 8673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8674 
      self.ex.write(oprot)
8675 
      oprot.writeFieldEnd()
8676 
    oprot.writeFieldStop()
8677 
    oprot.writeStructEnd()
8678 
 
3431 rajveer 8679 
  def validate(self):
8680 
    return
8681 
 
8682 
 
1208 chandransh 8683 
  def __repr__(self):
8684 
    L = ['%s=%r' % (key, value)
8685 
      for key, value in self.__dict__.iteritems()]
8686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8687 
 
8688 
  def __eq__(self, other):
8689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8690 
 
8691 
  def __ne__(self, other):
8692 
    return not (self == other)
8693 
 
3064 chandransh 8694 
class verifyOrder_args:
759 chandransh 8695 
  """
8696 
  Attributes:
3064 chandransh 8697 
   - orderId
759 chandransh 8698 
  """
8699 
 
8700 
  thrift_spec = (
8701 
    None, # 0
3064 chandransh 8702 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8703 
  )
8704 
 
3064 chandransh 8705 
  def __init__(self, orderId=None,):
8706 
    self.orderId = orderId
759 chandransh 8707 
 
8708 
  def read(self, iprot):
8709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8711 
      return
8712 
    iprot.readStructBegin()
8713 
    while True:
8714 
      (fname, ftype, fid) = iprot.readFieldBegin()
8715 
      if ftype == TType.STOP:
8716 
        break
8717 
      if fid == 1:
8718 
        if ftype == TType.I64:
3064 chandransh 8719 
          self.orderId = iprot.readI64();
759 chandransh 8720 
        else:
8721 
          iprot.skip(ftype)
8722 
      else:
8723 
        iprot.skip(ftype)
8724 
      iprot.readFieldEnd()
8725 
    iprot.readStructEnd()
8726 
 
8727 
  def write(self, oprot):
8728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8730 
      return
3064 chandransh 8731 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8732 
    if self.orderId is not None:
3064 chandransh 8733 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8734 
      oprot.writeI64(self.orderId)
759 chandransh 8735 
      oprot.writeFieldEnd()
8736 
    oprot.writeFieldStop()
8737 
    oprot.writeStructEnd()
8738 
 
3431 rajveer 8739 
  def validate(self):
8740 
    return
8741 
 
8742 
 
759 chandransh 8743 
  def __repr__(self):
8744 
    L = ['%s=%r' % (key, value)
8745 
      for key, value in self.__dict__.iteritems()]
8746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8747 
 
8748 
  def __eq__(self, other):
8749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8750 
 
8751 
  def __ne__(self, other):
8752 
    return not (self == other)
8753 
 
3064 chandransh 8754 
class verifyOrder_result:
759 chandransh 8755 
  """
8756 
  Attributes:
8757 
   - success
8758 
   - ex
8759 
  """
8760 
 
8761 
  thrift_spec = (
8762 
    (0, TType.BOOL, 'success', None, None, ), # 0
8763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8764 
  )
8765 
 
8766 
  def __init__(self, success=None, ex=None,):
8767 
    self.success = success
8768 
    self.ex = ex
8769 
 
8770 
  def read(self, iprot):
8771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8773 
      return
8774 
    iprot.readStructBegin()
8775 
    while True:
8776 
      (fname, ftype, fid) = iprot.readFieldBegin()
8777 
      if ftype == TType.STOP:
8778 
        break
8779 
      if fid == 0:
8780 
        if ftype == TType.BOOL:
8781 
          self.success = iprot.readBool();
8782 
        else:
8783 
          iprot.skip(ftype)
8784 
      elif fid == 1:
8785 
        if ftype == TType.STRUCT:
8786 
          self.ex = TransactionServiceException()
8787 
          self.ex.read(iprot)
8788 
        else:
8789 
          iprot.skip(ftype)
8790 
      else:
8791 
        iprot.skip(ftype)
8792 
      iprot.readFieldEnd()
8793 
    iprot.readStructEnd()
8794 
 
8795 
  def write(self, oprot):
8796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8798 
      return
3064 chandransh 8799 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8800 
    if self.success is not None:
759 chandransh 8801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8802 
      oprot.writeBool(self.success)
8803 
      oprot.writeFieldEnd()
3431 rajveer 8804 
    if self.ex is not None:
759 chandransh 8805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8806 
      self.ex.write(oprot)
8807 
      oprot.writeFieldEnd()
8808 
    oprot.writeFieldStop()
8809 
    oprot.writeStructEnd()
8810 
 
3431 rajveer 8811 
  def validate(self):
8812 
    return
8813 
 
8814 
 
759 chandransh 8815 
  def __repr__(self):
8816 
    L = ['%s=%r' % (key, value)
8817 
      for key, value in self.__dict__.iteritems()]
8818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8819 
 
8820 
  def __eq__(self, other):
8821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8822 
 
8823 
  def __ne__(self, other):
8824 
    return not (self == other)
8825 
 
3064 chandransh 8826 
class acceptOrder_args:
1113 chandransh 8827 
  """
8828 
  Attributes:
3064 chandransh 8829 
   - orderId
1113 chandransh 8830 
  """
8831 
 
8832 
  thrift_spec = (
8833 
    None, # 0
3064 chandransh 8834 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8835 
  )
8836 
 
3064 chandransh 8837 
  def __init__(self, orderId=None,):
8838 
    self.orderId = orderId
1113 chandransh 8839 
 
8840 
  def read(self, iprot):
8841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8843 
      return
8844 
    iprot.readStructBegin()
8845 
    while True:
8846 
      (fname, ftype, fid) = iprot.readFieldBegin()
8847 
      if ftype == TType.STOP:
8848 
        break
8849 
      if fid == 1:
8850 
        if ftype == TType.I64:
3064 chandransh 8851 
          self.orderId = iprot.readI64();
1113 chandransh 8852 
        else:
8853 
          iprot.skip(ftype)
8854 
      else:
8855 
        iprot.skip(ftype)
8856 
      iprot.readFieldEnd()
8857 
    iprot.readStructEnd()
8858 
 
8859 
  def write(self, oprot):
8860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8862 
      return
3064 chandransh 8863 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8864 
    if self.orderId is not None:
3064 chandransh 8865 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8866 
      oprot.writeI64(self.orderId)
1113 chandransh 8867 
      oprot.writeFieldEnd()
8868 
    oprot.writeFieldStop()
8869 
    oprot.writeStructEnd()
8870 
 
3431 rajveer 8871 
  def validate(self):
8872 
    return
8873 
 
8874 
 
1113 chandransh 8875 
  def __repr__(self):
8876 
    L = ['%s=%r' % (key, value)
8877 
      for key, value in self.__dict__.iteritems()]
8878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8879 
 
8880 
  def __eq__(self, other):
8881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8882 
 
8883 
  def __ne__(self, other):
8884 
    return not (self == other)
8885 
 
3064 chandransh 8886 
class acceptOrder_result:
1113 chandransh 8887 
  """
8888 
  Attributes:
8889 
   - success
8890 
   - ex
8891 
  """
8892 
 
8893 
  thrift_spec = (
3064 chandransh 8894 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8896 
  )
8897 
 
8898 
  def __init__(self, success=None, ex=None,):
8899 
    self.success = success
8900 
    self.ex = ex
8901 
 
8902 
  def read(self, iprot):
8903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8905 
      return
8906 
    iprot.readStructBegin()
8907 
    while True:
8908 
      (fname, ftype, fid) = iprot.readFieldBegin()
8909 
      if ftype == TType.STOP:
8910 
        break
8911 
      if fid == 0:
3064 chandransh 8912 
        if ftype == TType.BOOL:
8913 
          self.success = iprot.readBool();
1113 chandransh 8914 
        else:
8915 
          iprot.skip(ftype)
8916 
      elif fid == 1:
8917 
        if ftype == TType.STRUCT:
8918 
          self.ex = TransactionServiceException()
8919 
          self.ex.read(iprot)
8920 
        else:
8921 
          iprot.skip(ftype)
8922 
      else:
8923 
        iprot.skip(ftype)
8924 
      iprot.readFieldEnd()
8925 
    iprot.readStructEnd()
8926 
 
8927 
  def write(self, oprot):
8928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8930 
      return
3064 chandransh 8931 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8932 
    if self.success is not None:
3064 chandransh 8933 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8934 
      oprot.writeBool(self.success)
1113 chandransh 8935 
      oprot.writeFieldEnd()
3431 rajveer 8936 
    if self.ex is not None:
1113 chandransh 8937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8938 
      self.ex.write(oprot)
8939 
      oprot.writeFieldEnd()
8940 
    oprot.writeFieldStop()
8941 
    oprot.writeStructEnd()
8942 
 
3431 rajveer 8943 
  def validate(self):
8944 
    return
8945 
 
8946 
 
1113 chandransh 8947 
  def __repr__(self):
8948 
    L = ['%s=%r' % (key, value)
8949 
      for key, value in self.__dict__.iteritems()]
8950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8951 
 
8952 
  def __eq__(self, other):
8953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8954 
 
8955 
  def __ne__(self, other):
8956 
    return not (self == other)
8957 
 
3064 chandransh 8958 
class addBillingDetails_args:
1135 chandransh 8959 
  """
8960 
  Attributes:
3064 chandransh 8961 
   - orderId
8962 
   - invoice_number
4283 anupam.sin 8963 
   - imeiNumber
8964 
   - itemNumber
3064 chandransh 8965 
   - billed_by
4264 rajveer 8966 
   - jacketNumber
4283 anupam.sin 8967 
   - billingType
8968 
   - vendorId
1135 chandransh 8969 
  """
8970 
 
8971 
  thrift_spec = (
8972 
    None, # 0
3064 chandransh 8973 
    (1, TType.I64, 'orderId', None, None, ), # 1
8974 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8975 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8976 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8977 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8978 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8979 
    (7, TType.I64, 'billingType', None, None, ), # 7
8980 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8981 
  )
8982 
 
4283 anupam.sin 8983 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8984 
    self.orderId = orderId
8985 
    self.invoice_number = invoice_number
4283 anupam.sin 8986 
    self.imeiNumber = imeiNumber
8987 
    self.itemNumber = itemNumber
3064 chandransh 8988 
    self.billed_by = billed_by
4264 rajveer 8989 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8990 
    self.billingType = billingType
8991 
    self.vendorId = vendorId
1135 chandransh 8992 
 
8993 
  def read(self, iprot):
8994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8996 
      return
8997 
    iprot.readStructBegin()
8998 
    while True:
8999 
      (fname, ftype, fid) = iprot.readFieldBegin()
9000 
      if ftype == TType.STOP:
9001 
        break
9002 
      if fid == 1:
9003 
        if ftype == TType.I64:
3064 chandransh 9004 
          self.orderId = iprot.readI64();
1135 chandransh 9005 
        else:
9006 
          iprot.skip(ftype)
9007 
      elif fid == 2:
3064 chandransh 9008 
        if ftype == TType.STRING:
9009 
          self.invoice_number = iprot.readString();
1135 chandransh 9010 
        else:
9011 
          iprot.skip(ftype)
3064 chandransh 9012 
      elif fid == 3:
4264 rajveer 9013 
        if ftype == TType.I64:
3064 chandransh 9014 
          self.imeiNumber = iprot.readI64();
9015 
        else:
9016 
          iprot.skip(ftype)
9017 
      elif fid == 4:
9018 
        if ftype == TType.STRING:
9019 
          self.itemNumber = iprot.readString();
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      elif fid == 5:
9023 
        if ftype == TType.STRING:
4283 anupam.sin 9024 
          self.billed_by = iprot.readString();
3064 chandransh 9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      elif fid == 6:
9028 
        if ftype == TType.I64:
4283 anupam.sin 9029 
          self.jacketNumber = iprot.readI64();
9030 
        else:
9031 
          iprot.skip(ftype)
9032 
      elif fid == 7:
9033 
        if ftype == TType.I64:
3064 chandransh 9034 
          self.billingType = iprot.readI64();
9035 
        else:
9036 
          iprot.skip(ftype)
4283 anupam.sin 9037 
      elif fid == 8:
9038 
        if ftype == TType.I64:
9039 
          self.vendorId = iprot.readI64();
9040 
        else:
9041 
          iprot.skip(ftype)
1246 chandransh 9042 
      else:
9043 
        iprot.skip(ftype)
9044 
      iprot.readFieldEnd()
9045 
    iprot.readStructEnd()
9046 
 
9047 
  def write(self, oprot):
9048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9050 
      return
4283 anupam.sin 9051 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9052 
    if self.orderId is not None:
3064 chandransh 9053 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9054 
      oprot.writeI64(self.orderId)
1246 chandransh 9055 
      oprot.writeFieldEnd()
4283 anupam.sin 9056 
    if self.invoice_number is not None:
9057 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9058 
      oprot.writeString(self.invoice_number)
1246 chandransh 9059 
      oprot.writeFieldEnd()
3431 rajveer 9060 
    if self.imeiNumber is not None:
3064 chandransh 9061 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9062 
      oprot.writeI64(self.imeiNumber)
9063 
      oprot.writeFieldEnd()
3431 rajveer 9064 
    if self.itemNumber is not None:
3064 chandransh 9065 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9066 
      oprot.writeString(self.itemNumber)
9067 
      oprot.writeFieldEnd()
4283 anupam.sin 9068 
    if self.billed_by is not None:
9069 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9070 
      oprot.writeString(self.billed_by)
3064 chandransh 9071 
      oprot.writeFieldEnd()
4283 anupam.sin 9072 
    if self.jacketNumber is not None:
9073 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9074 
      oprot.writeI64(self.jacketNumber)
9075 
      oprot.writeFieldEnd()
3431 rajveer 9076 
    if self.billingType is not None:
4283 anupam.sin 9077 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9078 
      oprot.writeI64(self.billingType)
9079 
      oprot.writeFieldEnd()
4283 anupam.sin 9080 
    if self.vendorId is not None:
9081 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9082 
      oprot.writeI64(self.vendorId)
9083 
      oprot.writeFieldEnd()
1246 chandransh 9084 
    oprot.writeFieldStop()
9085 
    oprot.writeStructEnd()
9086 
 
3431 rajveer 9087 
  def validate(self):
9088 
    return
9089 
 
9090 
 
1246 chandransh 9091 
  def __repr__(self):
9092 
    L = ['%s=%r' % (key, value)
9093 
      for key, value in self.__dict__.iteritems()]
9094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9095 
 
9096 
  def __eq__(self, other):
9097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9098 
 
9099 
  def __ne__(self, other):
9100 
    return not (self == other)
9101 
 
4283 anupam.sin 9102 
class addBillingDetails_result:
1246 chandransh 9103 
  """
9104 
  Attributes:
3064 chandransh 9105 
   - success
1246 chandransh 9106 
   - ex
9107 
  """
9108 
 
9109 
  thrift_spec = (
3064 chandransh 9110 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9112 
  )
9113 
 
3064 chandransh 9114 
  def __init__(self, success=None, ex=None,):
9115 
    self.success = success
1246 chandransh 9116 
    self.ex = ex
9117 
 
9118 
  def read(self, iprot):
9119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9121 
      return
9122 
    iprot.readStructBegin()
9123 
    while True:
9124 
      (fname, ftype, fid) = iprot.readFieldBegin()
9125 
      if ftype == TType.STOP:
9126 
        break
3064 chandransh 9127 
      if fid == 0:
9128 
        if ftype == TType.BOOL:
9129 
          self.success = iprot.readBool();
9130 
        else:
9131 
          iprot.skip(ftype)
9132 
      elif fid == 1:
1246 chandransh 9133 
        if ftype == TType.STRUCT:
9134 
          self.ex = TransactionServiceException()
9135 
          self.ex.read(iprot)
9136 
        else:
9137 
          iprot.skip(ftype)
9138 
      else:
9139 
        iprot.skip(ftype)
9140 
      iprot.readFieldEnd()
9141 
    iprot.readStructEnd()
9142 
 
9143 
  def write(self, oprot):
9144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9146 
      return
4283 anupam.sin 9147 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9148 
    if self.success is not None:
3064 chandransh 9149 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9150 
      oprot.writeBool(self.success)
9151 
      oprot.writeFieldEnd()
3431 rajveer 9152 
    if self.ex is not None:
1246 chandransh 9153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9154 
      self.ex.write(oprot)
9155 
      oprot.writeFieldEnd()
9156 
    oprot.writeFieldStop()
9157 
    oprot.writeStructEnd()
9158 
 
3431 rajveer 9159 
  def validate(self):
9160 
    return
9161 
 
9162 
 
1246 chandransh 9163 
  def __repr__(self):
9164 
    L = ['%s=%r' % (key, value)
9165 
      for key, value in self.__dict__.iteritems()]
9166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9167 
 
9168 
  def __eq__(self, other):
9169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9170 
 
9171 
  def __ne__(self, other):
9172 
    return not (self == other)
9173 
 
3064 chandransh 9174 
class markOrdersAsManifested_args:
1408 ankur.sing 9175 
  """
9176 
  Attributes:
3064 chandransh 9177 
   - warehouseId
1408 ankur.sing 9178 
   - providerId
3064 chandransh 9179 
   - cod
1408 ankur.sing 9180 
  """
9181 
 
9182 
  thrift_spec = (
9183 
    None, # 0
3064 chandransh 9184 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9185 
    (2, TType.I64, 'providerId', None, None, ), # 2
9186 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9187 
  )
9188 
 
3064 chandransh 9189 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9190 
    self.warehouseId = warehouseId
1408 ankur.sing 9191 
    self.providerId = providerId
3064 chandransh 9192 
    self.cod = cod
1408 ankur.sing 9193 
 
9194 
  def read(self, iprot):
9195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9197 
      return
9198 
    iprot.readStructBegin()
9199 
    while True:
9200 
      (fname, ftype, fid) = iprot.readFieldBegin()
9201 
      if ftype == TType.STOP:
9202 
        break
9203 
      if fid == 1:
9204 
        if ftype == TType.I64:
3064 chandransh 9205 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      elif fid == 2:
9209 
        if ftype == TType.I64:
3064 chandransh 9210 
          self.providerId = iprot.readI64();
1408 ankur.sing 9211 
        else:
9212 
          iprot.skip(ftype)
3064 chandransh 9213 
      elif fid == 3:
9214 
        if ftype == TType.BOOL:
9215 
          self.cod = iprot.readBool();
9216 
        else:
9217 
          iprot.skip(ftype)
1408 ankur.sing 9218 
      else:
9219 
        iprot.skip(ftype)
9220 
      iprot.readFieldEnd()
9221 
    iprot.readStructEnd()
9222 
 
9223 
  def write(self, oprot):
9224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9226 
      return
3064 chandransh 9227 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9228 
    if self.warehouseId is not None:
3064 chandransh 9229 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9230 
      oprot.writeI64(self.warehouseId)
9231 
      oprot.writeFieldEnd()
3431 rajveer 9232 
    if self.providerId is not None:
3064 chandransh 9233 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9234 
      oprot.writeI64(self.providerId)
9235 
      oprot.writeFieldEnd()
3431 rajveer 9236 
    if self.cod is not None:
3064 chandransh 9237 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9238 
      oprot.writeBool(self.cod)
1408 ankur.sing 9239 
      oprot.writeFieldEnd()
9240 
    oprot.writeFieldStop()
9241 
    oprot.writeStructEnd()
9242 
 
3431 rajveer 9243 
  def validate(self):
9244 
    return
9245 
 
9246 
 
1408 ankur.sing 9247 
  def __repr__(self):
9248 
    L = ['%s=%r' % (key, value)
9249 
      for key, value in self.__dict__.iteritems()]
9250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9251 
 
9252 
  def __eq__(self, other):
9253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9254 
 
9255 
  def __ne__(self, other):
9256 
    return not (self == other)
9257 
 
3064 chandransh 9258 
class markOrdersAsManifested_result:
1408 ankur.sing 9259 
  """
9260 
  Attributes:
9261 
   - success
3064 chandransh 9262 
   - ex
1408 ankur.sing 9263 
  """
9264 
 
9265 
  thrift_spec = (
3064 chandransh 9266 
    (0, TType.BOOL, 'success', None, None, ), # 0
9267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9268 
  )
9269 
 
3064 chandransh 9270 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9271 
    self.success = success
3064 chandransh 9272 
    self.ex = ex
1408 ankur.sing 9273 
 
9274 
  def read(self, iprot):
9275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9277 
      return
9278 
    iprot.readStructBegin()
9279 
    while True:
9280 
      (fname, ftype, fid) = iprot.readFieldBegin()
9281 
      if ftype == TType.STOP:
9282 
        break
9283 
      if fid == 0:
3064 chandransh 9284 
        if ftype == TType.BOOL:
9285 
          self.success = iprot.readBool();
1408 ankur.sing 9286 
        else:
9287 
          iprot.skip(ftype)
3064 chandransh 9288 
      elif fid == 1:
9289 
        if ftype == TType.STRUCT:
9290 
          self.ex = TransactionServiceException()
9291 
          self.ex.read(iprot)
9292 
        else:
9293 
          iprot.skip(ftype)
1408 ankur.sing 9294 
      else:
9295 
        iprot.skip(ftype)
9296 
      iprot.readFieldEnd()
9297 
    iprot.readStructEnd()
9298 
 
9299 
  def write(self, oprot):
9300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9302 
      return
3064 chandransh 9303 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9304 
    if self.success is not None:
3064 chandransh 9305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9306 
      oprot.writeBool(self.success)
1408 ankur.sing 9307 
      oprot.writeFieldEnd()
3431 rajveer 9308 
    if self.ex is not None:
3064 chandransh 9309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9310 
      self.ex.write(oprot)
9311 
      oprot.writeFieldEnd()
1408 ankur.sing 9312 
    oprot.writeFieldStop()
9313 
    oprot.writeStructEnd()
9314 
 
3431 rajveer 9315 
  def validate(self):
9316 
    return
9317 
 
9318 
 
1408 ankur.sing 9319 
  def __repr__(self):
9320 
    L = ['%s=%r' % (key, value)
9321 
      for key, value in self.__dict__.iteritems()]
9322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9323 
 
9324 
  def __eq__(self, other):
9325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9326 
 
9327 
  def __ne__(self, other):
9328 
    return not (self == other)
9329 
 
4410 rajveer 9330 
class markOrdersAsShippedFromWarehouse_args:
9331 
  """
9332 
  Attributes:
9333 
   - warehouseId
9334 
   - providerId
9335 
   - cod
9336 
  """
9337 
 
9338 
  thrift_spec = (
9339 
    None, # 0
9340 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9341 
    (2, TType.I64, 'providerId', None, None, ), # 2
9342 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9343 
  )
9344 
 
9345 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9346 
    self.warehouseId = warehouseId
9347 
    self.providerId = providerId
9348 
    self.cod = cod
9349 
 
9350 
  def read(self, iprot):
9351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9353 
      return
9354 
    iprot.readStructBegin()
9355 
    while True:
9356 
      (fname, ftype, fid) = iprot.readFieldBegin()
9357 
      if ftype == TType.STOP:
9358 
        break
9359 
      if fid == 1:
9360 
        if ftype == TType.I64:
9361 
          self.warehouseId = iprot.readI64();
9362 
        else:
9363 
          iprot.skip(ftype)
9364 
      elif fid == 2:
9365 
        if ftype == TType.I64:
9366 
          self.providerId = iprot.readI64();
9367 
        else:
9368 
          iprot.skip(ftype)
9369 
      elif fid == 3:
9370 
        if ftype == TType.BOOL:
9371 
          self.cod = iprot.readBool();
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      else:
9375 
        iprot.skip(ftype)
9376 
      iprot.readFieldEnd()
9377 
    iprot.readStructEnd()
9378 
 
9379 
  def write(self, oprot):
9380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9382 
      return
9383 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9384 
    if self.warehouseId is not None:
9385 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9386 
      oprot.writeI64(self.warehouseId)
9387 
      oprot.writeFieldEnd()
9388 
    if self.providerId is not None:
9389 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9390 
      oprot.writeI64(self.providerId)
9391 
      oprot.writeFieldEnd()
9392 
    if self.cod is not None:
9393 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9394 
      oprot.writeBool(self.cod)
9395 
      oprot.writeFieldEnd()
9396 
    oprot.writeFieldStop()
9397 
    oprot.writeStructEnd()
9398 
 
9399 
  def validate(self):
9400 
    return
9401 
 
9402 
 
9403 
  def __repr__(self):
9404 
    L = ['%s=%r' % (key, value)
9405 
      for key, value in self.__dict__.iteritems()]
9406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9407 
 
9408 
  def __eq__(self, other):
9409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9410 
 
9411 
  def __ne__(self, other):
9412 
    return not (self == other)
9413 
 
9414 
class markOrdersAsShippedFromWarehouse_result:
9415 
  """
9416 
  Attributes:
9417 
   - success
9418 
   - ex
9419 
  """
9420 
 
9421 
  thrift_spec = (
9422 
    (0, TType.BOOL, 'success', None, None, ), # 0
9423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9424 
  )
9425 
 
9426 
  def __init__(self, success=None, ex=None,):
9427 
    self.success = success
9428 
    self.ex = ex
9429 
 
9430 
  def read(self, iprot):
9431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9433 
      return
9434 
    iprot.readStructBegin()
9435 
    while True:
9436 
      (fname, ftype, fid) = iprot.readFieldBegin()
9437 
      if ftype == TType.STOP:
9438 
        break
9439 
      if fid == 0:
9440 
        if ftype == TType.BOOL:
9441 
          self.success = iprot.readBool();
9442 
        else:
9443 
          iprot.skip(ftype)
9444 
      elif fid == 1:
9445 
        if ftype == TType.STRUCT:
9446 
          self.ex = TransactionServiceException()
9447 
          self.ex.read(iprot)
9448 
        else:
9449 
          iprot.skip(ftype)
9450 
      else:
9451 
        iprot.skip(ftype)
9452 
      iprot.readFieldEnd()
9453 
    iprot.readStructEnd()
9454 
 
9455 
  def write(self, oprot):
9456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9458 
      return
9459 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9460 
    if self.success is not None:
9461 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9462 
      oprot.writeBool(self.success)
9463 
      oprot.writeFieldEnd()
9464 
    if self.ex is not None:
9465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9466 
      self.ex.write(oprot)
9467 
      oprot.writeFieldEnd()
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
3064 chandransh 9486 
class markOrdersAsPickedUp_args:
304 ashish 9487 
  """
9488 
  Attributes:
3064 chandransh 9489 
   - providerId
9490 
   - pickupDetails
304 ashish 9491 
  """
94 ashish 9492 
 
304 ashish 9493 
  thrift_spec = (
9494 
    None, # 0
3064 chandransh 9495 
    (1, TType.I64, 'providerId', None, None, ), # 1
9496 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9497 
  )
9498 
 
3064 chandransh 9499 
  def __init__(self, providerId=None, pickupDetails=None,):
9500 
    self.providerId = providerId
9501 
    self.pickupDetails = pickupDetails
304 ashish 9502 
 
9503 
  def read(self, iprot):
9504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9506 
      return
9507 
    iprot.readStructBegin()
9508 
    while True:
9509 
      (fname, ftype, fid) = iprot.readFieldBegin()
9510 
      if ftype == TType.STOP:
9511 
        break
9512 
      if fid == 1:
9513 
        if ftype == TType.I64:
3064 chandransh 9514 
          self.providerId = iprot.readI64();
304 ashish 9515 
        else:
9516 
          iprot.skip(ftype)
9517 
      elif fid == 2:
3064 chandransh 9518 
        if ftype == TType.MAP:
9519 
          self.pickupDetails = {}
4133 chandransh 9520 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9521 
          for _i144 in xrange(_size140):
9522 
            _key145 = iprot.readString();
9523 
            _val146 = iprot.readString();
9524 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9525 
          iprot.readMapEnd()
304 ashish 9526 
        else:
9527 
          iprot.skip(ftype)
9528 
      else:
9529 
        iprot.skip(ftype)
9530 
      iprot.readFieldEnd()
9531 
    iprot.readStructEnd()
9532 
 
9533 
  def write(self, oprot):
9534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9536 
      return
3064 chandransh 9537 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9538 
    if self.providerId is not None:
3064 chandransh 9539 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9540 
      oprot.writeI64(self.providerId)
304 ashish 9541 
      oprot.writeFieldEnd()
3431 rajveer 9542 
    if self.pickupDetails is not None:
3064 chandransh 9543 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9544 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9545 
      for kiter147,viter148 in self.pickupDetails.items():
9546 
        oprot.writeString(kiter147)
9547 
        oprot.writeString(viter148)
3064 chandransh 9548 
      oprot.writeMapEnd()
304 ashish 9549 
      oprot.writeFieldEnd()
9550 
    oprot.writeFieldStop()
9551 
    oprot.writeStructEnd()
9552 
 
3431 rajveer 9553 
  def validate(self):
9554 
    return
9555 
 
9556 
 
304 ashish 9557 
  def __repr__(self):
9558 
    L = ['%s=%r' % (key, value)
9559 
      for key, value in self.__dict__.iteritems()]
9560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9561 
 
9562 
  def __eq__(self, other):
9563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9564 
 
9565 
  def __ne__(self, other):
9566 
    return not (self == other)
9567 
 
3064 chandransh 9568 
class markOrdersAsPickedUp_result:
304 ashish 9569 
  """
9570 
  Attributes:
9571 
   - success
3064 chandransh 9572 
   - ex
304 ashish 9573 
  """
9574 
 
9575 
  thrift_spec = (
3064 chandransh 9576 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9578 
  )
9579 
 
3064 chandransh 9580 
  def __init__(self, success=None, ex=None,):
304 ashish 9581 
    self.success = success
3064 chandransh 9582 
    self.ex = ex
304 ashish 9583 
 
9584 
  def read(self, iprot):
9585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9587 
      return
9588 
    iprot.readStructBegin()
9589 
    while True:
9590 
      (fname, ftype, fid) = iprot.readFieldBegin()
9591 
      if ftype == TType.STOP:
9592 
        break
9593 
      if fid == 0:
9594 
        if ftype == TType.LIST:
9595 
          self.success = []
4133 chandransh 9596 
          (_etype152, _size149) = iprot.readListBegin()
9597 
          for _i153 in xrange(_size149):
9598 
            _elem154 = Order()
9599 
            _elem154.read(iprot)
9600 
            self.success.append(_elem154)
304 ashish 9601 
          iprot.readListEnd()
9602 
        else:
9603 
          iprot.skip(ftype)
3064 chandransh 9604 
      elif fid == 1:
9605 
        if ftype == TType.STRUCT:
9606 
          self.ex = TransactionServiceException()
9607 
          self.ex.read(iprot)
9608 
        else:
9609 
          iprot.skip(ftype)
304 ashish 9610 
      else:
9611 
        iprot.skip(ftype)
9612 
      iprot.readFieldEnd()
9613 
    iprot.readStructEnd()
9614 
 
9615 
  def write(self, oprot):
9616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9618 
      return
3064 chandransh 9619 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9620 
    if self.success is not None:
304 ashish 9621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9622 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9623 
      for iter155 in self.success:
9624 
        iter155.write(oprot)
304 ashish 9625 
      oprot.writeListEnd()
9626 
      oprot.writeFieldEnd()
3431 rajveer 9627 
    if self.ex is not None:
3064 chandransh 9628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9629 
      self.ex.write(oprot)
9630 
      oprot.writeFieldEnd()
304 ashish 9631 
    oprot.writeFieldStop()
9632 
    oprot.writeStructEnd()
9633 
 
3431 rajveer 9634 
  def validate(self):
9635 
    return
9636 
 
9637 
 
304 ashish 9638 
  def __repr__(self):
9639 
    L = ['%s=%r' % (key, value)
9640 
      for key, value in self.__dict__.iteritems()]
9641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9642 
 
9643 
  def __eq__(self, other):
9644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9645 
 
9646 
  def __ne__(self, other):
9647 
    return not (self == other)
9648 
 
3064 chandransh 9649 
class markOrdersAsDelivered_args:
304 ashish 9650 
  """
9651 
  Attributes:
3064 chandransh 9652 
   - providerId
9653 
   - deliveredOrders
304 ashish 9654 
  """
9655 
 
9656 
  thrift_spec = (
9657 
    None, # 0
3064 chandransh 9658 
    (1, TType.I64, 'providerId', None, None, ), # 1
9659 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9660 
  )
9661 
 
3064 chandransh 9662 
  def __init__(self, providerId=None, deliveredOrders=None,):
9663 
    self.providerId = providerId
9664 
    self.deliveredOrders = deliveredOrders
304 ashish 9665 
 
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
9675 
      if fid == 1:
9676 
        if ftype == TType.I64:
3064 chandransh 9677 
          self.providerId = iprot.readI64();
304 ashish 9678 
        else:
9679 
          iprot.skip(ftype)
9680 
      elif fid == 2:
3064 chandransh 9681 
        if ftype == TType.MAP:
9682 
          self.deliveredOrders = {}
4133 chandransh 9683 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9684 
          for _i160 in xrange(_size156):
9685 
            _key161 = iprot.readString();
9686 
            _val162 = iprot.readString();
9687 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9688 
          iprot.readMapEnd()
304 ashish 9689 
        else:
9690 
          iprot.skip(ftype)
9691 
      else:
9692 
        iprot.skip(ftype)
9693 
      iprot.readFieldEnd()
9694 
    iprot.readStructEnd()
9695 
 
9696 
  def write(self, oprot):
9697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9699 
      return
3064 chandransh 9700 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9701 
    if self.providerId is not None:
3064 chandransh 9702 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9703 
      oprot.writeI64(self.providerId)
304 ashish 9704 
      oprot.writeFieldEnd()
3431 rajveer 9705 
    if self.deliveredOrders is not None:
3064 chandransh 9706 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9707 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9708 
      for kiter163,viter164 in self.deliveredOrders.items():
9709 
        oprot.writeString(kiter163)
9710 
        oprot.writeString(viter164)
3064 chandransh 9711 
      oprot.writeMapEnd()
304 ashish 9712 
      oprot.writeFieldEnd()
9713 
    oprot.writeFieldStop()
9714 
    oprot.writeStructEnd()
9715 
 
3431 rajveer 9716 
  def validate(self):
9717 
    return
9718 
 
9719 
 
304 ashish 9720 
  def __repr__(self):
9721 
    L = ['%s=%r' % (key, value)
9722 
      for key, value in self.__dict__.iteritems()]
9723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9724 
 
9725 
  def __eq__(self, other):
9726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9727 
 
9728 
  def __ne__(self, other):
9729 
    return not (self == other)
9730 
 
3064 chandransh 9731 
class markOrdersAsDelivered_result:
9732 
  """
9733 
  Attributes:
9734 
   - ex
9735 
  """
304 ashish 9736 
 
9737 
  thrift_spec = (
3064 chandransh 9738 
    None, # 0
9739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9740 
  )
9741 
 
3064 chandransh 9742 
  def __init__(self, ex=None,):
9743 
    self.ex = ex
304 ashish 9744 
 
1596 ankur.sing 9745 
  def read(self, iprot):
9746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9748 
      return
9749 
    iprot.readStructBegin()
9750 
    while True:
9751 
      (fname, ftype, fid) = iprot.readFieldBegin()
9752 
      if ftype == TType.STOP:
9753 
        break
3064 chandransh 9754 
      if fid == 1:
9755 
        if ftype == TType.STRUCT:
9756 
          self.ex = TransactionServiceException()
9757 
          self.ex.read(iprot)
9758 
        else:
9759 
          iprot.skip(ftype)
1596 ankur.sing 9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
3064 chandransh 9769 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9770 
    if self.ex is not None:
3064 chandransh 9771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9772 
      self.ex.write(oprot)
9773 
      oprot.writeFieldEnd()
1596 ankur.sing 9774 
    oprot.writeFieldStop()
9775 
    oprot.writeStructEnd()
9776 
 
3431 rajveer 9777 
  def validate(self):
9778 
    return
9779 
 
9780 
 
1596 ankur.sing 9781 
  def __repr__(self):
9782 
    L = ['%s=%r' % (key, value)
9783 
      for key, value in self.__dict__.iteritems()]
9784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9785 
 
9786 
  def __eq__(self, other):
9787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9788 
 
9789 
  def __ne__(self, other):
9790 
    return not (self == other)
9791 
 
3064 chandransh 9792 
class markOrdersAsFailed_args:
1596 ankur.sing 9793 
  """
9794 
  Attributes:
3064 chandransh 9795 
   - providerId
9796 
   - returnedOrders
1596 ankur.sing 9797 
  """
9798 
 
9799 
  thrift_spec = (
3064 chandransh 9800 
    None, # 0
9801 
    (1, TType.I64, 'providerId', None, None, ), # 1
9802 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9803 
  )
9804 
 
3064 chandransh 9805 
  def __init__(self, providerId=None, returnedOrders=None,):
9806 
    self.providerId = providerId
9807 
    self.returnedOrders = returnedOrders
1596 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:
1596 ankur.sing 9819 
        if ftype == TType.I64:
3064 chandransh 9820 
          self.providerId = iprot.readI64();
1596 ankur.sing 9821 
        else:
9822 
          iprot.skip(ftype)
3064 chandransh 9823 
      elif fid == 2:
9824 
        if ftype == TType.MAP:
9825 
          self.returnedOrders = {}
4133 chandransh 9826 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9827 
          for _i169 in xrange(_size165):
9828 
            _key170 = iprot.readString();
9829 
            _val171 = iprot.readString();
9830 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9831 
          iprot.readMapEnd()
9832 
        else:
9833 
          iprot.skip(ftype)
1596 ankur.sing 9834 
      else:
9835 
        iprot.skip(ftype)
9836 
      iprot.readFieldEnd()
9837 
    iprot.readStructEnd()
9838 
 
9839 
  def write(self, oprot):
9840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9842 
      return
3064 chandransh 9843 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9844 
    if self.providerId is not None:
3064 chandransh 9845 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9846 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9847 
      oprot.writeFieldEnd()
3431 rajveer 9848 
    if self.returnedOrders is not None:
3064 chandransh 9849 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9850 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9851 
      for kiter172,viter173 in self.returnedOrders.items():
9852 
        oprot.writeString(kiter172)
9853 
        oprot.writeString(viter173)
3064 chandransh 9854 
      oprot.writeMapEnd()
9855 
      oprot.writeFieldEnd()
1596 ankur.sing 9856 
    oprot.writeFieldStop()
9857 
    oprot.writeStructEnd()
9858 
 
3431 rajveer 9859 
  def validate(self):
9860 
    return
9861 
 
9862 
 
1596 ankur.sing 9863 
  def __repr__(self):
9864 
    L = ['%s=%r' % (key, value)
9865 
      for key, value in self.__dict__.iteritems()]
9866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9867 
 
9868 
  def __eq__(self, other):
9869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9870 
 
9871 
  def __ne__(self, other):
9872 
    return not (self == other)
9873 
 
3064 chandransh 9874 
class markOrdersAsFailed_result:
9875 
  """
9876 
  Attributes:
9877 
   - ex
9878 
  """
1596 ankur.sing 9879 
 
1627 ankur.sing 9880 
  thrift_spec = (
3064 chandransh 9881 
    None, # 0
9882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9883 
  )
9884 
 
3064 chandransh 9885 
  def __init__(self, ex=None,):
9886 
    self.ex = ex
9887 
 
1627 ankur.sing 9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
3064 chandransh 9897 
      if fid == 1:
9898 
        if ftype == TType.STRUCT:
9899 
          self.ex = TransactionServiceException()
9900 
          self.ex.read(iprot)
9901 
        else:
9902 
          iprot.skip(ftype)
1627 ankur.sing 9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
3064 chandransh 9912 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9913 
    if self.ex is not None:
3064 chandransh 9914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9915 
      self.ex.write(oprot)
9916 
      oprot.writeFieldEnd()
1627 ankur.sing 9917 
    oprot.writeFieldStop()
9918 
    oprot.writeStructEnd()
9919 
 
3431 rajveer 9920 
  def validate(self):
9921 
    return
9922 
 
9923 
 
1627 ankur.sing 9924 
  def __repr__(self):
9925 
    L = ['%s=%r' % (key, value)
9926 
      for key, value in self.__dict__.iteritems()]
9927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9928 
 
9929 
  def __eq__(self, other):
9930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9931 
 
9932 
  def __ne__(self, other):
9933 
    return not (self == other)
9934 
 
3064 chandransh 9935 
class updateNonDeliveryReason_args:
1627 ankur.sing 9936 
  """
9937 
  Attributes:
3064 chandransh 9938 
   - providerId
9939 
   - undeliveredOrders
1627 ankur.sing 9940 
  """
9941 
 
9942 
  thrift_spec = (
3064 chandransh 9943 
    None, # 0
9944 
    (1, TType.I64, 'providerId', None, None, ), # 1
9945 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9946 
  )
9947 
 
3064 chandransh 9948 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9949 
    self.providerId = providerId
9950 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9951 
 
9952 
  def read(self, iprot):
9953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9955 
      return
9956 
    iprot.readStructBegin()
9957 
    while True:
9958 
      (fname, ftype, fid) = iprot.readFieldBegin()
9959 
      if ftype == TType.STOP:
9960 
        break
3064 chandransh 9961 
      if fid == 1:
1627 ankur.sing 9962 
        if ftype == TType.I64:
3064 chandransh 9963 
          self.providerId = iprot.readI64();
1627 ankur.sing 9964 
        else:
9965 
          iprot.skip(ftype)
3064 chandransh 9966 
      elif fid == 2:
9967 
        if ftype == TType.MAP:
9968 
          self.undeliveredOrders = {}
4133 chandransh 9969 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9970 
          for _i178 in xrange(_size174):
9971 
            _key179 = iprot.readString();
9972 
            _val180 = iprot.readString();
9973 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9974 
          iprot.readMapEnd()
9975 
        else:
9976 
          iprot.skip(ftype)
1627 ankur.sing 9977 
      else:
9978 
        iprot.skip(ftype)
9979 
      iprot.readFieldEnd()
9980 
    iprot.readStructEnd()
9981 
 
9982 
  def write(self, oprot):
9983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9985 
      return
3064 chandransh 9986 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9987 
    if self.providerId is not None:
3064 chandransh 9988 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9989 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9990 
      oprot.writeFieldEnd()
3431 rajveer 9991 
    if self.undeliveredOrders is not None:
3064 chandransh 9992 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9993 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9994 
      for kiter181,viter182 in self.undeliveredOrders.items():
9995 
        oprot.writeString(kiter181)
9996 
        oprot.writeString(viter182)
3064 chandransh 9997 
      oprot.writeMapEnd()
9998 
      oprot.writeFieldEnd()
1627 ankur.sing 9999 
    oprot.writeFieldStop()
10000 
    oprot.writeStructEnd()
10001 
 
3431 rajveer 10002 
  def validate(self):
10003 
    return
10004 
 
10005 
 
1627 ankur.sing 10006 
  def __repr__(self):
10007 
    L = ['%s=%r' % (key, value)
10008 
      for key, value in self.__dict__.iteritems()]
10009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10010 
 
10011 
  def __eq__(self, other):
10012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10013 
 
10014 
  def __ne__(self, other):
10015 
    return not (self == other)
10016 
 
3064 chandransh 10017 
class updateNonDeliveryReason_result:
1627 ankur.sing 10018 
  """
10019 
  Attributes:
3064 chandransh 10020 
   - ex
1627 ankur.sing 10021 
  """
10022 
 
10023 
  thrift_spec = (
3064 chandransh 10024 
    None, # 0
10025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10026 
  )
10027 
 
3064 chandransh 10028 
  def __init__(self, ex=None,):
10029 
    self.ex = ex
1627 ankur.sing 10030 
 
10031 
  def read(self, iprot):
10032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10034 
      return
10035 
    iprot.readStructBegin()
10036 
    while True:
10037 
      (fname, ftype, fid) = iprot.readFieldBegin()
10038 
      if ftype == TType.STOP:
10039 
        break
3064 chandransh 10040 
      if fid == 1:
10041 
        if ftype == TType.STRUCT:
10042 
          self.ex = TransactionServiceException()
10043 
          self.ex.read(iprot)
1627 ankur.sing 10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      else:
10047 
        iprot.skip(ftype)
10048 
      iprot.readFieldEnd()
10049 
    iprot.readStructEnd()
10050 
 
10051 
  def write(self, oprot):
10052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10054 
      return
3064 chandransh 10055 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10056 
    if self.ex is not None:
3064 chandransh 10057 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10058 
      self.ex.write(oprot)
1627 ankur.sing 10059 
      oprot.writeFieldEnd()
10060 
    oprot.writeFieldStop()
10061 
    oprot.writeStructEnd()
10062 
 
3431 rajveer 10063 
  def validate(self):
10064 
    return
10065 
 
10066 
 
1627 ankur.sing 10067 
  def __repr__(self):
10068 
    L = ['%s=%r' % (key, value)
10069 
      for key, value in self.__dict__.iteritems()]
10070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10071 
 
10072 
  def __eq__(self, other):
10073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10074 
 
10075 
  def __ne__(self, other):
10076 
    return not (self == other)
10077 
 
3064 chandransh 10078 
class getUndeliveredOrders_args:
1886 ankur.sing 10079 
  """
10080 
  Attributes:
3064 chandransh 10081 
   - providerId
10082 
   - warehouseId
1886 ankur.sing 10083 
  """
1627 ankur.sing 10084 
 
1886 ankur.sing 10085 
  thrift_spec = (
10086 
    None, # 0
3064 chandransh 10087 
    (1, TType.I64, 'providerId', None, None, ), # 1
10088 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10089 
  )
10090 
 
3064 chandransh 10091 
  def __init__(self, providerId=None, warehouseId=None,):
10092 
    self.providerId = providerId
10093 
    self.warehouseId = warehouseId
1886 ankur.sing 10094 
 
10095 
  def read(self, iprot):
10096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10098 
      return
10099 
    iprot.readStructBegin()
10100 
    while True:
10101 
      (fname, ftype, fid) = iprot.readFieldBegin()
10102 
      if ftype == TType.STOP:
10103 
        break
10104 
      if fid == 1:
10105 
        if ftype == TType.I64:
3064 chandransh 10106 
          self.providerId = iprot.readI64();
1886 ankur.sing 10107 
        else:
10108 
          iprot.skip(ftype)
3064 chandransh 10109 
      elif fid == 2:
10110 
        if ftype == TType.I64:
10111 
          self.warehouseId = iprot.readI64();
10112 
        else:
10113 
          iprot.skip(ftype)
1886 ankur.sing 10114 
      else:
10115 
        iprot.skip(ftype)
10116 
      iprot.readFieldEnd()
10117 
    iprot.readStructEnd()
10118 
 
10119 
  def write(self, oprot):
10120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10122 
      return
3064 chandransh 10123 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10124 
    if self.providerId is not None:
3064 chandransh 10125 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10126 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10127 
      oprot.writeFieldEnd()
3431 rajveer 10128 
    if self.warehouseId is not None:
3064 chandransh 10129 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10130 
      oprot.writeI64(self.warehouseId)
10131 
      oprot.writeFieldEnd()
1886 ankur.sing 10132 
    oprot.writeFieldStop()
10133 
    oprot.writeStructEnd()
10134 
 
3431 rajveer 10135 
  def validate(self):
10136 
    return
10137 
 
10138 
 
1886 ankur.sing 10139 
  def __repr__(self):
10140 
    L = ['%s=%r' % (key, value)
10141 
      for key, value in self.__dict__.iteritems()]
10142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10143 
 
10144 
  def __eq__(self, other):
10145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10146 
 
10147 
  def __ne__(self, other):
10148 
    return not (self == other)
10149 
 
3064 chandransh 10150 
class getUndeliveredOrders_result:
1886 ankur.sing 10151 
  """
10152 
  Attributes:
10153 
   - success
10154 
  """
10155 
 
10156 
  thrift_spec = (
10157 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10158 
  )
10159 
 
10160 
  def __init__(self, success=None,):
10161 
    self.success = success
10162 
 
10163 
  def read(self, iprot):
10164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10166 
      return
10167 
    iprot.readStructBegin()
10168 
    while True:
10169 
      (fname, ftype, fid) = iprot.readFieldBegin()
10170 
      if ftype == TType.STOP:
10171 
        break
10172 
      if fid == 0:
10173 
        if ftype == TType.LIST:
10174 
          self.success = []
4133 chandransh 10175 
          (_etype186, _size183) = iprot.readListBegin()
10176 
          for _i187 in xrange(_size183):
10177 
            _elem188 = Order()
10178 
            _elem188.read(iprot)
10179 
            self.success.append(_elem188)
1886 ankur.sing 10180 
          iprot.readListEnd()
10181 
        else:
10182 
          iprot.skip(ftype)
10183 
      else:
10184 
        iprot.skip(ftype)
10185 
      iprot.readFieldEnd()
10186 
    iprot.readStructEnd()
10187 
 
10188 
  def write(self, oprot):
10189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10191 
      return
3064 chandransh 10192 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10193 
    if self.success is not None:
1886 ankur.sing 10194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10196 
      for iter189 in self.success:
10197 
        iter189.write(oprot)
1886 ankur.sing 10198 
      oprot.writeListEnd()
10199 
      oprot.writeFieldEnd()
10200 
    oprot.writeFieldStop()
10201 
    oprot.writeStructEnd()
10202 
 
3431 rajveer 10203 
  def validate(self):
10204 
    return
10205 
 
10206 
 
1886 ankur.sing 10207 
  def __repr__(self):
10208 
    L = ['%s=%r' % (key, value)
10209 
      for key, value in self.__dict__.iteritems()]
10210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10211 
 
10212 
  def __eq__(self, other):
10213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10214 
 
10215 
  def __ne__(self, other):
10216 
    return not (self == other)
10217 
 
2536 chandransh 10218 
class toggleDOAFlag_args:
10219 
  """
10220 
  Attributes:
10221 
   - orderId
10222 
  """
1886 ankur.sing 10223 
 
2536 chandransh 10224 
  thrift_spec = (
10225 
    None, # 0
10226 
    (1, TType.I64, 'orderId', None, None, ), # 1
10227 
  )
10228 
 
10229 
  def __init__(self, orderId=None,):
10230 
    self.orderId = orderId
10231 
 
10232 
  def read(self, iprot):
10233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10235 
      return
10236 
    iprot.readStructBegin()
10237 
    while True:
10238 
      (fname, ftype, fid) = iprot.readFieldBegin()
10239 
      if ftype == TType.STOP:
10240 
        break
10241 
      if fid == 1:
10242 
        if ftype == TType.I64:
10243 
          self.orderId = iprot.readI64();
10244 
        else:
10245 
          iprot.skip(ftype)
10246 
      else:
10247 
        iprot.skip(ftype)
10248 
      iprot.readFieldEnd()
10249 
    iprot.readStructEnd()
10250 
 
10251 
  def write(self, oprot):
10252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10254 
      return
10255 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10256 
    if self.orderId is not None:
2536 chandransh 10257 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10258 
      oprot.writeI64(self.orderId)
10259 
      oprot.writeFieldEnd()
10260 
    oprot.writeFieldStop()
10261 
    oprot.writeStructEnd()
10262 
 
3431 rajveer 10263 
  def validate(self):
10264 
    return
10265 
 
10266 
 
2536 chandransh 10267 
  def __repr__(self):
10268 
    L = ['%s=%r' % (key, value)
10269 
      for key, value in self.__dict__.iteritems()]
10270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10271 
 
10272 
  def __eq__(self, other):
10273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10274 
 
10275 
  def __ne__(self, other):
10276 
    return not (self == other)
10277 
 
10278 
class toggleDOAFlag_result:
10279 
  """
10280 
  Attributes:
10281 
   - success
10282 
   - ex
10283 
  """
10284 
 
10285 
  thrift_spec = (
10286 
    (0, TType.BOOL, 'success', None, None, ), # 0
10287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10288 
  )
10289 
 
10290 
  def __init__(self, success=None, ex=None,):
10291 
    self.success = success
10292 
    self.ex = ex
10293 
 
10294 
  def read(self, iprot):
10295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10297 
      return
10298 
    iprot.readStructBegin()
10299 
    while True:
10300 
      (fname, ftype, fid) = iprot.readFieldBegin()
10301 
      if ftype == TType.STOP:
10302 
        break
10303 
      if fid == 0:
10304 
        if ftype == TType.BOOL:
10305 
          self.success = iprot.readBool();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      elif fid == 1:
10309 
        if ftype == TType.STRUCT:
10310 
          self.ex = TransactionServiceException()
10311 
          self.ex.read(iprot)
10312 
        else:
10313 
          iprot.skip(ftype)
10314 
      else:
10315 
        iprot.skip(ftype)
10316 
      iprot.readFieldEnd()
10317 
    iprot.readStructEnd()
10318 
 
10319 
  def write(self, oprot):
10320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10322 
      return
10323 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10324 
    if self.success is not None:
2536 chandransh 10325 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10326 
      oprot.writeBool(self.success)
10327 
      oprot.writeFieldEnd()
3431 rajveer 10328 
    if self.ex is not None:
2536 chandransh 10329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10330 
      self.ex.write(oprot)
10331 
      oprot.writeFieldEnd()
10332 
    oprot.writeFieldStop()
10333 
    oprot.writeStructEnd()
10334 
 
3431 rajveer 10335 
  def validate(self):
10336 
    return
10337 
 
10338 
 
2536 chandransh 10339 
  def __repr__(self):
10340 
    L = ['%s=%r' % (key, value)
10341 
      for key, value in self.__dict__.iteritems()]
10342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10343 
 
10344 
  def __eq__(self, other):
10345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10346 
 
10347 
  def __ne__(self, other):
10348 
    return not (self == other)
10349 
 
10350 
class requestPickupNumber_args:
10351 
  """
10352 
  Attributes:
10353 
   - orderId
10354 
  """
10355 
 
10356 
  thrift_spec = (
10357 
    None, # 0
10358 
    (1, TType.I64, 'orderId', None, None, ), # 1
10359 
  )
10360 
 
10361 
  def __init__(self, orderId=None,):
10362 
    self.orderId = orderId
10363 
 
10364 
  def read(self, iprot):
10365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10367 
      return
10368 
    iprot.readStructBegin()
10369 
    while True:
10370 
      (fname, ftype, fid) = iprot.readFieldBegin()
10371 
      if ftype == TType.STOP:
10372 
        break
10373 
      if fid == 1:
10374 
        if ftype == TType.I64:
10375 
          self.orderId = iprot.readI64();
10376 
        else:
10377 
          iprot.skip(ftype)
10378 
      else:
10379 
        iprot.skip(ftype)
10380 
      iprot.readFieldEnd()
10381 
    iprot.readStructEnd()
10382 
 
10383 
  def write(self, oprot):
10384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10386 
      return
10387 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10388 
    if self.orderId is not None:
2536 chandransh 10389 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10390 
      oprot.writeI64(self.orderId)
10391 
      oprot.writeFieldEnd()
10392 
    oprot.writeFieldStop()
10393 
    oprot.writeStructEnd()
10394 
 
3431 rajveer 10395 
  def validate(self):
10396 
    return
10397 
 
10398 
 
2536 chandransh 10399 
  def __repr__(self):
10400 
    L = ['%s=%r' % (key, value)
10401 
      for key, value in self.__dict__.iteritems()]
10402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10403 
 
10404 
  def __eq__(self, other):
10405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10406 
 
10407 
  def __ne__(self, other):
10408 
    return not (self == other)
10409 
 
10410 
class requestPickupNumber_result:
10411 
  """
10412 
  Attributes:
10413 
   - success
10414 
   - ex
10415 
  """
10416 
 
10417 
  thrift_spec = (
10418 
    (0, TType.BOOL, 'success', None, None, ), # 0
10419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10420 
  )
10421 
 
10422 
  def __init__(self, success=None, ex=None,):
10423 
    self.success = success
10424 
    self.ex = ex
10425 
 
10426 
  def read(self, iprot):
10427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10429 
      return
10430 
    iprot.readStructBegin()
10431 
    while True:
10432 
      (fname, ftype, fid) = iprot.readFieldBegin()
10433 
      if ftype == TType.STOP:
10434 
        break
10435 
      if fid == 0:
10436 
        if ftype == TType.BOOL:
10437 
          self.success = iprot.readBool();
10438 
        else:
10439 
          iprot.skip(ftype)
10440 
      elif fid == 1:
10441 
        if ftype == TType.STRUCT:
10442 
          self.ex = TransactionServiceException()
10443 
          self.ex.read(iprot)
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('requestPickupNumber_result')
3431 rajveer 10456 
    if self.success is not None:
2536 chandransh 10457 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10458 
      oprot.writeBool(self.success)
10459 
      oprot.writeFieldEnd()
3431 rajveer 10460 
    if self.ex is not None:
2536 chandransh 10461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10462 
      self.ex.write(oprot)
10463 
      oprot.writeFieldEnd()
10464 
    oprot.writeFieldStop()
10465 
    oprot.writeStructEnd()
10466 
 
3431 rajveer 10467 
  def validate(self):
10468 
    return
10469 
 
10470 
 
2536 chandransh 10471 
  def __repr__(self):
10472 
    L = ['%s=%r' % (key, value)
10473 
      for key, value in self.__dict__.iteritems()]
10474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10475 
 
10476 
  def __eq__(self, other):
10477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10478 
 
10479 
  def __ne__(self, other):
10480 
    return not (self == other)
10481 
 
10482 
class authorizePickup_args:
10483 
  """
10484 
  Attributes:
10485 
   - orderId
10486 
   - pickupNumber
10487 
  """
10488 
 
10489 
  thrift_spec = (
10490 
    None, # 0
10491 
    (1, TType.I64, 'orderId', None, None, ), # 1
10492 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10493 
  )
10494 
 
10495 
  def __init__(self, orderId=None, pickupNumber=None,):
10496 
    self.orderId = orderId
10497 
    self.pickupNumber = pickupNumber
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 == 1:
10509 
        if ftype == TType.I64:
10510 
          self.orderId = iprot.readI64();
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      elif fid == 2:
10514 
        if ftype == TType.STRING:
10515 
          self.pickupNumber = iprot.readString();
10516 
        else:
10517 
          iprot.skip(ftype)
10518 
      else:
10519 
        iprot.skip(ftype)
10520 
      iprot.readFieldEnd()
10521 
    iprot.readStructEnd()
10522 
 
10523 
  def write(self, oprot):
10524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10526 
      return
10527 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10528 
    if self.orderId is not None:
2536 chandransh 10529 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10530 
      oprot.writeI64(self.orderId)
10531 
      oprot.writeFieldEnd()
3431 rajveer 10532 
    if self.pickupNumber is not None:
2536 chandransh 10533 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10534 
      oprot.writeString(self.pickupNumber)
10535 
      oprot.writeFieldEnd()
10536 
    oprot.writeFieldStop()
10537 
    oprot.writeStructEnd()
10538 
 
3431 rajveer 10539 
  def validate(self):
10540 
    return
10541 
 
10542 
 
2536 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 
 
10554 
class authorizePickup_result:
10555 
  """
10556 
  Attributes:
10557 
   - success
10558 
   - ex
10559 
  """
10560 
 
10561 
  thrift_spec = (
10562 
    (0, TType.BOOL, 'success', None, None, ), # 0
10563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10564 
  )
10565 
 
10566 
  def __init__(self, success=None, ex=None,):
10567 
    self.success = success
10568 
    self.ex = ex
10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      if fid == 0:
10580 
        if ftype == TType.BOOL:
10581 
          self.success = iprot.readBool();
10582 
        else:
10583 
          iprot.skip(ftype)
10584 
      elif fid == 1:
10585 
        if ftype == TType.STRUCT:
10586 
          self.ex = TransactionServiceException()
10587 
          self.ex.read(iprot)
10588 
        else:
10589 
          iprot.skip(ftype)
10590 
      else:
10591 
        iprot.skip(ftype)
10592 
      iprot.readFieldEnd()
10593 
    iprot.readStructEnd()
10594 
 
10595 
  def write(self, oprot):
10596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10598 
      return
10599 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10600 
    if self.success is not None:
2536 chandransh 10601 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10602 
      oprot.writeBool(self.success)
10603 
      oprot.writeFieldEnd()
3431 rajveer 10604 
    if self.ex is not None:
2536 chandransh 10605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10606 
      self.ex.write(oprot)
10607 
      oprot.writeFieldEnd()
10608 
    oprot.writeFieldStop()
10609 
    oprot.writeStructEnd()
10610 
 
3431 rajveer 10611 
  def validate(self):
10612 
    return
10613 
 
10614 
 
2536 chandransh 10615 
  def __repr__(self):
10616 
    L = ['%s=%r' % (key, value)
10617 
      for key, value in self.__dict__.iteritems()]
10618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10619 
 
10620 
  def __eq__(self, other):
10621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10622 
 
10623 
  def __ne__(self, other):
10624 
    return not (self == other)
10625 
 
2764 chandransh 10626 
class markDoasAsPickedUp_args:
10627 
  """
10628 
  Attributes:
10629 
   - providerId
10630 
   - pickupDetails
10631 
  """
10632 
 
10633 
  thrift_spec = (
10634 
    None, # 0
10635 
    (1, TType.I64, 'providerId', None, None, ), # 1
10636 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10637 
  )
10638 
 
10639 
  def __init__(self, providerId=None, pickupDetails=None,):
10640 
    self.providerId = providerId
10641 
    self.pickupDetails = pickupDetails
10642 
 
10643 
  def read(self, iprot):
10644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10646 
      return
10647 
    iprot.readStructBegin()
10648 
    while True:
10649 
      (fname, ftype, fid) = iprot.readFieldBegin()
10650 
      if ftype == TType.STOP:
10651 
        break
10652 
      if fid == 1:
10653 
        if ftype == TType.I64:
10654 
          self.providerId = iprot.readI64();
10655 
        else:
10656 
          iprot.skip(ftype)
10657 
      elif fid == 2:
10658 
        if ftype == TType.MAP:
10659 
          self.pickupDetails = {}
4133 chandransh 10660 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10661 
          for _i194 in xrange(_size190):
10662 
            _key195 = iprot.readString();
10663 
            _val196 = iprot.readString();
10664 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10665 
          iprot.readMapEnd()
10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      else:
10669 
        iprot.skip(ftype)
10670 
      iprot.readFieldEnd()
10671 
    iprot.readStructEnd()
10672 
 
10673 
  def write(self, oprot):
10674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10676 
      return
10677 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10678 
    if self.providerId is not None:
2764 chandransh 10679 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10680 
      oprot.writeI64(self.providerId)
10681 
      oprot.writeFieldEnd()
3431 rajveer 10682 
    if self.pickupDetails is not None:
2764 chandransh 10683 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10684 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10685 
      for kiter197,viter198 in self.pickupDetails.items():
10686 
        oprot.writeString(kiter197)
10687 
        oprot.writeString(viter198)
2764 chandransh 10688 
      oprot.writeMapEnd()
10689 
      oprot.writeFieldEnd()
10690 
    oprot.writeFieldStop()
10691 
    oprot.writeStructEnd()
10692 
 
3431 rajveer 10693 
  def validate(self):
10694 
    return
10695 
 
10696 
 
2764 chandransh 10697 
  def __repr__(self):
10698 
    L = ['%s=%r' % (key, value)
10699 
      for key, value in self.__dict__.iteritems()]
10700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10701 
 
10702 
  def __eq__(self, other):
10703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10704 
 
10705 
  def __ne__(self, other):
10706 
    return not (self == other)
10707 
 
10708 
class markDoasAsPickedUp_result:
10709 
  """
10710 
  Attributes:
10711 
   - success
10712 
  """
10713 
 
10714 
  thrift_spec = (
10715 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10716 
  )
10717 
 
10718 
  def __init__(self, success=None,):
10719 
    self.success = success
10720 
 
10721 
  def read(self, iprot):
10722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10724 
      return
10725 
    iprot.readStructBegin()
10726 
    while True:
10727 
      (fname, ftype, fid) = iprot.readFieldBegin()
10728 
      if ftype == TType.STOP:
10729 
        break
10730 
      if fid == 0:
10731 
        if ftype == TType.LIST:
10732 
          self.success = []
4133 chandransh 10733 
          (_etype202, _size199) = iprot.readListBegin()
10734 
          for _i203 in xrange(_size199):
10735 
            _elem204 = Order()
10736 
            _elem204.read(iprot)
10737 
            self.success.append(_elem204)
2764 chandransh 10738 
          iprot.readListEnd()
10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      else:
10742 
        iprot.skip(ftype)
10743 
      iprot.readFieldEnd()
10744 
    iprot.readStructEnd()
10745 
 
10746 
  def write(self, oprot):
10747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10749 
      return
10750 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10751 
    if self.success is not None:
2764 chandransh 10752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10754 
      for iter205 in self.success:
10755 
        iter205.write(oprot)
2764 chandransh 10756 
      oprot.writeListEnd()
10757 
      oprot.writeFieldEnd()
10758 
    oprot.writeFieldStop()
10759 
    oprot.writeStructEnd()
10760 
 
3431 rajveer 10761 
  def validate(self):
10762 
    return
10763 
 
10764 
 
2764 chandransh 10765 
  def __repr__(self):
10766 
    L = ['%s=%r' % (key, value)
10767 
      for key, value in self.__dict__.iteritems()]
10768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10769 
 
10770 
  def __eq__(self, other):
10771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10772 
 
10773 
  def __ne__(self, other):
10774 
    return not (self == other)
10775 
 
2616 chandransh 10776 
class receiveReturn_args:
2591 chandransh 10777 
  """
10778 
  Attributes:
10779 
   - orderId
10780 
  """
2536 chandransh 10781 
 
2591 chandransh 10782 
  thrift_spec = (
10783 
    None, # 0
10784 
    (1, TType.I64, 'orderId', None, None, ), # 1
10785 
  )
10786 
 
10787 
  def __init__(self, orderId=None,):
10788 
    self.orderId = orderId
10789 
 
10790 
  def read(self, iprot):
10791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10793 
      return
10794 
    iprot.readStructBegin()
10795 
    while True:
10796 
      (fname, ftype, fid) = iprot.readFieldBegin()
10797 
      if ftype == TType.STOP:
10798 
        break
10799 
      if fid == 1:
10800 
        if ftype == TType.I64:
10801 
          self.orderId = iprot.readI64();
10802 
        else:
10803 
          iprot.skip(ftype)
10804 
      else:
10805 
        iprot.skip(ftype)
10806 
      iprot.readFieldEnd()
10807 
    iprot.readStructEnd()
10808 
 
10809 
  def write(self, oprot):
10810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10812 
      return
2616 chandransh 10813 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10814 
    if self.orderId is not None:
2591 chandransh 10815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10816 
      oprot.writeI64(self.orderId)
10817 
      oprot.writeFieldEnd()
10818 
    oprot.writeFieldStop()
10819 
    oprot.writeStructEnd()
10820 
 
3431 rajveer 10821 
  def validate(self):
10822 
    return
10823 
 
10824 
 
2591 chandransh 10825 
  def __repr__(self):
10826 
    L = ['%s=%r' % (key, value)
10827 
      for key, value in self.__dict__.iteritems()]
10828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10829 
 
10830 
  def __eq__(self, other):
10831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10832 
 
10833 
  def __ne__(self, other):
10834 
    return not (self == other)
10835 
 
2616 chandransh 10836 
class receiveReturn_result:
2591 chandransh 10837 
  """
10838 
  Attributes:
10839 
   - success
10840 
   - ex
10841 
  """
10842 
 
10843 
  thrift_spec = (
10844 
    (0, TType.BOOL, 'success', None, None, ), # 0
10845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10846 
  )
10847 
 
10848 
  def __init__(self, success=None, ex=None,):
10849 
    self.success = success
10850 
    self.ex = ex
10851 
 
10852 
  def read(self, iprot):
10853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10855 
      return
10856 
    iprot.readStructBegin()
10857 
    while True:
10858 
      (fname, ftype, fid) = iprot.readFieldBegin()
10859 
      if ftype == TType.STOP:
10860 
        break
10861 
      if fid == 0:
10862 
        if ftype == TType.BOOL:
10863 
          self.success = iprot.readBool();
10864 
        else:
10865 
          iprot.skip(ftype)
10866 
      elif fid == 1:
10867 
        if ftype == TType.STRUCT:
10868 
          self.ex = TransactionServiceException()
10869 
          self.ex.read(iprot)
10870 
        else:
10871 
          iprot.skip(ftype)
10872 
      else:
10873 
        iprot.skip(ftype)
10874 
      iprot.readFieldEnd()
10875 
    iprot.readStructEnd()
10876 
 
10877 
  def write(self, oprot):
10878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10880 
      return
2616 chandransh 10881 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10882 
    if self.success is not None:
2591 chandransh 10883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10884 
      oprot.writeBool(self.success)
10885 
      oprot.writeFieldEnd()
3431 rajveer 10886 
    if self.ex is not None:
2591 chandransh 10887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10888 
      self.ex.write(oprot)
10889 
      oprot.writeFieldEnd()
10890 
    oprot.writeFieldStop()
10891 
    oprot.writeStructEnd()
10892 
 
3431 rajveer 10893 
  def validate(self):
10894 
    return
10895 
 
10896 
 
2591 chandransh 10897 
  def __repr__(self):
10898 
    L = ['%s=%r' % (key, value)
10899 
      for key, value in self.__dict__.iteritems()]
10900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10901 
 
10902 
  def __eq__(self, other):
10903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10904 
 
10905 
  def __ne__(self, other):
10906 
    return not (self == other)
10907 
 
10908 
class validateDoa_args:
10909 
  """
10910 
  Attributes:
10911 
   - orderId
10912 
   - isValid
10913 
  """
10914 
 
10915 
  thrift_spec = (
10916 
    None, # 0
10917 
    (1, TType.I64, 'orderId', None, None, ), # 1
10918 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10919 
  )
10920 
 
10921 
  def __init__(self, orderId=None, isValid=None,):
10922 
    self.orderId = orderId
10923 
    self.isValid = isValid
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      if fid == 1:
10935 
        if ftype == TType.I64:
10936 
          self.orderId = iprot.readI64();
10937 
        else:
10938 
          iprot.skip(ftype)
10939 
      elif fid == 2:
10940 
        if ftype == TType.BOOL:
10941 
          self.isValid = iprot.readBool();
10942 
        else:
10943 
          iprot.skip(ftype)
10944 
      else:
10945 
        iprot.skip(ftype)
10946 
      iprot.readFieldEnd()
10947 
    iprot.readStructEnd()
10948 
 
10949 
  def write(self, oprot):
10950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10952 
      return
10953 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10954 
    if self.orderId is not None:
2591 chandransh 10955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10956 
      oprot.writeI64(self.orderId)
10957 
      oprot.writeFieldEnd()
3431 rajveer 10958 
    if self.isValid is not None:
2591 chandransh 10959 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10960 
      oprot.writeBool(self.isValid)
10961 
      oprot.writeFieldEnd()
10962 
    oprot.writeFieldStop()
10963 
    oprot.writeStructEnd()
10964 
 
3431 rajveer 10965 
  def validate(self):
10966 
    return
10967 
 
10968 
 
2591 chandransh 10969 
  def __repr__(self):
10970 
    L = ['%s=%r' % (key, value)
10971 
      for key, value in self.__dict__.iteritems()]
10972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10973 
 
10974 
  def __eq__(self, other):
10975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10976 
 
10977 
  def __ne__(self, other):
10978 
    return not (self == other)
10979 
 
10980 
class validateDoa_result:
10981 
  """
10982 
  Attributes:
10983 
   - success
10984 
   - ex
10985 
  """
10986 
 
10987 
  thrift_spec = (
10988 
    (0, TType.BOOL, 'success', None, None, ), # 0
10989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10990 
  )
10991 
 
10992 
  def __init__(self, success=None, ex=None,):
10993 
    self.success = success
10994 
    self.ex = ex
10995 
 
10996 
  def read(self, iprot):
10997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10999 
      return
11000 
    iprot.readStructBegin()
11001 
    while True:
11002 
      (fname, ftype, fid) = iprot.readFieldBegin()
11003 
      if ftype == TType.STOP:
11004 
        break
11005 
      if fid == 0:
11006 
        if ftype == TType.BOOL:
11007 
          self.success = iprot.readBool();
11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      elif fid == 1:
11011 
        if ftype == TType.STRUCT:
11012 
          self.ex = TransactionServiceException()
11013 
          self.ex.read(iprot)
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      else:
11017 
        iprot.skip(ftype)
11018 
      iprot.readFieldEnd()
11019 
    iprot.readStructEnd()
11020 
 
11021 
  def write(self, oprot):
11022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11024 
      return
11025 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 11026 
    if self.success is not None:
2591 chandransh 11027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11028 
      oprot.writeBool(self.success)
11029 
      oprot.writeFieldEnd()
3431 rajveer 11030 
    if self.ex is not None:
2591 chandransh 11031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11032 
      self.ex.write(oprot)
11033 
      oprot.writeFieldEnd()
11034 
    oprot.writeFieldStop()
11035 
    oprot.writeStructEnd()
11036 
 
3431 rajveer 11037 
  def validate(self):
11038 
    return
11039 
 
11040 
 
2591 chandransh 11041 
  def __repr__(self):
11042 
    L = ['%s=%r' % (key, value)
11043 
      for key, value in self.__dict__.iteritems()]
11044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11045 
 
11046 
  def __eq__(self, other):
11047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11048 
 
11049 
  def __ne__(self, other):
11050 
    return not (self == other)
11051 
 
2616 chandransh 11052 
class reshipOrder_args:
11053 
  """
11054 
  Attributes:
11055 
   - orderId
11056 
  """
2591 chandransh 11057 
 
2616 chandransh 11058 
  thrift_spec = (
11059 
    None, # 0
11060 
    (1, TType.I64, 'orderId', None, None, ), # 1
11061 
  )
11062 
 
11063 
  def __init__(self, orderId=None,):
11064 
    self.orderId = orderId
11065 
 
11066 
  def read(self, iprot):
11067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11069 
      return
11070 
    iprot.readStructBegin()
11071 
    while True:
11072 
      (fname, ftype, fid) = iprot.readFieldBegin()
11073 
      if ftype == TType.STOP:
11074 
        break
11075 
      if fid == 1:
11076 
        if ftype == TType.I64:
11077 
          self.orderId = iprot.readI64();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      else:
11081 
        iprot.skip(ftype)
11082 
      iprot.readFieldEnd()
11083 
    iprot.readStructEnd()
11084 
 
11085 
  def write(self, oprot):
11086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11088 
      return
11089 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 11090 
    if self.orderId is not None:
2616 chandransh 11091 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11092 
      oprot.writeI64(self.orderId)
11093 
      oprot.writeFieldEnd()
11094 
    oprot.writeFieldStop()
11095 
    oprot.writeStructEnd()
11096 
 
3431 rajveer 11097 
  def validate(self):
11098 
    return
11099 
 
11100 
 
2616 chandransh 11101 
  def __repr__(self):
11102 
    L = ['%s=%r' % (key, value)
11103 
      for key, value in self.__dict__.iteritems()]
11104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11105 
 
11106 
  def __eq__(self, other):
11107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11108 
 
11109 
  def __ne__(self, other):
11110 
    return not (self == other)
11111 
 
11112 
class reshipOrder_result:
11113 
  """
11114 
  Attributes:
11115 
   - success
11116 
   - ex
11117 
  """
11118 
 
11119 
  thrift_spec = (
11120 
    (0, TType.I64, 'success', None, None, ), # 0
11121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11122 
  )
11123 
 
11124 
  def __init__(self, success=None, ex=None,):
11125 
    self.success = success
11126 
    self.ex = ex
11127 
 
11128 
  def read(self, iprot):
11129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11131 
      return
11132 
    iprot.readStructBegin()
11133 
    while True:
11134 
      (fname, ftype, fid) = iprot.readFieldBegin()
11135 
      if ftype == TType.STOP:
11136 
        break
11137 
      if fid == 0:
11138 
        if ftype == TType.I64:
11139 
          self.success = iprot.readI64();
11140 
        else:
11141 
          iprot.skip(ftype)
11142 
      elif fid == 1:
11143 
        if ftype == TType.STRUCT:
11144 
          self.ex = TransactionServiceException()
11145 
          self.ex.read(iprot)
11146 
        else:
11147 
          iprot.skip(ftype)
11148 
      else:
11149 
        iprot.skip(ftype)
11150 
      iprot.readFieldEnd()
11151 
    iprot.readStructEnd()
11152 
 
11153 
  def write(self, oprot):
11154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11156 
      return
11157 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 11158 
    if self.success is not None:
2616 chandransh 11159 
      oprot.writeFieldBegin('success', TType.I64, 0)
11160 
      oprot.writeI64(self.success)
11161 
      oprot.writeFieldEnd()
3431 rajveer 11162 
    if self.ex is not None:
2616 chandransh 11163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11164 
      self.ex.write(oprot)
11165 
      oprot.writeFieldEnd()
11166 
    oprot.writeFieldStop()
11167 
    oprot.writeStructEnd()
11168 
 
3431 rajveer 11169 
  def validate(self):
11170 
    return
11171 
 
11172 
 
2616 chandransh 11173 
  def __repr__(self):
11174 
    L = ['%s=%r' % (key, value)
11175 
      for key, value in self.__dict__.iteritems()]
11176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11177 
 
11178 
  def __eq__(self, other):
11179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11180 
 
11181 
  def __ne__(self, other):
11182 
    return not (self == other)
11183 
 
11184 
class refundOrder_args:
11185 
  """
11186 
  Attributes:
11187 
   - orderId
3226 chandransh 11188 
   - refundedBy
11189 
   - reason
2616 chandransh 11190 
  """
11191 
 
11192 
  thrift_spec = (
11193 
    None, # 0
11194 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 11195 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
11196 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 11197 
  )
11198 
 
3226 chandransh 11199 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 11200 
    self.orderId = orderId
3226 chandransh 11201 
    self.refundedBy = refundedBy
11202 
    self.reason = reason
2616 chandransh 11203 
 
11204 
  def read(self, iprot):
11205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11207 
      return
11208 
    iprot.readStructBegin()
11209 
    while True:
11210 
      (fname, ftype, fid) = iprot.readFieldBegin()
11211 
      if ftype == TType.STOP:
11212 
        break
11213 
      if fid == 1:
11214 
        if ftype == TType.I64:
11215 
          self.orderId = iprot.readI64();
11216 
        else:
11217 
          iprot.skip(ftype)
3226 chandransh 11218 
      elif fid == 2:
11219 
        if ftype == TType.STRING:
11220 
          self.refundedBy = iprot.readString();
11221 
        else:
11222 
          iprot.skip(ftype)
11223 
      elif fid == 3:
11224 
        if ftype == TType.STRING:
11225 
          self.reason = iprot.readString();
11226 
        else:
11227 
          iprot.skip(ftype)
2616 chandransh 11228 
      else:
11229 
        iprot.skip(ftype)
11230 
      iprot.readFieldEnd()
11231 
    iprot.readStructEnd()
11232 
 
11233 
  def write(self, oprot):
11234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11236 
      return
11237 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 11238 
    if self.orderId is not None:
2616 chandransh 11239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11240 
      oprot.writeI64(self.orderId)
11241 
      oprot.writeFieldEnd()
3431 rajveer 11242 
    if self.refundedBy is not None:
3226 chandransh 11243 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11244 
      oprot.writeString(self.refundedBy)
11245 
      oprot.writeFieldEnd()
3431 rajveer 11246 
    if self.reason is not None:
3226 chandransh 11247 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11248 
      oprot.writeString(self.reason)
11249 
      oprot.writeFieldEnd()
2616 chandransh 11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
3431 rajveer 11253 
  def validate(self):
11254 
    return
11255 
 
11256 
 
2616 chandransh 11257 
  def __repr__(self):
11258 
    L = ['%s=%r' % (key, value)
11259 
      for key, value in self.__dict__.iteritems()]
11260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11261 
 
11262 
  def __eq__(self, other):
11263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11264 
 
11265 
  def __ne__(self, other):
11266 
    return not (self == other)
11267 
 
11268 
class refundOrder_result:
11269 
  """
11270 
  Attributes:
11271 
   - success
11272 
   - ex
11273 
  """
11274 
 
11275 
  thrift_spec = (
11276 
    (0, TType.BOOL, 'success', None, None, ), # 0
11277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11278 
  )
11279 
 
11280 
  def __init__(self, success=None, ex=None,):
11281 
    self.success = success
11282 
    self.ex = ex
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 == 0:
11294 
        if ftype == TType.BOOL:
11295 
          self.success = iprot.readBool();
11296 
        else:
11297 
          iprot.skip(ftype)
11298 
      elif fid == 1:
11299 
        if ftype == TType.STRUCT:
11300 
          self.ex = TransactionServiceException()
11301 
          self.ex.read(iprot)
11302 
        else:
11303 
          iprot.skip(ftype)
11304 
      else:
11305 
        iprot.skip(ftype)
11306 
      iprot.readFieldEnd()
11307 
    iprot.readStructEnd()
11308 
 
11309 
  def write(self, oprot):
11310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11312 
      return
11313 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11314 
    if self.success is not None:
2616 chandransh 11315 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11316 
      oprot.writeBool(self.success)
11317 
      oprot.writeFieldEnd()
3431 rajveer 11318 
    if self.ex is not None:
2616 chandransh 11319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11320 
      self.ex.write(oprot)
11321 
      oprot.writeFieldEnd()
11322 
    oprot.writeFieldStop()
11323 
    oprot.writeStructEnd()
11324 
 
3431 rajveer 11325 
  def validate(self):
11326 
    return
11327 
 
11328 
 
2616 chandransh 11329 
  def __repr__(self):
11330 
    L = ['%s=%r' % (key, value)
11331 
      for key, value in self.__dict__.iteritems()]
11332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11333 
 
11334 
  def __eq__(self, other):
11335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11336 
 
11337 
  def __ne__(self, other):
11338 
    return not (self == other)
11339 
 
2690 chandransh 11340 
class getReturnOrders_args:
11341 
  """
11342 
  Attributes:
11343 
   - warehouseId
11344 
   - fromDate
11345 
   - toDate
11346 
  """
2616 chandransh 11347 
 
2690 chandransh 11348 
  thrift_spec = (
11349 
    None, # 0
11350 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11351 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11352 
    (3, TType.I64, 'toDate', None, None, ), # 3
11353 
  )
11354 
 
11355 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11356 
    self.warehouseId = warehouseId
11357 
    self.fromDate = fromDate
11358 
    self.toDate = toDate
11359 
 
11360 
  def read(self, iprot):
11361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11363 
      return
11364 
    iprot.readStructBegin()
11365 
    while True:
11366 
      (fname, ftype, fid) = iprot.readFieldBegin()
11367 
      if ftype == TType.STOP:
11368 
        break
11369 
      if fid == 1:
11370 
        if ftype == TType.I64:
11371 
          self.warehouseId = iprot.readI64();
11372 
        else:
11373 
          iprot.skip(ftype)
11374 
      elif fid == 2:
11375 
        if ftype == TType.I64:
11376 
          self.fromDate = iprot.readI64();
11377 
        else:
11378 
          iprot.skip(ftype)
11379 
      elif fid == 3:
11380 
        if ftype == TType.I64:
11381 
          self.toDate = iprot.readI64();
11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      else:
11385 
        iprot.skip(ftype)
11386 
      iprot.readFieldEnd()
11387 
    iprot.readStructEnd()
11388 
 
11389 
  def write(self, oprot):
11390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11392 
      return
11393 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11394 
    if self.warehouseId is not None:
2690 chandransh 11395 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11396 
      oprot.writeI64(self.warehouseId)
11397 
      oprot.writeFieldEnd()
3431 rajveer 11398 
    if self.fromDate is not None:
2690 chandransh 11399 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11400 
      oprot.writeI64(self.fromDate)
11401 
      oprot.writeFieldEnd()
3431 rajveer 11402 
    if self.toDate is not None:
2690 chandransh 11403 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11404 
      oprot.writeI64(self.toDate)
11405 
      oprot.writeFieldEnd()
11406 
    oprot.writeFieldStop()
11407 
    oprot.writeStructEnd()
11408 
 
3431 rajveer 11409 
  def validate(self):
11410 
    return
11411 
 
11412 
 
2690 chandransh 11413 
  def __repr__(self):
11414 
    L = ['%s=%r' % (key, value)
11415 
      for key, value in self.__dict__.iteritems()]
11416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11417 
 
11418 
  def __eq__(self, other):
11419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11420 
 
11421 
  def __ne__(self, other):
11422 
    return not (self == other)
11423 
 
11424 
class getReturnOrders_result:
11425 
  """
11426 
  Attributes:
11427 
   - success
11428 
  """
11429 
 
11430 
  thrift_spec = (
11431 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11432 
  )
11433 
 
11434 
  def __init__(self, success=None,):
11435 
    self.success = success
11436 
 
11437 
  def read(self, iprot):
11438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11440 
      return
11441 
    iprot.readStructBegin()
11442 
    while True:
11443 
      (fname, ftype, fid) = iprot.readFieldBegin()
11444 
      if ftype == TType.STOP:
11445 
        break
11446 
      if fid == 0:
11447 
        if ftype == TType.LIST:
11448 
          self.success = []
4133 chandransh 11449 
          (_etype209, _size206) = iprot.readListBegin()
11450 
          for _i210 in xrange(_size206):
11451 
            _elem211 = ReturnOrder()
11452 
            _elem211.read(iprot)
11453 
            self.success.append(_elem211)
2690 chandransh 11454 
          iprot.readListEnd()
11455 
        else:
11456 
          iprot.skip(ftype)
11457 
      else:
11458 
        iprot.skip(ftype)
11459 
      iprot.readFieldEnd()
11460 
    iprot.readStructEnd()
11461 
 
11462 
  def write(self, oprot):
11463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11465 
      return
11466 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11467 
    if self.success is not None:
2690 chandransh 11468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11470 
      for iter212 in self.success:
11471 
        iter212.write(oprot)
2690 chandransh 11472 
      oprot.writeListEnd()
11473 
      oprot.writeFieldEnd()
11474 
    oprot.writeFieldStop()
11475 
    oprot.writeStructEnd()
11476 
 
3431 rajveer 11477 
  def validate(self):
11478 
    return
11479 
 
11480 
 
2690 chandransh 11481 
  def __repr__(self):
11482 
    L = ['%s=%r' % (key, value)
11483 
      for key, value in self.__dict__.iteritems()]
11484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11485 
 
11486 
  def __eq__(self, other):
11487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11488 
 
11489 
  def __ne__(self, other):
11490 
    return not (self == other)
11491 
 
2700 chandransh 11492 
class getReturnOrder_args:
11493 
  """
11494 
  Attributes:
11495 
   - id
11496 
  """
11497 
 
11498 
  thrift_spec = (
11499 
    None, # 0
11500 
    (1, TType.I64, 'id', None, None, ), # 1
11501 
  )
11502 
 
11503 
  def __init__(self, id=None,):
11504 
    self.id = id
11505 
 
11506 
  def read(self, iprot):
11507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11509 
      return
11510 
    iprot.readStructBegin()
11511 
    while True:
11512 
      (fname, ftype, fid) = iprot.readFieldBegin()
11513 
      if ftype == TType.STOP:
11514 
        break
11515 
      if fid == 1:
11516 
        if ftype == TType.I64:
11517 
          self.id = iprot.readI64();
11518 
        else:
11519 
          iprot.skip(ftype)
11520 
      else:
11521 
        iprot.skip(ftype)
11522 
      iprot.readFieldEnd()
11523 
    iprot.readStructEnd()
11524 
 
11525 
  def write(self, oprot):
11526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11528 
      return
11529 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11530 
    if self.id is not None:
2700 chandransh 11531 
      oprot.writeFieldBegin('id', TType.I64, 1)
11532 
      oprot.writeI64(self.id)
11533 
      oprot.writeFieldEnd()
11534 
    oprot.writeFieldStop()
11535 
    oprot.writeStructEnd()
11536 
 
3431 rajveer 11537 
  def validate(self):
11538 
    return
11539 
 
11540 
 
2700 chandransh 11541 
  def __repr__(self):
11542 
    L = ['%s=%r' % (key, value)
11543 
      for key, value in self.__dict__.iteritems()]
11544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11545 
 
11546 
  def __eq__(self, other):
11547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11548 
 
11549 
  def __ne__(self, other):
11550 
    return not (self == other)
11551 
 
11552 
class getReturnOrder_result:
11553 
  """
11554 
  Attributes:
11555 
   - success
11556 
   - ex
11557 
  """
11558 
 
11559 
  thrift_spec = (
11560 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11562 
  )
11563 
 
11564 
  def __init__(self, success=None, ex=None,):
11565 
    self.success = success
11566 
    self.ex = ex
11567 
 
11568 
  def read(self, iprot):
11569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11571 
      return
11572 
    iprot.readStructBegin()
11573 
    while True:
11574 
      (fname, ftype, fid) = iprot.readFieldBegin()
11575 
      if ftype == TType.STOP:
11576 
        break
11577 
      if fid == 0:
11578 
        if ftype == TType.STRUCT:
11579 
          self.success = ReturnOrder()
11580 
          self.success.read(iprot)
11581 
        else:
11582 
          iprot.skip(ftype)
11583 
      elif fid == 1:
11584 
        if ftype == TType.STRUCT:
11585 
          self.ex = TransactionServiceException()
11586 
          self.ex.read(iprot)
11587 
        else:
11588 
          iprot.skip(ftype)
11589 
      else:
11590 
        iprot.skip(ftype)
11591 
      iprot.readFieldEnd()
11592 
    iprot.readStructEnd()
11593 
 
11594 
  def write(self, oprot):
11595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11597 
      return
11598 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11599 
    if self.success is not None:
2700 chandransh 11600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11601 
      self.success.write(oprot)
11602 
      oprot.writeFieldEnd()
3431 rajveer 11603 
    if self.ex is not None:
2700 chandransh 11604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11605 
      self.ex.write(oprot)
11606 
      oprot.writeFieldEnd()
11607 
    oprot.writeFieldStop()
11608 
    oprot.writeStructEnd()
11609 
 
3431 rajveer 11610 
  def validate(self):
11611 
    return
11612 
 
11613 
 
2700 chandransh 11614 
  def __repr__(self):
11615 
    L = ['%s=%r' % (key, value)
11616 
      for key, value in self.__dict__.iteritems()]
11617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11618 
 
11619 
  def __eq__(self, other):
11620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11621 
 
11622 
  def __ne__(self, other):
11623 
    return not (self == other)
11624 
 
2690 chandransh 11625 
class processReturn_args:
11626 
  """
11627 
  Attributes:
11628 
   - returnOrderId
11629 
  """
11630 
 
11631 
  thrift_spec = (
11632 
    None, # 0
11633 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11634 
  )
11635 
 
11636 
  def __init__(self, returnOrderId=None,):
11637 
    self.returnOrderId = returnOrderId
11638 
 
11639 
  def read(self, iprot):
11640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11642 
      return
11643 
    iprot.readStructBegin()
11644 
    while True:
11645 
      (fname, ftype, fid) = iprot.readFieldBegin()
11646 
      if ftype == TType.STOP:
11647 
        break
11648 
      if fid == 1:
11649 
        if ftype == TType.I64:
11650 
          self.returnOrderId = iprot.readI64();
11651 
        else:
11652 
          iprot.skip(ftype)
11653 
      else:
11654 
        iprot.skip(ftype)
11655 
      iprot.readFieldEnd()
11656 
    iprot.readStructEnd()
11657 
 
11658 
  def write(self, oprot):
11659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11661 
      return
11662 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11663 
    if self.returnOrderId is not None:
2690 chandransh 11664 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11665 
      oprot.writeI64(self.returnOrderId)
11666 
      oprot.writeFieldEnd()
11667 
    oprot.writeFieldStop()
11668 
    oprot.writeStructEnd()
11669 
 
3431 rajveer 11670 
  def validate(self):
11671 
    return
11672 
 
11673 
 
2690 chandransh 11674 
  def __repr__(self):
11675 
    L = ['%s=%r' % (key, value)
11676 
      for key, value in self.__dict__.iteritems()]
11677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11678 
 
11679 
  def __eq__(self, other):
11680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11681 
 
11682 
  def __ne__(self, other):
11683 
    return not (self == other)
11684 
 
11685 
class processReturn_result:
11686 
  """
11687 
  Attributes:
11688 
   - ex
11689 
  """
11690 
 
11691 
  thrift_spec = (
11692 
    None, # 0
11693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11694 
  )
11695 
 
11696 
  def __init__(self, ex=None,):
11697 
    self.ex = ex
11698 
 
11699 
  def read(self, iprot):
11700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11702 
      return
11703 
    iprot.readStructBegin()
11704 
    while True:
11705 
      (fname, ftype, fid) = iprot.readFieldBegin()
11706 
      if ftype == TType.STOP:
11707 
        break
11708 
      if fid == 1:
11709 
        if ftype == TType.STRUCT:
11710 
          self.ex = TransactionServiceException()
11711 
          self.ex.read(iprot)
11712 
        else:
11713 
          iprot.skip(ftype)
11714 
      else:
11715 
        iprot.skip(ftype)
11716 
      iprot.readFieldEnd()
11717 
    iprot.readStructEnd()
11718 
 
11719 
  def write(self, oprot):
11720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11722 
      return
11723 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11724 
    if self.ex is not None:
2690 chandransh 11725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11726 
      self.ex.write(oprot)
11727 
      oprot.writeFieldEnd()
11728 
    oprot.writeFieldStop()
11729 
    oprot.writeStructEnd()
11730 
 
3431 rajveer 11731 
  def validate(self):
11732 
    return
11733 
 
11734 
 
2690 chandransh 11735 
  def __repr__(self):
11736 
    L = ['%s=%r' % (key, value)
11737 
      for key, value in self.__dict__.iteritems()]
11738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11739 
 
11740 
  def __eq__(self, other):
11741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11742 
 
11743 
  def __ne__(self, other):
11744 
    return not (self == other)
11745 
 
2819 chandransh 11746 
class createPurchaseOrder_args:
11747 
  """
11748 
  Attributes:
11749 
   - warehouseId
11750 
  """
2690 chandransh 11751 
 
2819 chandransh 11752 
  thrift_spec = (
11753 
    None, # 0
11754 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11755 
  )
11756 
 
11757 
  def __init__(self, warehouseId=None,):
11758 
    self.warehouseId = warehouseId
11759 
 
11760 
  def read(self, iprot):
11761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11763 
      return
11764 
    iprot.readStructBegin()
11765 
    while True:
11766 
      (fname, ftype, fid) = iprot.readFieldBegin()
11767 
      if ftype == TType.STOP:
11768 
        break
11769 
      if fid == 1:
11770 
        if ftype == TType.I64:
11771 
          self.warehouseId = iprot.readI64();
11772 
        else:
11773 
          iprot.skip(ftype)
11774 
      else:
11775 
        iprot.skip(ftype)
11776 
      iprot.readFieldEnd()
11777 
    iprot.readStructEnd()
11778 
 
11779 
  def write(self, oprot):
11780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11782 
      return
11783 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11784 
    if self.warehouseId is not None:
2819 chandransh 11785 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11786 
      oprot.writeI64(self.warehouseId)
11787 
      oprot.writeFieldEnd()
11788 
    oprot.writeFieldStop()
11789 
    oprot.writeStructEnd()
11790 
 
3431 rajveer 11791 
  def validate(self):
11792 
    return
11793 
 
11794 
 
2819 chandransh 11795 
  def __repr__(self):
11796 
    L = ['%s=%r' % (key, value)
11797 
      for key, value in self.__dict__.iteritems()]
11798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11799 
 
11800 
  def __eq__(self, other):
11801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11802 
 
11803 
  def __ne__(self, other):
11804 
    return not (self == other)
11805 
 
11806 
class createPurchaseOrder_result:
11807 
  """
11808 
  Attributes:
11809 
   - success
11810 
   - ex
11811 
  """
11812 
 
11813 
  thrift_spec = (
11814 
    (0, TType.I64, 'success', None, None, ), # 0
11815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11816 
  )
11817 
 
11818 
  def __init__(self, success=None, ex=None,):
11819 
    self.success = success
11820 
    self.ex = ex
11821 
 
11822 
  def read(self, iprot):
11823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11825 
      return
11826 
    iprot.readStructBegin()
11827 
    while True:
11828 
      (fname, ftype, fid) = iprot.readFieldBegin()
11829 
      if ftype == TType.STOP:
11830 
        break
11831 
      if fid == 0:
11832 
        if ftype == TType.I64:
11833 
          self.success = iprot.readI64();
11834 
        else:
11835 
          iprot.skip(ftype)
11836 
      elif fid == 1:
11837 
        if ftype == TType.STRUCT:
11838 
          self.ex = TransactionServiceException()
11839 
          self.ex.read(iprot)
11840 
        else:
11841 
          iprot.skip(ftype)
11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
11851 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11852 
    if self.success is not None:
2819 chandransh 11853 
      oprot.writeFieldBegin('success', TType.I64, 0)
11854 
      oprot.writeI64(self.success)
11855 
      oprot.writeFieldEnd()
3431 rajveer 11856 
    if self.ex is not None:
2819 chandransh 11857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11858 
      self.ex.write(oprot)
11859 
      oprot.writeFieldEnd()
11860 
    oprot.writeFieldStop()
11861 
    oprot.writeStructEnd()
11862 
 
3431 rajveer 11863 
  def validate(self):
11864 
    return
11865 
 
11866 
 
2819 chandransh 11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
3451 chandransh 11877 
 
11878 
class updateWeight_args:
11879 
  """
11880 
  Attributes:
11881 
   - orderId
11882 
   - weight
11883 
  """
11884 
 
11885 
  thrift_spec = (
11886 
    None, # 0
11887 
    (1, TType.I64, 'orderId', None, None, ), # 1
11888 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11889 
  )
11890 
 
11891 
  def __init__(self, orderId=None, weight=None,):
11892 
    self.orderId = orderId
11893 
    self.weight = weight
11894 
 
11895 
  def read(self, iprot):
11896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11898 
      return
11899 
    iprot.readStructBegin()
11900 
    while True:
11901 
      (fname, ftype, fid) = iprot.readFieldBegin()
11902 
      if ftype == TType.STOP:
11903 
        break
11904 
      if fid == 1:
11905 
        if ftype == TType.I64:
11906 
          self.orderId = iprot.readI64();
11907 
        else:
11908 
          iprot.skip(ftype)
11909 
      elif fid == 2:
11910 
        if ftype == TType.DOUBLE:
11911 
          self.weight = iprot.readDouble();
11912 
        else:
11913 
          iprot.skip(ftype)
11914 
      else:
11915 
        iprot.skip(ftype)
11916 
      iprot.readFieldEnd()
11917 
    iprot.readStructEnd()
11918 
 
11919 
  def write(self, oprot):
11920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11922 
      return
11923 
    oprot.writeStructBegin('updateWeight_args')
11924 
    if self.orderId is not None:
11925 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11926 
      oprot.writeI64(self.orderId)
11927 
      oprot.writeFieldEnd()
11928 
    if self.weight is not None:
11929 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11930 
      oprot.writeDouble(self.weight)
11931 
      oprot.writeFieldEnd()
11932 
    oprot.writeFieldStop()
11933 
    oprot.writeStructEnd()
11934 
 
11935 
  def validate(self):
11936 
    return
11937 
 
11938 
 
11939 
  def __repr__(self):
11940 
    L = ['%s=%r' % (key, value)
11941 
      for key, value in self.__dict__.iteritems()]
11942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11943 
 
11944 
  def __eq__(self, other):
11945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11946 
 
11947 
  def __ne__(self, other):
11948 
    return not (self == other)
11949 
 
11950 
class updateWeight_result:
11951 
  """
11952 
  Attributes:
11953 
   - success
11954 
   - ex
11955 
  """
11956 
 
11957 
  thrift_spec = (
11958 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11960 
  )
11961 
 
11962 
  def __init__(self, success=None, ex=None,):
11963 
    self.success = success
11964 
    self.ex = ex
11965 
 
11966 
  def read(self, iprot):
11967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11969 
      return
11970 
    iprot.readStructBegin()
11971 
    while True:
11972 
      (fname, ftype, fid) = iprot.readFieldBegin()
11973 
      if ftype == TType.STOP:
11974 
        break
11975 
      if fid == 0:
11976 
        if ftype == TType.STRUCT:
11977 
          self.success = Order()
11978 
          self.success.read(iprot)
11979 
        else:
11980 
          iprot.skip(ftype)
11981 
      elif fid == 1:
11982 
        if ftype == TType.STRUCT:
11983 
          self.ex = TransactionServiceException()
11984 
          self.ex.read(iprot)
11985 
        else:
11986 
          iprot.skip(ftype)
11987 
      else:
11988 
        iprot.skip(ftype)
11989 
      iprot.readFieldEnd()
11990 
    iprot.readStructEnd()
11991 
 
11992 
  def write(self, oprot):
11993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11995 
      return
11996 
    oprot.writeStructBegin('updateWeight_result')
11997 
    if self.success is not None:
11998 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11999 
      self.success.write(oprot)
12000 
      oprot.writeFieldEnd()
12001 
    if self.ex is not None:
12002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12003 
      self.ex.write(oprot)
12004 
      oprot.writeFieldEnd()
12005 
    oprot.writeFieldStop()
12006 
    oprot.writeStructEnd()
12007 
 
12008 
  def validate(self):
12009 
    return
12010 
 
12011 
 
12012 
  def __repr__(self):
12013 
    L = ['%s=%r' % (key, value)
12014 
      for key, value in self.__dict__.iteritems()]
12015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12016 
 
12017 
  def __eq__(self, other):
12018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12019 
 
12020 
  def __ne__(self, other):
12021 
    return not (self == other)
3469 chandransh 12022 
 
12023 
class changeItem_args:
12024 
  """
12025 
  Attributes:
12026 
   - orderId
12027 
   - itemId
12028 
  """
12029 
 
12030 
  thrift_spec = (
12031 
    None, # 0
12032 
    (1, TType.I64, 'orderId', None, None, ), # 1
12033 
    (2, TType.I64, 'itemId', None, None, ), # 2
12034 
  )
12035 
 
12036 
  def __init__(self, orderId=None, itemId=None,):
12037 
    self.orderId = orderId
12038 
    self.itemId = itemId
12039 
 
12040 
  def read(self, iprot):
12041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12043 
      return
12044 
    iprot.readStructBegin()
12045 
    while True:
12046 
      (fname, ftype, fid) = iprot.readFieldBegin()
12047 
      if ftype == TType.STOP:
12048 
        break
12049 
      if fid == 1:
12050 
        if ftype == TType.I64:
12051 
          self.orderId = iprot.readI64();
12052 
        else:
12053 
          iprot.skip(ftype)
12054 
      elif fid == 2:
12055 
        if ftype == TType.I64:
12056 
          self.itemId = iprot.readI64();
12057 
        else:
12058 
          iprot.skip(ftype)
12059 
      else:
12060 
        iprot.skip(ftype)
12061 
      iprot.readFieldEnd()
12062 
    iprot.readStructEnd()
12063 
 
12064 
  def write(self, oprot):
12065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12067 
      return
12068 
    oprot.writeStructBegin('changeItem_args')
12069 
    if self.orderId is not None:
12070 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12071 
      oprot.writeI64(self.orderId)
12072 
      oprot.writeFieldEnd()
12073 
    if self.itemId is not None:
12074 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12075 
      oprot.writeI64(self.itemId)
12076 
      oprot.writeFieldEnd()
12077 
    oprot.writeFieldStop()
12078 
    oprot.writeStructEnd()
12079 
 
12080 
  def validate(self):
12081 
    return
12082 
 
12083 
 
12084 
  def __repr__(self):
12085 
    L = ['%s=%r' % (key, value)
12086 
      for key, value in self.__dict__.iteritems()]
12087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12088 
 
12089 
  def __eq__(self, other):
12090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12091 
 
12092 
  def __ne__(self, other):
12093 
    return not (self == other)
12094 
 
12095 
class changeItem_result:
12096 
  """
12097 
  Attributes:
12098 
   - success
12099 
   - ex
12100 
  """
12101 
 
12102 
  thrift_spec = (
12103 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12104 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12105 
  )
12106 
 
12107 
  def __init__(self, success=None, ex=None,):
12108 
    self.success = success
12109 
    self.ex = ex
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 == 0:
12121 
        if ftype == TType.STRUCT:
12122 
          self.success = Order()
12123 
          self.success.read(iprot)
12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      elif fid == 1:
12127 
        if ftype == TType.STRUCT:
12128 
          self.ex = TransactionServiceException()
12129 
          self.ex.read(iprot)
12130 
        else:
12131 
          iprot.skip(ftype)
12132 
      else:
12133 
        iprot.skip(ftype)
12134 
      iprot.readFieldEnd()
12135 
    iprot.readStructEnd()
12136 
 
12137 
  def write(self, oprot):
12138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12140 
      return
12141 
    oprot.writeStructBegin('changeItem_result')
12142 
    if self.success is not None:
12143 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12144 
      self.success.write(oprot)
12145 
      oprot.writeFieldEnd()
12146 
    if self.ex is not None:
12147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12148 
      self.ex.write(oprot)
12149 
      oprot.writeFieldEnd()
12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
12168 
class shiftToWarehouse_args:
12169 
  """
12170 
  Attributes:
12171 
   - orderId
12172 
   - warehouseId
12173 
  """
12174 
 
12175 
  thrift_spec = (
12176 
    None, # 0
12177 
    (1, TType.I64, 'orderId', None, None, ), # 1
12178 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12179 
  )
12180 
 
12181 
  def __init__(self, orderId=None, warehouseId=None,):
12182 
    self.orderId = orderId
12183 
    self.warehouseId = warehouseId
12184 
 
12185 
  def read(self, iprot):
12186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12188 
      return
12189 
    iprot.readStructBegin()
12190 
    while True:
12191 
      (fname, ftype, fid) = iprot.readFieldBegin()
12192 
      if ftype == TType.STOP:
12193 
        break
12194 
      if fid == 1:
12195 
        if ftype == TType.I64:
12196 
          self.orderId = iprot.readI64();
12197 
        else:
12198 
          iprot.skip(ftype)
12199 
      elif fid == 2:
12200 
        if ftype == TType.I64:
12201 
          self.warehouseId = iprot.readI64();
12202 
        else:
12203 
          iprot.skip(ftype)
12204 
      else:
12205 
        iprot.skip(ftype)
12206 
      iprot.readFieldEnd()
12207 
    iprot.readStructEnd()
12208 
 
12209 
  def write(self, oprot):
12210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12212 
      return
12213 
    oprot.writeStructBegin('shiftToWarehouse_args')
12214 
    if self.orderId is not None:
12215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12216 
      oprot.writeI64(self.orderId)
12217 
      oprot.writeFieldEnd()
12218 
    if self.warehouseId is not None:
12219 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12220 
      oprot.writeI64(self.warehouseId)
12221 
      oprot.writeFieldEnd()
12222 
    oprot.writeFieldStop()
12223 
    oprot.writeStructEnd()
12224 
 
12225 
  def validate(self):
12226 
    return
12227 
 
12228 
 
12229 
  def __repr__(self):
12230 
    L = ['%s=%r' % (key, value)
12231 
      for key, value in self.__dict__.iteritems()]
12232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12233 
 
12234 
  def __eq__(self, other):
12235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12236 
 
12237 
  def __ne__(self, other):
12238 
    return not (self == other)
12239 
 
12240 
class shiftToWarehouse_result:
12241 
  """
12242 
  Attributes:
12243 
   - success
12244 
   - ex
12245 
  """
12246 
 
12247 
  thrift_spec = (
12248 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12250 
  )
12251 
 
12252 
  def __init__(self, success=None, ex=None,):
12253 
    self.success = success
12254 
    self.ex = ex
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 0:
12266 
        if ftype == TType.STRUCT:
12267 
          self.success = Order()
12268 
          self.success.read(iprot)
12269 
        else:
12270 
          iprot.skip(ftype)
12271 
      elif fid == 1:
12272 
        if ftype == TType.STRUCT:
12273 
          self.ex = TransactionServiceException()
12274 
          self.ex.read(iprot)
12275 
        else:
12276 
          iprot.skip(ftype)
12277 
      else:
12278 
        iprot.skip(ftype)
12279 
      iprot.readFieldEnd()
12280 
    iprot.readStructEnd()
12281 
 
12282 
  def write(self, oprot):
12283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12285 
      return
12286 
    oprot.writeStructBegin('shiftToWarehouse_result')
12287 
    if self.success is not None:
12288 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12289 
      self.success.write(oprot)
12290 
      oprot.writeFieldEnd()
12291 
    if self.ex is not None:
12292 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12293 
      self.ex.write(oprot)
12294 
      oprot.writeFieldEnd()
12295 
    oprot.writeFieldStop()
12296 
    oprot.writeStructEnd()
12297 
 
12298 
  def validate(self):
12299 
    return
12300 
 
12301 
 
12302 
  def __repr__(self):
12303 
    L = ['%s=%r' % (key, value)
12304 
      for key, value in self.__dict__.iteritems()]
12305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12306 
 
12307 
  def __eq__(self, other):
12308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12309 
 
12310 
  def __ne__(self, other):
12311 
    return not (self == other)
3553 chandransh 12312 
 
12313 
class addDelayReason_args:
12314 
  """
12315 
  Attributes:
12316 
   - orderId
12317 
   - delayReason
3986 chandransh 12318 
   - furtherDelay
3553 chandransh 12319 
  """
12320 
 
12321 
  thrift_spec = (
12322 
    None, # 0
12323 
    (1, TType.I64, 'orderId', None, None, ), # 1
12324 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12325 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12326 
  )
12327 
 
3986 chandransh 12328 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12329 
    self.orderId = orderId
12330 
    self.delayReason = delayReason
3986 chandransh 12331 
    self.furtherDelay = furtherDelay
3553 chandransh 12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 1:
12343 
        if ftype == TType.I64:
12344 
          self.orderId = iprot.readI64();
12345 
        else:
12346 
          iprot.skip(ftype)
12347 
      elif fid == 2:
12348 
        if ftype == TType.I32:
12349 
          self.delayReason = iprot.readI32();
12350 
        else:
12351 
          iprot.skip(ftype)
3986 chandransh 12352 
      elif fid == 3:
12353 
        if ftype == TType.I64:
12354 
          self.furtherDelay = iprot.readI64();
12355 
        else:
12356 
          iprot.skip(ftype)
3553 chandransh 12357 
      else:
12358 
        iprot.skip(ftype)
12359 
      iprot.readFieldEnd()
12360 
    iprot.readStructEnd()
12361 
 
12362 
  def write(self, oprot):
12363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12365 
      return
12366 
    oprot.writeStructBegin('addDelayReason_args')
12367 
    if self.orderId is not None:
12368 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12369 
      oprot.writeI64(self.orderId)
12370 
      oprot.writeFieldEnd()
12371 
    if self.delayReason is not None:
12372 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12373 
      oprot.writeI32(self.delayReason)
12374 
      oprot.writeFieldEnd()
3986 chandransh 12375 
    if self.furtherDelay is not None:
12376 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12377 
      oprot.writeI64(self.furtherDelay)
12378 
      oprot.writeFieldEnd()
3553 chandransh 12379 
    oprot.writeFieldStop()
12380 
    oprot.writeStructEnd()
12381 
 
12382 
  def validate(self):
12383 
    return
12384 
 
12385 
 
12386 
  def __repr__(self):
12387 
    L = ['%s=%r' % (key, value)
12388 
      for key, value in self.__dict__.iteritems()]
12389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12390 
 
12391 
  def __eq__(self, other):
12392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12393 
 
12394 
  def __ne__(self, other):
12395 
    return not (self == other)
12396 
 
12397 
class addDelayReason_result:
12398 
  """
12399 
  Attributes:
12400 
   - success
12401 
   - ex
12402 
  """
12403 
 
12404 
  thrift_spec = (
12405 
    (0, TType.BOOL, 'success', None, None, ), # 0
12406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12407 
  )
12408 
 
12409 
  def __init__(self, success=None, ex=None,):
12410 
    self.success = success
12411 
    self.ex = ex
12412 
 
12413 
  def read(self, iprot):
12414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12416 
      return
12417 
    iprot.readStructBegin()
12418 
    while True:
12419 
      (fname, ftype, fid) = iprot.readFieldBegin()
12420 
      if ftype == TType.STOP:
12421 
        break
12422 
      if fid == 0:
12423 
        if ftype == TType.BOOL:
12424 
          self.success = iprot.readBool();
12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      elif fid == 1:
12428 
        if ftype == TType.STRUCT:
12429 
          self.ex = TransactionServiceException()
12430 
          self.ex.read(iprot)
12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      else:
12434 
        iprot.skip(ftype)
12435 
      iprot.readFieldEnd()
12436 
    iprot.readStructEnd()
12437 
 
12438 
  def write(self, oprot):
12439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12441 
      return
12442 
    oprot.writeStructBegin('addDelayReason_result')
12443 
    if self.success is not None:
12444 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12445 
      oprot.writeBool(self.success)
12446 
      oprot.writeFieldEnd()
12447 
    if self.ex is not None:
12448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12449 
      self.ex.write(oprot)
12450 
      oprot.writeFieldEnd()
12451 
    oprot.writeFieldStop()
12452 
    oprot.writeStructEnd()
12453 
 
12454 
  def validate(self):
12455 
    return
12456 
 
12457 
 
12458 
  def __repr__(self):
12459 
    L = ['%s=%r' % (key, value)
12460 
      for key, value in self.__dict__.iteritems()]
12461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12462 
 
12463 
  def __eq__(self, other):
12464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12465 
 
12466 
  def __ne__(self, other):
12467 
    return not (self == other)
3956 chandransh 12468 
 
12469 
class reconcileCodCollection_args:
12470 
  """
12471 
  Attributes:
12472 
   - collectedAmountMap
12473 
   - xferBy
12474 
   - xferTxnId
12475 
   - xferDate
12476 
  """
12477 
 
12478 
  thrift_spec = (
12479 
    None, # 0
12480 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12481 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12482 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12483 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12484 
  )
12485 
 
12486 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12487 
    self.collectedAmountMap = collectedAmountMap
12488 
    self.xferBy = xferBy
12489 
    self.xferTxnId = xferTxnId
12490 
    self.xferDate = xferDate
12491 
 
12492 
  def read(self, iprot):
12493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12495 
      return
12496 
    iprot.readStructBegin()
12497 
    while True:
12498 
      (fname, ftype, fid) = iprot.readFieldBegin()
12499 
      if ftype == TType.STOP:
12500 
        break
12501 
      if fid == 1:
12502 
        if ftype == TType.MAP:
12503 
          self.collectedAmountMap = {}
4133 chandransh 12504 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12505 
          for _i217 in xrange(_size213):
12506 
            _key218 = iprot.readString();
12507 
            _val219 = iprot.readDouble();
12508 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12509 
          iprot.readMapEnd()
12510 
        else:
12511 
          iprot.skip(ftype)
12512 
      elif fid == 2:
12513 
        if ftype == TType.STRING:
12514 
          self.xferBy = iprot.readString();
12515 
        else:
12516 
          iprot.skip(ftype)
12517 
      elif fid == 3:
12518 
        if ftype == TType.STRING:
12519 
          self.xferTxnId = iprot.readString();
12520 
        else:
12521 
          iprot.skip(ftype)
12522 
      elif fid == 4:
12523 
        if ftype == TType.I64:
12524 
          self.xferDate = iprot.readI64();
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('reconcileCodCollection_args')
12537 
    if self.collectedAmountMap is not None:
12538 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12539 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12540 
      for kiter220,viter221 in self.collectedAmountMap.items():
12541 
        oprot.writeString(kiter220)
12542 
        oprot.writeDouble(viter221)
3956 chandransh 12543 
      oprot.writeMapEnd()
12544 
      oprot.writeFieldEnd()
12545 
    if self.xferBy is not None:
12546 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12547 
      oprot.writeString(self.xferBy)
12548 
      oprot.writeFieldEnd()
12549 
    if self.xferTxnId is not None:
12550 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12551 
      oprot.writeString(self.xferTxnId)
12552 
      oprot.writeFieldEnd()
12553 
    if self.xferDate is not None:
12554 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12555 
      oprot.writeI64(self.xferDate)
12556 
      oprot.writeFieldEnd()
12557 
    oprot.writeFieldStop()
12558 
    oprot.writeStructEnd()
12559 
 
12560 
  def validate(self):
12561 
    return
12562 
 
12563 
 
12564 
  def __repr__(self):
12565 
    L = ['%s=%r' % (key, value)
12566 
      for key, value in self.__dict__.iteritems()]
12567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12568 
 
12569 
  def __eq__(self, other):
12570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12571 
 
12572 
  def __ne__(self, other):
12573 
    return not (self == other)
12574 
 
12575 
class reconcileCodCollection_result:
12576 
  """
12577 
  Attributes:
12578 
   - success
12579 
   - ex
12580 
  """
12581 
 
12582 
  thrift_spec = (
12583 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12585 
  )
12586 
 
12587 
  def __init__(self, success=None, ex=None,):
12588 
    self.success = success
12589 
    self.ex = ex
12590 
 
12591 
  def read(self, iprot):
12592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12594 
      return
12595 
    iprot.readStructBegin()
12596 
    while True:
12597 
      (fname, ftype, fid) = iprot.readFieldBegin()
12598 
      if ftype == TType.STOP:
12599 
        break
12600 
      if fid == 0:
12601 
        if ftype == TType.MAP:
12602 
          self.success = {}
4133 chandransh 12603 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12604 
          for _i226 in xrange(_size222):
12605 
            _key227 = iprot.readString();
12606 
            _val228 = iprot.readString();
12607 
            self.success[_key227] = _val228
3956 chandransh 12608 
          iprot.readMapEnd()
12609 
        else:
12610 
          iprot.skip(ftype)
12611 
      elif fid == 1:
12612 
        if ftype == TType.STRUCT:
12613 
          self.ex = TransactionServiceException()
12614 
          self.ex.read(iprot)
12615 
        else:
12616 
          iprot.skip(ftype)
12617 
      else:
12618 
        iprot.skip(ftype)
12619 
      iprot.readFieldEnd()
12620 
    iprot.readStructEnd()
12621 
 
12622 
  def write(self, oprot):
12623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12625 
      return
12626 
    oprot.writeStructBegin('reconcileCodCollection_result')
12627 
    if self.success is not None:
12628 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12629 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12630 
      for kiter229,viter230 in self.success.items():
12631 
        oprot.writeString(kiter229)
12632 
        oprot.writeString(viter230)
3956 chandransh 12633 
      oprot.writeMapEnd()
12634 
      oprot.writeFieldEnd()
12635 
    if self.ex is not None:
12636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12637 
      self.ex.write(oprot)
12638 
      oprot.writeFieldEnd()
12639 
    oprot.writeFieldStop()
12640 
    oprot.writeStructEnd()
12641 
 
12642 
  def validate(self):
12643 
    return
12644 
 
12645 
 
12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
4008 mandeep.dh 12656 
 
12657 
class getTransactionsRequiringExtraProcessing_args:
12658 
  """
12659 
  Attributes:
12660 
   - category
12661 
  """
12662 
 
12663 
  thrift_spec = (
12664 
    None, # 0
12665 
    (1, TType.I32, 'category', None, None, ), # 1
12666 
  )
12667 
 
12668 
  def __init__(self, category=None,):
12669 
    self.category = category
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 1:
12681 
        if ftype == TType.I32:
12682 
          self.category = iprot.readI32();
12683 
        else:
12684 
          iprot.skip(ftype)
12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
12694 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12695 
    if self.category is not None:
12696 
      oprot.writeFieldBegin('category', TType.I32, 1)
12697 
      oprot.writeI32(self.category)
12698 
      oprot.writeFieldEnd()
12699 
    oprot.writeFieldStop()
12700 
    oprot.writeStructEnd()
12701 
 
12702 
  def validate(self):
12703 
    return
12704 
 
12705 
 
12706 
  def __repr__(self):
12707 
    L = ['%s=%r' % (key, value)
12708 
      for key, value in self.__dict__.iteritems()]
12709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12710 
 
12711 
  def __eq__(self, other):
12712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12713 
 
12714 
  def __ne__(self, other):
12715 
    return not (self == other)
12716 
 
12717 
class getTransactionsRequiringExtraProcessing_result:
12718 
  """
12719 
  Attributes:
12720 
   - success
12721 
  """
12722 
 
12723 
  thrift_spec = (
12724 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12725 
  )
12726 
 
12727 
  def __init__(self, success=None,):
12728 
    self.success = success
12729 
 
12730 
  def read(self, iprot):
12731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12733 
      return
12734 
    iprot.readStructBegin()
12735 
    while True:
12736 
      (fname, ftype, fid) = iprot.readFieldBegin()
12737 
      if ftype == TType.STOP:
12738 
        break
12739 
      if fid == 0:
12740 
        if ftype == TType.LIST:
12741 
          self.success = []
4133 chandransh 12742 
          (_etype234, _size231) = iprot.readListBegin()
12743 
          for _i235 in xrange(_size231):
12744 
            _elem236 = iprot.readI64();
12745 
            self.success.append(_elem236)
4008 mandeep.dh 12746 
          iprot.readListEnd()
12747 
        else:
12748 
          iprot.skip(ftype)
12749 
      else:
12750 
        iprot.skip(ftype)
12751 
      iprot.readFieldEnd()
12752 
    iprot.readStructEnd()
12753 
 
12754 
  def write(self, oprot):
12755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12757 
      return
12758 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12759 
    if self.success is not None:
12760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12761 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12762 
      for iter237 in self.success:
12763 
        oprot.writeI64(iter237)
4008 mandeep.dh 12764 
      oprot.writeListEnd()
12765 
      oprot.writeFieldEnd()
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def validate(self):
12770 
    return
12771 
 
12772 
 
12773 
  def __repr__(self):
12774 
    L = ['%s=%r' % (key, value)
12775 
      for key, value in self.__dict__.iteritems()]
12776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12777 
 
12778 
  def __eq__(self, other):
12779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12780 
 
12781 
  def __ne__(self, other):
12782 
    return not (self == other)
12783 
 
12784 
class markTransactionAsProcessed_args:
12785 
  """
12786 
  Attributes:
12787 
   - transactionId
12788 
   - category
12789 
  """
12790 
 
12791 
  thrift_spec = (
12792 
    None, # 0
12793 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12794 
    (2, TType.I32, 'category', None, None, ), # 2
12795 
  )
12796 
 
12797 
  def __init__(self, transactionId=None, category=None,):
12798 
    self.transactionId = transactionId
12799 
    self.category = category
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.I64:
12812 
          self.transactionId = iprot.readI64();
12813 
        else:
12814 
          iprot.skip(ftype)
12815 
      elif fid == 2:
12816 
        if ftype == TType.I32:
12817 
          self.category = iprot.readI32();
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('markTransactionAsProcessed_args')
12830 
    if self.transactionId is not None:
12831 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12832 
      oprot.writeI64(self.transactionId)
12833 
      oprot.writeFieldEnd()
12834 
    if self.category is not None:
12835 
      oprot.writeFieldBegin('category', TType.I32, 2)
12836 
      oprot.writeI32(self.category)
12837 
      oprot.writeFieldEnd()
12838 
    oprot.writeFieldStop()
12839 
    oprot.writeStructEnd()
12840 
 
12841 
  def validate(self):
12842 
    return
12843 
 
12844 
 
12845 
  def __repr__(self):
12846 
    L = ['%s=%r' % (key, value)
12847 
      for key, value in self.__dict__.iteritems()]
12848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12849 
 
12850 
  def __eq__(self, other):
12851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12852 
 
12853 
  def __ne__(self, other):
12854 
    return not (self == other)
12855 
 
12856 
class markTransactionAsProcessed_result:
12857 
 
12858 
  thrift_spec = (
12859 
  )
12860 
 
12861 
  def read(self, iprot):
12862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12864 
      return
12865 
    iprot.readStructBegin()
12866 
    while True:
12867 
      (fname, ftype, fid) = iprot.readFieldBegin()
12868 
      if ftype == TType.STOP:
12869 
        break
12870 
      else:
12871 
        iprot.skip(ftype)
12872 
      iprot.readFieldEnd()
12873 
    iprot.readStructEnd()
12874 
 
12875 
  def write(self, oprot):
12876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12878 
      return
12879 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12880 
    oprot.writeFieldStop()
12881 
    oprot.writeStructEnd()
12882 
 
12883 
  def validate(self):
12884 
    return
12885 
 
12886 
 
12887 
  def __repr__(self):
12888 
    L = ['%s=%r' % (key, value)
12889 
      for key, value in self.__dict__.iteritems()]
12890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12891 
 
12892 
  def __eq__(self, other):
12893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12894 
 
12895 
  def __ne__(self, other):
12896 
    return not (self == other)
4018 chandransh 12897 
 
12898 
class getItemWiseRiskyOrdersCount_args:
12899 
 
12900 
  thrift_spec = (
12901 
  )
12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      else:
12913 
        iprot.skip(ftype)
12914 
      iprot.readFieldEnd()
12915 
    iprot.readStructEnd()
12916 
 
12917 
  def write(self, oprot):
12918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12920 
      return
12921 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12922 
    oprot.writeFieldStop()
12923 
    oprot.writeStructEnd()
12924 
 
12925 
  def validate(self):
12926 
    return
12927 
 
12928 
 
12929 
  def __repr__(self):
12930 
    L = ['%s=%r' % (key, value)
12931 
      for key, value in self.__dict__.iteritems()]
12932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12933 
 
12934 
  def __eq__(self, other):
12935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12936 
 
12937 
  def __ne__(self, other):
12938 
    return not (self == other)
12939 
 
12940 
class getItemWiseRiskyOrdersCount_result:
12941 
  """
12942 
  Attributes:
12943 
   - success
12944 
  """
12945 
 
12946 
  thrift_spec = (
12947 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12948 
  )
12949 
 
12950 
  def __init__(self, success=None,):
12951 
    self.success = success
12952 
 
12953 
  def read(self, iprot):
12954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12956 
      return
12957 
    iprot.readStructBegin()
12958 
    while True:
12959 
      (fname, ftype, fid) = iprot.readFieldBegin()
12960 
      if ftype == TType.STOP:
12961 
        break
12962 
      if fid == 0:
12963 
        if ftype == TType.MAP:
12964 
          self.success = {}
4133 chandransh 12965 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12966 
          for _i242 in xrange(_size238):
12967 
            _key243 = iprot.readI64();
12968 
            _val244 = iprot.readI64();
12969 
            self.success[_key243] = _val244
4018 chandransh 12970 
          iprot.readMapEnd()
12971 
        else:
12972 
          iprot.skip(ftype)
12973 
      else:
12974 
        iprot.skip(ftype)
12975 
      iprot.readFieldEnd()
12976 
    iprot.readStructEnd()
12977 
 
12978 
  def write(self, oprot):
12979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12981 
      return
12982 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12983 
    if self.success is not None:
12984 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12985 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12986 
      for kiter245,viter246 in self.success.items():
12987 
        oprot.writeI64(kiter245)
12988 
        oprot.writeI64(viter246)
4018 chandransh 12989 
      oprot.writeMapEnd()
12990 
      oprot.writeFieldEnd()
12991 
    oprot.writeFieldStop()
12992 
    oprot.writeStructEnd()
12993 
 
12994 
  def validate(self):
12995 
    return
12996 
 
12997 
 
12998 
  def __repr__(self):
12999 
    L = ['%s=%r' % (key, value)
13000 
      for key, value in self.__dict__.iteritems()]
13001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13002 
 
13003 
  def __eq__(self, other):
13004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13005 
 
13006 
  def __ne__(self, other):
13007 
    return not (self == other)
4247 rajveer 13008 
 
4295 varun.gupt 13009 
class getOrdersForItemIds_args:
13010 
  """
13011 
  Attributes:
13012 
   - itemIds
13013 
  """
13014 
 
13015 
  thrift_spec = (
13016 
    None, # 0
13017 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
13018 
  )
13019 
 
13020 
  def __init__(self, itemIds=None,):
13021 
    self.itemIds = itemIds
13022 
 
13023 
  def read(self, iprot):
13024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13026 
      return
13027 
    iprot.readStructBegin()
13028 
    while True:
13029 
      (fname, ftype, fid) = iprot.readFieldBegin()
13030 
      if ftype == TType.STOP:
13031 
        break
13032 
      if fid == 1:
13033 
        if ftype == TType.LIST:
13034 
          self.itemIds = []
13035 
          (_etype250, _size247) = iprot.readListBegin()
13036 
          for _i251 in xrange(_size247):
13037 
            _elem252 = iprot.readI64();
13038 
            self.itemIds.append(_elem252)
13039 
          iprot.readListEnd()
13040 
        else:
13041 
          iprot.skip(ftype)
13042 
      else:
13043 
        iprot.skip(ftype)
13044 
      iprot.readFieldEnd()
13045 
    iprot.readStructEnd()
13046 
 
13047 
  def write(self, oprot):
13048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13050 
      return
13051 
    oprot.writeStructBegin('getOrdersForItemIds_args')
13052 
    if self.itemIds is not None:
13053 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
13054 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13055 
      for iter253 in self.itemIds:
13056 
        oprot.writeI64(iter253)
13057 
      oprot.writeListEnd()
13058 
      oprot.writeFieldEnd()
13059 
    oprot.writeFieldStop()
13060 
    oprot.writeStructEnd()
13061 
 
13062 
  def validate(self):
13063 
    return
13064 
 
13065 
 
13066 
  def __repr__(self):
13067 
    L = ['%s=%r' % (key, value)
13068 
      for key, value in self.__dict__.iteritems()]
13069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13070 
 
13071 
  def __eq__(self, other):
13072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13073 
 
13074 
  def __ne__(self, other):
13075 
    return not (self == other)
13076 
 
13077 
class getOrdersForItemIds_result:
13078 
  """
13079 
  Attributes:
13080 
   - success
13081 
  """
13082 
 
13083 
  thrift_spec = (
13084 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13085 
  )
13086 
 
13087 
  def __init__(self, success=None,):
13088 
    self.success = success
13089 
 
13090 
  def read(self, iprot):
13091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13093 
      return
13094 
    iprot.readStructBegin()
13095 
    while True:
13096 
      (fname, ftype, fid) = iprot.readFieldBegin()
13097 
      if ftype == TType.STOP:
13098 
        break
13099 
      if fid == 0:
13100 
        if ftype == TType.LIST:
13101 
          self.success = []
13102 
          (_etype257, _size254) = iprot.readListBegin()
13103 
          for _i258 in xrange(_size254):
13104 
            _elem259 = Order()
13105 
            _elem259.read(iprot)
13106 
            self.success.append(_elem259)
13107 
          iprot.readListEnd()
13108 
        else:
13109 
          iprot.skip(ftype)
13110 
      else:
13111 
        iprot.skip(ftype)
13112 
      iprot.readFieldEnd()
13113 
    iprot.readStructEnd()
13114 
 
13115 
  def write(self, oprot):
13116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13118 
      return
13119 
    oprot.writeStructBegin('getOrdersForItemIds_result')
13120 
    if self.success is not None:
13121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13122 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13123 
      for iter260 in self.success:
13124 
        iter260.write(oprot)
13125 
      oprot.writeListEnd()
13126 
      oprot.writeFieldEnd()
13127 
    oprot.writeFieldStop()
13128 
    oprot.writeStructEnd()
13129 
 
13130 
  def validate(self):
13131 
    return
13132 
 
13133 
 
13134 
  def __repr__(self):
13135 
    L = ['%s=%r' % (key, value)
13136 
      for key, value in self.__dict__.iteritems()]
13137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13138 
 
13139 
  def __eq__(self, other):
13140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13141 
 
13142 
  def __ne__(self, other):
13143 
    return not (self == other)
13144 
 
4247 rajveer 13145 
class markOrderCancellationRequestReceived_args:
13146 
  """
13147 
  Attributes:
13148 
   - orderId
13149 
  """
13150 
 
13151 
  thrift_spec = (
13152 
    None, # 0
13153 
    (1, TType.I64, 'orderId', None, None, ), # 1
13154 
  )
13155 
 
13156 
  def __init__(self, orderId=None,):
13157 
    self.orderId = orderId
13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 1:
13169 
        if ftype == TType.I64:
13170 
          self.orderId = iprot.readI64();
13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      else:
13174 
        iprot.skip(ftype)
13175 
      iprot.readFieldEnd()
13176 
    iprot.readStructEnd()
13177 
 
13178 
  def write(self, oprot):
13179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13181 
      return
13182 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
13183 
    if self.orderId is not None:
13184 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13185 
      oprot.writeI64(self.orderId)
13186 
      oprot.writeFieldEnd()
13187 
    oprot.writeFieldStop()
13188 
    oprot.writeStructEnd()
13189 
 
13190 
  def validate(self):
13191 
    return
13192 
 
13193 
 
13194 
  def __repr__(self):
13195 
    L = ['%s=%r' % (key, value)
13196 
      for key, value in self.__dict__.iteritems()]
13197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13198 
 
13199 
  def __eq__(self, other):
13200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13201 
 
13202 
  def __ne__(self, other):
13203 
    return not (self == other)
13204 
 
13205 
class markOrderCancellationRequestReceived_result:
13206 
  """
13207 
  Attributes:
13208 
   - ex
13209 
  """
13210 
 
13211 
  thrift_spec = (
13212 
    None, # 0
13213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13214 
  )
13215 
 
13216 
  def __init__(self, ex=None,):
13217 
    self.ex = ex
13218 
 
13219 
  def read(self, iprot):
13220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13222 
      return
13223 
    iprot.readStructBegin()
13224 
    while True:
13225 
      (fname, ftype, fid) = iprot.readFieldBegin()
13226 
      if ftype == TType.STOP:
13227 
        break
13228 
      if fid == 1:
13229 
        if ftype == TType.STRUCT:
13230 
          self.ex = TransactionServiceException()
13231 
          self.ex.read(iprot)
13232 
        else:
13233 
          iprot.skip(ftype)
13234 
      else:
13235 
        iprot.skip(ftype)
13236 
      iprot.readFieldEnd()
13237 
    iprot.readStructEnd()
13238 
 
13239 
  def write(self, oprot):
13240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13242 
      return
13243 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13244 
    if self.ex is not None:
13245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13246 
      self.ex.write(oprot)
13247 
      oprot.writeFieldEnd()
13248 
    oprot.writeFieldStop()
13249 
    oprot.writeStructEnd()
13250 
 
13251 
  def validate(self):
13252 
    return
13253 
 
13254 
 
13255 
  def __repr__(self):
13256 
    L = ['%s=%r' % (key, value)
13257 
      for key, value in self.__dict__.iteritems()]
13258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13259 
 
13260 
  def __eq__(self, other):
13261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13262 
 
13263 
  def __ne__(self, other):
13264 
    return not (self == other)
13265 
 
13266 
class markOrderCancellationRequestConfirmed_args:
13267 
  """
13268 
  Attributes:
13269 
   - orderId
13270 
  """
13271 
 
13272 
  thrift_spec = (
13273 
    None, # 0
13274 
    (1, TType.I64, 'orderId', None, None, ), # 1
13275 
  )
13276 
 
13277 
  def __init__(self, orderId=None,):
13278 
    self.orderId = orderId
13279 
 
13280 
  def read(self, iprot):
13281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13283 
      return
13284 
    iprot.readStructBegin()
13285 
    while True:
13286 
      (fname, ftype, fid) = iprot.readFieldBegin()
13287 
      if ftype == TType.STOP:
13288 
        break
13289 
      if fid == 1:
13290 
        if ftype == TType.I64:
13291 
          self.orderId = iprot.readI64();
13292 
        else:
13293 
          iprot.skip(ftype)
13294 
      else:
13295 
        iprot.skip(ftype)
13296 
      iprot.readFieldEnd()
13297 
    iprot.readStructEnd()
13298 
 
13299 
  def write(self, oprot):
13300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13302 
      return
13303 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13304 
    if self.orderId is not None:
13305 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13306 
      oprot.writeI64(self.orderId)
13307 
      oprot.writeFieldEnd()
13308 
    oprot.writeFieldStop()
13309 
    oprot.writeStructEnd()
13310 
 
13311 
  def validate(self):
13312 
    return
13313 
 
13314 
 
13315 
  def __repr__(self):
13316 
    L = ['%s=%r' % (key, value)
13317 
      for key, value in self.__dict__.iteritems()]
13318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13319 
 
13320 
  def __eq__(self, other):
13321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13322 
 
13323 
  def __ne__(self, other):
13324 
    return not (self == other)
13325 
 
13326 
class markOrderCancellationRequestConfirmed_result:
13327 
  """
13328 
  Attributes:
13329 
   - ex
13330 
  """
13331 
 
13332 
  thrift_spec = (
13333 
    None, # 0
13334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13335 
  )
13336 
 
13337 
  def __init__(self, ex=None,):
13338 
    self.ex = ex
13339 
 
13340 
  def read(self, iprot):
13341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13343 
      return
13344 
    iprot.readStructBegin()
13345 
    while True:
13346 
      (fname, ftype, fid) = iprot.readFieldBegin()
13347 
      if ftype == TType.STOP:
13348 
        break
13349 
      if fid == 1:
13350 
        if ftype == TType.STRUCT:
13351 
          self.ex = TransactionServiceException()
13352 
          self.ex.read(iprot)
13353 
        else:
13354 
          iprot.skip(ftype)
13355 
      else:
13356 
        iprot.skip(ftype)
13357 
      iprot.readFieldEnd()
13358 
    iprot.readStructEnd()
13359 
 
13360 
  def write(self, oprot):
13361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13363 
      return
13364 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13365 
    if self.ex is not None:
13366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13367 
      self.ex.write(oprot)
13368 
      oprot.writeFieldEnd()
13369 
    oprot.writeFieldStop()
13370 
    oprot.writeStructEnd()
13371 
 
13372 
  def validate(self):
13373 
    return
13374 
 
13375 
 
13376 
  def __repr__(self):
13377 
    L = ['%s=%r' % (key, value)
13378 
      for key, value in self.__dict__.iteritems()]
13379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13380 
 
13381 
  def __eq__(self, other):
13382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13383 
 
13384 
  def __ne__(self, other):
13385 
    return not (self == other)
13386 
 
13387 
class markOrderCancellationRequestDenied_args:
13388 
  """
13389 
  Attributes:
13390 
   - orderId
13391 
  """
13392 
 
13393 
  thrift_spec = (
13394 
    None, # 0
13395 
    (1, TType.I64, 'orderId', None, None, ), # 1
13396 
  )
13397 
 
13398 
  def __init__(self, orderId=None,):
13399 
    self.orderId = orderId
13400 
 
13401 
  def read(self, iprot):
13402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13404 
      return
13405 
    iprot.readStructBegin()
13406 
    while True:
13407 
      (fname, ftype, fid) = iprot.readFieldBegin()
13408 
      if ftype == TType.STOP:
13409 
        break
13410 
      if fid == 1:
13411 
        if ftype == TType.I64:
13412 
          self.orderId = iprot.readI64();
13413 
        else:
13414 
          iprot.skip(ftype)
13415 
      else:
13416 
        iprot.skip(ftype)
13417 
      iprot.readFieldEnd()
13418 
    iprot.readStructEnd()
13419 
 
13420 
  def write(self, oprot):
13421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13423 
      return
13424 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13425 
    if self.orderId is not None:
13426 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13427 
      oprot.writeI64(self.orderId)
13428 
      oprot.writeFieldEnd()
13429 
    oprot.writeFieldStop()
13430 
    oprot.writeStructEnd()
13431 
 
13432 
  def validate(self):
13433 
    return
13434 
 
13435 
 
13436 
  def __repr__(self):
13437 
    L = ['%s=%r' % (key, value)
13438 
      for key, value in self.__dict__.iteritems()]
13439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13440 
 
13441 
  def __eq__(self, other):
13442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13443 
 
13444 
  def __ne__(self, other):
13445 
    return not (self == other)
13446 
 
13447 
class markOrderCancellationRequestDenied_result:
13448 
  """
13449 
  Attributes:
13450 
   - ex
13451 
  """
13452 
 
13453 
  thrift_spec = (
13454 
    None, # 0
13455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13456 
  )
13457 
 
13458 
  def __init__(self, ex=None,):
13459 
    self.ex = ex
13460 
 
13461 
  def read(self, iprot):
13462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13464 
      return
13465 
    iprot.readStructBegin()
13466 
    while True:
13467 
      (fname, ftype, fid) = iprot.readFieldBegin()
13468 
      if ftype == TType.STOP:
13469 
        break
13470 
      if fid == 1:
13471 
        if ftype == TType.STRUCT:
13472 
          self.ex = TransactionServiceException()
13473 
          self.ex.read(iprot)
13474 
        else:
13475 
          iprot.skip(ftype)
13476 
      else:
13477 
        iprot.skip(ftype)
13478 
      iprot.readFieldEnd()
13479 
    iprot.readStructEnd()
13480 
 
13481 
  def write(self, oprot):
13482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13484 
      return
13485 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13486 
    if self.ex is not None:
13487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13488 
      self.ex.write(oprot)
13489 
      oprot.writeFieldEnd()
13490 
    oprot.writeFieldStop()
13491 
    oprot.writeStructEnd()
13492 
 
13493 
  def validate(self):
13494 
    return
13495 
 
13496 
 
13497 
  def __repr__(self):
13498 
    L = ['%s=%r' % (key, value)
13499 
      for key, value in self.__dict__.iteritems()]
13500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13501 
 
13502 
  def __eq__(self, other):
13503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13504 
 
13505 
  def __ne__(self, other):
13506 
    return not (self == other)
13507 
 
4258 rajveer 13508 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13509 
  """
13510 
  Attributes:
4258 rajveer 13511 
   - transactionId
4247 rajveer 13512 
  """
13513 
 
13514 
  thrift_spec = (
13515 
    None, # 0
4258 rajveer 13516 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13517 
  )
13518 
 
4258 rajveer 13519 
  def __init__(self, transactionId=None,):
13520 
    self.transactionId = transactionId
4247 rajveer 13521 
 
13522 
  def read(self, iprot):
13523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13525 
      return
13526 
    iprot.readStructBegin()
13527 
    while True:
13528 
      (fname, ftype, fid) = iprot.readFieldBegin()
13529 
      if ftype == TType.STOP:
13530 
        break
13531 
      if fid == 1:
13532 
        if ftype == TType.I64:
4258 rajveer 13533 
          self.transactionId = iprot.readI64();
4247 rajveer 13534 
        else:
13535 
          iprot.skip(ftype)
13536 
      else:
13537 
        iprot.skip(ftype)
13538 
      iprot.readFieldEnd()
13539 
    iprot.readStructEnd()
13540 
 
13541 
  def write(self, oprot):
13542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13544 
      return
4258 rajveer 13545 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13546 
    if self.transactionId is not None:
13547 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13548 
      oprot.writeI64(self.transactionId)
4247 rajveer 13549 
      oprot.writeFieldEnd()
13550 
    oprot.writeFieldStop()
13551 
    oprot.writeStructEnd()
13552 
 
13553 
  def validate(self):
13554 
    return
13555 
 
13556 
 
13557 
  def __repr__(self):
13558 
    L = ['%s=%r' % (key, value)
13559 
      for key, value in self.__dict__.iteritems()]
13560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13561 
 
13562 
  def __eq__(self, other):
13563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13564 
 
13565 
  def __ne__(self, other):
13566 
    return not (self == other)
13567 
 
4258 rajveer 13568 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13569 
  """
13570 
  Attributes:
13571 
   - ex
13572 
  """
13573 
 
13574 
  thrift_spec = (
13575 
    None, # 0
13576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13577 
  )
13578 
 
13579 
  def __init__(self, ex=None,):
13580 
    self.ex = ex
13581 
 
13582 
  def read(self, iprot):
13583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13585 
      return
13586 
    iprot.readStructBegin()
13587 
    while True:
13588 
      (fname, ftype, fid) = iprot.readFieldBegin()
13589 
      if ftype == TType.STOP:
13590 
        break
13591 
      if fid == 1:
13592 
        if ftype == TType.STRUCT:
13593 
          self.ex = TransactionServiceException()
13594 
          self.ex.read(iprot)
13595 
        else:
13596 
          iprot.skip(ftype)
13597 
      else:
13598 
        iprot.skip(ftype)
13599 
      iprot.readFieldEnd()
13600 
    iprot.readStructEnd()
13601 
 
13602 
  def write(self, oprot):
13603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13605 
      return
4258 rajveer 13606 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13607 
    if self.ex is not None:
13608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13609 
      self.ex.write(oprot)
13610 
      oprot.writeFieldEnd()
13611 
    oprot.writeFieldStop()
13612 
    oprot.writeStructEnd()
13613 
 
13614 
  def validate(self):
13615 
    return
13616 
 
13617 
 
13618 
  def __repr__(self):
13619 
    L = ['%s=%r' % (key, value)
13620 
      for key, value in self.__dict__.iteritems()]
13621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13622 
 
13623 
  def __eq__(self, other):
13624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13625 
 
13626 
  def __ne__(self, other):
13627 
    return not (self == other)
4259 anupam.sin 13628 
 
13629 
class refundTransaction_args:
13630 
  """
13631 
  Attributes:
13632 
   - transactionId
13633 
   - refundedBy
13634 
   - reason
13635 
  """
13636 
 
13637 
  thrift_spec = (
13638 
    None, # 0
13639 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13640 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13641 
    (3, TType.STRING, 'reason', None, None, ), # 3
13642 
  )
13643 
 
13644 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13645 
    self.transactionId = transactionId
13646 
    self.refundedBy = refundedBy
13647 
    self.reason = reason
13648 
 
13649 
  def read(self, iprot):
13650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13652 
      return
13653 
    iprot.readStructBegin()
13654 
    while True:
13655 
      (fname, ftype, fid) = iprot.readFieldBegin()
13656 
      if ftype == TType.STOP:
13657 
        break
13658 
      if fid == 1:
13659 
        if ftype == TType.I64:
13660 
          self.transactionId = iprot.readI64();
13661 
        else:
13662 
          iprot.skip(ftype)
13663 
      elif fid == 2:
13664 
        if ftype == TType.STRING:
13665 
          self.refundedBy = iprot.readString();
13666 
        else:
13667 
          iprot.skip(ftype)
13668 
      elif fid == 3:
13669 
        if ftype == TType.STRING:
13670 
          self.reason = iprot.readString();
13671 
        else:
13672 
          iprot.skip(ftype)
13673 
      else:
13674 
        iprot.skip(ftype)
13675 
      iprot.readFieldEnd()
13676 
    iprot.readStructEnd()
13677 
 
13678 
  def write(self, oprot):
13679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13681 
      return
13682 
    oprot.writeStructBegin('refundTransaction_args')
13683 
    if self.transactionId is not None:
13684 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13685 
      oprot.writeI64(self.transactionId)
13686 
      oprot.writeFieldEnd()
13687 
    if self.refundedBy is not None:
13688 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13689 
      oprot.writeString(self.refundedBy)
13690 
      oprot.writeFieldEnd()
13691 
    if self.reason is not None:
13692 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13693 
      oprot.writeString(self.reason)
13694 
      oprot.writeFieldEnd()
13695 
    oprot.writeFieldStop()
13696 
    oprot.writeStructEnd()
13697 
 
13698 
  def validate(self):
13699 
    return
13700 
 
13701 
 
13702 
  def __repr__(self):
13703 
    L = ['%s=%r' % (key, value)
13704 
      for key, value in self.__dict__.iteritems()]
13705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13706 
 
13707 
  def __eq__(self, other):
13708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13709 
 
13710 
  def __ne__(self, other):
13711 
    return not (self == other)
13712 
 
13713 
class refundTransaction_result:
13714 
  """
13715 
  Attributes:
13716 
   - ex
13717 
  """
13718 
 
13719 
  thrift_spec = (
13720 
    None, # 0
13721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13722 
  )
13723 
 
13724 
  def __init__(self, ex=None,):
13725 
    self.ex = ex
13726 
 
13727 
  def read(self, iprot):
13728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13730 
      return
13731 
    iprot.readStructBegin()
13732 
    while True:
13733 
      (fname, ftype, fid) = iprot.readFieldBegin()
13734 
      if ftype == TType.STOP:
13735 
        break
13736 
      if fid == 1:
13737 
        if ftype == TType.STRUCT:
13738 
          self.ex = TransactionServiceException()
13739 
          self.ex.read(iprot)
13740 
        else:
13741 
          iprot.skip(ftype)
13742 
      else:
13743 
        iprot.skip(ftype)
13744 
      iprot.readFieldEnd()
13745 
    iprot.readStructEnd()
13746 
 
13747 
  def write(self, oprot):
13748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13750 
      return
13751 
    oprot.writeStructBegin('refundTransaction_result')
13752 
    if self.ex is not None:
13753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13754 
      self.ex.write(oprot)
13755 
      oprot.writeFieldEnd()
13756 
    oprot.writeFieldStop()
13757 
    oprot.writeStructEnd()
13758 
 
13759 
  def validate(self):
13760 
    return
13761 
 
13762 
 
13763 
  def __repr__(self):
13764 
    L = ['%s=%r' % (key, value)
13765 
      for key, value in self.__dict__.iteritems()]
13766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13767 
 
13768 
  def __eq__(self, other):
13769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13770 
 
13771 
  def __ne__(self, other):
13772 
    return not (self == other)
4285 rajveer 13773 
 
4324 mandeep.dh 13774 
class updateShipmentAddress_args:
13775 
  """
13776 
  Attributes:
13777 
   - orderId
13778 
   - addressId
13779 
  """
13780 
 
13781 
  thrift_spec = (
13782 
    None, # 0
13783 
    (1, TType.I64, 'orderId', None, None, ), # 1
13784 
    (2, TType.I64, 'addressId', None, None, ), # 2
13785 
  )
13786 
 
13787 
  def __init__(self, orderId=None, addressId=None,):
13788 
    self.orderId = orderId
13789 
    self.addressId = addressId
13790 
 
13791 
  def read(self, iprot):
13792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13794 
      return
13795 
    iprot.readStructBegin()
13796 
    while True:
13797 
      (fname, ftype, fid) = iprot.readFieldBegin()
13798 
      if ftype == TType.STOP:
13799 
        break
13800 
      if fid == 1:
13801 
        if ftype == TType.I64:
13802 
          self.orderId = iprot.readI64();
13803 
        else:
13804 
          iprot.skip(ftype)
13805 
      elif fid == 2:
13806 
        if ftype == TType.I64:
13807 
          self.addressId = iprot.readI64();
13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      else:
13811 
        iprot.skip(ftype)
13812 
      iprot.readFieldEnd()
13813 
    iprot.readStructEnd()
13814 
 
13815 
  def write(self, oprot):
13816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13818 
      return
13819 
    oprot.writeStructBegin('updateShipmentAddress_args')
13820 
    if self.orderId is not None:
13821 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13822 
      oprot.writeI64(self.orderId)
13823 
      oprot.writeFieldEnd()
13824 
    if self.addressId is not None:
13825 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
13826 
      oprot.writeI64(self.addressId)
13827 
      oprot.writeFieldEnd()
13828 
    oprot.writeFieldStop()
13829 
    oprot.writeStructEnd()
13830 
 
13831 
  def validate(self):
13832 
    return
13833 
 
13834 
 
13835 
  def __repr__(self):
13836 
    L = ['%s=%r' % (key, value)
13837 
      for key, value in self.__dict__.iteritems()]
13838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13839 
 
13840 
  def __eq__(self, other):
13841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13842 
 
13843 
  def __ne__(self, other):
13844 
    return not (self == other)
13845 
 
13846 
class updateShipmentAddress_result:
13847 
  """
13848 
  Attributes:
13849 
   - ex
13850 
  """
13851 
 
13852 
  thrift_spec = (
13853 
    None, # 0
13854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13855 
  )
13856 
 
13857 
  def __init__(self, ex=None,):
13858 
    self.ex = ex
13859 
 
13860 
  def read(self, iprot):
13861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13863 
      return
13864 
    iprot.readStructBegin()
13865 
    while True:
13866 
      (fname, ftype, fid) = iprot.readFieldBegin()
13867 
      if ftype == TType.STOP:
13868 
        break
13869 
      if fid == 1:
13870 
        if ftype == TType.STRUCT:
13871 
          self.ex = TransactionServiceException()
13872 
          self.ex.read(iprot)
13873 
        else:
13874 
          iprot.skip(ftype)
13875 
      else:
13876 
        iprot.skip(ftype)
13877 
      iprot.readFieldEnd()
13878 
    iprot.readStructEnd()
13879 
 
13880 
  def write(self, oprot):
13881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13883 
      return
13884 
    oprot.writeStructBegin('updateShipmentAddress_result')
13885 
    if self.ex is not None:
13886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13887 
      self.ex.write(oprot)
13888 
      oprot.writeFieldEnd()
13889 
    oprot.writeFieldStop()
13890 
    oprot.writeStructEnd()
13891 
 
13892 
  def validate(self):
13893 
    return
13894 
 
13895 
 
13896 
  def __repr__(self):
13897 
    L = ['%s=%r' % (key, value)
13898 
      for key, value in self.__dict__.iteritems()]
13899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13900 
 
13901 
  def __eq__(self, other):
13902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13903 
 
13904 
  def __ne__(self, other):
13905 
    return not (self == other)
13906 
 
4285 rajveer 13907 
class acceptOrdersForItemId_args:
13908 
  """
13909 
  Attributes:
13910 
   - itemId
13911 
   - inventory
13912 
  """
13913 
 
13914 
  thrift_spec = (
13915 
    None, # 0
13916 
    (1, TType.I64, 'itemId', None, None, ), # 1
13917 
    (2, TType.I64, 'inventory', None, None, ), # 2
13918 
  )
13919 
 
13920 
  def __init__(self, itemId=None, inventory=None,):
13921 
    self.itemId = itemId
13922 
    self.inventory = inventory
13923 
 
13924 
  def read(self, iprot):
13925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13927 
      return
13928 
    iprot.readStructBegin()
13929 
    while True:
13930 
      (fname, ftype, fid) = iprot.readFieldBegin()
13931 
      if ftype == TType.STOP:
13932 
        break
13933 
      if fid == 1:
13934 
        if ftype == TType.I64:
13935 
          self.itemId = iprot.readI64();
13936 
        else:
13937 
          iprot.skip(ftype)
13938 
      elif fid == 2:
13939 
        if ftype == TType.I64:
13940 
          self.inventory = iprot.readI64();
13941 
        else:
13942 
          iprot.skip(ftype)
13943 
      else:
13944 
        iprot.skip(ftype)
13945 
      iprot.readFieldEnd()
13946 
    iprot.readStructEnd()
13947 
 
13948 
  def write(self, oprot):
13949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13951 
      return
13952 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13953 
    if self.itemId is not None:
13954 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13955 
      oprot.writeI64(self.itemId)
13956 
      oprot.writeFieldEnd()
13957 
    if self.inventory is not None:
13958 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13959 
      oprot.writeI64(self.inventory)
13960 
      oprot.writeFieldEnd()
13961 
    oprot.writeFieldStop()
13962 
    oprot.writeStructEnd()
13963 
 
13964 
  def validate(self):
13965 
    return
13966 
 
13967 
 
13968 
  def __repr__(self):
13969 
    L = ['%s=%r' % (key, value)
13970 
      for key, value in self.__dict__.iteritems()]
13971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13972 
 
13973 
  def __eq__(self, other):
13974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13975 
 
13976 
  def __ne__(self, other):
13977 
    return not (self == other)
13978 
 
13979 
class acceptOrdersForItemId_result:
13980 
  """
13981 
  Attributes:
13982 
   - success
13983 
   - ex
13984 
  """
13985 
 
13986 
  thrift_spec = (
13987 
    (0, TType.BOOL, 'success', None, None, ), # 0
13988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13989 
  )
13990 
 
13991 
  def __init__(self, success=None, ex=None,):
13992 
    self.success = success
13993 
    self.ex = ex
13994 
 
13995 
  def read(self, iprot):
13996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13998 
      return
13999 
    iprot.readStructBegin()
14000 
    while True:
14001 
      (fname, ftype, fid) = iprot.readFieldBegin()
14002 
      if ftype == TType.STOP:
14003 
        break
14004 
      if fid == 0:
14005 
        if ftype == TType.BOOL:
14006 
          self.success = iprot.readBool();
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      elif fid == 1:
14010 
        if ftype == TType.STRUCT:
14011 
          self.ex = TransactionServiceException()
14012 
          self.ex.read(iprot)
14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      else:
14016 
        iprot.skip(ftype)
14017 
      iprot.readFieldEnd()
14018 
    iprot.readStructEnd()
14019 
 
14020 
  def write(self, oprot):
14021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14023 
      return
14024 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
14025 
    if self.success is not None:
14026 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14027 
      oprot.writeBool(self.success)
14028 
      oprot.writeFieldEnd()
14029 
    if self.ex is not None:
14030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14031 
      self.ex.write(oprot)
14032 
      oprot.writeFieldEnd()
14033 
    oprot.writeFieldStop()
14034 
    oprot.writeStructEnd()
14035 
 
14036 
  def validate(self):
14037 
    return
14038 
 
14039 
 
14040 
  def __repr__(self):
14041 
    L = ['%s=%r' % (key, value)
14042 
      for key, value in self.__dict__.iteritems()]
14043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14044 
 
14045 
  def __eq__(self, other):
14046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14047 
 
14048 
  def __ne__(self, other):
14049 
    return not (self == other)
4303 rajveer 14050 
 
14051 
class markOrdersAsPORaised_args:
14052 
  """
14053 
  Attributes:
14054 
   - vendorId
14055 
   - itemId
14056 
   - quantity
14057 
   - estimate
4369 rajveer 14058 
   - isReminder
4303 rajveer 14059 
  """
14060 
 
14061 
  thrift_spec = (
14062 
    None, # 0
14063 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14064 
    (2, TType.I64, 'itemId', None, None, ), # 2
14065 
    (3, TType.I64, 'quantity', None, None, ), # 3
14066 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14067 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14068 
  )
14069 
 
4369 rajveer 14070 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14071 
    self.vendorId = vendorId
14072 
    self.itemId = itemId
14073 
    self.quantity = quantity
14074 
    self.estimate = estimate
4369 rajveer 14075 
    self.isReminder = isReminder
4303 rajveer 14076 
 
14077 
  def read(self, iprot):
14078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14080 
      return
14081 
    iprot.readStructBegin()
14082 
    while True:
14083 
      (fname, ftype, fid) = iprot.readFieldBegin()
14084 
      if ftype == TType.STOP:
14085 
        break
14086 
      if fid == 1:
14087 
        if ftype == TType.I64:
14088 
          self.vendorId = iprot.readI64();
14089 
        else:
14090 
          iprot.skip(ftype)
14091 
      elif fid == 2:
14092 
        if ftype == TType.I64:
14093 
          self.itemId = iprot.readI64();
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      elif fid == 3:
14097 
        if ftype == TType.I64:
14098 
          self.quantity = iprot.readI64();
14099 
        else:
14100 
          iprot.skip(ftype)
14101 
      elif fid == 4:
14102 
        if ftype == TType.I64:
14103 
          self.estimate = iprot.readI64();
14104 
        else:
14105 
          iprot.skip(ftype)
4369 rajveer 14106 
      elif fid == 5:
14107 
        if ftype == TType.BOOL:
14108 
          self.isReminder = iprot.readBool();
14109 
        else:
14110 
          iprot.skip(ftype)
4303 rajveer 14111 
      else:
14112 
        iprot.skip(ftype)
14113 
      iprot.readFieldEnd()
14114 
    iprot.readStructEnd()
14115 
 
14116 
  def write(self, oprot):
14117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14119 
      return
14120 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
14121 
    if self.vendorId is not None:
14122 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14123 
      oprot.writeI64(self.vendorId)
14124 
      oprot.writeFieldEnd()
14125 
    if self.itemId is not None:
14126 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14127 
      oprot.writeI64(self.itemId)
14128 
      oprot.writeFieldEnd()
14129 
    if self.quantity is not None:
14130 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14131 
      oprot.writeI64(self.quantity)
14132 
      oprot.writeFieldEnd()
14133 
    if self.estimate is not None:
14134 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14135 
      oprot.writeI64(self.estimate)
14136 
      oprot.writeFieldEnd()
4369 rajveer 14137 
    if self.isReminder is not None:
14138 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14139 
      oprot.writeBool(self.isReminder)
14140 
      oprot.writeFieldEnd()
4303 rajveer 14141 
    oprot.writeFieldStop()
14142 
    oprot.writeStructEnd()
14143 
 
14144 
  def validate(self):
14145 
    return
14146 
 
14147 
 
14148 
  def __repr__(self):
14149 
    L = ['%s=%r' % (key, value)
14150 
      for key, value in self.__dict__.iteritems()]
14151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14152 
 
14153 
  def __eq__(self, other):
14154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14155 
 
14156 
  def __ne__(self, other):
14157 
    return not (self == other)
14158 
 
14159 
class markOrdersAsPORaised_result:
14160 
  """
14161 
  Attributes:
14162 
   - ex
14163 
  """
14164 
 
14165 
  thrift_spec = (
14166 
    None, # 0
14167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14168 
  )
14169 
 
14170 
  def __init__(self, ex=None,):
14171 
    self.ex = ex
14172 
 
14173 
  def read(self, iprot):
14174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14176 
      return
14177 
    iprot.readStructBegin()
14178 
    while True:
14179 
      (fname, ftype, fid) = iprot.readFieldBegin()
14180 
      if ftype == TType.STOP:
14181 
        break
14182 
      if fid == 1:
14183 
        if ftype == TType.STRUCT:
14184 
          self.ex = TransactionServiceException()
14185 
          self.ex.read(iprot)
14186 
        else:
14187 
          iprot.skip(ftype)
14188 
      else:
14189 
        iprot.skip(ftype)
14190 
      iprot.readFieldEnd()
14191 
    iprot.readStructEnd()
14192 
 
14193 
  def write(self, oprot):
14194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14196 
      return
14197 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
14198 
    if self.ex is not None:
14199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14200 
      self.ex.write(oprot)
14201 
      oprot.writeFieldEnd()
14202 
    oprot.writeFieldStop()
14203 
    oprot.writeStructEnd()
14204 
 
14205 
  def validate(self):
14206 
    return
14207 
 
14208 
 
14209 
  def __repr__(self):
14210 
    L = ['%s=%r' % (key, value)
14211 
      for key, value in self.__dict__.iteritems()]
14212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14213 
 
14214 
  def __eq__(self, other):
14215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14216 
 
14217 
  def __ne__(self, other):
14218 
    return not (self == other)
14219 
 
14220 
class markOrdersAsReversalInitiated_args:
14221 
  """
14222 
  Attributes:
14223 
   - vendorId
14224 
   - itemId
14225 
   - quantity
14226 
   - estimate
4369 rajveer 14227 
   - isReminder
4303 rajveer 14228 
  """
14229 
 
14230 
  thrift_spec = (
14231 
    None, # 0
14232 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14233 
    (2, TType.I64, 'itemId', None, None, ), # 2
14234 
    (3, TType.I64, 'quantity', None, None, ), # 3
14235 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14236 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14237 
  )
14238 
 
4369 rajveer 14239 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14240 
    self.vendorId = vendorId
14241 
    self.itemId = itemId
14242 
    self.quantity = quantity
14243 
    self.estimate = estimate
4369 rajveer 14244 
    self.isReminder = isReminder
4303 rajveer 14245 
 
14246 
  def read(self, iprot):
14247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14249 
      return
14250 
    iprot.readStructBegin()
14251 
    while True:
14252 
      (fname, ftype, fid) = iprot.readFieldBegin()
14253 
      if ftype == TType.STOP:
14254 
        break
14255 
      if fid == 1:
14256 
        if ftype == TType.I64:
14257 
          self.vendorId = iprot.readI64();
14258 
        else:
14259 
          iprot.skip(ftype)
14260 
      elif fid == 2:
14261 
        if ftype == TType.I64:
14262 
          self.itemId = iprot.readI64();
14263 
        else:
14264 
          iprot.skip(ftype)
14265 
      elif fid == 3:
14266 
        if ftype == TType.I64:
14267 
          self.quantity = iprot.readI64();
14268 
        else:
14269 
          iprot.skip(ftype)
14270 
      elif fid == 4:
14271 
        if ftype == TType.I64:
14272 
          self.estimate = iprot.readI64();
14273 
        else:
14274 
          iprot.skip(ftype)
4369 rajveer 14275 
      elif fid == 5:
14276 
        if ftype == TType.BOOL:
14277 
          self.isReminder = iprot.readBool();
14278 
        else:
14279 
          iprot.skip(ftype)
4303 rajveer 14280 
      else:
14281 
        iprot.skip(ftype)
14282 
      iprot.readFieldEnd()
14283 
    iprot.readStructEnd()
14284 
 
14285 
  def write(self, oprot):
14286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14288 
      return
14289 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14290 
    if self.vendorId is not None:
14291 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14292 
      oprot.writeI64(self.vendorId)
14293 
      oprot.writeFieldEnd()
14294 
    if self.itemId is not None:
14295 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14296 
      oprot.writeI64(self.itemId)
14297 
      oprot.writeFieldEnd()
14298 
    if self.quantity is not None:
14299 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14300 
      oprot.writeI64(self.quantity)
14301 
      oprot.writeFieldEnd()
14302 
    if self.estimate is not None:
14303 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14304 
      oprot.writeI64(self.estimate)
14305 
      oprot.writeFieldEnd()
4369 rajveer 14306 
    if self.isReminder is not None:
14307 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14308 
      oprot.writeBool(self.isReminder)
14309 
      oprot.writeFieldEnd()
4303 rajveer 14310 
    oprot.writeFieldStop()
14311 
    oprot.writeStructEnd()
14312 
 
14313 
  def validate(self):
14314 
    return
14315 
 
14316 
 
14317 
  def __repr__(self):
14318 
    L = ['%s=%r' % (key, value)
14319 
      for key, value in self.__dict__.iteritems()]
14320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14321 
 
14322 
  def __eq__(self, other):
14323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14324 
 
14325 
  def __ne__(self, other):
14326 
    return not (self == other)
14327 
 
14328 
class markOrdersAsReversalInitiated_result:
14329 
  """
14330 
  Attributes:
14331 
   - ex
14332 
  """
14333 
 
14334 
  thrift_spec = (
14335 
    None, # 0
14336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14337 
  )
14338 
 
14339 
  def __init__(self, ex=None,):
14340 
    self.ex = ex
14341 
 
14342 
  def read(self, iprot):
14343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14345 
      return
14346 
    iprot.readStructBegin()
14347 
    while True:
14348 
      (fname, ftype, fid) = iprot.readFieldBegin()
14349 
      if ftype == TType.STOP:
14350 
        break
14351 
      if fid == 1:
14352 
        if ftype == TType.STRUCT:
14353 
          self.ex = TransactionServiceException()
14354 
          self.ex.read(iprot)
14355 
        else:
14356 
          iprot.skip(ftype)
14357 
      else:
14358 
        iprot.skip(ftype)
14359 
      iprot.readFieldEnd()
14360 
    iprot.readStructEnd()
14361 
 
14362 
  def write(self, oprot):
14363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14365 
      return
14366 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14367 
    if self.ex is not None:
14368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14369 
      self.ex.write(oprot)
14370 
      oprot.writeFieldEnd()
14371 
    oprot.writeFieldStop()
14372 
    oprot.writeStructEnd()
14373 
 
14374 
  def validate(self):
14375 
    return
14376 
 
14377 
 
14378 
  def __repr__(self):
14379 
    L = ['%s=%r' % (key, value)
14380 
      for key, value in self.__dict__.iteritems()]
14381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14382 
 
14383 
  def __eq__(self, other):
14384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14385 
 
14386 
  def __ne__(self, other):
14387 
    return not (self == other)
14388 
 
14389 
class markOrdersAsNotAvailabke_args:
14390 
  """
14391 
  Attributes:
14392 
   - vendorId
14393 
   - itemId
14394 
   - quantity
14395 
   - estimate
4369 rajveer 14396 
   - isReminder
4303 rajveer 14397 
  """
14398 
 
14399 
  thrift_spec = (
14400 
    None, # 0
14401 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14402 
    (2, TType.I64, 'itemId', None, None, ), # 2
14403 
    (3, TType.I64, 'quantity', None, None, ), # 3
14404 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14405 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14406 
  )
14407 
 
4369 rajveer 14408 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14409 
    self.vendorId = vendorId
14410 
    self.itemId = itemId
14411 
    self.quantity = quantity
14412 
    self.estimate = estimate
4369 rajveer 14413 
    self.isReminder = isReminder
4303 rajveer 14414 
 
14415 
  def read(self, iprot):
14416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14418 
      return
14419 
    iprot.readStructBegin()
14420 
    while True:
14421 
      (fname, ftype, fid) = iprot.readFieldBegin()
14422 
      if ftype == TType.STOP:
14423 
        break
14424 
      if fid == 1:
14425 
        if ftype == TType.I64:
14426 
          self.vendorId = iprot.readI64();
14427 
        else:
14428 
          iprot.skip(ftype)
14429 
      elif fid == 2:
14430 
        if ftype == TType.I64:
14431 
          self.itemId = iprot.readI64();
14432 
        else:
14433 
          iprot.skip(ftype)
14434 
      elif fid == 3:
14435 
        if ftype == TType.I64:
14436 
          self.quantity = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      elif fid == 4:
14440 
        if ftype == TType.I64:
14441 
          self.estimate = iprot.readI64();
14442 
        else:
14443 
          iprot.skip(ftype)
4369 rajveer 14444 
      elif fid == 5:
14445 
        if ftype == TType.BOOL:
14446 
          self.isReminder = iprot.readBool();
14447 
        else:
14448 
          iprot.skip(ftype)
4303 rajveer 14449 
      else:
14450 
        iprot.skip(ftype)
14451 
      iprot.readFieldEnd()
14452 
    iprot.readStructEnd()
14453 
 
14454 
  def write(self, oprot):
14455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14457 
      return
14458 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14459 
    if self.vendorId is not None:
14460 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14461 
      oprot.writeI64(self.vendorId)
14462 
      oprot.writeFieldEnd()
14463 
    if self.itemId is not None:
14464 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14465 
      oprot.writeI64(self.itemId)
14466 
      oprot.writeFieldEnd()
14467 
    if self.quantity is not None:
14468 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14469 
      oprot.writeI64(self.quantity)
14470 
      oprot.writeFieldEnd()
14471 
    if self.estimate is not None:
14472 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14473 
      oprot.writeI64(self.estimate)
14474 
      oprot.writeFieldEnd()
4369 rajveer 14475 
    if self.isReminder is not None:
14476 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14477 
      oprot.writeBool(self.isReminder)
14478 
      oprot.writeFieldEnd()
4303 rajveer 14479 
    oprot.writeFieldStop()
14480 
    oprot.writeStructEnd()
14481 
 
14482 
  def validate(self):
14483 
    return
14484 
 
14485 
 
14486 
  def __repr__(self):
14487 
    L = ['%s=%r' % (key, value)
14488 
      for key, value in self.__dict__.iteritems()]
14489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14490 
 
14491 
  def __eq__(self, other):
14492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14493 
 
14494 
  def __ne__(self, other):
14495 
    return not (self == other)
14496 
 
14497 
class markOrdersAsNotAvailabke_result:
14498 
  """
14499 
  Attributes:
14500 
   - ex
14501 
  """
14502 
 
14503 
  thrift_spec = (
14504 
    None, # 0
14505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14506 
  )
14507 
 
14508 
  def __init__(self, ex=None,):
14509 
    self.ex = ex
14510 
 
14511 
  def read(self, iprot):
14512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14514 
      return
14515 
    iprot.readStructBegin()
14516 
    while True:
14517 
      (fname, ftype, fid) = iprot.readFieldBegin()
14518 
      if ftype == TType.STOP:
14519 
        break
14520 
      if fid == 1:
14521 
        if ftype == TType.STRUCT:
14522 
          self.ex = TransactionServiceException()
14523 
          self.ex.read(iprot)
14524 
        else:
14525 
          iprot.skip(ftype)
14526 
      else:
14527 
        iprot.skip(ftype)
14528 
      iprot.readFieldEnd()
14529 
    iprot.readStructEnd()
14530 
 
14531 
  def write(self, oprot):
14532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14534 
      return
14535 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14536 
    if self.ex is not None:
14537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14538 
      self.ex.write(oprot)
14539 
      oprot.writeFieldEnd()
14540 
    oprot.writeFieldStop()
14541 
    oprot.writeStructEnd()
14542 
 
14543 
  def validate(self):
14544 
    return
14545 
 
14546 
 
14547 
  def __repr__(self):
14548 
    L = ['%s=%r' % (key, value)
14549 
      for key, value in self.__dict__.iteritems()]
14550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14551 
 
14552 
  def __eq__(self, other):
14553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14554 
 
14555 
  def __ne__(self, other):
14556 
    return not (self == other)
4369 rajveer 14557 
 
14558 
class markOrdersAsTimeout_args:
14559 
  """
14560 
  Attributes:
14561 
   - vendorId
14562 
  """
14563 
 
14564 
  thrift_spec = (
14565 
    None, # 0
14566 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14567 
  )
14568 
 
14569 
  def __init__(self, vendorId=None,):
14570 
    self.vendorId = vendorId
14571 
 
14572 
  def read(self, iprot):
14573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14575 
      return
14576 
    iprot.readStructBegin()
14577 
    while True:
14578 
      (fname, ftype, fid) = iprot.readFieldBegin()
14579 
      if ftype == TType.STOP:
14580 
        break
14581 
      if fid == 1:
14582 
        if ftype == TType.I64:
14583 
          self.vendorId = iprot.readI64();
14584 
        else:
14585 
          iprot.skip(ftype)
14586 
      else:
14587 
        iprot.skip(ftype)
14588 
      iprot.readFieldEnd()
14589 
    iprot.readStructEnd()
14590 
 
14591 
  def write(self, oprot):
14592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14594 
      return
14595 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
14596 
    if self.vendorId is not None:
14597 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14598 
      oprot.writeI64(self.vendorId)
14599 
      oprot.writeFieldEnd()
14600 
    oprot.writeFieldStop()
14601 
    oprot.writeStructEnd()
14602 
 
14603 
  def validate(self):
14604 
    return
14605 
 
14606 
 
14607 
  def __repr__(self):
14608 
    L = ['%s=%r' % (key, value)
14609 
      for key, value in self.__dict__.iteritems()]
14610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14611 
 
14612 
  def __eq__(self, other):
14613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14614 
 
14615 
  def __ne__(self, other):
14616 
    return not (self == other)
14617 
 
14618 
class markOrdersAsTimeout_result:
14619 
  """
14620 
  Attributes:
14621 
   - success
14622 
   - ex
14623 
  """
14624 
 
14625 
  thrift_spec = (
14626 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
14627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14628 
  )
14629 
 
14630 
  def __init__(self, success=None, ex=None,):
14631 
    self.success = success
14632 
    self.ex = ex
14633 
 
14634 
  def read(self, iprot):
14635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14637 
      return
14638 
    iprot.readStructBegin()
14639 
    while True:
14640 
      (fname, ftype, fid) = iprot.readFieldBegin()
14641 
      if ftype == TType.STOP:
14642 
        break
14643 
      if fid == 0:
14644 
        if ftype == TType.MAP:
14645 
          self.success = {}
14646 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
14647 
          for _i265 in xrange(_size261):
14648 
            _key266 = iprot.readI32();
14649 
            _val267 = TimeoutSummary()
14650 
            _val267.read(iprot)
14651 
            self.success[_key266] = _val267
14652 
          iprot.readMapEnd()
14653 
        else:
14654 
          iprot.skip(ftype)
14655 
      elif fid == 1:
14656 
        if ftype == TType.STRUCT:
14657 
          self.ex = TransactionServiceException()
14658 
          self.ex.read(iprot)
14659 
        else:
14660 
          iprot.skip(ftype)
14661 
      else:
14662 
        iprot.skip(ftype)
14663 
      iprot.readFieldEnd()
14664 
    iprot.readStructEnd()
14665 
 
14666 
  def write(self, oprot):
14667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14669 
      return
14670 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
14671 
    if self.success is not None:
14672 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14673 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
14674 
      for kiter268,viter269 in self.success.items():
14675 
        oprot.writeI32(kiter268)
14676 
        viter269.write(oprot)
14677 
      oprot.writeMapEnd()
14678 
      oprot.writeFieldEnd()
14679 
    if self.ex is not None:
14680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14681 
      self.ex.write(oprot)
14682 
      oprot.writeFieldEnd()
14683 
    oprot.writeFieldStop()
14684 
    oprot.writeStructEnd()
14685 
 
14686 
  def validate(self):
14687 
    return
14688 
 
14689 
 
14690 
  def __repr__(self):
14691 
    L = ['%s=%r' % (key, value)
14692 
      for key, value in self.__dict__.iteritems()]
14693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14694 
 
14695 
  def __eq__(self, other):
14696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14697 
 
14698 
  def __ne__(self, other):
14699 
    return not (self == other)
4386 anupam.sin 14700 
 
14701 
class getOrderForAwb_args:
14702 
  """
14703 
  Attributes:
14704 
   - awb
14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    None, # 0
14709 
    (1, TType.STRING, 'awb', None, None, ), # 1
14710 
  )
14711 
 
14712 
  def __init__(self, awb=None,):
14713 
    self.awb = awb
14714 
 
14715 
  def read(self, iprot):
14716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14718 
      return
14719 
    iprot.readStructBegin()
14720 
    while True:
14721 
      (fname, ftype, fid) = iprot.readFieldBegin()
14722 
      if ftype == TType.STOP:
14723 
        break
14724 
      if fid == 1:
14725 
        if ftype == TType.STRING:
14726 
          self.awb = iprot.readString();
14727 
        else:
14728 
          iprot.skip(ftype)
14729 
      else:
14730 
        iprot.skip(ftype)
14731 
      iprot.readFieldEnd()
14732 
    iprot.readStructEnd()
14733 
 
14734 
  def write(self, oprot):
14735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14737 
      return
14738 
    oprot.writeStructBegin('getOrderForAwb_args')
14739 
    if self.awb is not None:
14740 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
14741 
      oprot.writeString(self.awb)
14742 
      oprot.writeFieldEnd()
14743 
    oprot.writeFieldStop()
14744 
    oprot.writeStructEnd()
14745 
 
14746 
  def validate(self):
14747 
    return
14748 
 
14749 
 
14750 
  def __repr__(self):
14751 
    L = ['%s=%r' % (key, value)
14752 
      for key, value in self.__dict__.iteritems()]
14753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14754 
 
14755 
  def __eq__(self, other):
14756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14757 
 
14758 
  def __ne__(self, other):
14759 
    return not (self == other)
14760 
 
14761 
class getOrderForAwb_result:
14762 
  """
14763 
  Attributes:
14764 
   - success
14765 
   - ex
14766 
  """
14767 
 
14768 
  thrift_spec = (
14769 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14770 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14771 
  )
14772 
 
14773 
  def __init__(self, success=None, ex=None,):
14774 
    self.success = success
14775 
    self.ex = ex
14776 
 
14777 
  def read(self, iprot):
14778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14780 
      return
14781 
    iprot.readStructBegin()
14782 
    while True:
14783 
      (fname, ftype, fid) = iprot.readFieldBegin()
14784 
      if ftype == TType.STOP:
14785 
        break
14786 
      if fid == 0:
14787 
        if ftype == TType.STRUCT:
14788 
          self.success = Order()
14789 
          self.success.read(iprot)
14790 
        else:
14791 
          iprot.skip(ftype)
14792 
      elif fid == 1:
14793 
        if ftype == TType.STRUCT:
14794 
          self.ex = TransactionServiceException()
14795 
          self.ex.read(iprot)
14796 
        else:
14797 
          iprot.skip(ftype)
14798 
      else:
14799 
        iprot.skip(ftype)
14800 
      iprot.readFieldEnd()
14801 
    iprot.readStructEnd()
14802 
 
14803 
  def write(self, oprot):
14804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14806 
      return
14807 
    oprot.writeStructBegin('getOrderForAwb_result')
14808 
    if self.success is not None:
14809 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14810 
      self.success.write(oprot)
14811 
      oprot.writeFieldEnd()
14812 
    if self.ex is not None:
14813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14814 
      self.ex.write(oprot)
14815 
      oprot.writeFieldEnd()
14816 
    oprot.writeFieldStop()
14817 
    oprot.writeStructEnd()
14818 
 
14819 
  def validate(self):
14820 
    return
14821 
 
14822 
 
14823 
  def __repr__(self):
14824 
    L = ['%s=%r' % (key, value)
14825 
      for key, value in self.__dict__.iteritems()]
14826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14827 
 
14828 
  def __eq__(self, other):
14829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14830 
 
14831 
  def __ne__(self, other):
14832 
    return not (self == other)