Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
404 
    Returns the final flag status.
405 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4247 rajveer 659 
  def markOrderCancellationRequestReceived(self, orderId):
660 
    """
661 
    Mark order as cancellation request received. If customer sends request of cancellation of
662 
    a particular order, this method will be called. It will just change status of the order
663 
    depending on its current status. It also records the previous status, so that we can move
664 
    back to that status if cancellation request is denied.
4018 chandransh 665 
 
4247 rajveer 666 
    Parameters:
667 
     - orderId
668 
    """
669 
    pass
670 
 
671 
  def markOrderCancellationRequestConfirmed(self, orderId):
672 
    """
673 
    If we decide to to cancel order, CRM will call this method to move the status of order to
674 
    cancellation request confirmed. After this OM will be able to cancel the order.
675 
 
676 
    Parameters:
677 
     - orderId
678 
    """
679 
    pass
680 
 
681 
  def markOrderCancellationRequestDenied(self, orderId):
682 
    """
683 
    If we decide to not to cancel order, we will move the order ro previous status.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
4258 rajveer 690 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 691 
    """
4258 rajveer 692 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
693 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 694 
 
695 
    Parameters:
4258 rajveer 696 
     - transactionId
4247 rajveer 697 
    """
698 
    pass
699 
 
4259 anupam.sin 700 
  def refundTransaction(self, transactionId, refundedBy, reason):
701 
    """
702 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
703 
    need to be cancelled
4247 rajveer 704 
 
4259 anupam.sin 705 
    Parameters:
706 
     - transactionId
707 
     - refundedBy
708 
     - reason
709 
    """
710 
    pass
711 
 
4285 rajveer 712 
  def acceptOrdersForItemId(self, itemId, inventory):
713 
    """
714 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
715 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 716 
 
4285 rajveer 717 
    Parameters:
718 
     - itemId
719 
     - inventory
720 
    """
721 
    pass
722 
 
723 
 
3376 rajveer 724 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 725 
  def __init__(self, iprot, oprot=None):
3376 rajveer 726 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 727 
 
728 
  def createTransaction(self, transaction):
729 
    """
730 
    Parameters:
731 
     - transaction
732 
    """
733 
    self.send_createTransaction(transaction)
132 ashish 734 
    return self.recv_createTransaction()
94 ashish 735 
 
736 
  def send_createTransaction(self, transaction):
737 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
738 
    args = createTransaction_args()
739 
    args.transaction = transaction
740 
    args.write(self._oprot)
741 
    self._oprot.writeMessageEnd()
742 
    self._oprot.trans.flush()
743 
 
744 
  def recv_createTransaction(self, ):
745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
746 
    if mtype == TMessageType.EXCEPTION:
747 
      x = TApplicationException()
748 
      x.read(self._iprot)
749 
      self._iprot.readMessageEnd()
750 
      raise x
751 
    result = createTransaction_result()
752 
    result.read(self._iprot)
753 
    self._iprot.readMessageEnd()
3431 rajveer 754 
    if result.success is not None:
132 ashish 755 
      return result.success
3431 rajveer 756 
    if result.ex is not None:
94 ashish 757 
      raise result.ex
132 ashish 758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 759 
 
760 
  def getTransaction(self, id):
761 
    """
762 
    Parameters:
763 
     - id
764 
    """
765 
    self.send_getTransaction(id)
766 
    return self.recv_getTransaction()
767 
 
768 
  def send_getTransaction(self, id):
769 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
770 
    args = getTransaction_args()
771 
    args.id = id
772 
    args.write(self._oprot)
773 
    self._oprot.writeMessageEnd()
774 
    self._oprot.trans.flush()
775 
 
776 
  def recv_getTransaction(self, ):
777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
778 
    if mtype == TMessageType.EXCEPTION:
779 
      x = TApplicationException()
780 
      x.read(self._iprot)
781 
      self._iprot.readMessageEnd()
782 
      raise x
783 
    result = getTransaction_result()
784 
    result.read(self._iprot)
785 
    self._iprot.readMessageEnd()
3431 rajveer 786 
    if result.success is not None:
94 ashish 787 
      return result.success
3431 rajveer 788 
    if result.ex is not None:
94 ashish 789 
      raise result.ex
790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
791 
 
792 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
793 
    """
794 
    Parameters:
795 
     - customerId
796 
     - from_date
797 
     - to_date
798 
     - status
799 
    """
800 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
801 
    return self.recv_getTransactionsForCustomer()
802 
 
803 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
804 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
805 
    args = getTransactionsForCustomer_args()
806 
    args.customerId = customerId
807 
    args.from_date = from_date
808 
    args.to_date = to_date
809 
    args.status = status
810 
    args.write(self._oprot)
811 
    self._oprot.writeMessageEnd()
812 
    self._oprot.trans.flush()
813 
 
814 
  def recv_getTransactionsForCustomer(self, ):
815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
816 
    if mtype == TMessageType.EXCEPTION:
817 
      x = TApplicationException()
818 
      x.read(self._iprot)
819 
      self._iprot.readMessageEnd()
820 
      raise x
821 
    result = getTransactionsForCustomer_result()
822 
    result.read(self._iprot)
823 
    self._iprot.readMessageEnd()
3431 rajveer 824 
    if result.success is not None:
94 ashish 825 
      return result.success
3431 rajveer 826 
    if result.ex is not None:
94 ashish 827 
      raise result.ex
828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
829 
 
132 ashish 830 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
831 
    """
832 
    Parameters:
833 
     - shoppingCartId
834 
    """
835 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
836 
    return self.recv_getTransactionsForShoppingCartId()
837 
 
838 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
839 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
840 
    args = getTransactionsForShoppingCartId_args()
841 
    args.shoppingCartId = shoppingCartId
842 
    args.write(self._oprot)
843 
    self._oprot.writeMessageEnd()
844 
    self._oprot.trans.flush()
845 
 
846 
  def recv_getTransactionsForShoppingCartId(self, ):
847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
848 
    if mtype == TMessageType.EXCEPTION:
849 
      x = TApplicationException()
850 
      x.read(self._iprot)
851 
      self._iprot.readMessageEnd()
852 
      raise x
853 
    result = getTransactionsForShoppingCartId_result()
854 
    result.read(self._iprot)
855 
    self._iprot.readMessageEnd()
3431 rajveer 856 
    if result.success is not None:
132 ashish 857 
      return result.success
3431 rajveer 858 
    if result.ex is not None:
132 ashish 859 
      raise result.ex
860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
861 
 
94 ashish 862 
  def getTransactionStatus(self, transactionId):
863 
    """
864 
    Parameters:
865 
     - transactionId
866 
    """
867 
    self.send_getTransactionStatus(transactionId)
868 
    return self.recv_getTransactionStatus()
869 
 
870 
  def send_getTransactionStatus(self, transactionId):
871 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
872 
    args = getTransactionStatus_args()
873 
    args.transactionId = transactionId
874 
    args.write(self._oprot)
875 
    self._oprot.writeMessageEnd()
876 
    self._oprot.trans.flush()
877 
 
878 
  def recv_getTransactionStatus(self, ):
879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
880 
    if mtype == TMessageType.EXCEPTION:
881 
      x = TApplicationException()
882 
      x.read(self._iprot)
883 
      self._iprot.readMessageEnd()
884 
      raise x
885 
    result = getTransactionStatus_result()
886 
    result.read(self._iprot)
887 
    self._iprot.readMessageEnd()
3431 rajveer 888 
    if result.success is not None:
94 ashish 889 
      return result.success
3431 rajveer 890 
    if result.ex is not None:
94 ashish 891 
      raise result.ex
892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
893 
 
894 
  def changeTransactionStatus(self, transactionId, status, description):
895 
    """
896 
    Parameters:
897 
     - transactionId
898 
     - status
899 
     - description
900 
    """
901 
    self.send_changeTransactionStatus(transactionId, status, description)
902 
    return self.recv_changeTransactionStatus()
903 
 
904 
  def send_changeTransactionStatus(self, transactionId, status, description):
905 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
906 
    args = changeTransactionStatus_args()
907 
    args.transactionId = transactionId
908 
    args.status = status
909 
    args.description = description
910 
    args.write(self._oprot)
911 
    self._oprot.writeMessageEnd()
912 
    self._oprot.trans.flush()
913 
 
914 
  def recv_changeTransactionStatus(self, ):
915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
916 
    if mtype == TMessageType.EXCEPTION:
917 
      x = TApplicationException()
918 
      x.read(self._iprot)
919 
      self._iprot.readMessageEnd()
920 
      raise x
921 
    result = changeTransactionStatus_result()
922 
    result.read(self._iprot)
923 
    self._iprot.readMessageEnd()
3431 rajveer 924 
    if result.success is not None:
94 ashish 925 
      return result.success
3431 rajveer 926 
    if result.ex is not None:
94 ashish 927 
      raise result.ex
928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
929 
 
1398 varun.gupt 930 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 931 
    """
932 
    Parameters:
933 
     - transactionId
934 
    """
1398 varun.gupt 935 
    self.send_enqueueTransactionInfoEmail(transactionId)
936 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 937 
 
1398 varun.gupt 938 
  def send_enqueueTransactionInfoEmail(self, transactionId):
939 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
940 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 941 
    args.transactionId = transactionId
942 
    args.write(self._oprot)
943 
    self._oprot.writeMessageEnd()
944 
    self._oprot.trans.flush()
945 
 
1398 varun.gupt 946 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
948 
    if mtype == TMessageType.EXCEPTION:
949 
      x = TApplicationException()
950 
      x.read(self._iprot)
951 
      self._iprot.readMessageEnd()
952 
      raise x
1398 varun.gupt 953 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 954 
    result.read(self._iprot)
955 
    self._iprot.readMessageEnd()
3431 rajveer 956 
    if result.success is not None:
1382 varun.gupt 957 
      return result.success
3431 rajveer 958 
    if result.ex is not None:
1382 varun.gupt 959 
      raise result.ex
1398 varun.gupt 960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 961 
 
483 rajveer 962 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 963 
    """
964 
    Parameters:
483 rajveer 965 
     - status
966 
     - from_date
967 
     - to_date
968 
     - warehouse_id
94 ashish 969 
    """
483 rajveer 970 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
971 
    return self.recv_getAllOrders()
94 ashish 972 
 
483 rajveer 973 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
974 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
975 
    args = getAllOrders_args()
976 
    args.status = status
977 
    args.from_date = from_date
978 
    args.to_date = to_date
979 
    args.warehouse_id = warehouse_id
94 ashish 980 
    args.write(self._oprot)
981 
    self._oprot.writeMessageEnd()
982 
    self._oprot.trans.flush()
983 
 
483 rajveer 984 
  def recv_getAllOrders(self, ):
94 ashish 985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
986 
    if mtype == TMessageType.EXCEPTION:
987 
      x = TApplicationException()
988 
      x.read(self._iprot)
989 
      self._iprot.readMessageEnd()
990 
      raise x
483 rajveer 991 
    result = getAllOrders_result()
94 ashish 992 
    result.read(self._iprot)
993 
    self._iprot.readMessageEnd()
3431 rajveer 994 
    if result.success is not None:
94 ashish 995 
      return result.success
3431 rajveer 996 
    if result.ex is not None:
94 ashish 997 
      raise result.ex
483 rajveer 998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 999 
 
4133 chandransh 1000 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1001 
    """
1002 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1003 
    Pass the status as null and the limit as 0 to ignore them.
1004 
 
1005 
    Parameters:
1006 
     - statuses
1007 
     - offset
1008 
     - limit
1009 
     - warehouse_id
1010 
    """
1011 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1012 
    return self.recv_getOrdersInBatch()
1013 
 
1014 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1015 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1016 
    args = getOrdersInBatch_args()
1017 
    args.statuses = statuses
1018 
    args.offset = offset
1019 
    args.limit = limit
1020 
    args.warehouse_id = warehouse_id
1021 
    args.write(self._oprot)
1022 
    self._oprot.writeMessageEnd()
1023 
    self._oprot.trans.flush()
1024 
 
1025 
  def recv_getOrdersInBatch(self, ):
1026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1027 
    if mtype == TMessageType.EXCEPTION:
1028 
      x = TApplicationException()
1029 
      x.read(self._iprot)
1030 
      self._iprot.readMessageEnd()
1031 
      raise x
1032 
    result = getOrdersInBatch_result()
1033 
    result.read(self._iprot)
1034 
    self._iprot.readMessageEnd()
1035 
    if result.success is not None:
1036 
      return result.success
1037 
    if result.ex is not None:
1038 
      raise result.ex
1039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1040 
 
1041 
  def getOrderCount(self, statuses, warehouseId):
1042 
    """
1043 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1044 
 
1045 
    Parameters:
1046 
     - statuses
1047 
     - warehouseId
1048 
    """
1049 
    self.send_getOrderCount(statuses, warehouseId)
1050 
    return self.recv_getOrderCount()
1051 
 
1052 
  def send_getOrderCount(self, statuses, warehouseId):
1053 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1054 
    args = getOrderCount_args()
1055 
    args.statuses = statuses
1056 
    args.warehouseId = warehouseId
1057 
    args.write(self._oprot)
1058 
    self._oprot.writeMessageEnd()
1059 
    self._oprot.trans.flush()
1060 
 
1061 
  def recv_getOrderCount(self, ):
1062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1063 
    if mtype == TMessageType.EXCEPTION:
1064 
      x = TApplicationException()
1065 
      x.read(self._iprot)
1066 
      self._iprot.readMessageEnd()
1067 
      raise x
1068 
    result = getOrderCount_result()
1069 
    result.read(self._iprot)
1070 
    self._iprot.readMessageEnd()
1071 
    if result.success is not None:
1072 
      return result.success
1073 
    if result.ex is not None:
1074 
      raise result.ex
1075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1076 
 
999 varun.gupt 1077 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1078 
    """
1132 chandransh 1079 
    Returns orders within a range of their billing dates
3431 rajveer 1080 
 
999 varun.gupt 1081 
    Parameters:
1082 
     - status
1083 
     - start_billing_date
1084 
     - end_billing_date
1085 
     - warehouse_id
1086 
    """
1087 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1088 
    return self.recv_getOrdersByBillingDate()
1089 
 
1090 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1091 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1092 
    args = getOrdersByBillingDate_args()
1093 
    args.status = status
1094 
    args.start_billing_date = start_billing_date
1095 
    args.end_billing_date = end_billing_date
1096 
    args.warehouse_id = warehouse_id
1097 
    args.write(self._oprot)
1098 
    self._oprot.writeMessageEnd()
1099 
    self._oprot.trans.flush()
1100 
 
1101 
  def recv_getOrdersByBillingDate(self, ):
1102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1103 
    if mtype == TMessageType.EXCEPTION:
1104 
      x = TApplicationException()
1105 
      x.read(self._iprot)
1106 
      self._iprot.readMessageEnd()
1107 
      raise x
1108 
    result = getOrdersByBillingDate_result()
1109 
    result.read(self._iprot)
1110 
    self._iprot.readMessageEnd()
3431 rajveer 1111 
    if result.success is not None:
999 varun.gupt 1112 
      return result.success
3431 rajveer 1113 
    if result.ex is not None:
999 varun.gupt 1114 
      raise result.ex
1115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1116 
 
3451 chandransh 1117 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1118 
    """
1119 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1120 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1121 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1122 
 
3427 chandransh 1123 
    Parameters:
1124 
     - fromShippingDate
1125 
     - toShippingDate
1126 
     - providerId
1127 
     - warehouseId
3451 chandransh 1128 
     - cod
3427 chandransh 1129 
    """
3451 chandransh 1130 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1131 
    return self.recv_getOrdersByShippingDate()
1132 
 
3451 chandransh 1133 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1134 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1135 
    args = getOrdersByShippingDate_args()
1136 
    args.fromShippingDate = fromShippingDate
1137 
    args.toShippingDate = toShippingDate
1138 
    args.providerId = providerId
1139 
    args.warehouseId = warehouseId
3451 chandransh 1140 
    args.cod = cod
3427 chandransh 1141 
    args.write(self._oprot)
1142 
    self._oprot.writeMessageEnd()
1143 
    self._oprot.trans.flush()
1144 
 
1145 
  def recv_getOrdersByShippingDate(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 = getOrdersByShippingDate_result()
1153 
    result.read(self._iprot)
1154 
    self._iprot.readMessageEnd()
3431 rajveer 1155 
    if result.success is not None:
3427 chandransh 1156 
      return result.success
3431 rajveer 1157 
    if result.ex is not None:
3427 chandransh 1158 
      raise result.ex
1159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1160 
 
1382 varun.gupt 1161 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1162 
    """
1163 
    Returns order ids for orders which can be returned
3431 rajveer 1164 
 
1382 varun.gupt 1165 
    Parameters:
1166 
     - customer_id
1167 
     - limit
1168 
    """
1169 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1170 
    return self.recv_getReturnableOrdersForCustomer()
1171 
 
1172 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1173 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1174 
    args = getReturnableOrdersForCustomer_args()
1175 
    args.customer_id = customer_id
1176 
    args.limit = limit
1177 
    args.write(self._oprot)
1178 
    self._oprot.writeMessageEnd()
1179 
    self._oprot.trans.flush()
1180 
 
1181 
  def recv_getReturnableOrdersForCustomer(self, ):
1182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1183 
    if mtype == TMessageType.EXCEPTION:
1184 
      x = TApplicationException()
1185 
      x.read(self._iprot)
1186 
      self._iprot.readMessageEnd()
1187 
      raise x
1188 
    result = getReturnableOrdersForCustomer_result()
1189 
    result.read(self._iprot)
1190 
    self._iprot.readMessageEnd()
3431 rajveer 1191 
    if result.success is not None:
1382 varun.gupt 1192 
      return result.success
3431 rajveer 1193 
    if result.ex is not None:
1382 varun.gupt 1194 
      raise result.ex
1195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1196 
 
1197 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1198 
    """
1199 
    Returns order ids for orders which can be cancelled
3431 rajveer 1200 
 
1382 varun.gupt 1201 
    Parameters:
1202 
     - customer_id
1203 
     - limit
1204 
    """
1205 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1206 
    return self.recv_getCancellableOrdersForCustomer()
1207 
 
1208 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1209 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1210 
    args = getCancellableOrdersForCustomer_args()
1211 
    args.customer_id = customer_id
1212 
    args.limit = limit
1213 
    args.write(self._oprot)
1214 
    self._oprot.writeMessageEnd()
1215 
    self._oprot.trans.flush()
1216 
 
1217 
  def recv_getCancellableOrdersForCustomer(self, ):
1218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1219 
    if mtype == TMessageType.EXCEPTION:
1220 
      x = TApplicationException()
1221 
      x.read(self._iprot)
1222 
      self._iprot.readMessageEnd()
1223 
      raise x
1224 
    result = getCancellableOrdersForCustomer_result()
1225 
    result.read(self._iprot)
1226 
    self._iprot.readMessageEnd()
3431 rajveer 1227 
    if result.success is not None:
1382 varun.gupt 1228 
      return result.success
3431 rajveer 1229 
    if result.ex is not None:
1382 varun.gupt 1230 
      raise result.ex
1231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1232 
 
483 rajveer 1233 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1234 
    """
1235 
    Parameters:
483 rajveer 1236 
     - orderId
1237 
     - status
1238 
     - description
94 ashish 1239 
    """
483 rajveer 1240 
    self.send_changeOrderStatus(orderId, status, description)
1241 
    return self.recv_changeOrderStatus()
94 ashish 1242 
 
483 rajveer 1243 
  def send_changeOrderStatus(self, orderId, status, description):
1244 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1245 
    args = changeOrderStatus_args()
1246 
    args.orderId = orderId
1247 
    args.status = status
1248 
    args.description = description
94 ashish 1249 
    args.write(self._oprot)
1250 
    self._oprot.writeMessageEnd()
1251 
    self._oprot.trans.flush()
1252 
 
483 rajveer 1253 
  def recv_changeOrderStatus(self, ):
94 ashish 1254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1255 
    if mtype == TMessageType.EXCEPTION:
1256 
      x = TApplicationException()
1257 
      x.read(self._iprot)
1258 
      self._iprot.readMessageEnd()
1259 
      raise x
483 rajveer 1260 
    result = changeOrderStatus_result()
94 ashish 1261 
    result.read(self._iprot)
1262 
    self._iprot.readMessageEnd()
3431 rajveer 1263 
    if result.success is not None:
94 ashish 1264 
      return result.success
3431 rajveer 1265 
    if result.ex is not None:
94 ashish 1266 
      raise result.ex
483 rajveer 1267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1268 
 
1528 ankur.sing 1269 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1270 
    """
1528 ankur.sing 1271 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1272 
    only user who owns the transaction can view its order details.
3431 rajveer 1273 
 
94 ashish 1274 
    Parameters:
1275 
     - transactionId
1528 ankur.sing 1276 
     - customerId
94 ashish 1277 
    """
1528 ankur.sing 1278 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1279 
    return self.recv_getOrdersForTransaction()
94 ashish 1280 
 
1528 ankur.sing 1281 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1282 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1283 
    args = getOrdersForTransaction_args()
94 ashish 1284 
    args.transactionId = transactionId
1528 ankur.sing 1285 
    args.customerId = customerId
94 ashish 1286 
    args.write(self._oprot)
1287 
    self._oprot.writeMessageEnd()
1288 
    self._oprot.trans.flush()
1289 
 
483 rajveer 1290 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1292 
    if mtype == TMessageType.EXCEPTION:
1293 
      x = TApplicationException()
1294 
      x.read(self._iprot)
1295 
      self._iprot.readMessageEnd()
1296 
      raise x
483 rajveer 1297 
    result = getOrdersForTransaction_result()
94 ashish 1298 
    result.read(self._iprot)
1299 
    self._iprot.readMessageEnd()
3431 rajveer 1300 
    if result.success is not None:
94 ashish 1301 
      return result.success
3431 rajveer 1302 
    if result.ex is not None:
94 ashish 1303 
      raise result.ex
483 rajveer 1304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1305 
 
3014 chandransh 1306 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1307 
    """
3014 chandransh 1308 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1309 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1310 
 
94 ashish 1311 
    Parameters:
483 rajveer 1312 
     - customerId
1313 
     - from_date
1314 
     - to_date
3014 chandransh 1315 
     - statuses
94 ashish 1316 
    """
3014 chandransh 1317 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1318 
    return self.recv_getOrdersForCustomer()
94 ashish 1319 
 
3014 chandransh 1320 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1321 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1322 
    args = getOrdersForCustomer_args()
1323 
    args.customerId = customerId
1324 
    args.from_date = from_date
1325 
    args.to_date = to_date
3014 chandransh 1326 
    args.statuses = statuses
94 ashish 1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
483 rajveer 1331 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
483 rajveer 1338 
    result = getOrdersForCustomer_result()
94 ashish 1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
3431 rajveer 1341 
    if result.success is not None:
94 ashish 1342 
      return result.success
3431 rajveer 1343 
    if result.ex is not None:
94 ashish 1344 
      raise result.ex
483 rajveer 1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1346 
 
483 rajveer 1347 
  def createOrder(self, order):
94 ashish 1348 
    """
1349 
    Parameters:
483 rajveer 1350 
     - order
94 ashish 1351 
    """
483 rajveer 1352 
    self.send_createOrder(order)
1353 
    return self.recv_createOrder()
94 ashish 1354 
 
483 rajveer 1355 
  def send_createOrder(self, order):
1356 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1357 
    args = createOrder_args()
1358 
    args.order = order
94 ashish 1359 
    args.write(self._oprot)
1360 
    self._oprot.writeMessageEnd()
1361 
    self._oprot.trans.flush()
1362 
 
483 rajveer 1363 
  def recv_createOrder(self, ):
94 ashish 1364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1365 
    if mtype == TMessageType.EXCEPTION:
1366 
      x = TApplicationException()
1367 
      x.read(self._iprot)
1368 
      self._iprot.readMessageEnd()
1369 
      raise x
483 rajveer 1370 
    result = createOrder_result()
94 ashish 1371 
    result.read(self._iprot)
1372 
    self._iprot.readMessageEnd()
3431 rajveer 1373 
    if result.success is not None:
94 ashish 1374 
      return result.success
3431 rajveer 1375 
    if result.ex is not None:
94 ashish 1376 
      raise result.ex
483 rajveer 1377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1378 
 
483 rajveer 1379 
  def getOrder(self, id):
94 ashish 1380 
    """
1381 
    Parameters:
483 rajveer 1382 
     - id
94 ashish 1383 
    """
483 rajveer 1384 
    self.send_getOrder(id)
1385 
    return self.recv_getOrder()
94 ashish 1386 
 
483 rajveer 1387 
  def send_getOrder(self, id):
1388 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1389 
    args = getOrder_args()
1390 
    args.id = id
94 ashish 1391 
    args.write(self._oprot)
1392 
    self._oprot.writeMessageEnd()
1393 
    self._oprot.trans.flush()
1394 
 
483 rajveer 1395 
  def recv_getOrder(self, ):
94 ashish 1396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1397 
    if mtype == TMessageType.EXCEPTION:
1398 
      x = TApplicationException()
1399 
      x.read(self._iprot)
1400 
      self._iprot.readMessageEnd()
1401 
      raise x
483 rajveer 1402 
    result = getOrder_result()
94 ashish 1403 
    result.read(self._iprot)
1404 
    self._iprot.readMessageEnd()
3431 rajveer 1405 
    if result.success is not None:
94 ashish 1406 
      return result.success
3431 rajveer 1407 
    if result.ex is not None:
94 ashish 1408 
      raise result.ex
483 rajveer 1409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1410 
 
483 rajveer 1411 
  def getLineItemsForOrder(self, orderId):
94 ashish 1412 
    """
1413 
    Parameters:
483 rajveer 1414 
     - orderId
94 ashish 1415 
    """
483 rajveer 1416 
    self.send_getLineItemsForOrder(orderId)
1417 
    return self.recv_getLineItemsForOrder()
94 ashish 1418 
 
483 rajveer 1419 
  def send_getLineItemsForOrder(self, orderId):
1420 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1421 
    args = getLineItemsForOrder_args()
1422 
    args.orderId = orderId
94 ashish 1423 
    args.write(self._oprot)
1424 
    self._oprot.writeMessageEnd()
1425 
    self._oprot.trans.flush()
1426 
 
483 rajveer 1427 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1429 
    if mtype == TMessageType.EXCEPTION:
1430 
      x = TApplicationException()
1431 
      x.read(self._iprot)
1432 
      self._iprot.readMessageEnd()
1433 
      raise x
483 rajveer 1434 
    result = getLineItemsForOrder_result()
94 ashish 1435 
    result.read(self._iprot)
1436 
    self._iprot.readMessageEnd()
3431 rajveer 1437 
    if result.success is not None:
94 ashish 1438 
      return result.success
3431 rajveer 1439 
    if result.ex is not None:
94 ashish 1440 
      raise result.ex
483 rajveer 1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1442 
 
1528 ankur.sing 1443 
  def getOrderForCustomer(self, orderId, customerId):
1444 
    """
1445 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1446 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1447 
 
1528 ankur.sing 1448 
    Parameters:
1449 
     - orderId
1450 
     - customerId
1451 
    """
1452 
    self.send_getOrderForCustomer(orderId, customerId)
1453 
    return self.recv_getOrderForCustomer()
1454 
 
1455 
  def send_getOrderForCustomer(self, orderId, customerId):
1456 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1457 
    args = getOrderForCustomer_args()
1458 
    args.orderId = orderId
1459 
    args.customerId = customerId
1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1464 
  def recv_getOrderForCustomer(self, ):
1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1471 
    result = getOrderForCustomer_result()
1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
3431 rajveer 1474 
    if result.success is not None:
1528 ankur.sing 1475 
      return result.success
3431 rajveer 1476 
    if result.ex is not None:
1528 ankur.sing 1477 
      raise result.ex
1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1479 
 
3064 chandransh 1480 
  def getAlerts(self, orderId, valid):
1481 
    """
1482 
    Parameters:
1483 
     - orderId
1484 
     - valid
1485 
    """
1486 
    self.send_getAlerts(orderId, valid)
1487 
    return self.recv_getAlerts()
1488 
 
1489 
  def send_getAlerts(self, orderId, valid):
1490 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1491 
    args = getAlerts_args()
1492 
    args.orderId = orderId
1493 
    args.valid = valid
1494 
    args.write(self._oprot)
1495 
    self._oprot.writeMessageEnd()
1496 
    self._oprot.trans.flush()
1497 
 
1498 
  def recv_getAlerts(self, ):
1499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1500 
    if mtype == TMessageType.EXCEPTION:
1501 
      x = TApplicationException()
1502 
      x.read(self._iprot)
1503 
      self._iprot.readMessageEnd()
1504 
      raise x
1505 
    result = getAlerts_result()
1506 
    result.read(self._iprot)
1507 
    self._iprot.readMessageEnd()
3431 rajveer 1508 
    if result.success is not None:
3064 chandransh 1509 
      return result.success
1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1511 
 
1512 
  def setAlert(self, orderId, unset, type, comment):
1513 
    """
1514 
    Parameters:
1515 
     - orderId
1516 
     - unset
1517 
     - type
1518 
     - comment
1519 
    """
1520 
    self.send_setAlert(orderId, unset, type, comment)
1521 
    self.recv_setAlert()
1522 
 
1523 
  def send_setAlert(self, orderId, unset, type, comment):
1524 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1525 
    args = setAlert_args()
1526 
    args.orderId = orderId
1527 
    args.unset = unset
1528 
    args.type = type
1529 
    args.comment = comment
1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_setAlert(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = setAlert_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
1544 
    return
1545 
 
1546 
  def getValidOrderCount(self, ):
1547 
    """
1548 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1549 
    """
1550 
    self.send_getValidOrderCount()
1551 
    return self.recv_getValidOrderCount()
1552 
 
1553 
  def send_getValidOrderCount(self, ):
1554 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1555 
    args = getValidOrderCount_args()
1556 
    args.write(self._oprot)
1557 
    self._oprot.writeMessageEnd()
1558 
    self._oprot.trans.flush()
1559 
 
1560 
  def recv_getValidOrderCount(self, ):
1561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1562 
    if mtype == TMessageType.EXCEPTION:
1563 
      x = TApplicationException()
1564 
      x.read(self._iprot)
1565 
      self._iprot.readMessageEnd()
1566 
      raise x
1567 
    result = getValidOrderCount_result()
1568 
    result.read(self._iprot)
1569 
    self._iprot.readMessageEnd()
3431 rajveer 1570 
    if result.success is not None:
3064 chandransh 1571 
      return result.success
1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1573 
 
1574 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1575 
    """
1576 
    Returns the number of distinct customers who have done successful transactions
1577 
    """
1578 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1579 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1580 
 
1581 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1582 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1583 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
3431 rajveer 1598 
    if result.success is not None:
3064 chandransh 1599 
      return result.success
1600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1601 
 
1602 
  def getValidOrdersAmountRange(self, ):
1603 
    """
1604 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1605 
    List contains two values, first minimum amount and second maximum amount.
1606 
    """
1607 
    self.send_getValidOrdersAmountRange()
1608 
    return self.recv_getValidOrdersAmountRange()
1609 
 
1610 
  def send_getValidOrdersAmountRange(self, ):
1611 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1612 
    args = getValidOrdersAmountRange_args()
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getValidOrdersAmountRange(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getValidOrdersAmountRange_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
3431 rajveer 1627 
    if result.success is not None:
3064 chandransh 1628 
      return result.success
1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1630 
 
1631 
  def getValidOrders(self, limit):
1632 
    """
1633 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1634 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1635 
 
3064 chandransh 1636 
    Parameters:
1637 
     - limit
1638 
    """
1639 
    self.send_getValidOrders(limit)
1640 
    return self.recv_getValidOrders()
1641 
 
1642 
  def send_getValidOrders(self, limit):
1643 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1644 
    args = getValidOrders_args()
1645 
    args.limit = limit
1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_getValidOrders(self, ):
1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
1657 
    result = getValidOrders_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
3431 rajveer 1660 
    if result.success is not None:
3064 chandransh 1661 
      return result.success
1662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1663 
 
1220 chandransh 1664 
  def batchOrders(self, warehouseId):
1665 
    """
1666 
    Create a batch of all the pending orders for the given warehouse.
1667 
    The returned list is orderd by created_timestamp.
1668 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1669 
 
1220 chandransh 1670 
    Parameters:
1671 
     - warehouseId
1672 
    """
1673 
    self.send_batchOrders(warehouseId)
1674 
    return self.recv_batchOrders()
1675 
 
1676 
  def send_batchOrders(self, warehouseId):
1677 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1678 
    args = batchOrders_args()
1679 
    args.warehouseId = warehouseId
1680 
    args.write(self._oprot)
1681 
    self._oprot.writeMessageEnd()
1682 
    self._oprot.trans.flush()
1683 
 
1684 
  def recv_batchOrders(self, ):
1685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1686 
    if mtype == TMessageType.EXCEPTION:
1687 
      x = TApplicationException()
1688 
      x.read(self._iprot)
1689 
      self._iprot.readMessageEnd()
1690 
      raise x
1691 
    result = batchOrders_result()
1692 
    result.read(self._iprot)
1693 
    self._iprot.readMessageEnd()
3431 rajveer 1694 
    if result.success is not None:
1220 chandransh 1695 
      return result.success
3431 rajveer 1696 
    if result.ex is not None:
1220 chandransh 1697 
      raise result.ex
1698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1699 
 
1208 chandransh 1700 
  def markOrderAsOutOfStock(self, orderId):
1701 
    """
1702 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1703 
 
1208 chandransh 1704 
    Parameters:
1705 
     - orderId
1706 
    """
1707 
    self.send_markOrderAsOutOfStock(orderId)
1708 
    return self.recv_markOrderAsOutOfStock()
1709 
 
1710 
  def send_markOrderAsOutOfStock(self, orderId):
1711 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1712 
    args = markOrderAsOutOfStock_args()
1713 
    args.orderId = orderId
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_markOrderAsOutOfStock(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = markOrderAsOutOfStock_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
3431 rajveer 1728 
    if result.success is not None:
1208 chandransh 1729 
      return result.success
3431 rajveer 1730 
    if result.ex is not None:
1208 chandransh 1731 
      raise result.ex
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1733 
 
3064 chandransh 1734 
  def verifyOrder(self, orderId):
759 chandransh 1735 
    """
3064 chandransh 1736 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1737 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1738 
    used for all other orders as well.
1739 
    Throws an exception if no such order exists.
3431 rajveer 1740 
 
759 chandransh 1741 
    Parameters:
3064 chandransh 1742 
     - orderId
759 chandransh 1743 
    """
3064 chandransh 1744 
    self.send_verifyOrder(orderId)
1745 
    return self.recv_verifyOrder()
759 chandransh 1746 
 
3064 chandransh 1747 
  def send_verifyOrder(self, orderId):
1748 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1749 
    args = verifyOrder_args()
1750 
    args.orderId = orderId
759 chandransh 1751 
    args.write(self._oprot)
1752 
    self._oprot.writeMessageEnd()
1753 
    self._oprot.trans.flush()
1754 
 
3064 chandransh 1755 
  def recv_verifyOrder(self, ):
759 chandransh 1756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1757 
    if mtype == TMessageType.EXCEPTION:
1758 
      x = TApplicationException()
1759 
      x.read(self._iprot)
1760 
      self._iprot.readMessageEnd()
1761 
      raise x
3064 chandransh 1762 
    result = verifyOrder_result()
759 chandransh 1763 
    result.read(self._iprot)
1764 
    self._iprot.readMessageEnd()
3431 rajveer 1765 
    if result.success is not None:
759 chandransh 1766 
      return result.success
3431 rajveer 1767 
    if result.ex is not None:
759 chandransh 1768 
      raise result.ex
3064 chandransh 1769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1770 
 
3064 chandransh 1771 
  def acceptOrder(self, orderId):
1113 chandransh 1772 
    """
3064 chandransh 1773 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1774 
    given order is not a COD order, it also captures the payment if the same has
1775 
    not been captured.
1776 
    Throws an exception if no such order exists.
3431 rajveer 1777 
 
1113 chandransh 1778 
    Parameters:
3064 chandransh 1779 
     - orderId
1113 chandransh 1780 
    """
3064 chandransh 1781 
    self.send_acceptOrder(orderId)
1782 
    return self.recv_acceptOrder()
1113 chandransh 1783 
 
3064 chandransh 1784 
  def send_acceptOrder(self, orderId):
1785 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1786 
    args = acceptOrder_args()
1787 
    args.orderId = orderId
1113 chandransh 1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
3064 chandransh 1792 
  def recv_acceptOrder(self, ):
1113 chandransh 1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
3064 chandransh 1799 
    result = acceptOrder_result()
1113 chandransh 1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
3431 rajveer 1802 
    if result.success is not None:
1113 chandransh 1803 
      return result.success
3431 rajveer 1804 
    if result.ex is not None:
1113 chandransh 1805 
      raise result.ex
3064 chandransh 1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1807 
 
4283 anupam.sin 1808 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1809 
    """
3064 chandransh 1810 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1811 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1812 
    the IMEI no. if a -1 is supplied.
1813 
    Also, it generates an invoice number for the order, marks the order as
1814 
    BILLED and sets the billing timestamp.
1815 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1816 
 
1135 chandransh 1817 
    Parameters:
3064 chandransh 1818 
     - orderId
1819 
     - invoice_number
4283 anupam.sin 1820 
     - imeiNumber
1821 
     - itemNumber
3064 chandransh 1822 
     - billed_by
4264 rajveer 1823 
     - jacketNumber
4283 anupam.sin 1824 
     - billingType
1825 
     - vendorId
1135 chandransh 1826 
    """
4283 anupam.sin 1827 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1828 
    return self.recv_addBillingDetails()
1135 chandransh 1829 
 
4283 anupam.sin 1830 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1831 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1832 
    args = addBillingDetails_args()
1833 
    args.orderId = orderId
1834 
    args.invoice_number = invoice_number
4283 anupam.sin 1835 
    args.imeiNumber = imeiNumber
1836 
    args.itemNumber = itemNumber
3064 chandransh 1837 
    args.billed_by = billed_by
4264 rajveer 1838 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1839 
    args.billingType = billingType
1840 
    args.vendorId = vendorId
1135 chandransh 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
3064 chandransh 1845 
  def recv_addBillingDetails(self, ):
1135 chandransh 1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
3064 chandransh 1852 
    result = addBillingDetails_result()
1135 chandransh 1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
3064 chandransh 1856 
      return result.success
3431 rajveer 1857 
    if result.ex is not None:
1135 chandransh 1858 
      raise result.ex
3064 chandransh 1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1860 
 
3064 chandransh 1861 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1862 
    """
3064 chandransh 1863 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1864 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1865 
 
1408 ankur.sing 1866 
    Parameters:
3064 chandransh 1867 
     - warehouseId
1408 ankur.sing 1868 
     - providerId
3064 chandransh 1869 
     - cod
1408 ankur.sing 1870 
    """
3064 chandransh 1871 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1872 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1873 
 
3064 chandransh 1874 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1875 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1876 
    args = markOrdersAsManifested_args()
1877 
    args.warehouseId = warehouseId
1408 ankur.sing 1878 
    args.providerId = providerId
3064 chandransh 1879 
    args.cod = cod
1408 ankur.sing 1880 
    args.write(self._oprot)
1881 
    self._oprot.writeMessageEnd()
1882 
    self._oprot.trans.flush()
1883 
 
3064 chandransh 1884 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1886 
    if mtype == TMessageType.EXCEPTION:
1887 
      x = TApplicationException()
1888 
      x.read(self._iprot)
1889 
      self._iprot.readMessageEnd()
1890 
      raise x
3064 chandransh 1891 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1892 
    result.read(self._iprot)
1893 
    self._iprot.readMessageEnd()
3431 rajveer 1894 
    if result.success is not None:
1408 ankur.sing 1895 
      return result.success
3431 rajveer 1896 
    if result.ex is not None:
3064 chandransh 1897 
      raise result.ex
1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1899 
 
3064 chandransh 1900 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1901 
    """
3064 chandransh 1902 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1903 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1904 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1905 
 
94 ashish 1906 
    Parameters:
3064 chandransh 1907 
     - providerId
1908 
     - pickupDetails
304 ashish 1909 
    """
3064 chandransh 1910 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1911 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1912 
 
3064 chandransh 1913 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1914 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1915 
    args = markOrdersAsPickedUp_args()
1916 
    args.providerId = providerId
1917 
    args.pickupDetails = pickupDetails
304 ashish 1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
3064 chandransh 1922 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
3064 chandransh 1929 
    result = markOrdersAsPickedUp_result()
304 ashish 1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
3431 rajveer 1932 
    if result.success is not None:
304 ashish 1933 
      return result.success
3431 rajveer 1934 
    if result.ex is not None:
3064 chandransh 1935 
      raise result.ex
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1937 
 
3064 chandransh 1938 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1939 
    """
3064 chandransh 1940 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1941 
    the name of the receiver.
1942 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1943 
 
304 ashish 1944 
    Parameters:
3064 chandransh 1945 
     - providerId
1946 
     - deliveredOrders
304 ashish 1947 
    """
3064 chandransh 1948 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1949 
    self.recv_markOrdersAsDelivered()
304 ashish 1950 
 
3064 chandransh 1951 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1952 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1953 
    args = markOrdersAsDelivered_args()
1954 
    args.providerId = providerId
1955 
    args.deliveredOrders = deliveredOrders
304 ashish 1956 
    args.write(self._oprot)
1957 
    self._oprot.writeMessageEnd()
1958 
    self._oprot.trans.flush()
1959 
 
3064 chandransh 1960 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 1961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1962 
    if mtype == TMessageType.EXCEPTION:
1963 
      x = TApplicationException()
1964 
      x.read(self._iprot)
1965 
      self._iprot.readMessageEnd()
1966 
      raise x
3064 chandransh 1967 
    result = markOrdersAsDelivered_result()
304 ashish 1968 
    result.read(self._iprot)
1969 
    self._iprot.readMessageEnd()
3431 rajveer 1970 
    if result.ex is not None:
3064 chandransh 1971 
      raise result.ex
304 ashish 1972 
    return
1973 
 
3064 chandransh 1974 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 1975 
    """
3064 chandransh 1976 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1977 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1978 
 
3064 chandransh 1979 
    Parameters:
1980 
     - providerId
1981 
     - returnedOrders
1596 ankur.sing 1982 
    """
3064 chandransh 1983 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1984 
    self.recv_markOrdersAsFailed()
304 ashish 1985 
 
3064 chandransh 1986 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1987 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1988 
    args = markOrdersAsFailed_args()
1989 
    args.providerId = providerId
1990 
    args.returnedOrders = returnedOrders
1596 ankur.sing 1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
3064 chandransh 1995 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
3064 chandransh 2002 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
3431 rajveer 2005 
    if result.ex is not None:
3064 chandransh 2006 
      raise result.ex
2007 
    return
1596 ankur.sing 2008 
 
3064 chandransh 2009 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2010 
    """
3064 chandransh 2011 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2012 
 
3064 chandransh 2013 
    Parameters:
2014 
     - providerId
2015 
     - undeliveredOrders
1627 ankur.sing 2016 
    """
3064 chandransh 2017 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2018 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2019 
 
3064 chandransh 2020 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2021 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2022 
    args = updateNonDeliveryReason_args()
2023 
    args.providerId = providerId
2024 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
3064 chandransh 2029 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
3064 chandransh 2036 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.ex is not None:
3064 chandransh 2040 
      raise result.ex
2041 
    return
1627 ankur.sing 2042 
 
3064 chandransh 2043 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2044 
    """
3064 chandransh 2045 
    Returns the list of orders whose delivery time has passed but have not been
2046 
    delivered yet for the given provider and warehouse. To get a complete list of
2047 
    undelivered orders, pass them as -1.
2048 
    Returns an empty list if no such orders exist.
3431 rajveer 2049 
 
1886 ankur.sing 2050 
    Parameters:
3064 chandransh 2051 
     - providerId
2052 
     - warehouseId
1886 ankur.sing 2053 
    """
3064 chandransh 2054 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2055 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2056 
 
3064 chandransh 2057 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2058 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2059 
    args = getUndeliveredOrders_args()
2060 
    args.providerId = providerId
2061 
    args.warehouseId = warehouseId
1886 ankur.sing 2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
3064 chandransh 2066 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
3064 chandransh 2073 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
3431 rajveer 2076 
    if result.success is not None:
1886 ankur.sing 2077 
      return result.success
3064 chandransh 2078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2079 
 
2536 chandransh 2080 
  def toggleDOAFlag(self, orderId):
2081 
    """
2082 
    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.
2083 
    Returns the final flag status.
2084 
    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 2085 
 
2536 chandransh 2086 
    Parameters:
2087 
     - orderId
2088 
    """
2089 
    self.send_toggleDOAFlag(orderId)
2090 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2091 
 
2536 chandransh 2092 
  def send_toggleDOAFlag(self, orderId):
2093 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2094 
    args = toggleDOAFlag_args()
2095 
    args.orderId = orderId
2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_toggleDOAFlag(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = toggleDOAFlag_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
3431 rajveer 2110 
    if result.success is not None:
2536 chandransh 2111 
      return result.success
3431 rajveer 2112 
    if result.ex is not None:
2536 chandransh 2113 
      raise result.ex
2114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2115 
 
2116 
  def requestPickupNumber(self, orderId):
2117 
    """
2118 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2119 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2120 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2121 
    For any other status, it returns false.
2122 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2123 
 
2536 chandransh 2124 
    Parameters:
2125 
     - orderId
2126 
    """
2127 
    self.send_requestPickupNumber(orderId)
2128 
    return self.recv_requestPickupNumber()
2129 
 
2130 
  def send_requestPickupNumber(self, orderId):
2131 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2132 
    args = requestPickupNumber_args()
2133 
    args.orderId = orderId
2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
2138 
  def recv_requestPickupNumber(self, ):
2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
2145 
    result = requestPickupNumber_result()
2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
3431 rajveer 2148 
    if result.success is not None:
2536 chandransh 2149 
      return result.success
3431 rajveer 2150 
    if result.ex is not None:
2536 chandransh 2151 
      raise result.ex
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2153 
 
2154 
  def authorizePickup(self, orderId, pickupNumber):
2155 
    """
2156 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2157 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2158 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2159 
    	3. Returns true
2591 chandransh 2160 
    If the order is in any other status, it returns false.
2536 chandransh 2161 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2162 
 
2536 chandransh 2163 
    Parameters:
2164 
     - orderId
2165 
     - pickupNumber
2166 
    """
2167 
    self.send_authorizePickup(orderId, pickupNumber)
2168 
    return self.recv_authorizePickup()
2169 
 
2170 
  def send_authorizePickup(self, orderId, pickupNumber):
2171 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2172 
    args = authorizePickup_args()
2173 
    args.orderId = orderId
2174 
    args.pickupNumber = pickupNumber
2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
2179 
  def recv_authorizePickup(self, ):
2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
2186 
    result = authorizePickup_result()
2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
2536 chandransh 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
2536 chandransh 2192 
      raise result.ex
2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2194 
 
2764 chandransh 2195 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2196 
    """
2197 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2198 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2199 
 
2764 chandransh 2200 
    Parameters:
2201 
     - providerId
2202 
     - pickupDetails
2203 
    """
2204 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2205 
    return self.recv_markDoasAsPickedUp()
2206 
 
2207 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2208 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2209 
    args = markDoasAsPickedUp_args()
2210 
    args.providerId = providerId
2211 
    args.pickupDetails = pickupDetails
2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
2216 
  def recv_markDoasAsPickedUp(self, ):
2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
2223 
    result = markDoasAsPickedUp_result()
2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
3431 rajveer 2226 
    if result.success is not None:
2764 chandransh 2227 
      return result.success
2228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2229 
 
2616 chandransh 2230 
  def receiveReturn(self, orderId):
2591 chandransh 2231 
    """
2599 chandransh 2232 
    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 2233 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2234 
    If the order is in any other state, it returns false.
2235 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2236 
 
2591 chandransh 2237 
    Parameters:
2238 
     - orderId
2239 
    """
2616 chandransh 2240 
    self.send_receiveReturn(orderId)
2241 
    return self.recv_receiveReturn()
2536 chandransh 2242 
 
2616 chandransh 2243 
  def send_receiveReturn(self, orderId):
2244 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2245 
    args = receiveReturn_args()
2591 chandransh 2246 
    args.orderId = orderId
2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2616 chandransh 2251 
  def recv_receiveReturn(self, ):
2591 chandransh 2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2616 chandransh 2258 
    result = receiveReturn_result()
2591 chandransh 2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
3431 rajveer 2261 
    if result.success is not None:
2591 chandransh 2262 
      return result.success
3431 rajveer 2263 
    if result.ex is not None:
2591 chandransh 2264 
      raise result.ex
2616 chandransh 2265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2266 
 
2267 
  def validateDoa(self, orderId, isValid):
2268 
    """
2599 chandransh 2269 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2270 
    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 2271 
    If the order is in any other state, it returns false.
2272 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2273 
 
2591 chandransh 2274 
    Parameters:
2275 
     - orderId
2276 
     - isValid
2277 
    """
2278 
    self.send_validateDoa(orderId, isValid)
2279 
    return self.recv_validateDoa()
2280 
 
2281 
  def send_validateDoa(self, orderId, isValid):
2282 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2283 
    args = validateDoa_args()
2284 
    args.orderId = orderId
2285 
    args.isValid = isValid
2286 
    args.write(self._oprot)
2287 
    self._oprot.writeMessageEnd()
2288 
    self._oprot.trans.flush()
2289 
 
2290 
  def recv_validateDoa(self, ):
2291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2292 
    if mtype == TMessageType.EXCEPTION:
2293 
      x = TApplicationException()
2294 
      x.read(self._iprot)
2295 
      self._iprot.readMessageEnd()
2296 
      raise x
2297 
    result = validateDoa_result()
2298 
    result.read(self._iprot)
2299 
    self._iprot.readMessageEnd()
3431 rajveer 2300 
    if result.success is not None:
2591 chandransh 2301 
      return result.success
3431 rajveer 2302 
    if result.ex is not None:
2591 chandransh 2303 
      raise result.ex
2304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2305 
 
2616 chandransh 2306 
  def reshipOrder(self, orderId):
2307 
    """
2308 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2309 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2310 
    	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.
2311 
 
2312 
    If the order is in DOA_CERT_VALID state, it does the following:
2313 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2314 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2315 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2316 
 
2616 chandransh 2317 
    Returns the id of the newly created order.
3431 rajveer 2318 
 
2616 chandransh 2319 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2320 
 
2616 chandransh 2321 
    Parameters:
2322 
     - orderId
2323 
    """
2324 
    self.send_reshipOrder(orderId)
2325 
    return self.recv_reshipOrder()
2591 chandransh 2326 
 
2616 chandransh 2327 
  def send_reshipOrder(self, orderId):
2328 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2329 
    args = reshipOrder_args()
2330 
    args.orderId = orderId
2331 
    args.write(self._oprot)
2332 
    self._oprot.writeMessageEnd()
2333 
    self._oprot.trans.flush()
2334 
 
2335 
  def recv_reshipOrder(self, ):
2336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2337 
    if mtype == TMessageType.EXCEPTION:
2338 
      x = TApplicationException()
2339 
      x.read(self._iprot)
2340 
      self._iprot.readMessageEnd()
2341 
      raise x
2342 
    result = reshipOrder_result()
2343 
    result.read(self._iprot)
2344 
    self._iprot.readMessageEnd()
3431 rajveer 2345 
    if result.success is not None:
2616 chandransh 2346 
      return result.success
3431 rajveer 2347 
    if result.ex is not None:
2616 chandransh 2348 
      raise result.ex
2349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2350 
 
3226 chandransh 2351 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2352 
    """
2353 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2354 
    	1. Creates a refund request for batch processing.
2355 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2356 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2357 
 
2616 chandransh 2358 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2359 
    	1. Creates a refund request for batch processing.
3226 chandransh 2360 
    	2. Cancels the reservation of the item in the warehouse.
2361 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2362 
 
3226 chandransh 2363 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2364 
    	1. Cancels the reservation of the item in the warehouse.
2365 
    	2. Marks the current order as CANCELED.
2366 
 
2367 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2368 
 
2616 chandransh 2369 
    Returns True if it is successful, False otherwise.
3431 rajveer 2370 
 
2616 chandransh 2371 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2372 
 
2616 chandransh 2373 
    Parameters:
2374 
     - orderId
3226 chandransh 2375 
     - refundedBy
2376 
     - reason
2616 chandransh 2377 
    """
3226 chandransh 2378 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2379 
    return self.recv_refundOrder()
2380 
 
3226 chandransh 2381 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2382 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2383 
    args = refundOrder_args()
2384 
    args.orderId = orderId
3226 chandransh 2385 
    args.refundedBy = refundedBy
2386 
    args.reason = reason
2616 chandransh 2387 
    args.write(self._oprot)
2388 
    self._oprot.writeMessageEnd()
2389 
    self._oprot.trans.flush()
2390 
 
2391 
  def recv_refundOrder(self, ):
2392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2393 
    if mtype == TMessageType.EXCEPTION:
2394 
      x = TApplicationException()
2395 
      x.read(self._iprot)
2396 
      self._iprot.readMessageEnd()
2397 
      raise x
2398 
    result = refundOrder_result()
2399 
    result.read(self._iprot)
2400 
    self._iprot.readMessageEnd()
3431 rajveer 2401 
    if result.success is not None:
2616 chandransh 2402 
      return result.success
3431 rajveer 2403 
    if result.ex is not None:
2616 chandransh 2404 
      raise result.ex
2405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2406 
 
2690 chandransh 2407 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2408 
    """
2409 
    Get all return orders created between the from and to dates for the given warehouse.
2410 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2411 
 
2690 chandransh 2412 
    Parameters:
2413 
     - warehouseId
2414 
     - fromDate
2415 
     - toDate
2416 
    """
2417 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2418 
    return self.recv_getReturnOrders()
2616 chandransh 2419 
 
2690 chandransh 2420 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2421 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2422 
    args = getReturnOrders_args()
2423 
    args.warehouseId = warehouseId
2424 
    args.fromDate = fromDate
2425 
    args.toDate = toDate
2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_getReturnOrders(self, ):
2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
2437 
    result = getReturnOrders_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
3431 rajveer 2440 
    if result.success is not None:
2690 chandransh 2441 
      return result.success
2442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2443 
 
2700 chandransh 2444 
  def getReturnOrder(self, id):
2445 
    """
2446 
    Returns the ReturnOrder corresponding to the given id.
2447 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2448 
 
2700 chandransh 2449 
    Parameters:
2450 
     - id
2451 
    """
2452 
    self.send_getReturnOrder(id)
2453 
    return self.recv_getReturnOrder()
2454 
 
2455 
  def send_getReturnOrder(self, id):
2456 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2457 
    args = getReturnOrder_args()
2458 
    args.id = id
2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
2463 
  def recv_getReturnOrder(self, ):
2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
2470 
    result = getReturnOrder_result()
2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
3431 rajveer 2473 
    if result.success is not None:
2700 chandransh 2474 
      return result.success
3431 rajveer 2475 
    if result.ex is not None:
2700 chandransh 2476 
      raise result.ex
2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2478 
 
2690 chandransh 2479 
  def processReturn(self, returnOrderId):
2480 
    """
2481 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2482 
 
2690 chandransh 2483 
    Parameters:
2484 
     - returnOrderId
2485 
    """
2486 
    self.send_processReturn(returnOrderId)
2487 
    self.recv_processReturn()
2488 
 
2489 
  def send_processReturn(self, returnOrderId):
2490 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2491 
    args = processReturn_args()
2492 
    args.returnOrderId = returnOrderId
2493 
    args.write(self._oprot)
2494 
    self._oprot.writeMessageEnd()
2495 
    self._oprot.trans.flush()
2496 
 
2497 
  def recv_processReturn(self, ):
2498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2499 
    if mtype == TMessageType.EXCEPTION:
2500 
      x = TApplicationException()
2501 
      x.read(self._iprot)
2502 
      self._iprot.readMessageEnd()
2503 
      raise x
2504 
    result = processReturn_result()
2505 
    result.read(self._iprot)
2506 
    self._iprot.readMessageEnd()
3431 rajveer 2507 
    if result.ex is not None:
2690 chandransh 2508 
      raise result.ex
2509 
    return
2510 
 
2819 chandransh 2511 
  def createPurchaseOrder(self, warehouseId):
2512 
    """
2513 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2514 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2515 
 
2819 chandransh 2516 
    Parameters:
2517 
     - warehouseId
2518 
    """
2519 
    self.send_createPurchaseOrder(warehouseId)
2520 
    return self.recv_createPurchaseOrder()
2690 chandransh 2521 
 
2819 chandransh 2522 
  def send_createPurchaseOrder(self, warehouseId):
2523 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2524 
    args = createPurchaseOrder_args()
2525 
    args.warehouseId = warehouseId
2526 
    args.write(self._oprot)
2527 
    self._oprot.writeMessageEnd()
2528 
    self._oprot.trans.flush()
2529 
 
2530 
  def recv_createPurchaseOrder(self, ):
2531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2532 
    if mtype == TMessageType.EXCEPTION:
2533 
      x = TApplicationException()
2534 
      x.read(self._iprot)
2535 
      self._iprot.readMessageEnd()
2536 
      raise x
2537 
    result = createPurchaseOrder_result()
2538 
    result.read(self._iprot)
2539 
    self._iprot.readMessageEnd()
3431 rajveer 2540 
    if result.success is not None:
2819 chandransh 2541 
      return result.success
3431 rajveer 2542 
    if result.ex is not None:
2819 chandransh 2543 
      raise result.ex
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2545 
 
3451 chandransh 2546 
  def updateWeight(self, orderId, weight):
2547 
    """
2548 
    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 2549 
 
3451 chandransh 2550 
    Parameters:
2551 
     - orderId
2552 
     - weight
2553 
    """
2554 
    self.send_updateWeight(orderId, weight)
2555 
    return self.recv_updateWeight()
2556 
 
2557 
  def send_updateWeight(self, orderId, weight):
2558 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2559 
    args = updateWeight_args()
2560 
    args.orderId = orderId
2561 
    args.weight = weight
2562 
    args.write(self._oprot)
2563 
    self._oprot.writeMessageEnd()
2564 
    self._oprot.trans.flush()
2565 
 
2566 
  def recv_updateWeight(self, ):
2567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2568 
    if mtype == TMessageType.EXCEPTION:
2569 
      x = TApplicationException()
2570 
      x.read(self._iprot)
2571 
      self._iprot.readMessageEnd()
2572 
      raise x
2573 
    result = updateWeight_result()
2574 
    result.read(self._iprot)
2575 
    self._iprot.readMessageEnd()
2576 
    if result.success is not None:
2577 
      return result.success
2578 
    if result.ex is not None:
2579 
      raise result.ex
2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2581 
 
3469 chandransh 2582 
  def changeItem(self, orderId, itemId):
2583 
    """
2584 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2585 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2586 
 
3469 chandransh 2587 
    Parameters:
2588 
     - orderId
2589 
     - itemId
2590 
    """
2591 
    self.send_changeItem(orderId, itemId)
2592 
    return self.recv_changeItem()
2593 
 
2594 
  def send_changeItem(self, orderId, itemId):
2595 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2596 
    args = changeItem_args()
2597 
    args.orderId = orderId
2598 
    args.itemId = itemId
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_changeItem(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = changeItem_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    if result.success is not None:
2614 
      return result.success
2615 
    if result.ex is not None:
2616 
      raise result.ex
2617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2618 
 
2619 
  def shiftToWarehouse(self, orderId, warehouseId):
2620 
    """
2621 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2622 
 
2623 
    Parameters:
2624 
     - orderId
2625 
     - warehouseId
2626 
    """
2627 
    self.send_shiftToWarehouse(orderId, warehouseId)
2628 
    return self.recv_shiftToWarehouse()
2629 
 
2630 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2631 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2632 
    args = shiftToWarehouse_args()
2633 
    args.orderId = orderId
2634 
    args.warehouseId = warehouseId
2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
2639 
  def recv_shiftToWarehouse(self, ):
2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
2646 
    result = shiftToWarehouse_result()
2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
2649 
    if result.success is not None:
2650 
      return result.success
2651 
    if result.ex is not None:
2652 
      raise result.ex
2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2654 
 
3986 chandransh 2655 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2656 
    """
2657 
    Adds the given delay reason to the given order.
3986 chandransh 2658 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2659 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2660 
 
3553 chandransh 2661 
    Parameters:
2662 
     - orderId
2663 
     - delayReason
3986 chandransh 2664 
     - furtherDelay
3553 chandransh 2665 
    """
3986 chandransh 2666 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2667 
    return self.recv_addDelayReason()
2668 
 
3986 chandransh 2669 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2670 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2671 
    args = addDelayReason_args()
2672 
    args.orderId = orderId
2673 
    args.delayReason = delayReason
3986 chandransh 2674 
    args.furtherDelay = furtherDelay
3553 chandransh 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_addDelayReason(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = addDelayReason_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
2689 
    if result.success is not None:
2690 
      return result.success
2691 
    if result.ex is not None:
2692 
      raise result.ex
2693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2694 
 
3956 chandransh 2695 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2696 
    """
2697 
    Marks the COD orders with given AWB nos. as having been processed.
2698 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2699 
 
3956 chandransh 2700 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2701 
    1. There is no order corresponding to an AWB number.
2702 
    2. The captured amount for a payment exceeds the total payment.
2703 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2704 
 
2705 
    Parameters:
2706 
     - collectedAmountMap
2707 
     - xferBy
2708 
     - xferTxnId
2709 
     - xferDate
2710 
    """
2711 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2712 
    return self.recv_reconcileCodCollection()
2713 
 
2714 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2715 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2716 
    args = reconcileCodCollection_args()
2717 
    args.collectedAmountMap = collectedAmountMap
2718 
    args.xferBy = xferBy
2719 
    args.xferTxnId = xferTxnId
2720 
    args.xferDate = xferDate
2721 
    args.write(self._oprot)
2722 
    self._oprot.writeMessageEnd()
2723 
    self._oprot.trans.flush()
2724 
 
2725 
  def recv_reconcileCodCollection(self, ):
2726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2727 
    if mtype == TMessageType.EXCEPTION:
2728 
      x = TApplicationException()
2729 
      x.read(self._iprot)
2730 
      self._iprot.readMessageEnd()
2731 
      raise x
2732 
    result = reconcileCodCollection_result()
2733 
    result.read(self._iprot)
2734 
    self._iprot.readMessageEnd()
2735 
    if result.success is not None:
2736 
      return result.success
2737 
    if result.ex is not None:
2738 
      raise result.ex
2739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2740 
 
4008 mandeep.dh 2741 
  def getTransactionsRequiringExtraProcessing(self, category):
2742 
    """
4065 mandeep.dh 2743 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2744 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2745 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2746 
 
4008 mandeep.dh 2747 
    Parameters:
2748 
     - category
2749 
    """
2750 
    self.send_getTransactionsRequiringExtraProcessing(category)
2751 
    return self.recv_getTransactionsRequiringExtraProcessing()
2752 
 
2753 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2754 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2755 
    args = getTransactionsRequiringExtraProcessing_args()
2756 
    args.category = category
2757 
    args.write(self._oprot)
2758 
    self._oprot.writeMessageEnd()
2759 
    self._oprot.trans.flush()
2760 
 
2761 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2763 
    if mtype == TMessageType.EXCEPTION:
2764 
      x = TApplicationException()
2765 
      x.read(self._iprot)
2766 
      self._iprot.readMessageEnd()
2767 
      raise x
2768 
    result = getTransactionsRequiringExtraProcessing_result()
2769 
    result.read(self._iprot)
2770 
    self._iprot.readMessageEnd()
2771 
    if result.success is not None:
2772 
      return result.success
2773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2774 
 
2775 
  def markTransactionAsProcessed(self, transactionId, category):
2776 
    """
2777 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2778 
    It essentially deletes the transaction id record for a particular
2779 
    processing type category (if present) from DB.
2780 
    This is currently used by CRM application.
4008 mandeep.dh 2781 
 
2782 
    Parameters:
2783 
     - transactionId
2784 
     - category
2785 
    """
2786 
    self.send_markTransactionAsProcessed(transactionId, category)
2787 
    self.recv_markTransactionAsProcessed()
2788 
 
2789 
  def send_markTransactionAsProcessed(self, transactionId, category):
2790 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2791 
    args = markTransactionAsProcessed_args()
2792 
    args.transactionId = transactionId
2793 
    args.category = category
2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2798 
  def recv_markTransactionAsProcessed(self, ):
2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
2805 
    result = markTransactionAsProcessed_result()
2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
2808 
    return
2809 
 
4018 chandransh 2810 
  def getItemWiseRiskyOrdersCount(self, ):
2811 
    """
2812 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2813 
    is defined as one whose shipping date is about to expire.
2814 
    """
2815 
    self.send_getItemWiseRiskyOrdersCount()
2816 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2817 
 
4018 chandransh 2818 
  def send_getItemWiseRiskyOrdersCount(self, ):
2819 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2820 
    args = getItemWiseRiskyOrdersCount_args()
2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getItemWiseRiskyOrdersCount_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success is not None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2838 
 
4247 rajveer 2839 
  def markOrderCancellationRequestReceived(self, orderId):
2840 
    """
2841 
    Mark order as cancellation request received. If customer sends request of cancellation of
2842 
    a particular order, this method will be called. It will just change status of the order
2843 
    depending on its current status. It also records the previous status, so that we can move
2844 
    back to that status if cancellation request is denied.
4018 chandransh 2845 
 
4247 rajveer 2846 
    Parameters:
2847 
     - orderId
2848 
    """
2849 
    self.send_markOrderCancellationRequestReceived(orderId)
2850 
    self.recv_markOrderCancellationRequestReceived()
2851 
 
2852 
  def send_markOrderCancellationRequestReceived(self, orderId):
2853 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2854 
    args = markOrderCancellationRequestReceived_args()
2855 
    args.orderId = orderId
2856 
    args.write(self._oprot)
2857 
    self._oprot.writeMessageEnd()
2858 
    self._oprot.trans.flush()
2859 
 
2860 
  def recv_markOrderCancellationRequestReceived(self, ):
2861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2862 
    if mtype == TMessageType.EXCEPTION:
2863 
      x = TApplicationException()
2864 
      x.read(self._iprot)
2865 
      self._iprot.readMessageEnd()
2866 
      raise x
2867 
    result = markOrderCancellationRequestReceived_result()
2868 
    result.read(self._iprot)
2869 
    self._iprot.readMessageEnd()
2870 
    if result.ex is not None:
2871 
      raise result.ex
2872 
    return
2873 
 
2874 
  def markOrderCancellationRequestConfirmed(self, orderId):
2875 
    """
2876 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2877 
    cancellation request confirmed. After this OM will be able to cancel the order.
2878 
 
2879 
    Parameters:
2880 
     - orderId
2881 
    """
2882 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2883 
    self.recv_markOrderCancellationRequestConfirmed()
2884 
 
2885 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2886 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2887 
    args = markOrderCancellationRequestConfirmed_args()
2888 
    args.orderId = orderId
2889 
    args.write(self._oprot)
2890 
    self._oprot.writeMessageEnd()
2891 
    self._oprot.trans.flush()
2892 
 
2893 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2895 
    if mtype == TMessageType.EXCEPTION:
2896 
      x = TApplicationException()
2897 
      x.read(self._iprot)
2898 
      self._iprot.readMessageEnd()
2899 
      raise x
2900 
    result = markOrderCancellationRequestConfirmed_result()
2901 
    result.read(self._iprot)
2902 
    self._iprot.readMessageEnd()
2903 
    if result.ex is not None:
2904 
      raise result.ex
2905 
    return
2906 
 
2907 
  def markOrderCancellationRequestDenied(self, orderId):
2908 
    """
2909 
    If we decide to not to cancel order, we will move the order ro previous status.
2910 
 
2911 
    Parameters:
2912 
     - orderId
2913 
    """
2914 
    self.send_markOrderCancellationRequestDenied(orderId)
2915 
    self.recv_markOrderCancellationRequestDenied()
2916 
 
2917 
  def send_markOrderCancellationRequestDenied(self, orderId):
2918 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2919 
    args = markOrderCancellationRequestDenied_args()
2920 
    args.orderId = orderId
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_markOrderCancellationRequestDenied(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = markOrderCancellationRequestDenied_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
2935 
    if result.ex is not None:
2936 
      raise result.ex
2937 
    return
2938 
 
4258 rajveer 2939 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 2940 
    """
4258 rajveer 2941 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
2942 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 2943 
 
2944 
    Parameters:
4258 rajveer 2945 
     - transactionId
4247 rajveer 2946 
    """
4258 rajveer 2947 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
2948 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 2949 
 
4258 rajveer 2950 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
2951 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
2952 
    args = markTransactionAsPaymentFlagRemoved_args()
2953 
    args.transactionId = transactionId
4247 rajveer 2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
4258 rajveer 2958 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
4258 rajveer 2965 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.ex is not None:
2969 
      raise result.ex
2970 
    return
2971 
 
4259 anupam.sin 2972 
  def refundTransaction(self, transactionId, refundedBy, reason):
2973 
    """
2974 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
2975 
    need to be cancelled
4247 rajveer 2976 
 
4259 anupam.sin 2977 
    Parameters:
2978 
     - transactionId
2979 
     - refundedBy
2980 
     - reason
2981 
    """
2982 
    self.send_refundTransaction(transactionId, refundedBy, reason)
2983 
    self.recv_refundTransaction()
2984 
 
2985 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
2986 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
2987 
    args = refundTransaction_args()
2988 
    args.transactionId = transactionId
2989 
    args.refundedBy = refundedBy
2990 
    args.reason = reason
2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
2995 
  def recv_refundTransaction(self, ):
2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
3002 
    result = refundTransaction_result()
3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3005 
    if result.ex is not None:
3006 
      raise result.ex
3007 
    return
3008 
 
4285 rajveer 3009 
  def acceptOrdersForItemId(self, itemId, inventory):
3010 
    """
3011 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3012 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3013 
 
4285 rajveer 3014 
    Parameters:
3015 
     - itemId
3016 
     - inventory
3017 
    """
3018 
    self.send_acceptOrdersForItemId(itemId, inventory)
3019 
    return self.recv_acceptOrdersForItemId()
3020 
 
3021 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3022 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3023 
    args = acceptOrdersForItemId_args()
3024 
    args.itemId = itemId
3025 
    args.inventory = inventory
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_acceptOrdersForItemId(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = acceptOrdersForItemId_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3040 
    if result.success is not None:
3041 
      return result.success
3042 
    if result.ex is not None:
3043 
      raise result.ex
3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3045 
 
3046 
 
3376 rajveer 3047 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3048 
  def __init__(self, handler):
3376 rajveer 3049 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3050 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3051 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3052 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3053 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3054 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3055 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3056 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3057 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3058 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3059 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3060 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3061 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3062 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3063 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3064 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3065 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3066 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3067 
    self._processMap["createOrder"] = Processor.process_createOrder
3068 
    self._processMap["getOrder"] = Processor.process_getOrder
3069 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3070 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3071 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3072 
    self._processMap["setAlert"] = Processor.process_setAlert
3073 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3074 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3075 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3076 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3077 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3078 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3079 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3080 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3081 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3082 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3083 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3084 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3085 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3086 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3087 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3088 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3089 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3090 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3091 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3092 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3093 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3094 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3095 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3096 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3097 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3098 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3099 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3100 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3101 
    self._processMap["changeItem"] = Processor.process_changeItem
3102 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3103 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3104 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3105 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3106 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3107 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4247 rajveer 3108 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3109 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3110 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3111 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3112 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4285 rajveer 3113 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
94 ashish 3114 
 
3115 
  def process(self, iprot, oprot):
3116 
    (name, type, seqid) = iprot.readMessageBegin()
3117 
    if name not in self._processMap:
3118 
      iprot.skip(TType.STRUCT)
3119 
      iprot.readMessageEnd()
3120 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3121 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3122 
      x.write(oprot)
3123 
      oprot.writeMessageEnd()
3124 
      oprot.trans.flush()
3125 
      return
3126 
    else:
3127 
      self._processMap[name](self, seqid, iprot, oprot)
3128 
    return True
3129 
 
3130 
  def process_createTransaction(self, seqid, iprot, oprot):
3131 
    args = createTransaction_args()
3132 
    args.read(iprot)
3133 
    iprot.readMessageEnd()
3134 
    result = createTransaction_result()
3135 
    try:
132 ashish 3136 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3137 
    except TransactionServiceException, ex:
3138 
      result.ex = ex
3139 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3140 
    result.write(oprot)
3141 
    oprot.writeMessageEnd()
3142 
    oprot.trans.flush()
3143 
 
3144 
  def process_getTransaction(self, seqid, iprot, oprot):
3145 
    args = getTransaction_args()
3146 
    args.read(iprot)
3147 
    iprot.readMessageEnd()
3148 
    result = getTransaction_result()
3149 
    try:
3150 
      result.success = self._handler.getTransaction(args.id)
3151 
    except TransactionServiceException, ex:
3152 
      result.ex = ex
3153 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3154 
    result.write(oprot)
3155 
    oprot.writeMessageEnd()
3156 
    oprot.trans.flush()
3157 
 
3158 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3159 
    args = getTransactionsForCustomer_args()
3160 
    args.read(iprot)
3161 
    iprot.readMessageEnd()
3162 
    result = getTransactionsForCustomer_result()
3163 
    try:
3164 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3165 
    except TransactionServiceException, ex:
3166 
      result.ex = ex
3167 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3168 
    result.write(oprot)
3169 
    oprot.writeMessageEnd()
3170 
    oprot.trans.flush()
3171 
 
132 ashish 3172 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3173 
    args = getTransactionsForShoppingCartId_args()
3174 
    args.read(iprot)
3175 
    iprot.readMessageEnd()
3176 
    result = getTransactionsForShoppingCartId_result()
3177 
    try:
3178 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3179 
    except TransactionServiceException, ex:
3180 
      result.ex = ex
3181 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3182 
    result.write(oprot)
3183 
    oprot.writeMessageEnd()
3184 
    oprot.trans.flush()
3185 
 
94 ashish 3186 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3187 
    args = getTransactionStatus_args()
3188 
    args.read(iprot)
3189 
    iprot.readMessageEnd()
3190 
    result = getTransactionStatus_result()
3191 
    try:
3192 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3193 
    except TransactionServiceException, ex:
3194 
      result.ex = ex
3195 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3196 
    result.write(oprot)
3197 
    oprot.writeMessageEnd()
3198 
    oprot.trans.flush()
3199 
 
3200 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3201 
    args = changeTransactionStatus_args()
3202 
    args.read(iprot)
3203 
    iprot.readMessageEnd()
3204 
    result = changeTransactionStatus_result()
3205 
    try:
3206 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3207 
    except TransactionServiceException, ex:
3208 
      result.ex = ex
3209 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3210 
    result.write(oprot)
3211 
    oprot.writeMessageEnd()
3212 
    oprot.trans.flush()
3213 
 
1398 varun.gupt 3214 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3215 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3216 
    args.read(iprot)
3217 
    iprot.readMessageEnd()
1398 varun.gupt 3218 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3219 
    try:
1398 varun.gupt 3220 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3221 
    except TransactionServiceException, ex:
3222 
      result.ex = ex
1398 varun.gupt 3223 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3224 
    result.write(oprot)
3225 
    oprot.writeMessageEnd()
3226 
    oprot.trans.flush()
3227 
 
483 rajveer 3228 
  def process_getAllOrders(self, seqid, iprot, oprot):
3229 
    args = getAllOrders_args()
94 ashish 3230 
    args.read(iprot)
3231 
    iprot.readMessageEnd()
483 rajveer 3232 
    result = getAllOrders_result()
94 ashish 3233 
    try:
483 rajveer 3234 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3235 
    except TransactionServiceException, ex:
3236 
      result.ex = ex
483 rajveer 3237 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3238 
    result.write(oprot)
3239 
    oprot.writeMessageEnd()
3240 
    oprot.trans.flush()
3241 
 
4133 chandransh 3242 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3243 
    args = getOrdersInBatch_args()
3244 
    args.read(iprot)
3245 
    iprot.readMessageEnd()
3246 
    result = getOrdersInBatch_result()
3247 
    try:
3248 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3249 
    except TransactionServiceException, ex:
3250 
      result.ex = ex
3251 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3252 
    result.write(oprot)
3253 
    oprot.writeMessageEnd()
3254 
    oprot.trans.flush()
3255 
 
3256 
  def process_getOrderCount(self, seqid, iprot, oprot):
3257 
    args = getOrderCount_args()
3258 
    args.read(iprot)
3259 
    iprot.readMessageEnd()
3260 
    result = getOrderCount_result()
3261 
    try:
3262 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3263 
    except TransactionServiceException, ex:
3264 
      result.ex = ex
3265 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3266 
    result.write(oprot)
3267 
    oprot.writeMessageEnd()
3268 
    oprot.trans.flush()
3269 
 
999 varun.gupt 3270 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3271 
    args = getOrdersByBillingDate_args()
3272 
    args.read(iprot)
3273 
    iprot.readMessageEnd()
3274 
    result = getOrdersByBillingDate_result()
3275 
    try:
3276 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3277 
    except TransactionServiceException, ex:
3278 
      result.ex = ex
3279 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3280 
    result.write(oprot)
3281 
    oprot.writeMessageEnd()
3282 
    oprot.trans.flush()
3283 
 
3427 chandransh 3284 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3285 
    args = getOrdersByShippingDate_args()
3286 
    args.read(iprot)
3287 
    iprot.readMessageEnd()
3288 
    result = getOrdersByShippingDate_result()
3289 
    try:
3451 chandransh 3290 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3291 
    except TransactionServiceException, ex:
3292 
      result.ex = ex
3293 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3294 
    result.write(oprot)
3295 
    oprot.writeMessageEnd()
3296 
    oprot.trans.flush()
3297 
 
1382 varun.gupt 3298 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3299 
    args = getReturnableOrdersForCustomer_args()
3300 
    args.read(iprot)
3301 
    iprot.readMessageEnd()
3302 
    result = getReturnableOrdersForCustomer_result()
3303 
    try:
3304 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3305 
    except TransactionServiceException, ex:
3306 
      result.ex = ex
3307 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3308 
    result.write(oprot)
3309 
    oprot.writeMessageEnd()
3310 
    oprot.trans.flush()
3311 
 
3312 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3313 
    args = getCancellableOrdersForCustomer_args()
3314 
    args.read(iprot)
3315 
    iprot.readMessageEnd()
3316 
    result = getCancellableOrdersForCustomer_result()
3317 
    try:
3318 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3319 
    except TransactionServiceException, ex:
3320 
      result.ex = ex
3321 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3322 
    result.write(oprot)
3323 
    oprot.writeMessageEnd()
3324 
    oprot.trans.flush()
3325 
 
483 rajveer 3326 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3327 
    args = changeOrderStatus_args()
94 ashish 3328 
    args.read(iprot)
3329 
    iprot.readMessageEnd()
483 rajveer 3330 
    result = changeOrderStatus_result()
94 ashish 3331 
    try:
483 rajveer 3332 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3333 
    except TransactionServiceException, ex:
3334 
      result.ex = ex
483 rajveer 3335 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3336 
    result.write(oprot)
3337 
    oprot.writeMessageEnd()
3338 
    oprot.trans.flush()
3339 
 
483 rajveer 3340 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3341 
    args = getOrdersForTransaction_args()
94 ashish 3342 
    args.read(iprot)
3343 
    iprot.readMessageEnd()
483 rajveer 3344 
    result = getOrdersForTransaction_result()
94 ashish 3345 
    try:
1528 ankur.sing 3346 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3347 
    except TransactionServiceException, ex:
3348 
      result.ex = ex
483 rajveer 3349 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3350 
    result.write(oprot)
3351 
    oprot.writeMessageEnd()
3352 
    oprot.trans.flush()
3353 
 
483 rajveer 3354 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3355 
    args = getOrdersForCustomer_args()
94 ashish 3356 
    args.read(iprot)
3357 
    iprot.readMessageEnd()
483 rajveer 3358 
    result = getOrdersForCustomer_result()
94 ashish 3359 
    try:
3014 chandransh 3360 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3361 
    except TransactionServiceException, ex:
3362 
      result.ex = ex
483 rajveer 3363 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3364 
    result.write(oprot)
3365 
    oprot.writeMessageEnd()
3366 
    oprot.trans.flush()
3367 
 
483 rajveer 3368 
  def process_createOrder(self, seqid, iprot, oprot):
3369 
    args = createOrder_args()
94 ashish 3370 
    args.read(iprot)
3371 
    iprot.readMessageEnd()
483 rajveer 3372 
    result = createOrder_result()
94 ashish 3373 
    try:
483 rajveer 3374 
      result.success = self._handler.createOrder(args.order)
94 ashish 3375 
    except TransactionServiceException, ex:
3376 
      result.ex = ex
483 rajveer 3377 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3378 
    result.write(oprot)
3379 
    oprot.writeMessageEnd()
3380 
    oprot.trans.flush()
3381 
 
483 rajveer 3382 
  def process_getOrder(self, seqid, iprot, oprot):
3383 
    args = getOrder_args()
94 ashish 3384 
    args.read(iprot)
3385 
    iprot.readMessageEnd()
483 rajveer 3386 
    result = getOrder_result()
94 ashish 3387 
    try:
483 rajveer 3388 
      result.success = self._handler.getOrder(args.id)
94 ashish 3389 
    except TransactionServiceException, ex:
3390 
      result.ex = ex
483 rajveer 3391 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3392 
    result.write(oprot)
3393 
    oprot.writeMessageEnd()
3394 
    oprot.trans.flush()
3395 
 
483 rajveer 3396 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3397 
    args = getLineItemsForOrder_args()
94 ashish 3398 
    args.read(iprot)
3399 
    iprot.readMessageEnd()
483 rajveer 3400 
    result = getLineItemsForOrder_result()
94 ashish 3401 
    try:
483 rajveer 3402 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3403 
    except TransactionServiceException, ex:
3404 
      result.ex = ex
483 rajveer 3405 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3406 
    result.write(oprot)
3407 
    oprot.writeMessageEnd()
3408 
    oprot.trans.flush()
3409 
 
1528 ankur.sing 3410 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3411 
    args = getOrderForCustomer_args()
3412 
    args.read(iprot)
3413 
    iprot.readMessageEnd()
3414 
    result = getOrderForCustomer_result()
3415 
    try:
3416 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3417 
    except TransactionServiceException, ex:
3418 
      result.ex = ex
3419 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3420 
    result.write(oprot)
3421 
    oprot.writeMessageEnd()
3422 
    oprot.trans.flush()
3423 
 
3064 chandransh 3424 
  def process_getAlerts(self, seqid, iprot, oprot):
3425 
    args = getAlerts_args()
3426 
    args.read(iprot)
3427 
    iprot.readMessageEnd()
3428 
    result = getAlerts_result()
3429 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3430 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3431 
    result.write(oprot)
3432 
    oprot.writeMessageEnd()
3433 
    oprot.trans.flush()
3434 
 
3435 
  def process_setAlert(self, seqid, iprot, oprot):
3436 
    args = setAlert_args()
3437 
    args.read(iprot)
3438 
    iprot.readMessageEnd()
3439 
    result = setAlert_result()
3440 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3441 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3442 
    result.write(oprot)
3443 
    oprot.writeMessageEnd()
3444 
    oprot.trans.flush()
3445 
 
3446 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3447 
    args = getValidOrderCount_args()
3448 
    args.read(iprot)
3449 
    iprot.readMessageEnd()
3450 
    result = getValidOrderCount_result()
3451 
    result.success = self._handler.getValidOrderCount()
3452 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3453 
    result.write(oprot)
3454 
    oprot.writeMessageEnd()
3455 
    oprot.trans.flush()
3456 
 
3457 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3458 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3459 
    args.read(iprot)
3460 
    iprot.readMessageEnd()
3461 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3462 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3463 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3464 
    result.write(oprot)
3465 
    oprot.writeMessageEnd()
3466 
    oprot.trans.flush()
3467 
 
3468 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3469 
    args = getValidOrdersAmountRange_args()
3470 
    args.read(iprot)
3471 
    iprot.readMessageEnd()
3472 
    result = getValidOrdersAmountRange_result()
3473 
    result.success = self._handler.getValidOrdersAmountRange()
3474 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3475 
    result.write(oprot)
3476 
    oprot.writeMessageEnd()
3477 
    oprot.trans.flush()
3478 
 
3479 
  def process_getValidOrders(self, seqid, iprot, oprot):
3480 
    args = getValidOrders_args()
3481 
    args.read(iprot)
3482 
    iprot.readMessageEnd()
3483 
    result = getValidOrders_result()
3484 
    result.success = self._handler.getValidOrders(args.limit)
3485 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3486 
    result.write(oprot)
3487 
    oprot.writeMessageEnd()
3488 
    oprot.trans.flush()
3489 
 
1220 chandransh 3490 
  def process_batchOrders(self, seqid, iprot, oprot):
3491 
    args = batchOrders_args()
3492 
    args.read(iprot)
3493 
    iprot.readMessageEnd()
3494 
    result = batchOrders_result()
3495 
    try:
3496 
      result.success = self._handler.batchOrders(args.warehouseId)
3497 
    except TransactionServiceException, ex:
3498 
      result.ex = ex
3499 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3500 
    result.write(oprot)
3501 
    oprot.writeMessageEnd()
3502 
    oprot.trans.flush()
3503 
 
1208 chandransh 3504 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3505 
    args = markOrderAsOutOfStock_args()
3506 
    args.read(iprot)
3507 
    iprot.readMessageEnd()
3508 
    result = markOrderAsOutOfStock_result()
3509 
    try:
3510 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3511 
    except TransactionServiceException, ex:
3512 
      result.ex = ex
3513 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3514 
    result.write(oprot)
3515 
    oprot.writeMessageEnd()
3516 
    oprot.trans.flush()
3517 
 
3064 chandransh 3518 
  def process_verifyOrder(self, seqid, iprot, oprot):
3519 
    args = verifyOrder_args()
759 chandransh 3520 
    args.read(iprot)
3521 
    iprot.readMessageEnd()
3064 chandransh 3522 
    result = verifyOrder_result()
759 chandransh 3523 
    try:
3064 chandransh 3524 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3525 
    except TransactionServiceException, ex:
3526 
      result.ex = ex
3064 chandransh 3527 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3528 
    result.write(oprot)
3529 
    oprot.writeMessageEnd()
3530 
    oprot.trans.flush()
3531 
 
3064 chandransh 3532 
  def process_acceptOrder(self, seqid, iprot, oprot):
3533 
    args = acceptOrder_args()
1113 chandransh 3534 
    args.read(iprot)
3535 
    iprot.readMessageEnd()
3064 chandransh 3536 
    result = acceptOrder_result()
1113 chandransh 3537 
    try:
3064 chandransh 3538 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3539 
    except TransactionServiceException, ex:
3540 
      result.ex = ex
3064 chandransh 3541 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3542 
    result.write(oprot)
3543 
    oprot.writeMessageEnd()
3544 
    oprot.trans.flush()
3545 
 
3064 chandransh 3546 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3547 
    args = addBillingDetails_args()
1135 chandransh 3548 
    args.read(iprot)
3549 
    iprot.readMessageEnd()
3064 chandransh 3550 
    result = addBillingDetails_result()
1135 chandransh 3551 
    try:
4283 anupam.sin 3552 
      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 3553 
    except TransactionServiceException, ex:
3554 
      result.ex = ex
3064 chandransh 3555 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3556 
    result.write(oprot)
3557 
    oprot.writeMessageEnd()
3558 
    oprot.trans.flush()
3559 
 
3064 chandransh 3560 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3561 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3562 
    args.read(iprot)
3563 
    iprot.readMessageEnd()
3064 chandransh 3564 
    result = markOrdersAsManifested_result()
3565 
    try:
3566 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3567 
    except TransactionServiceException, ex:
3568 
      result.ex = ex
3569 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3570 
    result.write(oprot)
3571 
    oprot.writeMessageEnd()
3572 
    oprot.trans.flush()
3573 
 
3064 chandransh 3574 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3575 
    args = markOrdersAsPickedUp_args()
304 ashish 3576 
    args.read(iprot)
3577 
    iprot.readMessageEnd()
3064 chandransh 3578 
    result = markOrdersAsPickedUp_result()
3579 
    try:
3580 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3581 
    except TransactionServiceException, ex:
3582 
      result.ex = ex
3583 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3584 
    result.write(oprot)
3585 
    oprot.writeMessageEnd()
3586 
    oprot.trans.flush()
94 ashish 3587 
 
3064 chandransh 3588 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3589 
    args = markOrdersAsDelivered_args()
304 ashish 3590 
    args.read(iprot)
3591 
    iprot.readMessageEnd()
3064 chandransh 3592 
    result = markOrdersAsDelivered_result()
3593 
    try:
3594 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3595 
    except TransactionServiceException, ex:
3596 
      result.ex = ex
3597 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3598 
    result.write(oprot)
3599 
    oprot.writeMessageEnd()
3600 
    oprot.trans.flush()
3601 
 
3064 chandransh 3602 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3603 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3604 
    args.read(iprot)
3605 
    iprot.readMessageEnd()
3064 chandransh 3606 
    result = markOrdersAsFailed_result()
3607 
    try:
3608 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3609 
    except TransactionServiceException, ex:
3610 
      result.ex = ex
3611 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3612 
    result.write(oprot)
3613 
    oprot.writeMessageEnd()
3614 
    oprot.trans.flush()
304 ashish 3615 
 
3064 chandransh 3616 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3617 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3618 
    args.read(iprot)
3619 
    iprot.readMessageEnd()
3064 chandransh 3620 
    result = updateNonDeliveryReason_result()
3621 
    try:
3622 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3623 
    except TransactionServiceException, ex:
3624 
      result.ex = ex
3625 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3626 
    result.write(oprot)
3627 
    oprot.writeMessageEnd()
3628 
    oprot.trans.flush()
1596 ankur.sing 3629 
 
3064 chandransh 3630 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3631 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3632 
    args.read(iprot)
3633 
    iprot.readMessageEnd()
3064 chandransh 3634 
    result = getUndeliveredOrders_result()
3635 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3636 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3637 
    result.write(oprot)
3638 
    oprot.writeMessageEnd()
3639 
    oprot.trans.flush()
3640 
 
2536 chandransh 3641 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3642 
    args = toggleDOAFlag_args()
3643 
    args.read(iprot)
3644 
    iprot.readMessageEnd()
3645 
    result = toggleDOAFlag_result()
3646 
    try:
3647 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3648 
    except TransactionServiceException, ex:
3649 
      result.ex = ex
3650 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3651 
    result.write(oprot)
3652 
    oprot.writeMessageEnd()
3653 
    oprot.trans.flush()
1886 ankur.sing 3654 
 
2536 chandransh 3655 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3656 
    args = requestPickupNumber_args()
3657 
    args.read(iprot)
3658 
    iprot.readMessageEnd()
3659 
    result = requestPickupNumber_result()
3660 
    try:
3661 
      result.success = self._handler.requestPickupNumber(args.orderId)
3662 
    except TransactionServiceException, ex:
3663 
      result.ex = ex
3664 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3665 
    result.write(oprot)
3666 
    oprot.writeMessageEnd()
3667 
    oprot.trans.flush()
3668 
 
3669 
  def process_authorizePickup(self, seqid, iprot, oprot):
3670 
    args = authorizePickup_args()
3671 
    args.read(iprot)
3672 
    iprot.readMessageEnd()
3673 
    result = authorizePickup_result()
3674 
    try:
3675 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3676 
    except TransactionServiceException, ex:
3677 
      result.ex = ex
3678 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3679 
    result.write(oprot)
3680 
    oprot.writeMessageEnd()
3681 
    oprot.trans.flush()
3682 
 
2764 chandransh 3683 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3684 
    args = markDoasAsPickedUp_args()
3685 
    args.read(iprot)
3686 
    iprot.readMessageEnd()
3687 
    result = markDoasAsPickedUp_result()
3688 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3689 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3690 
    result.write(oprot)
3691 
    oprot.writeMessageEnd()
3692 
    oprot.trans.flush()
3693 
 
2616 chandransh 3694 
  def process_receiveReturn(self, seqid, iprot, oprot):
3695 
    args = receiveReturn_args()
2591 chandransh 3696 
    args.read(iprot)
3697 
    iprot.readMessageEnd()
2616 chandransh 3698 
    result = receiveReturn_result()
2591 chandransh 3699 
    try:
2616 chandransh 3700 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3701 
    except TransactionServiceException, ex:
3702 
      result.ex = ex
2616 chandransh 3703 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3704 
    result.write(oprot)
3705 
    oprot.writeMessageEnd()
3706 
    oprot.trans.flush()
2536 chandransh 3707 
 
2591 chandransh 3708 
  def process_validateDoa(self, seqid, iprot, oprot):
3709 
    args = validateDoa_args()
3710 
    args.read(iprot)
3711 
    iprot.readMessageEnd()
3712 
    result = validateDoa_result()
3713 
    try:
3714 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3715 
    except TransactionServiceException, ex:
3716 
      result.ex = ex
3717 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3718 
    result.write(oprot)
3719 
    oprot.writeMessageEnd()
3720 
    oprot.trans.flush()
3721 
 
2616 chandransh 3722 
  def process_reshipOrder(self, seqid, iprot, oprot):
3723 
    args = reshipOrder_args()
3724 
    args.read(iprot)
3725 
    iprot.readMessageEnd()
3726 
    result = reshipOrder_result()
3727 
    try:
3728 
      result.success = self._handler.reshipOrder(args.orderId)
3729 
    except TransactionServiceException, ex:
3730 
      result.ex = ex
3731 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3732 
    result.write(oprot)
3733 
    oprot.writeMessageEnd()
3734 
    oprot.trans.flush()
2591 chandransh 3735 
 
2616 chandransh 3736 
  def process_refundOrder(self, seqid, iprot, oprot):
3737 
    args = refundOrder_args()
3738 
    args.read(iprot)
3739 
    iprot.readMessageEnd()
3740 
    result = refundOrder_result()
3741 
    try:
3226 chandransh 3742 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3743 
    except TransactionServiceException, ex:
3744 
      result.ex = ex
3745 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3746 
    result.write(oprot)
3747 
    oprot.writeMessageEnd()
3748 
    oprot.trans.flush()
3749 
 
2690 chandransh 3750 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3751 
    args = getReturnOrders_args()
3752 
    args.read(iprot)
3753 
    iprot.readMessageEnd()
3754 
    result = getReturnOrders_result()
3755 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3756 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3757 
    result.write(oprot)
3758 
    oprot.writeMessageEnd()
3759 
    oprot.trans.flush()
2616 chandransh 3760 
 
2700 chandransh 3761 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3762 
    args = getReturnOrder_args()
3763 
    args.read(iprot)
3764 
    iprot.readMessageEnd()
3765 
    result = getReturnOrder_result()
3766 
    try:
3767 
      result.success = self._handler.getReturnOrder(args.id)
3768 
    except TransactionServiceException, ex:
3769 
      result.ex = ex
3770 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3771 
    result.write(oprot)
3772 
    oprot.writeMessageEnd()
3773 
    oprot.trans.flush()
3774 
 
2690 chandransh 3775 
  def process_processReturn(self, seqid, iprot, oprot):
3776 
    args = processReturn_args()
3777 
    args.read(iprot)
3778 
    iprot.readMessageEnd()
3779 
    result = processReturn_result()
3780 
    try:
3781 
      self._handler.processReturn(args.returnOrderId)
3782 
    except TransactionServiceException, ex:
3783 
      result.ex = ex
3784 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3785 
    result.write(oprot)
3786 
    oprot.writeMessageEnd()
3787 
    oprot.trans.flush()
3788 
 
2819 chandransh 3789 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3790 
    args = createPurchaseOrder_args()
3791 
    args.read(iprot)
3792 
    iprot.readMessageEnd()
3793 
    result = createPurchaseOrder_result()
3794 
    try:
3795 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3796 
    except TransactionServiceException, ex:
3797 
      result.ex = ex
3798 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3799 
    result.write(oprot)
3800 
    oprot.writeMessageEnd()
3801 
    oprot.trans.flush()
2690 chandransh 3802 
 
3451 chandransh 3803 
  def process_updateWeight(self, seqid, iprot, oprot):
3804 
    args = updateWeight_args()
3805 
    args.read(iprot)
3806 
    iprot.readMessageEnd()
3807 
    result = updateWeight_result()
3808 
    try:
3809 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3810 
    except TransactionServiceException, ex:
3811 
      result.ex = ex
3812 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3813 
    result.write(oprot)
3814 
    oprot.writeMessageEnd()
3815 
    oprot.trans.flush()
2819 chandransh 3816 
 
3469 chandransh 3817 
  def process_changeItem(self, seqid, iprot, oprot):
3818 
    args = changeItem_args()
3819 
    args.read(iprot)
3820 
    iprot.readMessageEnd()
3821 
    result = changeItem_result()
3822 
    try:
3823 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3824 
    except TransactionServiceException, ex:
3825 
      result.ex = ex
3826 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3827 
    result.write(oprot)
3828 
    oprot.writeMessageEnd()
3829 
    oprot.trans.flush()
3451 chandransh 3830 
 
3469 chandransh 3831 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3832 
    args = shiftToWarehouse_args()
3833 
    args.read(iprot)
3834 
    iprot.readMessageEnd()
3835 
    result = shiftToWarehouse_result()
3836 
    try:
3837 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3838 
    except TransactionServiceException, ex:
3839 
      result.ex = ex
3840 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3841 
    result.write(oprot)
3842 
    oprot.writeMessageEnd()
3843 
    oprot.trans.flush()
3844 
 
3553 chandransh 3845 
  def process_addDelayReason(self, seqid, iprot, oprot):
3846 
    args = addDelayReason_args()
3847 
    args.read(iprot)
3848 
    iprot.readMessageEnd()
3849 
    result = addDelayReason_result()
3850 
    try:
3986 chandransh 3851 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3852 
    except TransactionServiceException, ex:
3853 
      result.ex = ex
3854 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
3469 chandransh 3858 
 
3956 chandransh 3859 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3860 
    args = reconcileCodCollection_args()
3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
3863 
    result = reconcileCodCollection_result()
3864 
    try:
3865 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3866 
    except TransactionServiceException, ex:
3867 
      result.ex = ex
3868 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3869 
    result.write(oprot)
3870 
    oprot.writeMessageEnd()
3871 
    oprot.trans.flush()
3553 chandransh 3872 
 
4008 mandeep.dh 3873 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3874 
    args = getTransactionsRequiringExtraProcessing_args()
3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
3877 
    result = getTransactionsRequiringExtraProcessing_result()
3878 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3879 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3880 
    result.write(oprot)
3881 
    oprot.writeMessageEnd()
3882 
    oprot.trans.flush()
3956 chandransh 3883 
 
4008 mandeep.dh 3884 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3885 
    args = markTransactionAsProcessed_args()
3886 
    args.read(iprot)
3887 
    iprot.readMessageEnd()
3888 
    result = markTransactionAsProcessed_result()
3889 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3890 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3891 
    result.write(oprot)
3892 
    oprot.writeMessageEnd()
3893 
    oprot.trans.flush()
3894 
 
4018 chandransh 3895 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3896 
    args = getItemWiseRiskyOrdersCount_args()
3897 
    args.read(iprot)
3898 
    iprot.readMessageEnd()
3899 
    result = getItemWiseRiskyOrdersCount_result()
3900 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3901 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3902 
    result.write(oprot)
3903 
    oprot.writeMessageEnd()
3904 
    oprot.trans.flush()
4008 mandeep.dh 3905 
 
4247 rajveer 3906 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3907 
    args = markOrderCancellationRequestReceived_args()
3908 
    args.read(iprot)
3909 
    iprot.readMessageEnd()
3910 
    result = markOrderCancellationRequestReceived_result()
3911 
    try:
3912 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3913 
    except TransactionServiceException, ex:
3914 
      result.ex = ex
3915 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3916 
    result.write(oprot)
3917 
    oprot.writeMessageEnd()
3918 
    oprot.trans.flush()
4018 chandransh 3919 
 
4247 rajveer 3920 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3921 
    args = markOrderCancellationRequestConfirmed_args()
3922 
    args.read(iprot)
3923 
    iprot.readMessageEnd()
3924 
    result = markOrderCancellationRequestConfirmed_result()
3925 
    try:
3926 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3927 
    except TransactionServiceException, ex:
3928 
      result.ex = ex
3929 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
3930 
    result.write(oprot)
3931 
    oprot.writeMessageEnd()
3932 
    oprot.trans.flush()
3933 
 
3934 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
3935 
    args = markOrderCancellationRequestDenied_args()
3936 
    args.read(iprot)
3937 
    iprot.readMessageEnd()
3938 
    result = markOrderCancellationRequestDenied_result()
3939 
    try:
3940 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
3941 
    except TransactionServiceException, ex:
3942 
      result.ex = ex
3943 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
3944 
    result.write(oprot)
3945 
    oprot.writeMessageEnd()
3946 
    oprot.trans.flush()
3947 
 
4258 rajveer 3948 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
3949 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 3950 
    args.read(iprot)
3951 
    iprot.readMessageEnd()
4258 rajveer 3952 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3953 
    try:
4258 rajveer 3954 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 3955 
    except TransactionServiceException, ex:
3956 
      result.ex = ex
4258 rajveer 3957 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 3958 
    result.write(oprot)
3959 
    oprot.writeMessageEnd()
3960 
    oprot.trans.flush()
3961 
 
4259 anupam.sin 3962 
  def process_refundTransaction(self, seqid, iprot, oprot):
3963 
    args = refundTransaction_args()
3964 
    args.read(iprot)
3965 
    iprot.readMessageEnd()
3966 
    result = refundTransaction_result()
3967 
    try:
3968 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
3969 
    except TransactionServiceException, ex:
3970 
      result.ex = ex
3971 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
3972 
    result.write(oprot)
3973 
    oprot.writeMessageEnd()
3974 
    oprot.trans.flush()
4247 rajveer 3975 
 
4285 rajveer 3976 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
3977 
    args = acceptOrdersForItemId_args()
3978 
    args.read(iprot)
3979 
    iprot.readMessageEnd()
3980 
    result = acceptOrdersForItemId_result()
3981 
    try:
3982 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
3983 
    except TransactionServiceException, ex:
3984 
      result.ex = ex
3985 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
3986 
    result.write(oprot)
3987 
    oprot.writeMessageEnd()
3988 
    oprot.trans.flush()
4259 anupam.sin 3989 
 
4285 rajveer 3990 
 
94 ashish 3991 
# HELPER FUNCTIONS AND STRUCTURES
3992 
 
3993 
class createTransaction_args:
3994 
  """
3995 
  Attributes:
3996 
   - transaction
3997 
  """
3998 
 
3999 
  thrift_spec = (
4000 
    None, # 0
4001 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4002 
  )
4003 
 
4004 
  def __init__(self, transaction=None,):
4005 
    self.transaction = transaction
4006 
 
4007 
  def read(self, iprot):
4008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4010 
      return
4011 
    iprot.readStructBegin()
4012 
    while True:
4013 
      (fname, ftype, fid) = iprot.readFieldBegin()
4014 
      if ftype == TType.STOP:
4015 
        break
4016 
      if fid == 1:
4017 
        if ftype == TType.STRUCT:
4018 
          self.transaction = Transaction()
4019 
          self.transaction.read(iprot)
4020 
        else:
4021 
          iprot.skip(ftype)
4022 
      else:
4023 
        iprot.skip(ftype)
4024 
      iprot.readFieldEnd()
4025 
    iprot.readStructEnd()
4026 
 
4027 
  def write(self, oprot):
4028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4030 
      return
4031 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4032 
    if self.transaction is not None:
94 ashish 4033 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4034 
      self.transaction.write(oprot)
4035 
      oprot.writeFieldEnd()
4036 
    oprot.writeFieldStop()
4037 
    oprot.writeStructEnd()
4038 
 
3431 rajveer 4039 
  def validate(self):
4040 
    return
4041 
 
4042 
 
94 ashish 4043 
  def __repr__(self):
4044 
    L = ['%s=%r' % (key, value)
4045 
      for key, value in self.__dict__.iteritems()]
4046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4047 
 
4048 
  def __eq__(self, other):
4049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4050 
 
4051 
  def __ne__(self, other):
4052 
    return not (self == other)
4053 
 
4054 
class createTransaction_result:
4055 
  """
4056 
  Attributes:
132 ashish 4057 
   - success
94 ashish 4058 
   - ex
4059 
  """
4060 
 
4061 
  thrift_spec = (
132 ashish 4062 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4064 
  )
4065 
 
132 ashish 4066 
  def __init__(self, success=None, ex=None,):
4067 
    self.success = success
94 ashish 4068 
    self.ex = ex
4069 
 
4070 
  def read(self, iprot):
4071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4073 
      return
4074 
    iprot.readStructBegin()
4075 
    while True:
4076 
      (fname, ftype, fid) = iprot.readFieldBegin()
4077 
      if ftype == TType.STOP:
4078 
        break
132 ashish 4079 
      if fid == 0:
4080 
        if ftype == TType.I64:
4081 
          self.success = iprot.readI64();
4082 
        else:
4083 
          iprot.skip(ftype)
4084 
      elif fid == 1:
94 ashish 4085 
        if ftype == TType.STRUCT:
4086 
          self.ex = TransactionServiceException()
4087 
          self.ex.read(iprot)
4088 
        else:
4089 
          iprot.skip(ftype)
4090 
      else:
4091 
        iprot.skip(ftype)
4092 
      iprot.readFieldEnd()
4093 
    iprot.readStructEnd()
4094 
 
4095 
  def write(self, oprot):
4096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4098 
      return
4099 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4100 
    if self.success is not None:
132 ashish 4101 
      oprot.writeFieldBegin('success', TType.I64, 0)
4102 
      oprot.writeI64(self.success)
4103 
      oprot.writeFieldEnd()
3431 rajveer 4104 
    if self.ex is not None:
94 ashish 4105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4106 
      self.ex.write(oprot)
4107 
      oprot.writeFieldEnd()
4108 
    oprot.writeFieldStop()
4109 
    oprot.writeStructEnd()
4110 
 
3431 rajveer 4111 
  def validate(self):
4112 
    return
4113 
 
4114 
 
94 ashish 4115 
  def __repr__(self):
4116 
    L = ['%s=%r' % (key, value)
4117 
      for key, value in self.__dict__.iteritems()]
4118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4119 
 
4120 
  def __eq__(self, other):
4121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4122 
 
4123 
  def __ne__(self, other):
4124 
    return not (self == other)
4125 
 
4126 
class getTransaction_args:
4127 
  """
4128 
  Attributes:
4129 
   - id
4130 
  """
4131 
 
4132 
  thrift_spec = (
4133 
    None, # 0
4134 
    (1, TType.I64, 'id', None, None, ), # 1
4135 
  )
4136 
 
4137 
  def __init__(self, id=None,):
4138 
    self.id = id
4139 
 
4140 
  def read(self, iprot):
4141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4143 
      return
4144 
    iprot.readStructBegin()
4145 
    while True:
4146 
      (fname, ftype, fid) = iprot.readFieldBegin()
4147 
      if ftype == TType.STOP:
4148 
        break
4149 
      if fid == 1:
4150 
        if ftype == TType.I64:
4151 
          self.id = iprot.readI64();
4152 
        else:
4153 
          iprot.skip(ftype)
4154 
      else:
4155 
        iprot.skip(ftype)
4156 
      iprot.readFieldEnd()
4157 
    iprot.readStructEnd()
4158 
 
4159 
  def write(self, oprot):
4160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4162 
      return
4163 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4164 
    if self.id is not None:
94 ashish 4165 
      oprot.writeFieldBegin('id', TType.I64, 1)
4166 
      oprot.writeI64(self.id)
4167 
      oprot.writeFieldEnd()
4168 
    oprot.writeFieldStop()
4169 
    oprot.writeStructEnd()
4170 
 
3431 rajveer 4171 
  def validate(self):
4172 
    return
4173 
 
4174 
 
94 ashish 4175 
  def __repr__(self):
4176 
    L = ['%s=%r' % (key, value)
4177 
      for key, value in self.__dict__.iteritems()]
4178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4179 
 
4180 
  def __eq__(self, other):
4181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4182 
 
4183 
  def __ne__(self, other):
4184 
    return not (self == other)
4185 
 
4186 
class getTransaction_result:
4187 
  """
4188 
  Attributes:
4189 
   - success
4190 
   - ex
4191 
  """
4192 
 
4193 
  thrift_spec = (
4194 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4196 
  )
4197 
 
4198 
  def __init__(self, success=None, ex=None,):
4199 
    self.success = success
4200 
    self.ex = ex
4201 
 
4202 
  def read(self, iprot):
4203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4205 
      return
4206 
    iprot.readStructBegin()
4207 
    while True:
4208 
      (fname, ftype, fid) = iprot.readFieldBegin()
4209 
      if ftype == TType.STOP:
4210 
        break
4211 
      if fid == 0:
4212 
        if ftype == TType.STRUCT:
4213 
          self.success = Transaction()
4214 
          self.success.read(iprot)
4215 
        else:
4216 
          iprot.skip(ftype)
4217 
      elif fid == 1:
4218 
        if ftype == TType.STRUCT:
4219 
          self.ex = TransactionServiceException()
4220 
          self.ex.read(iprot)
4221 
        else:
4222 
          iprot.skip(ftype)
4223 
      else:
4224 
        iprot.skip(ftype)
4225 
      iprot.readFieldEnd()
4226 
    iprot.readStructEnd()
4227 
 
4228 
  def write(self, oprot):
4229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4231 
      return
4232 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4233 
    if self.success is not None:
94 ashish 4234 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4235 
      self.success.write(oprot)
4236 
      oprot.writeFieldEnd()
3431 rajveer 4237 
    if self.ex is not None:
94 ashish 4238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4239 
      self.ex.write(oprot)
4240 
      oprot.writeFieldEnd()
4241 
    oprot.writeFieldStop()
4242 
    oprot.writeStructEnd()
4243 
 
3431 rajveer 4244 
  def validate(self):
4245 
    return
4246 
 
4247 
 
94 ashish 4248 
  def __repr__(self):
4249 
    L = ['%s=%r' % (key, value)
4250 
      for key, value in self.__dict__.iteritems()]
4251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4252 
 
4253 
  def __eq__(self, other):
4254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4255 
 
4256 
  def __ne__(self, other):
4257 
    return not (self == other)
4258 
 
4259 
class getTransactionsForCustomer_args:
4260 
  """
4261 
  Attributes:
4262 
   - customerId
4263 
   - from_date
4264 
   - to_date
4265 
   - status
4266 
  """
4267 
 
4268 
  thrift_spec = (
4269 
    None, # 0
4270 
    (1, TType.I64, 'customerId', None, None, ), # 1
4271 
    (2, TType.I64, 'from_date', None, None, ), # 2
4272 
    (3, TType.I64, 'to_date', None, None, ), # 3
4273 
    (4, TType.I32, 'status', None, None, ), # 4
4274 
  )
4275 
 
4276 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4277 
    self.customerId = customerId
4278 
    self.from_date = from_date
4279 
    self.to_date = to_date
4280 
    self.status = status
4281 
 
4282 
  def read(self, iprot):
4283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4285 
      return
4286 
    iprot.readStructBegin()
4287 
    while True:
4288 
      (fname, ftype, fid) = iprot.readFieldBegin()
4289 
      if ftype == TType.STOP:
4290 
        break
4291 
      if fid == 1:
4292 
        if ftype == TType.I64:
4293 
          self.customerId = iprot.readI64();
4294 
        else:
4295 
          iprot.skip(ftype)
4296 
      elif fid == 2:
4297 
        if ftype == TType.I64:
4298 
          self.from_date = iprot.readI64();
4299 
        else:
4300 
          iprot.skip(ftype)
4301 
      elif fid == 3:
4302 
        if ftype == TType.I64:
4303 
          self.to_date = iprot.readI64();
4304 
        else:
4305 
          iprot.skip(ftype)
4306 
      elif fid == 4:
4307 
        if ftype == TType.I32:
4308 
          self.status = iprot.readI32();
4309 
        else:
4310 
          iprot.skip(ftype)
4311 
      else:
4312 
        iprot.skip(ftype)
4313 
      iprot.readFieldEnd()
4314 
    iprot.readStructEnd()
4315 
 
4316 
  def write(self, oprot):
4317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4319 
      return
4320 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4321 
    if self.customerId is not None:
94 ashish 4322 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4323 
      oprot.writeI64(self.customerId)
4324 
      oprot.writeFieldEnd()
3431 rajveer 4325 
    if self.from_date is not None:
94 ashish 4326 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4327 
      oprot.writeI64(self.from_date)
4328 
      oprot.writeFieldEnd()
3431 rajveer 4329 
    if self.to_date is not None:
94 ashish 4330 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4331 
      oprot.writeI64(self.to_date)
4332 
      oprot.writeFieldEnd()
3431 rajveer 4333 
    if self.status is not None:
94 ashish 4334 
      oprot.writeFieldBegin('status', TType.I32, 4)
4335 
      oprot.writeI32(self.status)
4336 
      oprot.writeFieldEnd()
4337 
    oprot.writeFieldStop()
4338 
    oprot.writeStructEnd()
4339 
 
3431 rajveer 4340 
  def validate(self):
4341 
    return
4342 
 
4343 
 
94 ashish 4344 
  def __repr__(self):
4345 
    L = ['%s=%r' % (key, value)
4346 
      for key, value in self.__dict__.iteritems()]
4347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4348 
 
4349 
  def __eq__(self, other):
4350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4351 
 
4352 
  def __ne__(self, other):
4353 
    return not (self == other)
4354 
 
4355 
class getTransactionsForCustomer_result:
4356 
  """
4357 
  Attributes:
4358 
   - success
4359 
   - ex
4360 
  """
4361 
 
4362 
  thrift_spec = (
4363 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4365 
  )
4366 
 
4367 
  def __init__(self, success=None, ex=None,):
4368 
    self.success = success
4369 
    self.ex = ex
4370 
 
4371 
  def read(self, iprot):
4372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4374 
      return
4375 
    iprot.readStructBegin()
4376 
    while True:
4377 
      (fname, ftype, fid) = iprot.readFieldBegin()
4378 
      if ftype == TType.STOP:
4379 
        break
4380 
      if fid == 0:
4381 
        if ftype == TType.LIST:
4382 
          self.success = []
685 chandransh 4383 
          (_etype17, _size14) = iprot.readListBegin()
4384 
          for _i18 in xrange(_size14):
4385 
            _elem19 = Transaction()
4386 
            _elem19.read(iprot)
4387 
            self.success.append(_elem19)
94 ashish 4388 
          iprot.readListEnd()
4389 
        else:
4390 
          iprot.skip(ftype)
4391 
      elif fid == 1:
4392 
        if ftype == TType.STRUCT:
4393 
          self.ex = TransactionServiceException()
4394 
          self.ex.read(iprot)
4395 
        else:
4396 
          iprot.skip(ftype)
4397 
      else:
4398 
        iprot.skip(ftype)
4399 
      iprot.readFieldEnd()
4400 
    iprot.readStructEnd()
4401 
 
4402 
  def write(self, oprot):
4403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4405 
      return
4406 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4407 
    if self.success is not None:
94 ashish 4408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4410 
      for iter20 in self.success:
4411 
        iter20.write(oprot)
94 ashish 4412 
      oprot.writeListEnd()
4413 
      oprot.writeFieldEnd()
3431 rajveer 4414 
    if self.ex is not None:
94 ashish 4415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4416 
      self.ex.write(oprot)
4417 
      oprot.writeFieldEnd()
4418 
    oprot.writeFieldStop()
4419 
    oprot.writeStructEnd()
4420 
 
3431 rajveer 4421 
  def validate(self):
4422 
    return
4423 
 
4424 
 
94 ashish 4425 
  def __repr__(self):
4426 
    L = ['%s=%r' % (key, value)
4427 
      for key, value in self.__dict__.iteritems()]
4428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4429 
 
4430 
  def __eq__(self, other):
4431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4432 
 
4433 
  def __ne__(self, other):
4434 
    return not (self == other)
4435 
 
132 ashish 4436 
class getTransactionsForShoppingCartId_args:
4437 
  """
4438 
  Attributes:
4439 
   - shoppingCartId
4440 
  """
4441 
 
4442 
  thrift_spec = (
4443 
    None, # 0
4444 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4445 
  )
4446 
 
4447 
  def __init__(self, shoppingCartId=None,):
4448 
    self.shoppingCartId = shoppingCartId
4449 
 
4450 
  def read(self, iprot):
4451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4453 
      return
4454 
    iprot.readStructBegin()
4455 
    while True:
4456 
      (fname, ftype, fid) = iprot.readFieldBegin()
4457 
      if ftype == TType.STOP:
4458 
        break
4459 
      if fid == 1:
4460 
        if ftype == TType.I64:
4461 
          self.shoppingCartId = iprot.readI64();
4462 
        else:
4463 
          iprot.skip(ftype)
4464 
      else:
4465 
        iprot.skip(ftype)
4466 
      iprot.readFieldEnd()
4467 
    iprot.readStructEnd()
4468 
 
4469 
  def write(self, oprot):
4470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4472 
      return
4473 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4474 
    if self.shoppingCartId is not None:
132 ashish 4475 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4476 
      oprot.writeI64(self.shoppingCartId)
4477 
      oprot.writeFieldEnd()
4478 
    oprot.writeFieldStop()
4479 
    oprot.writeStructEnd()
4480 
 
3431 rajveer 4481 
  def validate(self):
4482 
    return
4483 
 
4484 
 
132 ashish 4485 
  def __repr__(self):
4486 
    L = ['%s=%r' % (key, value)
4487 
      for key, value in self.__dict__.iteritems()]
4488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4489 
 
4490 
  def __eq__(self, other):
4491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4492 
 
4493 
  def __ne__(self, other):
4494 
    return not (self == other)
4495 
 
4496 
class getTransactionsForShoppingCartId_result:
4497 
  """
4498 
  Attributes:
4499 
   - success
4500 
   - ex
4501 
  """
4502 
 
4503 
  thrift_spec = (
4504 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4506 
  )
4507 
 
4508 
  def __init__(self, success=None, ex=None,):
4509 
    self.success = success
4510 
    self.ex = ex
4511 
 
4512 
  def read(self, iprot):
4513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4515 
      return
4516 
    iprot.readStructBegin()
4517 
    while True:
4518 
      (fname, ftype, fid) = iprot.readFieldBegin()
4519 
      if ftype == TType.STOP:
4520 
        break
4521 
      if fid == 0:
4522 
        if ftype == TType.LIST:
4523 
          self.success = []
685 chandransh 4524 
          (_etype24, _size21) = iprot.readListBegin()
4525 
          for _i25 in xrange(_size21):
4526 
            _elem26 = Transaction()
4527 
            _elem26.read(iprot)
4528 
            self.success.append(_elem26)
132 ashish 4529 
          iprot.readListEnd()
4530 
        else:
4531 
          iprot.skip(ftype)
4532 
      elif fid == 1:
4533 
        if ftype == TType.STRUCT:
4534 
          self.ex = TransactionServiceException()
4535 
          self.ex.read(iprot)
4536 
        else:
4537 
          iprot.skip(ftype)
4538 
      else:
4539 
        iprot.skip(ftype)
4540 
      iprot.readFieldEnd()
4541 
    iprot.readStructEnd()
4542 
 
4543 
  def write(self, oprot):
4544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4546 
      return
4547 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4548 
    if self.success is not None:
132 ashish 4549 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4550 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4551 
      for iter27 in self.success:
4552 
        iter27.write(oprot)
132 ashish 4553 
      oprot.writeListEnd()
4554 
      oprot.writeFieldEnd()
3431 rajveer 4555 
    if self.ex is not None:
132 ashish 4556 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4557 
      self.ex.write(oprot)
4558 
      oprot.writeFieldEnd()
4559 
    oprot.writeFieldStop()
4560 
    oprot.writeStructEnd()
4561 
 
3431 rajveer 4562 
  def validate(self):
4563 
    return
4564 
 
4565 
 
132 ashish 4566 
  def __repr__(self):
4567 
    L = ['%s=%r' % (key, value)
4568 
      for key, value in self.__dict__.iteritems()]
4569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4570 
 
4571 
  def __eq__(self, other):
4572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4573 
 
4574 
  def __ne__(self, other):
4575 
    return not (self == other)
4576 
 
94 ashish 4577 
class getTransactionStatus_args:
4578 
  """
4579 
  Attributes:
4580 
   - transactionId
4581 
  """
4582 
 
4583 
  thrift_spec = (
4584 
    None, # 0
4585 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4586 
  )
4587 
 
4588 
  def __init__(self, transactionId=None,):
4589 
    self.transactionId = transactionId
4590 
 
4591 
  def read(self, iprot):
4592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4594 
      return
4595 
    iprot.readStructBegin()
4596 
    while True:
4597 
      (fname, ftype, fid) = iprot.readFieldBegin()
4598 
      if ftype == TType.STOP:
4599 
        break
4600 
      if fid == 1:
4601 
        if ftype == TType.I64:
4602 
          self.transactionId = iprot.readI64();
4603 
        else:
4604 
          iprot.skip(ftype)
4605 
      else:
4606 
        iprot.skip(ftype)
4607 
      iprot.readFieldEnd()
4608 
    iprot.readStructEnd()
4609 
 
4610 
  def write(self, oprot):
4611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4613 
      return
4614 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4615 
    if self.transactionId is not None:
94 ashish 4616 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4617 
      oprot.writeI64(self.transactionId)
4618 
      oprot.writeFieldEnd()
4619 
    oprot.writeFieldStop()
4620 
    oprot.writeStructEnd()
4621 
 
3431 rajveer 4622 
  def validate(self):
4623 
    return
4624 
 
4625 
 
94 ashish 4626 
  def __repr__(self):
4627 
    L = ['%s=%r' % (key, value)
4628 
      for key, value in self.__dict__.iteritems()]
4629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4630 
 
4631 
  def __eq__(self, other):
4632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4633 
 
4634 
  def __ne__(self, other):
4635 
    return not (self == other)
4636 
 
4637 
class getTransactionStatus_result:
4638 
  """
4639 
  Attributes:
4640 
   - success
4641 
   - ex
4642 
  """
4643 
 
4644 
  thrift_spec = (
4645 
    (0, TType.I32, 'success', None, None, ), # 0
4646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4647 
  )
4648 
 
4649 
  def __init__(self, success=None, ex=None,):
4650 
    self.success = success
4651 
    self.ex = ex
4652 
 
4653 
  def read(self, iprot):
4654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4656 
      return
4657 
    iprot.readStructBegin()
4658 
    while True:
4659 
      (fname, ftype, fid) = iprot.readFieldBegin()
4660 
      if ftype == TType.STOP:
4661 
        break
4662 
      if fid == 0:
4663 
        if ftype == TType.I32:
4664 
          self.success = iprot.readI32();
4665 
        else:
4666 
          iprot.skip(ftype)
4667 
      elif fid == 1:
4668 
        if ftype == TType.STRUCT:
4669 
          self.ex = TransactionServiceException()
4670 
          self.ex.read(iprot)
4671 
        else:
4672 
          iprot.skip(ftype)
4673 
      else:
4674 
        iprot.skip(ftype)
4675 
      iprot.readFieldEnd()
4676 
    iprot.readStructEnd()
4677 
 
4678 
  def write(self, oprot):
4679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4681 
      return
4682 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4683 
    if self.success is not None:
94 ashish 4684 
      oprot.writeFieldBegin('success', TType.I32, 0)
4685 
      oprot.writeI32(self.success)
4686 
      oprot.writeFieldEnd()
3431 rajveer 4687 
    if self.ex is not None:
94 ashish 4688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4689 
      self.ex.write(oprot)
4690 
      oprot.writeFieldEnd()
4691 
    oprot.writeFieldStop()
4692 
    oprot.writeStructEnd()
4693 
 
3431 rajveer 4694 
  def validate(self):
4695 
    return
4696 
 
4697 
 
94 ashish 4698 
  def __repr__(self):
4699 
    L = ['%s=%r' % (key, value)
4700 
      for key, value in self.__dict__.iteritems()]
4701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4702 
 
4703 
  def __eq__(self, other):
4704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4705 
 
4706 
  def __ne__(self, other):
4707 
    return not (self == other)
4708 
 
4709 
class changeTransactionStatus_args:
4710 
  """
4711 
  Attributes:
4712 
   - transactionId
4713 
   - status
4714 
   - description
4715 
  """
4716 
 
4717 
  thrift_spec = (
4718 
    None, # 0
4719 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4720 
    (2, TType.I32, 'status', None, None, ), # 2
4721 
    (3, TType.STRING, 'description', None, None, ), # 3
4722 
  )
4723 
 
4724 
  def __init__(self, transactionId=None, status=None, description=None,):
4725 
    self.transactionId = transactionId
4726 
    self.status = status
4727 
    self.description = description
4728 
 
4729 
  def read(self, iprot):
4730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4732 
      return
4733 
    iprot.readStructBegin()
4734 
    while True:
4735 
      (fname, ftype, fid) = iprot.readFieldBegin()
4736 
      if ftype == TType.STOP:
4737 
        break
4738 
      if fid == 1:
4739 
        if ftype == TType.I64:
4740 
          self.transactionId = iprot.readI64();
4741 
        else:
4742 
          iprot.skip(ftype)
4743 
      elif fid == 2:
4744 
        if ftype == TType.I32:
4745 
          self.status = iprot.readI32();
4746 
        else:
4747 
          iprot.skip(ftype)
4748 
      elif fid == 3:
4749 
        if ftype == TType.STRING:
4750 
          self.description = iprot.readString();
4751 
        else:
4752 
          iprot.skip(ftype)
4753 
      else:
4754 
        iprot.skip(ftype)
4755 
      iprot.readFieldEnd()
4756 
    iprot.readStructEnd()
4757 
 
4758 
  def write(self, oprot):
4759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4761 
      return
4762 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4763 
    if self.transactionId is not None:
94 ashish 4764 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4765 
      oprot.writeI64(self.transactionId)
4766 
      oprot.writeFieldEnd()
3431 rajveer 4767 
    if self.status is not None:
94 ashish 4768 
      oprot.writeFieldBegin('status', TType.I32, 2)
4769 
      oprot.writeI32(self.status)
4770 
      oprot.writeFieldEnd()
3431 rajveer 4771 
    if self.description is not None:
94 ashish 4772 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4773 
      oprot.writeString(self.description)
4774 
      oprot.writeFieldEnd()
4775 
    oprot.writeFieldStop()
4776 
    oprot.writeStructEnd()
4777 
 
3431 rajveer 4778 
  def validate(self):
4779 
    return
4780 
 
4781 
 
94 ashish 4782 
  def __repr__(self):
4783 
    L = ['%s=%r' % (key, value)
4784 
      for key, value in self.__dict__.iteritems()]
4785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4786 
 
4787 
  def __eq__(self, other):
4788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4789 
 
4790 
  def __ne__(self, other):
4791 
    return not (self == other)
4792 
 
4793 
class changeTransactionStatus_result:
4794 
  """
4795 
  Attributes:
4796 
   - success
4797 
   - ex
4798 
  """
4799 
 
4800 
  thrift_spec = (
4801 
    (0, TType.BOOL, 'success', None, None, ), # 0
4802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4803 
  )
4804 
 
4805 
  def __init__(self, success=None, ex=None,):
4806 
    self.success = success
4807 
    self.ex = ex
4808 
 
4809 
  def read(self, iprot):
4810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4812 
      return
4813 
    iprot.readStructBegin()
4814 
    while True:
4815 
      (fname, ftype, fid) = iprot.readFieldBegin()
4816 
      if ftype == TType.STOP:
4817 
        break
4818 
      if fid == 0:
4819 
        if ftype == TType.BOOL:
4820 
          self.success = iprot.readBool();
4821 
        else:
4822 
          iprot.skip(ftype)
4823 
      elif fid == 1:
4824 
        if ftype == TType.STRUCT:
4825 
          self.ex = TransactionServiceException()
4826 
          self.ex.read(iprot)
4827 
        else:
4828 
          iprot.skip(ftype)
4829 
      else:
4830 
        iprot.skip(ftype)
4831 
      iprot.readFieldEnd()
4832 
    iprot.readStructEnd()
4833 
 
4834 
  def write(self, oprot):
4835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4837 
      return
4838 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4839 
    if self.success is not None:
94 ashish 4840 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4841 
      oprot.writeBool(self.success)
4842 
      oprot.writeFieldEnd()
3431 rajveer 4843 
    if self.ex is not None:
94 ashish 4844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4845 
      self.ex.write(oprot)
4846 
      oprot.writeFieldEnd()
4847 
    oprot.writeFieldStop()
4848 
    oprot.writeStructEnd()
4849 
 
3431 rajveer 4850 
  def validate(self):
4851 
    return
4852 
 
4853 
 
94 ashish 4854 
  def __repr__(self):
4855 
    L = ['%s=%r' % (key, value)
4856 
      for key, value in self.__dict__.iteritems()]
4857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4858 
 
4859 
  def __eq__(self, other):
4860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4861 
 
4862 
  def __ne__(self, other):
4863 
    return not (self == other)
4864 
 
1398 varun.gupt 4865 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4866 
  """
4867 
  Attributes:
4868 
   - transactionId
4869 
  """
4870 
 
4871 
  thrift_spec = (
4872 
    None, # 0
4873 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4874 
  )
4875 
 
4876 
  def __init__(self, transactionId=None,):
4877 
    self.transactionId = transactionId
4878 
 
4879 
  def read(self, iprot):
4880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4882 
      return
4883 
    iprot.readStructBegin()
4884 
    while True:
4885 
      (fname, ftype, fid) = iprot.readFieldBegin()
4886 
      if ftype == TType.STOP:
4887 
        break
4888 
      if fid == 1:
4889 
        if ftype == TType.I64:
4890 
          self.transactionId = iprot.readI64();
4891 
        else:
4892 
          iprot.skip(ftype)
4893 
      else:
4894 
        iprot.skip(ftype)
4895 
      iprot.readFieldEnd()
4896 
    iprot.readStructEnd()
4897 
 
4898 
  def write(self, oprot):
4899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4901 
      return
1398 varun.gupt 4902 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4903 
    if self.transactionId is not None:
1382 varun.gupt 4904 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4905 
      oprot.writeI64(self.transactionId)
4906 
      oprot.writeFieldEnd()
4907 
    oprot.writeFieldStop()
4908 
    oprot.writeStructEnd()
4909 
 
3431 rajveer 4910 
  def validate(self):
4911 
    return
4912 
 
4913 
 
1382 varun.gupt 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 
 
1398 varun.gupt 4925 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4926 
  """
4927 
  Attributes:
4928 
   - success
4929 
   - ex
4930 
  """
4931 
 
4932 
  thrift_spec = (
4933 
    (0, TType.BOOL, 'success', None, None, ), # 0
4934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4935 
  )
4936 
 
4937 
  def __init__(self, success=None, ex=None,):
4938 
    self.success = success
4939 
    self.ex = ex
4940 
 
4941 
  def read(self, iprot):
4942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4944 
      return
4945 
    iprot.readStructBegin()
4946 
    while True:
4947 
      (fname, ftype, fid) = iprot.readFieldBegin()
4948 
      if ftype == TType.STOP:
4949 
        break
4950 
      if fid == 0:
4951 
        if ftype == TType.BOOL:
4952 
          self.success = iprot.readBool();
4953 
        else:
4954 
          iprot.skip(ftype)
4955 
      elif fid == 1:
4956 
        if ftype == TType.STRUCT:
4957 
          self.ex = TransactionServiceException()
4958 
          self.ex.read(iprot)
4959 
        else:
4960 
          iprot.skip(ftype)
4961 
      else:
4962 
        iprot.skip(ftype)
4963 
      iprot.readFieldEnd()
4964 
    iprot.readStructEnd()
4965 
 
4966 
  def write(self, oprot):
4967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4969 
      return
1398 varun.gupt 4970 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 4971 
    if self.success is not None:
1382 varun.gupt 4972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4973 
      oprot.writeBool(self.success)
4974 
      oprot.writeFieldEnd()
3431 rajveer 4975 
    if self.ex is not None:
1382 varun.gupt 4976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4977 
      self.ex.write(oprot)
4978 
      oprot.writeFieldEnd()
4979 
    oprot.writeFieldStop()
4980 
    oprot.writeStructEnd()
4981 
 
3431 rajveer 4982 
  def validate(self):
4983 
    return
4984 
 
4985 
 
1382 varun.gupt 4986 
  def __repr__(self):
4987 
    L = ['%s=%r' % (key, value)
4988 
      for key, value in self.__dict__.iteritems()]
4989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4990 
 
4991 
  def __eq__(self, other):
4992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4993 
 
4994 
  def __ne__(self, other):
4995 
    return not (self == other)
4996 
 
483 rajveer 4997 
class getAllOrders_args:
94 ashish 4998 
  """
4999 
  Attributes:
483 rajveer 5000 
   - status
5001 
   - from_date
5002 
   - to_date
5003 
   - warehouse_id
94 ashish 5004 
  """
5005 
 
5006 
  thrift_spec = (
5007 
    None, # 0
483 rajveer 5008 
    (1, TType.I32, 'status', None, None, ), # 1
5009 
    (2, TType.I64, 'from_date', None, None, ), # 2
5010 
    (3, TType.I64, 'to_date', None, None, ), # 3
5011 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5012 
  )
5013 
 
483 rajveer 5014 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5015 
    self.status = status
5016 
    self.from_date = from_date
5017 
    self.to_date = to_date
5018 
    self.warehouse_id = warehouse_id
94 ashish 5019 
 
5020 
  def read(self, iprot):
5021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5023 
      return
5024 
    iprot.readStructBegin()
5025 
    while True:
5026 
      (fname, ftype, fid) = iprot.readFieldBegin()
5027 
      if ftype == TType.STOP:
5028 
        break
5029 
      if fid == 1:
483 rajveer 5030 
        if ftype == TType.I32:
5031 
          self.status = iprot.readI32();
94 ashish 5032 
        else:
5033 
          iprot.skip(ftype)
483 rajveer 5034 
      elif fid == 2:
5035 
        if ftype == TType.I64:
5036 
          self.from_date = iprot.readI64();
94 ashish 5037 
        else:
5038 
          iprot.skip(ftype)
483 rajveer 5039 
      elif fid == 3:
5040 
        if ftype == TType.I64:
5041 
          self.to_date = iprot.readI64();
94 ashish 5042 
        else:
5043 
          iprot.skip(ftype)
483 rajveer 5044 
      elif fid == 4:
94 ashish 5045 
        if ftype == TType.I64:
483 rajveer 5046 
          self.warehouse_id = iprot.readI64();
94 ashish 5047 
        else:
5048 
          iprot.skip(ftype)
5049 
      else:
5050 
        iprot.skip(ftype)
5051 
      iprot.readFieldEnd()
5052 
    iprot.readStructEnd()
5053 
 
5054 
  def write(self, oprot):
5055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5057 
      return
483 rajveer 5058 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5059 
    if self.status is not None:
483 rajveer 5060 
      oprot.writeFieldBegin('status', TType.I32, 1)
5061 
      oprot.writeI32(self.status)
94 ashish 5062 
      oprot.writeFieldEnd()
3431 rajveer 5063 
    if self.from_date is not None:
483 rajveer 5064 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5065 
      oprot.writeI64(self.from_date)
94 ashish 5066 
      oprot.writeFieldEnd()
3431 rajveer 5067 
    if self.to_date is not None:
483 rajveer 5068 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5069 
      oprot.writeI64(self.to_date)
94 ashish 5070 
      oprot.writeFieldEnd()
3431 rajveer 5071 
    if self.warehouse_id is not None:
483 rajveer 5072 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5073 
      oprot.writeI64(self.warehouse_id)
94 ashish 5074 
      oprot.writeFieldEnd()
5075 
    oprot.writeFieldStop()
5076 
    oprot.writeStructEnd()
5077 
 
3431 rajveer 5078 
  def validate(self):
5079 
    return
5080 
 
5081 
 
94 ashish 5082 
  def __repr__(self):
5083 
    L = ['%s=%r' % (key, value)
5084 
      for key, value in self.__dict__.iteritems()]
5085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5086 
 
5087 
  def __eq__(self, other):
5088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5089 
 
5090 
  def __ne__(self, other):
5091 
    return not (self == other)
5092 
 
483 rajveer 5093 
class getAllOrders_result:
94 ashish 5094 
  """
5095 
  Attributes:
5096 
   - success
5097 
   - ex
5098 
  """
5099 
 
5100 
  thrift_spec = (
483 rajveer 5101 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5103 
  )
5104 
 
5105 
  def __init__(self, success=None, ex=None,):
5106 
    self.success = success
5107 
    self.ex = ex
5108 
 
5109 
  def read(self, iprot):
5110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5112 
      return
5113 
    iprot.readStructBegin()
5114 
    while True:
5115 
      (fname, ftype, fid) = iprot.readFieldBegin()
5116 
      if ftype == TType.STOP:
5117 
        break
5118 
      if fid == 0:
483 rajveer 5119 
        if ftype == TType.LIST:
5120 
          self.success = []
685 chandransh 5121 
          (_etype31, _size28) = iprot.readListBegin()
5122 
          for _i32 in xrange(_size28):
5123 
            _elem33 = Order()
5124 
            _elem33.read(iprot)
5125 
            self.success.append(_elem33)
483 rajveer 5126 
          iprot.readListEnd()
94 ashish 5127 
        else:
5128 
          iprot.skip(ftype)
5129 
      elif fid == 1:
5130 
        if ftype == TType.STRUCT:
5131 
          self.ex = TransactionServiceException()
5132 
          self.ex.read(iprot)
5133 
        else:
5134 
          iprot.skip(ftype)
5135 
      else:
5136 
        iprot.skip(ftype)
5137 
      iprot.readFieldEnd()
5138 
    iprot.readStructEnd()
5139 
 
5140 
  def write(self, oprot):
5141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5143 
      return
483 rajveer 5144 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5145 
    if self.success is not None:
483 rajveer 5146 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5147 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5148 
      for iter34 in self.success:
5149 
        iter34.write(oprot)
483 rajveer 5150 
      oprot.writeListEnd()
94 ashish 5151 
      oprot.writeFieldEnd()
3431 rajveer 5152 
    if self.ex is not None:
94 ashish 5153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5154 
      self.ex.write(oprot)
5155 
      oprot.writeFieldEnd()
5156 
    oprot.writeFieldStop()
5157 
    oprot.writeStructEnd()
5158 
 
3431 rajveer 5159 
  def validate(self):
5160 
    return
5161 
 
5162 
 
94 ashish 5163 
  def __repr__(self):
5164 
    L = ['%s=%r' % (key, value)
5165 
      for key, value in self.__dict__.iteritems()]
5166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5167 
 
5168 
  def __eq__(self, other):
5169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5170 
 
5171 
  def __ne__(self, other):
5172 
    return not (self == other)
5173 
 
4133 chandransh 5174 
class getOrdersInBatch_args:
5175 
  """
5176 
  Attributes:
5177 
   - statuses
5178 
   - offset
5179 
   - limit
5180 
   - warehouse_id
5181 
  """
5182 
 
5183 
  thrift_spec = (
5184 
    None, # 0
5185 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5186 
    (2, TType.I64, 'offset', None, None, ), # 2
5187 
    (3, TType.I64, 'limit', None, None, ), # 3
5188 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5189 
  )
5190 
 
5191 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5192 
    self.statuses = statuses
5193 
    self.offset = offset
5194 
    self.limit = limit
5195 
    self.warehouse_id = warehouse_id
5196 
 
5197 
  def read(self, iprot):
5198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5200 
      return
5201 
    iprot.readStructBegin()
5202 
    while True:
5203 
      (fname, ftype, fid) = iprot.readFieldBegin()
5204 
      if ftype == TType.STOP:
5205 
        break
5206 
      if fid == 1:
5207 
        if ftype == TType.LIST:
5208 
          self.statuses = []
5209 
          (_etype38, _size35) = iprot.readListBegin()
5210 
          for _i39 in xrange(_size35):
5211 
            _elem40 = iprot.readI32();
5212 
            self.statuses.append(_elem40)
5213 
          iprot.readListEnd()
5214 
        else:
5215 
          iprot.skip(ftype)
5216 
      elif fid == 2:
5217 
        if ftype == TType.I64:
5218 
          self.offset = iprot.readI64();
5219 
        else:
5220 
          iprot.skip(ftype)
5221 
      elif fid == 3:
5222 
        if ftype == TType.I64:
5223 
          self.limit = iprot.readI64();
5224 
        else:
5225 
          iprot.skip(ftype)
5226 
      elif fid == 4:
5227 
        if ftype == TType.I64:
5228 
          self.warehouse_id = iprot.readI64();
5229 
        else:
5230 
          iprot.skip(ftype)
5231 
      else:
5232 
        iprot.skip(ftype)
5233 
      iprot.readFieldEnd()
5234 
    iprot.readStructEnd()
5235 
 
5236 
  def write(self, oprot):
5237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5239 
      return
5240 
    oprot.writeStructBegin('getOrdersInBatch_args')
5241 
    if self.statuses is not None:
5242 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5243 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5244 
      for iter41 in self.statuses:
5245 
        oprot.writeI32(iter41)
5246 
      oprot.writeListEnd()
5247 
      oprot.writeFieldEnd()
5248 
    if self.offset is not None:
5249 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5250 
      oprot.writeI64(self.offset)
5251 
      oprot.writeFieldEnd()
5252 
    if self.limit is not None:
5253 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5254 
      oprot.writeI64(self.limit)
5255 
      oprot.writeFieldEnd()
5256 
    if self.warehouse_id is not None:
5257 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5258 
      oprot.writeI64(self.warehouse_id)
5259 
      oprot.writeFieldEnd()
5260 
    oprot.writeFieldStop()
5261 
    oprot.writeStructEnd()
5262 
 
5263 
  def validate(self):
5264 
    return
5265 
 
5266 
 
5267 
  def __repr__(self):
5268 
    L = ['%s=%r' % (key, value)
5269 
      for key, value in self.__dict__.iteritems()]
5270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5271 
 
5272 
  def __eq__(self, other):
5273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5274 
 
5275 
  def __ne__(self, other):
5276 
    return not (self == other)
5277 
 
5278 
class getOrdersInBatch_result:
5279 
  """
5280 
  Attributes:
5281 
   - success
5282 
   - ex
5283 
  """
5284 
 
5285 
  thrift_spec = (
5286 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5288 
  )
5289 
 
5290 
  def __init__(self, success=None, ex=None,):
5291 
    self.success = success
5292 
    self.ex = ex
5293 
 
5294 
  def read(self, iprot):
5295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5297 
      return
5298 
    iprot.readStructBegin()
5299 
    while True:
5300 
      (fname, ftype, fid) = iprot.readFieldBegin()
5301 
      if ftype == TType.STOP:
5302 
        break
5303 
      if fid == 0:
5304 
        if ftype == TType.LIST:
5305 
          self.success = []
5306 
          (_etype45, _size42) = iprot.readListBegin()
5307 
          for _i46 in xrange(_size42):
5308 
            _elem47 = Order()
5309 
            _elem47.read(iprot)
5310 
            self.success.append(_elem47)
5311 
          iprot.readListEnd()
5312 
        else:
5313 
          iprot.skip(ftype)
5314 
      elif fid == 1:
5315 
        if ftype == TType.STRUCT:
5316 
          self.ex = TransactionServiceException()
5317 
          self.ex.read(iprot)
5318 
        else:
5319 
          iprot.skip(ftype)
5320 
      else:
5321 
        iprot.skip(ftype)
5322 
      iprot.readFieldEnd()
5323 
    iprot.readStructEnd()
5324 
 
5325 
  def write(self, oprot):
5326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5328 
      return
5329 
    oprot.writeStructBegin('getOrdersInBatch_result')
5330 
    if self.success is not None:
5331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5333 
      for iter48 in self.success:
5334 
        iter48.write(oprot)
5335 
      oprot.writeListEnd()
5336 
      oprot.writeFieldEnd()
5337 
    if self.ex is not None:
5338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5339 
      self.ex.write(oprot)
5340 
      oprot.writeFieldEnd()
5341 
    oprot.writeFieldStop()
5342 
    oprot.writeStructEnd()
5343 
 
5344 
  def validate(self):
5345 
    return
5346 
 
5347 
 
5348 
  def __repr__(self):
5349 
    L = ['%s=%r' % (key, value)
5350 
      for key, value in self.__dict__.iteritems()]
5351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5352 
 
5353 
  def __eq__(self, other):
5354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5355 
 
5356 
  def __ne__(self, other):
5357 
    return not (self == other)
5358 
 
5359 
class getOrderCount_args:
5360 
  """
5361 
  Attributes:
5362 
   - statuses
5363 
   - warehouseId
5364 
  """
5365 
 
5366 
  thrift_spec = (
5367 
    None, # 0
5368 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5369 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5370 
  )
5371 
 
5372 
  def __init__(self, statuses=None, warehouseId=None,):
5373 
    self.statuses = statuses
5374 
    self.warehouseId = warehouseId
5375 
 
5376 
  def read(self, iprot):
5377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5379 
      return
5380 
    iprot.readStructBegin()
5381 
    while True:
5382 
      (fname, ftype, fid) = iprot.readFieldBegin()
5383 
      if ftype == TType.STOP:
5384 
        break
5385 
      if fid == 1:
5386 
        if ftype == TType.LIST:
5387 
          self.statuses = []
5388 
          (_etype52, _size49) = iprot.readListBegin()
5389 
          for _i53 in xrange(_size49):
5390 
            _elem54 = iprot.readI32();
5391 
            self.statuses.append(_elem54)
5392 
          iprot.readListEnd()
5393 
        else:
5394 
          iprot.skip(ftype)
5395 
      elif fid == 2:
5396 
        if ftype == TType.I64:
5397 
          self.warehouseId = iprot.readI64();
5398 
        else:
5399 
          iprot.skip(ftype)
5400 
      else:
5401 
        iprot.skip(ftype)
5402 
      iprot.readFieldEnd()
5403 
    iprot.readStructEnd()
5404 
 
5405 
  def write(self, oprot):
5406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5408 
      return
5409 
    oprot.writeStructBegin('getOrderCount_args')
5410 
    if self.statuses is not None:
5411 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5412 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5413 
      for iter55 in self.statuses:
5414 
        oprot.writeI32(iter55)
5415 
      oprot.writeListEnd()
5416 
      oprot.writeFieldEnd()
5417 
    if self.warehouseId is not None:
5418 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5419 
      oprot.writeI64(self.warehouseId)
5420 
      oprot.writeFieldEnd()
5421 
    oprot.writeFieldStop()
5422 
    oprot.writeStructEnd()
5423 
 
5424 
  def validate(self):
5425 
    return
5426 
 
5427 
 
5428 
  def __repr__(self):
5429 
    L = ['%s=%r' % (key, value)
5430 
      for key, value in self.__dict__.iteritems()]
5431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5432 
 
5433 
  def __eq__(self, other):
5434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5435 
 
5436 
  def __ne__(self, other):
5437 
    return not (self == other)
5438 
 
5439 
class getOrderCount_result:
5440 
  """
5441 
  Attributes:
5442 
   - success
5443 
   - ex
5444 
  """
5445 
 
5446 
  thrift_spec = (
5447 
    (0, TType.I32, 'success', None, None, ), # 0
5448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5449 
  )
5450 
 
5451 
  def __init__(self, success=None, ex=None,):
5452 
    self.success = success
5453 
    self.ex = ex
5454 
 
5455 
  def read(self, iprot):
5456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5458 
      return
5459 
    iprot.readStructBegin()
5460 
    while True:
5461 
      (fname, ftype, fid) = iprot.readFieldBegin()
5462 
      if ftype == TType.STOP:
5463 
        break
5464 
      if fid == 0:
5465 
        if ftype == TType.I32:
5466 
          self.success = iprot.readI32();
5467 
        else:
5468 
          iprot.skip(ftype)
5469 
      elif fid == 1:
5470 
        if ftype == TType.STRUCT:
5471 
          self.ex = TransactionServiceException()
5472 
          self.ex.read(iprot)
5473 
        else:
5474 
          iprot.skip(ftype)
5475 
      else:
5476 
        iprot.skip(ftype)
5477 
      iprot.readFieldEnd()
5478 
    iprot.readStructEnd()
5479 
 
5480 
  def write(self, oprot):
5481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5483 
      return
5484 
    oprot.writeStructBegin('getOrderCount_result')
5485 
    if self.success is not None:
5486 
      oprot.writeFieldBegin('success', TType.I32, 0)
5487 
      oprot.writeI32(self.success)
5488 
      oprot.writeFieldEnd()
5489 
    if self.ex is not None:
5490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5491 
      self.ex.write(oprot)
5492 
      oprot.writeFieldEnd()
5493 
    oprot.writeFieldStop()
5494 
    oprot.writeStructEnd()
5495 
 
5496 
  def validate(self):
5497 
    return
5498 
 
5499 
 
5500 
  def __repr__(self):
5501 
    L = ['%s=%r' % (key, value)
5502 
      for key, value in self.__dict__.iteritems()]
5503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5504 
 
5505 
  def __eq__(self, other):
5506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5507 
 
5508 
  def __ne__(self, other):
5509 
    return not (self == other)
5510 
 
999 varun.gupt 5511 
class getOrdersByBillingDate_args:
5512 
  """
5513 
  Attributes:
5514 
   - status
5515 
   - start_billing_date
5516 
   - end_billing_date
5517 
   - warehouse_id
5518 
  """
5519 
 
5520 
  thrift_spec = (
5521 
    None, # 0
5522 
    (1, TType.I32, 'status', None, None, ), # 1
5523 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5524 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5525 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5526 
  )
5527 
 
5528 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5529 
    self.status = status
5530 
    self.start_billing_date = start_billing_date
5531 
    self.end_billing_date = end_billing_date
5532 
    self.warehouse_id = warehouse_id
5533 
 
5534 
  def read(self, iprot):
5535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5537 
      return
5538 
    iprot.readStructBegin()
5539 
    while True:
5540 
      (fname, ftype, fid) = iprot.readFieldBegin()
5541 
      if ftype == TType.STOP:
5542 
        break
5543 
      if fid == 1:
5544 
        if ftype == TType.I32:
5545 
          self.status = iprot.readI32();
5546 
        else:
5547 
          iprot.skip(ftype)
5548 
      elif fid == 2:
5549 
        if ftype == TType.I64:
5550 
          self.start_billing_date = iprot.readI64();
5551 
        else:
5552 
          iprot.skip(ftype)
5553 
      elif fid == 3:
5554 
        if ftype == TType.I64:
5555 
          self.end_billing_date = iprot.readI64();
5556 
        else:
5557 
          iprot.skip(ftype)
5558 
      elif fid == 4:
5559 
        if ftype == TType.I64:
5560 
          self.warehouse_id = iprot.readI64();
5561 
        else:
5562 
          iprot.skip(ftype)
5563 
      else:
5564 
        iprot.skip(ftype)
5565 
      iprot.readFieldEnd()
5566 
    iprot.readStructEnd()
5567 
 
5568 
  def write(self, oprot):
5569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5571 
      return
5572 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5573 
    if self.status is not None:
999 varun.gupt 5574 
      oprot.writeFieldBegin('status', TType.I32, 1)
5575 
      oprot.writeI32(self.status)
5576 
      oprot.writeFieldEnd()
3431 rajveer 5577 
    if self.start_billing_date is not None:
999 varun.gupt 5578 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5579 
      oprot.writeI64(self.start_billing_date)
5580 
      oprot.writeFieldEnd()
3431 rajveer 5581 
    if self.end_billing_date is not None:
999 varun.gupt 5582 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5583 
      oprot.writeI64(self.end_billing_date)
5584 
      oprot.writeFieldEnd()
3431 rajveer 5585 
    if self.warehouse_id is not None:
999 varun.gupt 5586 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5587 
      oprot.writeI64(self.warehouse_id)
5588 
      oprot.writeFieldEnd()
5589 
    oprot.writeFieldStop()
5590 
    oprot.writeStructEnd()
5591 
 
3431 rajveer 5592 
  def validate(self):
5593 
    return
5594 
 
5595 
 
999 varun.gupt 5596 
  def __repr__(self):
5597 
    L = ['%s=%r' % (key, value)
5598 
      for key, value in self.__dict__.iteritems()]
5599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5600 
 
5601 
  def __eq__(self, other):
5602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5603 
 
5604 
  def __ne__(self, other):
5605 
    return not (self == other)
5606 
 
5607 
class getOrdersByBillingDate_result:
5608 
  """
5609 
  Attributes:
5610 
   - success
5611 
   - ex
5612 
  """
5613 
 
5614 
  thrift_spec = (
5615 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5617 
  )
5618 
 
5619 
  def __init__(self, success=None, ex=None,):
5620 
    self.success = success
5621 
    self.ex = ex
5622 
 
5623 
  def read(self, iprot):
5624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5626 
      return
5627 
    iprot.readStructBegin()
5628 
    while True:
5629 
      (fname, ftype, fid) = iprot.readFieldBegin()
5630 
      if ftype == TType.STOP:
5631 
        break
5632 
      if fid == 0:
5633 
        if ftype == TType.LIST:
5634 
          self.success = []
4133 chandransh 5635 
          (_etype59, _size56) = iprot.readListBegin()
5636 
          for _i60 in xrange(_size56):
5637 
            _elem61 = Order()
5638 
            _elem61.read(iprot)
5639 
            self.success.append(_elem61)
999 varun.gupt 5640 
          iprot.readListEnd()
5641 
        else:
5642 
          iprot.skip(ftype)
5643 
      elif fid == 1:
5644 
        if ftype == TType.STRUCT:
5645 
          self.ex = TransactionServiceException()
5646 
          self.ex.read(iprot)
5647 
        else:
5648 
          iprot.skip(ftype)
5649 
      else:
5650 
        iprot.skip(ftype)
5651 
      iprot.readFieldEnd()
5652 
    iprot.readStructEnd()
5653 
 
5654 
  def write(self, oprot):
5655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5657 
      return
5658 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5659 
    if self.success is not None:
999 varun.gupt 5660 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5661 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5662 
      for iter62 in self.success:
5663 
        iter62.write(oprot)
999 varun.gupt 5664 
      oprot.writeListEnd()
5665 
      oprot.writeFieldEnd()
3431 rajveer 5666 
    if self.ex is not None:
999 varun.gupt 5667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5668 
      self.ex.write(oprot)
5669 
      oprot.writeFieldEnd()
5670 
    oprot.writeFieldStop()
5671 
    oprot.writeStructEnd()
5672 
 
3431 rajveer 5673 
  def validate(self):
5674 
    return
5675 
 
5676 
 
999 varun.gupt 5677 
  def __repr__(self):
5678 
    L = ['%s=%r' % (key, value)
5679 
      for key, value in self.__dict__.iteritems()]
5680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5681 
 
5682 
  def __eq__(self, other):
5683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5684 
 
5685 
  def __ne__(self, other):
5686 
    return not (self == other)
5687 
 
3427 chandransh 5688 
class getOrdersByShippingDate_args:
5689 
  """
5690 
  Attributes:
5691 
   - fromShippingDate
5692 
   - toShippingDate
5693 
   - providerId
5694 
   - warehouseId
3451 chandransh 5695 
   - cod
3427 chandransh 5696 
  """
5697 
 
5698 
  thrift_spec = (
5699 
    None, # 0
5700 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5701 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5702 
    (3, TType.I64, 'providerId', None, None, ), # 3
5703 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5704 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5705 
  )
5706 
 
3451 chandransh 5707 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5708 
    self.fromShippingDate = fromShippingDate
5709 
    self.toShippingDate = toShippingDate
5710 
    self.providerId = providerId
5711 
    self.warehouseId = warehouseId
3451 chandransh 5712 
    self.cod = cod
3427 chandransh 5713 
 
5714 
  def read(self, iprot):
5715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5717 
      return
5718 
    iprot.readStructBegin()
5719 
    while True:
5720 
      (fname, ftype, fid) = iprot.readFieldBegin()
5721 
      if ftype == TType.STOP:
5722 
        break
5723 
      if fid == 1:
5724 
        if ftype == TType.I64:
5725 
          self.fromShippingDate = iprot.readI64();
5726 
        else:
5727 
          iprot.skip(ftype)
5728 
      elif fid == 2:
5729 
        if ftype == TType.I64:
5730 
          self.toShippingDate = iprot.readI64();
5731 
        else:
5732 
          iprot.skip(ftype)
5733 
      elif fid == 3:
5734 
        if ftype == TType.I64:
5735 
          self.providerId = iprot.readI64();
5736 
        else:
5737 
          iprot.skip(ftype)
5738 
      elif fid == 4:
5739 
        if ftype == TType.I64:
5740 
          self.warehouseId = iprot.readI64();
5741 
        else:
5742 
          iprot.skip(ftype)
3451 chandransh 5743 
      elif fid == 5:
5744 
        if ftype == TType.BOOL:
5745 
          self.cod = iprot.readBool();
5746 
        else:
5747 
          iprot.skip(ftype)
3427 chandransh 5748 
      else:
5749 
        iprot.skip(ftype)
5750 
      iprot.readFieldEnd()
5751 
    iprot.readStructEnd()
5752 
 
5753 
  def write(self, oprot):
5754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5756 
      return
5757 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5758 
    if self.fromShippingDate is not None:
3427 chandransh 5759 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5760 
      oprot.writeI64(self.fromShippingDate)
5761 
      oprot.writeFieldEnd()
3431 rajveer 5762 
    if self.toShippingDate is not None:
3427 chandransh 5763 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5764 
      oprot.writeI64(self.toShippingDate)
5765 
      oprot.writeFieldEnd()
3431 rajveer 5766 
    if self.providerId is not None:
3427 chandransh 5767 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5768 
      oprot.writeI64(self.providerId)
5769 
      oprot.writeFieldEnd()
3431 rajveer 5770 
    if self.warehouseId is not None:
3427 chandransh 5771 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5772 
      oprot.writeI64(self.warehouseId)
5773 
      oprot.writeFieldEnd()
3451 chandransh 5774 
    if self.cod is not None:
5775 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5776 
      oprot.writeBool(self.cod)
5777 
      oprot.writeFieldEnd()
3427 chandransh 5778 
    oprot.writeFieldStop()
5779 
    oprot.writeStructEnd()
5780 
 
3431 rajveer 5781 
  def validate(self):
5782 
    return
5783 
 
5784 
 
3427 chandransh 5785 
  def __repr__(self):
5786 
    L = ['%s=%r' % (key, value)
5787 
      for key, value in self.__dict__.iteritems()]
5788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5789 
 
5790 
  def __eq__(self, other):
5791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5792 
 
5793 
  def __ne__(self, other):
5794 
    return not (self == other)
5795 
 
5796 
class getOrdersByShippingDate_result:
5797 
  """
5798 
  Attributes:
5799 
   - success
5800 
   - ex
5801 
  """
5802 
 
5803 
  thrift_spec = (
5804 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5806 
  )
5807 
 
5808 
  def __init__(self, success=None, ex=None,):
5809 
    self.success = success
5810 
    self.ex = ex
5811 
 
5812 
  def read(self, iprot):
5813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5815 
      return
5816 
    iprot.readStructBegin()
5817 
    while True:
5818 
      (fname, ftype, fid) = iprot.readFieldBegin()
5819 
      if ftype == TType.STOP:
5820 
        break
5821 
      if fid == 0:
5822 
        if ftype == TType.LIST:
5823 
          self.success = []
4133 chandransh 5824 
          (_etype66, _size63) = iprot.readListBegin()
5825 
          for _i67 in xrange(_size63):
5826 
            _elem68 = Order()
5827 
            _elem68.read(iprot)
5828 
            self.success.append(_elem68)
3427 chandransh 5829 
          iprot.readListEnd()
5830 
        else:
5831 
          iprot.skip(ftype)
5832 
      elif fid == 1:
5833 
        if ftype == TType.STRUCT:
5834 
          self.ex = TransactionServiceException()
5835 
          self.ex.read(iprot)
5836 
        else:
5837 
          iprot.skip(ftype)
5838 
      else:
5839 
        iprot.skip(ftype)
5840 
      iprot.readFieldEnd()
5841 
    iprot.readStructEnd()
5842 
 
5843 
  def write(self, oprot):
5844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5846 
      return
5847 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5848 
    if self.success is not None:
3427 chandransh 5849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5850 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5851 
      for iter69 in self.success:
5852 
        iter69.write(oprot)
3427 chandransh 5853 
      oprot.writeListEnd()
5854 
      oprot.writeFieldEnd()
3431 rajveer 5855 
    if self.ex is not None:
3427 chandransh 5856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5857 
      self.ex.write(oprot)
5858 
      oprot.writeFieldEnd()
5859 
    oprot.writeFieldStop()
5860 
    oprot.writeStructEnd()
5861 
 
3431 rajveer 5862 
  def validate(self):
5863 
    return
5864 
 
5865 
 
3427 chandransh 5866 
  def __repr__(self):
5867 
    L = ['%s=%r' % (key, value)
5868 
      for key, value in self.__dict__.iteritems()]
5869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5870 
 
5871 
  def __eq__(self, other):
5872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5873 
 
5874 
  def __ne__(self, other):
5875 
    return not (self == other)
5876 
 
1382 varun.gupt 5877 
class getReturnableOrdersForCustomer_args:
5878 
  """
5879 
  Attributes:
5880 
   - customer_id
5881 
   - limit
5882 
  """
5883 
 
5884 
  thrift_spec = (
5885 
    None, # 0
5886 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5887 
    (2, TType.I64, 'limit', None, None, ), # 2
5888 
  )
5889 
 
5890 
  def __init__(self, customer_id=None, limit=None,):
5891 
    self.customer_id = customer_id
5892 
    self.limit = limit
5893 
 
5894 
  def read(self, iprot):
5895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5897 
      return
5898 
    iprot.readStructBegin()
5899 
    while True:
5900 
      (fname, ftype, fid) = iprot.readFieldBegin()
5901 
      if ftype == TType.STOP:
5902 
        break
5903 
      if fid == 1:
5904 
        if ftype == TType.I64:
5905 
          self.customer_id = iprot.readI64();
5906 
        else:
5907 
          iprot.skip(ftype)
5908 
      elif fid == 2:
5909 
        if ftype == TType.I64:
5910 
          self.limit = iprot.readI64();
5911 
        else:
5912 
          iprot.skip(ftype)
5913 
      else:
5914 
        iprot.skip(ftype)
5915 
      iprot.readFieldEnd()
5916 
    iprot.readStructEnd()
5917 
 
5918 
  def write(self, oprot):
5919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5921 
      return
5922 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5923 
    if self.customer_id is not None:
1382 varun.gupt 5924 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5925 
      oprot.writeI64(self.customer_id)
5926 
      oprot.writeFieldEnd()
3431 rajveer 5927 
    if self.limit is not None:
1382 varun.gupt 5928 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5929 
      oprot.writeI64(self.limit)
5930 
      oprot.writeFieldEnd()
5931 
    oprot.writeFieldStop()
5932 
    oprot.writeStructEnd()
5933 
 
3431 rajveer 5934 
  def validate(self):
5935 
    return
5936 
 
5937 
 
1382 varun.gupt 5938 
  def __repr__(self):
5939 
    L = ['%s=%r' % (key, value)
5940 
      for key, value in self.__dict__.iteritems()]
5941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5942 
 
5943 
  def __eq__(self, other):
5944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5945 
 
5946 
  def __ne__(self, other):
5947 
    return not (self == other)
5948 
 
5949 
class getReturnableOrdersForCustomer_result:
5950 
  """
5951 
  Attributes:
5952 
   - success
5953 
   - ex
5954 
  """
5955 
 
5956 
  thrift_spec = (
5957 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5959 
  )
5960 
 
5961 
  def __init__(self, success=None, ex=None,):
5962 
    self.success = success
5963 
    self.ex = ex
5964 
 
5965 
  def read(self, iprot):
5966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5968 
      return
5969 
    iprot.readStructBegin()
5970 
    while True:
5971 
      (fname, ftype, fid) = iprot.readFieldBegin()
5972 
      if ftype == TType.STOP:
5973 
        break
5974 
      if fid == 0:
5975 
        if ftype == TType.LIST:
5976 
          self.success = []
4133 chandransh 5977 
          (_etype73, _size70) = iprot.readListBegin()
5978 
          for _i74 in xrange(_size70):
5979 
            _elem75 = iprot.readI64();
5980 
            self.success.append(_elem75)
1382 varun.gupt 5981 
          iprot.readListEnd()
5982 
        else:
5983 
          iprot.skip(ftype)
5984 
      elif fid == 1:
5985 
        if ftype == TType.STRUCT:
5986 
          self.ex = TransactionServiceException()
5987 
          self.ex.read(iprot)
5988 
        else:
5989 
          iprot.skip(ftype)
5990 
      else:
5991 
        iprot.skip(ftype)
5992 
      iprot.readFieldEnd()
5993 
    iprot.readStructEnd()
5994 
 
5995 
  def write(self, oprot):
5996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5998 
      return
5999 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6000 
    if self.success is not None:
1382 varun.gupt 6001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6002 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6003 
      for iter76 in self.success:
6004 
        oprot.writeI64(iter76)
1382 varun.gupt 6005 
      oprot.writeListEnd()
6006 
      oprot.writeFieldEnd()
3431 rajveer 6007 
    if self.ex is not None:
1382 varun.gupt 6008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6009 
      self.ex.write(oprot)
6010 
      oprot.writeFieldEnd()
6011 
    oprot.writeFieldStop()
6012 
    oprot.writeStructEnd()
6013 
 
3431 rajveer 6014 
  def validate(self):
6015 
    return
6016 
 
6017 
 
1382 varun.gupt 6018 
  def __repr__(self):
6019 
    L = ['%s=%r' % (key, value)
6020 
      for key, value in self.__dict__.iteritems()]
6021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6022 
 
6023 
  def __eq__(self, other):
6024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6025 
 
6026 
  def __ne__(self, other):
6027 
    return not (self == other)
6028 
 
6029 
class getCancellableOrdersForCustomer_args:
6030 
  """
6031 
  Attributes:
6032 
   - customer_id
6033 
   - limit
6034 
  """
6035 
 
6036 
  thrift_spec = (
6037 
    None, # 0
6038 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6039 
    (2, TType.I64, 'limit', None, None, ), # 2
6040 
  )
6041 
 
6042 
  def __init__(self, customer_id=None, limit=None,):
6043 
    self.customer_id = customer_id
6044 
    self.limit = limit
6045 
 
6046 
  def read(self, iprot):
6047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6049 
      return
6050 
    iprot.readStructBegin()
6051 
    while True:
6052 
      (fname, ftype, fid) = iprot.readFieldBegin()
6053 
      if ftype == TType.STOP:
6054 
        break
6055 
      if fid == 1:
6056 
        if ftype == TType.I64:
6057 
          self.customer_id = iprot.readI64();
6058 
        else:
6059 
          iprot.skip(ftype)
6060 
      elif fid == 2:
6061 
        if ftype == TType.I64:
6062 
          self.limit = iprot.readI64();
6063 
        else:
6064 
          iprot.skip(ftype)
6065 
      else:
6066 
        iprot.skip(ftype)
6067 
      iprot.readFieldEnd()
6068 
    iprot.readStructEnd()
6069 
 
6070 
  def write(self, oprot):
6071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6073 
      return
6074 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6075 
    if self.customer_id is not None:
1382 varun.gupt 6076 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6077 
      oprot.writeI64(self.customer_id)
6078 
      oprot.writeFieldEnd()
3431 rajveer 6079 
    if self.limit is not None:
1382 varun.gupt 6080 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6081 
      oprot.writeI64(self.limit)
6082 
      oprot.writeFieldEnd()
6083 
    oprot.writeFieldStop()
6084 
    oprot.writeStructEnd()
6085 
 
3431 rajveer 6086 
  def validate(self):
6087 
    return
6088 
 
6089 
 
1382 varun.gupt 6090 
  def __repr__(self):
6091 
    L = ['%s=%r' % (key, value)
6092 
      for key, value in self.__dict__.iteritems()]
6093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6094 
 
6095 
  def __eq__(self, other):
6096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6097 
 
6098 
  def __ne__(self, other):
6099 
    return not (self == other)
6100 
 
6101 
class getCancellableOrdersForCustomer_result:
6102 
  """
6103 
  Attributes:
6104 
   - success
6105 
   - ex
6106 
  """
6107 
 
6108 
  thrift_spec = (
6109 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6111 
  )
6112 
 
6113 
  def __init__(self, success=None, ex=None,):
6114 
    self.success = success
6115 
    self.ex = ex
6116 
 
6117 
  def read(self, iprot):
6118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6120 
      return
6121 
    iprot.readStructBegin()
6122 
    while True:
6123 
      (fname, ftype, fid) = iprot.readFieldBegin()
6124 
      if ftype == TType.STOP:
6125 
        break
6126 
      if fid == 0:
6127 
        if ftype == TType.LIST:
6128 
          self.success = []
4133 chandransh 6129 
          (_etype80, _size77) = iprot.readListBegin()
6130 
          for _i81 in xrange(_size77):
6131 
            _elem82 = iprot.readI64();
6132 
            self.success.append(_elem82)
1382 varun.gupt 6133 
          iprot.readListEnd()
6134 
        else:
6135 
          iprot.skip(ftype)
6136 
      elif fid == 1:
6137 
        if ftype == TType.STRUCT:
6138 
          self.ex = TransactionServiceException()
6139 
          self.ex.read(iprot)
6140 
        else:
6141 
          iprot.skip(ftype)
6142 
      else:
6143 
        iprot.skip(ftype)
6144 
      iprot.readFieldEnd()
6145 
    iprot.readStructEnd()
6146 
 
6147 
  def write(self, oprot):
6148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6150 
      return
6151 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6152 
    if self.success is not None:
1382 varun.gupt 6153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6154 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6155 
      for iter83 in self.success:
6156 
        oprot.writeI64(iter83)
1382 varun.gupt 6157 
      oprot.writeListEnd()
6158 
      oprot.writeFieldEnd()
3431 rajveer 6159 
    if self.ex is not None:
1382 varun.gupt 6160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6161 
      self.ex.write(oprot)
6162 
      oprot.writeFieldEnd()
6163 
    oprot.writeFieldStop()
6164 
    oprot.writeStructEnd()
6165 
 
3431 rajveer 6166 
  def validate(self):
6167 
    return
6168 
 
6169 
 
1382 varun.gupt 6170 
  def __repr__(self):
6171 
    L = ['%s=%r' % (key, value)
6172 
      for key, value in self.__dict__.iteritems()]
6173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6174 
 
6175 
  def __eq__(self, other):
6176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6177 
 
6178 
  def __ne__(self, other):
6179 
    return not (self == other)
6180 
 
483 rajveer 6181 
class changeOrderStatus_args:
94 ashish 6182 
  """
6183 
  Attributes:
483 rajveer 6184 
   - orderId
6185 
   - status
6186 
   - description
94 ashish 6187 
  """
6188 
 
6189 
  thrift_spec = (
6190 
    None, # 0
483 rajveer 6191 
    (1, TType.I64, 'orderId', None, None, ), # 1
6192 
    (2, TType.I32, 'status', None, None, ), # 2
6193 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6194 
  )
6195 
 
483 rajveer 6196 
  def __init__(self, orderId=None, status=None, description=None,):
6197 
    self.orderId = orderId
6198 
    self.status = status
6199 
    self.description = description
94 ashish 6200 
 
6201 
  def read(self, iprot):
6202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6204 
      return
6205 
    iprot.readStructBegin()
6206 
    while True:
6207 
      (fname, ftype, fid) = iprot.readFieldBegin()
6208 
      if ftype == TType.STOP:
6209 
        break
6210 
      if fid == 1:
6211 
        if ftype == TType.I64:
483 rajveer 6212 
          self.orderId = iprot.readI64();
94 ashish 6213 
        else:
6214 
          iprot.skip(ftype)
6215 
      elif fid == 2:
483 rajveer 6216 
        if ftype == TType.I32:
6217 
          self.status = iprot.readI32();
94 ashish 6218 
        else:
6219 
          iprot.skip(ftype)
483 rajveer 6220 
      elif fid == 3:
6221 
        if ftype == TType.STRING:
6222 
          self.description = iprot.readString();
6223 
        else:
6224 
          iprot.skip(ftype)
94 ashish 6225 
      else:
6226 
        iprot.skip(ftype)
6227 
      iprot.readFieldEnd()
6228 
    iprot.readStructEnd()
6229 
 
6230 
  def write(self, oprot):
6231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6233 
      return
483 rajveer 6234 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6235 
    if self.orderId is not None:
483 rajveer 6236 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6237 
      oprot.writeI64(self.orderId)
94 ashish 6238 
      oprot.writeFieldEnd()
3431 rajveer 6239 
    if self.status is not None:
483 rajveer 6240 
      oprot.writeFieldBegin('status', TType.I32, 2)
6241 
      oprot.writeI32(self.status)
94 ashish 6242 
      oprot.writeFieldEnd()
3431 rajveer 6243 
    if self.description is not None:
483 rajveer 6244 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6245 
      oprot.writeString(self.description)
6246 
      oprot.writeFieldEnd()
94 ashish 6247 
    oprot.writeFieldStop()
6248 
    oprot.writeStructEnd()
6249 
 
3431 rajveer 6250 
  def validate(self):
6251 
    return
6252 
 
6253 
 
94 ashish 6254 
  def __repr__(self):
6255 
    L = ['%s=%r' % (key, value)
6256 
      for key, value in self.__dict__.iteritems()]
6257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6258 
 
6259 
  def __eq__(self, other):
6260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6261 
 
6262 
  def __ne__(self, other):
6263 
    return not (self == other)
6264 
 
483 rajveer 6265 
class changeOrderStatus_result:
94 ashish 6266 
  """
6267 
  Attributes:
6268 
   - success
6269 
   - ex
6270 
  """
6271 
 
6272 
  thrift_spec = (
6273 
    (0, TType.BOOL, 'success', None, None, ), # 0
6274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6275 
  )
6276 
 
6277 
  def __init__(self, success=None, ex=None,):
6278 
    self.success = success
6279 
    self.ex = ex
6280 
 
6281 
  def read(self, iprot):
6282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6284 
      return
6285 
    iprot.readStructBegin()
6286 
    while True:
6287 
      (fname, ftype, fid) = iprot.readFieldBegin()
6288 
      if ftype == TType.STOP:
6289 
        break
6290 
      if fid == 0:
6291 
        if ftype == TType.BOOL:
6292 
          self.success = iprot.readBool();
6293 
        else:
6294 
          iprot.skip(ftype)
6295 
      elif fid == 1:
6296 
        if ftype == TType.STRUCT:
6297 
          self.ex = TransactionServiceException()
6298 
          self.ex.read(iprot)
6299 
        else:
6300 
          iprot.skip(ftype)
6301 
      else:
6302 
        iprot.skip(ftype)
6303 
      iprot.readFieldEnd()
6304 
    iprot.readStructEnd()
6305 
 
6306 
  def write(self, oprot):
6307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6309 
      return
483 rajveer 6310 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6311 
    if self.success is not None:
94 ashish 6312 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6313 
      oprot.writeBool(self.success)
6314 
      oprot.writeFieldEnd()
3431 rajveer 6315 
    if self.ex is not None:
94 ashish 6316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6317 
      self.ex.write(oprot)
6318 
      oprot.writeFieldEnd()
6319 
    oprot.writeFieldStop()
6320 
    oprot.writeStructEnd()
6321 
 
3431 rajveer 6322 
  def validate(self):
6323 
    return
6324 
 
6325 
 
94 ashish 6326 
  def __repr__(self):
6327 
    L = ['%s=%r' % (key, value)
6328 
      for key, value in self.__dict__.iteritems()]
6329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6330 
 
6331 
  def __eq__(self, other):
6332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6333 
 
6334 
  def __ne__(self, other):
6335 
    return not (self == other)
6336 
 
3064 chandransh 6337 
class getOrdersForTransaction_args:
494 rajveer 6338 
  """
6339 
  Attributes:
3064 chandransh 6340 
   - transactionId
6341 
   - customerId
494 rajveer 6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    None, # 0
3064 chandransh 6346 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6347 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6348 
  )
6349 
 
3064 chandransh 6350 
  def __init__(self, transactionId=None, customerId=None,):
6351 
    self.transactionId = transactionId
6352 
    self.customerId = customerId
494 rajveer 6353 
 
6354 
  def read(self, iprot):
6355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6357 
      return
6358 
    iprot.readStructBegin()
6359 
    while True:
6360 
      (fname, ftype, fid) = iprot.readFieldBegin()
6361 
      if ftype == TType.STOP:
6362 
        break
6363 
      if fid == 1:
6364 
        if ftype == TType.I64:
3064 chandransh 6365 
          self.transactionId = iprot.readI64();
494 rajveer 6366 
        else:
6367 
          iprot.skip(ftype)
6368 
      elif fid == 2:
3064 chandransh 6369 
        if ftype == TType.I64:
6370 
          self.customerId = iprot.readI64();
494 rajveer 6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      else:
6374 
        iprot.skip(ftype)
6375 
      iprot.readFieldEnd()
6376 
    iprot.readStructEnd()
6377 
 
6378 
  def write(self, oprot):
6379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6381 
      return
3064 chandransh 6382 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6383 
    if self.transactionId is not None:
3064 chandransh 6384 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6385 
      oprot.writeI64(self.transactionId)
494 rajveer 6386 
      oprot.writeFieldEnd()
3431 rajveer 6387 
    if self.customerId is not None:
3064 chandransh 6388 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6389 
      oprot.writeI64(self.customerId)
494 rajveer 6390 
      oprot.writeFieldEnd()
6391 
    oprot.writeFieldStop()
6392 
    oprot.writeStructEnd()
6393 
 
3431 rajveer 6394 
  def validate(self):
6395 
    return
6396 
 
6397 
 
494 rajveer 6398 
  def __repr__(self):
6399 
    L = ['%s=%r' % (key, value)
6400 
      for key, value in self.__dict__.iteritems()]
6401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6402 
 
6403 
  def __eq__(self, other):
6404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6405 
 
6406 
  def __ne__(self, other):
6407 
    return not (self == other)
6408 
 
3064 chandransh 6409 
class getOrdersForTransaction_result:
494 rajveer 6410 
  """
6411 
  Attributes:
6412 
   - success
6413 
   - ex
6414 
  """
6415 
 
6416 
  thrift_spec = (
3064 chandransh 6417 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6419 
  )
6420 
 
6421 
  def __init__(self, success=None, ex=None,):
6422 
    self.success = success
6423 
    self.ex = ex
6424 
 
6425 
  def read(self, iprot):
6426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6428 
      return
6429 
    iprot.readStructBegin()
6430 
    while True:
6431 
      (fname, ftype, fid) = iprot.readFieldBegin()
6432 
      if ftype == TType.STOP:
6433 
        break
6434 
      if fid == 0:
3064 chandransh 6435 
        if ftype == TType.LIST:
6436 
          self.success = []
4133 chandransh 6437 
          (_etype87, _size84) = iprot.readListBegin()
6438 
          for _i88 in xrange(_size84):
6439 
            _elem89 = Order()
6440 
            _elem89.read(iprot)
6441 
            self.success.append(_elem89)
3064 chandransh 6442 
          iprot.readListEnd()
494 rajveer 6443 
        else:
6444 
          iprot.skip(ftype)
6445 
      elif fid == 1:
6446 
        if ftype == TType.STRUCT:
6447 
          self.ex = TransactionServiceException()
6448 
          self.ex.read(iprot)
6449 
        else:
6450 
          iprot.skip(ftype)
6451 
      else:
6452 
        iprot.skip(ftype)
6453 
      iprot.readFieldEnd()
6454 
    iprot.readStructEnd()
6455 
 
6456 
  def write(self, oprot):
6457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6459 
      return
3064 chandransh 6460 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6461 
    if self.success is not None:
3064 chandransh 6462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6464 
      for iter90 in self.success:
6465 
        iter90.write(oprot)
3064 chandransh 6466 
      oprot.writeListEnd()
494 rajveer 6467 
      oprot.writeFieldEnd()
3431 rajveer 6468 
    if self.ex is not None:
494 rajveer 6469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6470 
      self.ex.write(oprot)
6471 
      oprot.writeFieldEnd()
6472 
    oprot.writeFieldStop()
6473 
    oprot.writeStructEnd()
6474 
 
3431 rajveer 6475 
  def validate(self):
6476 
    return
6477 
 
6478 
 
494 rajveer 6479 
  def __repr__(self):
6480 
    L = ['%s=%r' % (key, value)
6481 
      for key, value in self.__dict__.iteritems()]
6482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6483 
 
6484 
  def __eq__(self, other):
6485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6486 
 
6487 
  def __ne__(self, other):
6488 
    return not (self == other)
6489 
 
3064 chandransh 6490 
class getOrdersForCustomer_args:
1149 chandransh 6491 
  """
6492 
  Attributes:
3064 chandransh 6493 
   - customerId
6494 
   - from_date
6495 
   - to_date
6496 
   - statuses
1149 chandransh 6497 
  """
6498 
 
6499 
  thrift_spec = (
6500 
    None, # 0
3064 chandransh 6501 
    (1, TType.I64, 'customerId', None, None, ), # 1
6502 
    (2, TType.I64, 'from_date', None, None, ), # 2
6503 
    (3, TType.I64, 'to_date', None, None, ), # 3
6504 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6505 
  )
6506 
 
3064 chandransh 6507 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6508 
    self.customerId = customerId
6509 
    self.from_date = from_date
6510 
    self.to_date = to_date
6511 
    self.statuses = statuses
1149 chandransh 6512 
 
6513 
  def read(self, iprot):
6514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6516 
      return
6517 
    iprot.readStructBegin()
6518 
    while True:
6519 
      (fname, ftype, fid) = iprot.readFieldBegin()
6520 
      if ftype == TType.STOP:
6521 
        break
6522 
      if fid == 1:
6523 
        if ftype == TType.I64:
3064 chandransh 6524 
          self.customerId = iprot.readI64();
1149 chandransh 6525 
        else:
6526 
          iprot.skip(ftype)
6527 
      elif fid == 2:
6528 
        if ftype == TType.I64:
3064 chandransh 6529 
          self.from_date = iprot.readI64();
1149 chandransh 6530 
        else:
6531 
          iprot.skip(ftype)
2783 chandransh 6532 
      elif fid == 3:
6533 
        if ftype == TType.I64:
3064 chandransh 6534 
          self.to_date = iprot.readI64();
2783 chandransh 6535 
        else:
6536 
          iprot.skip(ftype)
6537 
      elif fid == 4:
3064 chandransh 6538 
        if ftype == TType.LIST:
6539 
          self.statuses = []
4133 chandransh 6540 
          (_etype94, _size91) = iprot.readListBegin()
6541 
          for _i95 in xrange(_size91):
6542 
            _elem96 = iprot.readI32();
6543 
            self.statuses.append(_elem96)
3064 chandransh 6544 
          iprot.readListEnd()
2783 chandransh 6545 
        else:
6546 
          iprot.skip(ftype)
1149 chandransh 6547 
      else:
6548 
        iprot.skip(ftype)
6549 
      iprot.readFieldEnd()
6550 
    iprot.readStructEnd()
6551 
 
6552 
  def write(self, oprot):
6553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6555 
      return
3064 chandransh 6556 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6557 
    if self.customerId is not None:
3064 chandransh 6558 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6559 
      oprot.writeI64(self.customerId)
1149 chandransh 6560 
      oprot.writeFieldEnd()
3431 rajveer 6561 
    if self.from_date is not None:
3064 chandransh 6562 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6563 
      oprot.writeI64(self.from_date)
1149 chandransh 6564 
      oprot.writeFieldEnd()
3431 rajveer 6565 
    if self.to_date is not None:
3064 chandransh 6566 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6567 
      oprot.writeI64(self.to_date)
2783 chandransh 6568 
      oprot.writeFieldEnd()
3431 rajveer 6569 
    if self.statuses is not None:
3064 chandransh 6570 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6571 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6572 
      for iter97 in self.statuses:
6573 
        oprot.writeI32(iter97)
3064 chandransh 6574 
      oprot.writeListEnd()
2783 chandransh 6575 
      oprot.writeFieldEnd()
1149 chandransh 6576 
    oprot.writeFieldStop()
6577 
    oprot.writeStructEnd()
6578 
 
3431 rajveer 6579 
  def validate(self):
6580 
    return
6581 
 
6582 
 
1149 chandransh 6583 
  def __repr__(self):
6584 
    L = ['%s=%r' % (key, value)
6585 
      for key, value in self.__dict__.iteritems()]
6586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6587 
 
6588 
  def __eq__(self, other):
6589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6590 
 
6591 
  def __ne__(self, other):
6592 
    return not (self == other)
6593 
 
3064 chandransh 6594 
class getOrdersForCustomer_result:
1149 chandransh 6595 
  """
6596 
  Attributes:
6597 
   - success
6598 
   - ex
6599 
  """
6600 
 
6601 
  thrift_spec = (
3064 chandransh 6602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6604 
  )
6605 
 
6606 
  def __init__(self, success=None, ex=None,):
6607 
    self.success = success
6608 
    self.ex = ex
6609 
 
6610 
  def read(self, iprot):
6611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6613 
      return
6614 
    iprot.readStructBegin()
6615 
    while True:
6616 
      (fname, ftype, fid) = iprot.readFieldBegin()
6617 
      if ftype == TType.STOP:
6618 
        break
6619 
      if fid == 0:
3064 chandransh 6620 
        if ftype == TType.LIST:
6621 
          self.success = []
4133 chandransh 6622 
          (_etype101, _size98) = iprot.readListBegin()
6623 
          for _i102 in xrange(_size98):
6624 
            _elem103 = Order()
6625 
            _elem103.read(iprot)
6626 
            self.success.append(_elem103)
3064 chandransh 6627 
          iprot.readListEnd()
1149 chandransh 6628 
        else:
6629 
          iprot.skip(ftype)
6630 
      elif fid == 1:
6631 
        if ftype == TType.STRUCT:
6632 
          self.ex = TransactionServiceException()
6633 
          self.ex.read(iprot)
6634 
        else:
6635 
          iprot.skip(ftype)
6636 
      else:
6637 
        iprot.skip(ftype)
6638 
      iprot.readFieldEnd()
6639 
    iprot.readStructEnd()
6640 
 
6641 
  def write(self, oprot):
6642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6644 
      return
3064 chandransh 6645 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6646 
    if self.success is not None:
3064 chandransh 6647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6649 
      for iter104 in self.success:
6650 
        iter104.write(oprot)
3064 chandransh 6651 
      oprot.writeListEnd()
1149 chandransh 6652 
      oprot.writeFieldEnd()
3431 rajveer 6653 
    if self.ex is not None:
1149 chandransh 6654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6655 
      self.ex.write(oprot)
6656 
      oprot.writeFieldEnd()
6657 
    oprot.writeFieldStop()
6658 
    oprot.writeStructEnd()
6659 
 
3431 rajveer 6660 
  def validate(self):
6661 
    return
6662 
 
6663 
 
1149 chandransh 6664 
  def __repr__(self):
6665 
    L = ['%s=%r' % (key, value)
6666 
      for key, value in self.__dict__.iteritems()]
6667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6668 
 
6669 
  def __eq__(self, other):
6670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6671 
 
6672 
  def __ne__(self, other):
6673 
    return not (self == other)
6674 
 
3064 chandransh 6675 
class createOrder_args:
921 rajveer 6676 
  """
6677 
  Attributes:
3064 chandransh 6678 
   - order
921 rajveer 6679 
  """
6680 
 
6681 
  thrift_spec = (
6682 
    None, # 0
3064 chandransh 6683 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6684 
  )
6685 
 
3064 chandransh 6686 
  def __init__(self, order=None,):
6687 
    self.order = order
921 rajveer 6688 
 
6689 
  def read(self, iprot):
6690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6692 
      return
6693 
    iprot.readStructBegin()
6694 
    while True:
6695 
      (fname, ftype, fid) = iprot.readFieldBegin()
6696 
      if ftype == TType.STOP:
6697 
        break
6698 
      if fid == 1:
3064 chandransh 6699 
        if ftype == TType.STRUCT:
6700 
          self.order = Order()
6701 
          self.order.read(iprot)
921 rajveer 6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      else:
6705 
        iprot.skip(ftype)
6706 
      iprot.readFieldEnd()
6707 
    iprot.readStructEnd()
6708 
 
6709 
  def write(self, oprot):
6710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6712 
      return
3064 chandransh 6713 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6714 
    if self.order is not None:
3064 chandransh 6715 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6716 
      self.order.write(oprot)
921 rajveer 6717 
      oprot.writeFieldEnd()
6718 
    oprot.writeFieldStop()
6719 
    oprot.writeStructEnd()
6720 
 
3431 rajveer 6721 
  def validate(self):
6722 
    return
6723 
 
6724 
 
921 rajveer 6725 
  def __repr__(self):
6726 
    L = ['%s=%r' % (key, value)
6727 
      for key, value in self.__dict__.iteritems()]
6728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6729 
 
6730 
  def __eq__(self, other):
6731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6732 
 
6733 
  def __ne__(self, other):
6734 
    return not (self == other)
6735 
 
3064 chandransh 6736 
class createOrder_result:
921 rajveer 6737 
  """
6738 
  Attributes:
6739 
   - success
6740 
   - ex
6741 
  """
6742 
 
6743 
  thrift_spec = (
3064 chandransh 6744 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6745 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6746 
  )
6747 
 
6748 
  def __init__(self, success=None, ex=None,):
6749 
    self.success = success
6750 
    self.ex = ex
6751 
 
6752 
  def read(self, iprot):
6753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6755 
      return
6756 
    iprot.readStructBegin()
6757 
    while True:
6758 
      (fname, ftype, fid) = iprot.readFieldBegin()
6759 
      if ftype == TType.STOP:
6760 
        break
6761 
      if fid == 0:
3064 chandransh 6762 
        if ftype == TType.I64:
6763 
          self.success = iprot.readI64();
921 rajveer 6764 
        else:
6765 
          iprot.skip(ftype)
6766 
      elif fid == 1:
6767 
        if ftype == TType.STRUCT:
6768 
          self.ex = TransactionServiceException()
6769 
          self.ex.read(iprot)
6770 
        else:
6771 
          iprot.skip(ftype)
6772 
      else:
6773 
        iprot.skip(ftype)
6774 
      iprot.readFieldEnd()
6775 
    iprot.readStructEnd()
6776 
 
6777 
  def write(self, oprot):
6778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6780 
      return
3064 chandransh 6781 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6782 
    if self.success is not None:
3064 chandransh 6783 
      oprot.writeFieldBegin('success', TType.I64, 0)
6784 
      oprot.writeI64(self.success)
921 rajveer 6785 
      oprot.writeFieldEnd()
3431 rajveer 6786 
    if self.ex is not None:
921 rajveer 6787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6788 
      self.ex.write(oprot)
6789 
      oprot.writeFieldEnd()
6790 
    oprot.writeFieldStop()
6791 
    oprot.writeStructEnd()
6792 
 
3431 rajveer 6793 
  def validate(self):
6794 
    return
6795 
 
6796 
 
921 rajveer 6797 
  def __repr__(self):
6798 
    L = ['%s=%r' % (key, value)
6799 
      for key, value in self.__dict__.iteritems()]
6800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6801 
 
6802 
  def __eq__(self, other):
6803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6804 
 
6805 
  def __ne__(self, other):
6806 
    return not (self == other)
6807 
 
3064 chandransh 6808 
class getOrder_args:
921 rajveer 6809 
  """
6810 
  Attributes:
3064 chandransh 6811 
   - id
921 rajveer 6812 
  """
6813 
 
6814 
  thrift_spec = (
6815 
    None, # 0
3064 chandransh 6816 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6817 
  )
6818 
 
3064 chandransh 6819 
  def __init__(self, id=None,):
6820 
    self.id = id
921 rajveer 6821 
 
6822 
  def read(self, iprot):
6823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6825 
      return
6826 
    iprot.readStructBegin()
6827 
    while True:
6828 
      (fname, ftype, fid) = iprot.readFieldBegin()
6829 
      if ftype == TType.STOP:
6830 
        break
6831 
      if fid == 1:
6832 
        if ftype == TType.I64:
3064 chandransh 6833 
          self.id = iprot.readI64();
921 rajveer 6834 
        else:
6835 
          iprot.skip(ftype)
6836 
      else:
6837 
        iprot.skip(ftype)
6838 
      iprot.readFieldEnd()
6839 
    iprot.readStructEnd()
6840 
 
6841 
  def write(self, oprot):
6842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6844 
      return
3064 chandransh 6845 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 6846 
    if self.id is not None:
3064 chandransh 6847 
      oprot.writeFieldBegin('id', TType.I64, 1)
6848 
      oprot.writeI64(self.id)
921 rajveer 6849 
      oprot.writeFieldEnd()
6850 
    oprot.writeFieldStop()
6851 
    oprot.writeStructEnd()
6852 
 
3431 rajveer 6853 
  def validate(self):
6854 
    return
6855 
 
6856 
 
921 rajveer 6857 
  def __repr__(self):
6858 
    L = ['%s=%r' % (key, value)
6859 
      for key, value in self.__dict__.iteritems()]
6860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6861 
 
6862 
  def __eq__(self, other):
6863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6864 
 
6865 
  def __ne__(self, other):
6866 
    return not (self == other)
6867 
 
3064 chandransh 6868 
class getOrder_result:
921 rajveer 6869 
  """
6870 
  Attributes:
6871 
   - success
6872 
   - ex
6873 
  """
6874 
 
6875 
  thrift_spec = (
3064 chandransh 6876 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6878 
  )
6879 
 
6880 
  def __init__(self, success=None, ex=None,):
6881 
    self.success = success
6882 
    self.ex = ex
6883 
 
6884 
  def read(self, iprot):
6885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6887 
      return
6888 
    iprot.readStructBegin()
6889 
    while True:
6890 
      (fname, ftype, fid) = iprot.readFieldBegin()
6891 
      if ftype == TType.STOP:
6892 
        break
6893 
      if fid == 0:
3064 chandransh 6894 
        if ftype == TType.STRUCT:
6895 
          self.success = Order()
6896 
          self.success.read(iprot)
921 rajveer 6897 
        else:
6898 
          iprot.skip(ftype)
6899 
      elif fid == 1:
6900 
        if ftype == TType.STRUCT:
6901 
          self.ex = TransactionServiceException()
6902 
          self.ex.read(iprot)
6903 
        else:
6904 
          iprot.skip(ftype)
6905 
      else:
6906 
        iprot.skip(ftype)
6907 
      iprot.readFieldEnd()
6908 
    iprot.readStructEnd()
6909 
 
6910 
  def write(self, oprot):
6911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6913 
      return
3064 chandransh 6914 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6915 
    if self.success is not None:
3064 chandransh 6916 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6917 
      self.success.write(oprot)
921 rajveer 6918 
      oprot.writeFieldEnd()
3431 rajveer 6919 
    if self.ex is not None:
921 rajveer 6920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6921 
      self.ex.write(oprot)
6922 
      oprot.writeFieldEnd()
6923 
    oprot.writeFieldStop()
6924 
    oprot.writeStructEnd()
6925 
 
3431 rajveer 6926 
  def validate(self):
6927 
    return
6928 
 
6929 
 
921 rajveer 6930 
  def __repr__(self):
6931 
    L = ['%s=%r' % (key, value)
6932 
      for key, value in self.__dict__.iteritems()]
6933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6934 
 
6935 
  def __eq__(self, other):
6936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6937 
 
6938 
  def __ne__(self, other):
6939 
    return not (self == other)
6940 
 
3064 chandransh 6941 
class getLineItemsForOrder_args:
94 ashish 6942 
  """
6943 
  Attributes:
3064 chandransh 6944 
   - orderId
94 ashish 6945 
  """
6946 
 
6947 
  thrift_spec = (
6948 
    None, # 0
3064 chandransh 6949 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 6950 
  )
6951 
 
3064 chandransh 6952 
  def __init__(self, orderId=None,):
6953 
    self.orderId = orderId
94 ashish 6954 
 
6955 
  def read(self, iprot):
6956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6958 
      return
6959 
    iprot.readStructBegin()
6960 
    while True:
6961 
      (fname, ftype, fid) = iprot.readFieldBegin()
6962 
      if ftype == TType.STOP:
6963 
        break
6964 
      if fid == 1:
6965 
        if ftype == TType.I64:
3064 chandransh 6966 
          self.orderId = iprot.readI64();
94 ashish 6967 
        else:
6968 
          iprot.skip(ftype)
6969 
      else:
6970 
        iprot.skip(ftype)
6971 
      iprot.readFieldEnd()
6972 
    iprot.readStructEnd()
6973 
 
6974 
  def write(self, oprot):
6975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6977 
      return
3064 chandransh 6978 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 6979 
    if self.orderId is not None:
3064 chandransh 6980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6981 
      oprot.writeI64(self.orderId)
94 ashish 6982 
      oprot.writeFieldEnd()
6983 
    oprot.writeFieldStop()
6984 
    oprot.writeStructEnd()
6985 
 
3431 rajveer 6986 
  def validate(self):
6987 
    return
6988 
 
6989 
 
94 ashish 6990 
  def __repr__(self):
6991 
    L = ['%s=%r' % (key, value)
6992 
      for key, value in self.__dict__.iteritems()]
6993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6994 
 
6995 
  def __eq__(self, other):
6996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6997 
 
6998 
  def __ne__(self, other):
6999 
    return not (self == other)
7000 
 
3064 chandransh 7001 
class getLineItemsForOrder_result:
94 ashish 7002 
  """
7003 
  Attributes:
7004 
   - success
7005 
   - ex
7006 
  """
7007 
 
7008 
  thrift_spec = (
3064 chandransh 7009 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7011 
  )
7012 
 
7013 
  def __init__(self, success=None, ex=None,):
7014 
    self.success = success
7015 
    self.ex = ex
7016 
 
7017 
  def read(self, iprot):
7018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7020 
      return
7021 
    iprot.readStructBegin()
7022 
    while True:
7023 
      (fname, ftype, fid) = iprot.readFieldBegin()
7024 
      if ftype == TType.STOP:
7025 
        break
7026 
      if fid == 0:
483 rajveer 7027 
        if ftype == TType.LIST:
7028 
          self.success = []
4133 chandransh 7029 
          (_etype108, _size105) = iprot.readListBegin()
7030 
          for _i109 in xrange(_size105):
7031 
            _elem110 = LineItem()
7032 
            _elem110.read(iprot)
7033 
            self.success.append(_elem110)
483 rajveer 7034 
          iprot.readListEnd()
94 ashish 7035 
        else:
7036 
          iprot.skip(ftype)
7037 
      elif fid == 1:
7038 
        if ftype == TType.STRUCT:
7039 
          self.ex = TransactionServiceException()
7040 
          self.ex.read(iprot)
7041 
        else:
7042 
          iprot.skip(ftype)
7043 
      else:
7044 
        iprot.skip(ftype)
7045 
      iprot.readFieldEnd()
7046 
    iprot.readStructEnd()
7047 
 
7048 
  def write(self, oprot):
7049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7051 
      return
3064 chandransh 7052 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7053 
    if self.success is not None:
483 rajveer 7054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7055 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7056 
      for iter111 in self.success:
7057 
        iter111.write(oprot)
483 rajveer 7058 
      oprot.writeListEnd()
94 ashish 7059 
      oprot.writeFieldEnd()
3431 rajveer 7060 
    if self.ex is not None:
94 ashish 7061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7062 
      self.ex.write(oprot)
7063 
      oprot.writeFieldEnd()
7064 
    oprot.writeFieldStop()
7065 
    oprot.writeStructEnd()
7066 
 
3431 rajveer 7067 
  def validate(self):
7068 
    return
7069 
 
7070 
 
94 ashish 7071 
  def __repr__(self):
7072 
    L = ['%s=%r' % (key, value)
7073 
      for key, value in self.__dict__.iteritems()]
7074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7075 
 
7076 
  def __eq__(self, other):
7077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7078 
 
7079 
  def __ne__(self, other):
7080 
    return not (self == other)
7081 
 
3064 chandransh 7082 
class getOrderForCustomer_args:
94 ashish 7083 
  """
7084 
  Attributes:
3064 chandransh 7085 
   - orderId
483 rajveer 7086 
   - customerId
94 ashish 7087 
  """
7088 
 
7089 
  thrift_spec = (
7090 
    None, # 0
3064 chandransh 7091 
    (1, TType.I64, 'orderId', None, None, ), # 1
7092 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7093 
  )
7094 
 
3064 chandransh 7095 
  def __init__(self, orderId=None, customerId=None,):
7096 
    self.orderId = orderId
483 rajveer 7097 
    self.customerId = customerId
94 ashish 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 == 1:
7109 
        if ftype == TType.I64:
3064 chandransh 7110 
          self.orderId = iprot.readI64();
94 ashish 7111 
        else:
7112 
          iprot.skip(ftype)
7113 
      elif fid == 2:
7114 
        if ftype == TType.I64:
3064 chandransh 7115 
          self.customerId = iprot.readI64();
94 ashish 7116 
        else:
7117 
          iprot.skip(ftype)
7118 
      else:
7119 
        iprot.skip(ftype)
7120 
      iprot.readFieldEnd()
7121 
    iprot.readStructEnd()
7122 
 
7123 
  def write(self, oprot):
7124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7126 
      return
3064 chandransh 7127 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7128 
    if self.orderId is not None:
3064 chandransh 7129 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7130 
      oprot.writeI64(self.orderId)
7131 
      oprot.writeFieldEnd()
3431 rajveer 7132 
    if self.customerId is not None:
3064 chandransh 7133 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7134 
      oprot.writeI64(self.customerId)
94 ashish 7135 
      oprot.writeFieldEnd()
7136 
    oprot.writeFieldStop()
7137 
    oprot.writeStructEnd()
7138 
 
3431 rajveer 7139 
  def validate(self):
7140 
    return
7141 
 
7142 
 
94 ashish 7143 
  def __repr__(self):
7144 
    L = ['%s=%r' % (key, value)
7145 
      for key, value in self.__dict__.iteritems()]
7146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7147 
 
7148 
  def __eq__(self, other):
7149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7150 
 
7151 
  def __ne__(self, other):
7152 
    return not (self == other)
7153 
 
3064 chandransh 7154 
class getOrderForCustomer_result:
94 ashish 7155 
  """
7156 
  Attributes:
7157 
   - success
7158 
   - ex
7159 
  """
7160 
 
7161 
  thrift_spec = (
3064 chandransh 7162 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7164 
  )
7165 
 
7166 
  def __init__(self, success=None, ex=None,):
7167 
    self.success = success
7168 
    self.ex = ex
7169 
 
7170 
  def read(self, iprot):
7171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7173 
      return
7174 
    iprot.readStructBegin()
7175 
    while True:
7176 
      (fname, ftype, fid) = iprot.readFieldBegin()
7177 
      if ftype == TType.STOP:
7178 
        break
7179 
      if fid == 0:
3064 chandransh 7180 
        if ftype == TType.STRUCT:
7181 
          self.success = Order()
7182 
          self.success.read(iprot)
94 ashish 7183 
        else:
7184 
          iprot.skip(ftype)
7185 
      elif fid == 1:
7186 
        if ftype == TType.STRUCT:
7187 
          self.ex = TransactionServiceException()
7188 
          self.ex.read(iprot)
7189 
        else:
7190 
          iprot.skip(ftype)
7191 
      else:
7192 
        iprot.skip(ftype)
7193 
      iprot.readFieldEnd()
7194 
    iprot.readStructEnd()
7195 
 
7196 
  def write(self, oprot):
7197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7199 
      return
3064 chandransh 7200 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7201 
    if self.success is not None:
3064 chandransh 7202 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7203 
      self.success.write(oprot)
94 ashish 7204 
      oprot.writeFieldEnd()
3431 rajveer 7205 
    if self.ex is not None:
94 ashish 7206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7207 
      self.ex.write(oprot)
7208 
      oprot.writeFieldEnd()
7209 
    oprot.writeFieldStop()
7210 
    oprot.writeStructEnd()
7211 
 
3431 rajveer 7212 
  def validate(self):
7213 
    return
7214 
 
7215 
 
94 ashish 7216 
  def __repr__(self):
7217 
    L = ['%s=%r' % (key, value)
7218 
      for key, value in self.__dict__.iteritems()]
7219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7220 
 
7221 
  def __eq__(self, other):
7222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7223 
 
7224 
  def __ne__(self, other):
7225 
    return not (self == other)
7226 
 
3064 chandransh 7227 
class getAlerts_args:
94 ashish 7228 
  """
7229 
  Attributes:
3064 chandransh 7230 
   - orderId
7231 
   - valid
94 ashish 7232 
  """
7233 
 
7234 
  thrift_spec = (
7235 
    None, # 0
3064 chandransh 7236 
    (1, TType.I64, 'orderId', None, None, ), # 1
7237 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7238 
  )
7239 
 
3064 chandransh 7240 
  def __init__(self, orderId=None, valid=None,):
7241 
    self.orderId = orderId
7242 
    self.valid = valid
94 ashish 7243 
 
7244 
  def read(self, iprot):
7245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7247 
      return
7248 
    iprot.readStructBegin()
7249 
    while True:
7250 
      (fname, ftype, fid) = iprot.readFieldBegin()
7251 
      if ftype == TType.STOP:
7252 
        break
7253 
      if fid == 1:
3064 chandransh 7254 
        if ftype == TType.I64:
7255 
          self.orderId = iprot.readI64();
94 ashish 7256 
        else:
7257 
          iprot.skip(ftype)
3064 chandransh 7258 
      elif fid == 2:
7259 
        if ftype == TType.BOOL:
7260 
          self.valid = iprot.readBool();
7261 
        else:
7262 
          iprot.skip(ftype)
94 ashish 7263 
      else:
7264 
        iprot.skip(ftype)
7265 
      iprot.readFieldEnd()
7266 
    iprot.readStructEnd()
7267 
 
7268 
  def write(self, oprot):
7269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7271 
      return
3064 chandransh 7272 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7273 
    if self.orderId is not None:
3064 chandransh 7274 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7275 
      oprot.writeI64(self.orderId)
94 ashish 7276 
      oprot.writeFieldEnd()
3431 rajveer 7277 
    if self.valid is not None:
3064 chandransh 7278 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7279 
      oprot.writeBool(self.valid)
7280 
      oprot.writeFieldEnd()
94 ashish 7281 
    oprot.writeFieldStop()
7282 
    oprot.writeStructEnd()
7283 
 
3431 rajveer 7284 
  def validate(self):
7285 
    return
7286 
 
7287 
 
94 ashish 7288 
  def __repr__(self):
7289 
    L = ['%s=%r' % (key, value)
7290 
      for key, value in self.__dict__.iteritems()]
7291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7292 
 
7293 
  def __eq__(self, other):
7294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7295 
 
7296 
  def __ne__(self, other):
7297 
    return not (self == other)
7298 
 
3064 chandransh 7299 
class getAlerts_result:
94 ashish 7300 
  """
7301 
  Attributes:
7302 
   - success
7303 
  """
7304 
 
7305 
  thrift_spec = (
3064 chandransh 7306 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7307 
  )
7308 
 
3064 chandransh 7309 
  def __init__(self, success=None,):
94 ashish 7310 
    self.success = success
7311 
 
7312 
  def read(self, iprot):
7313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7315 
      return
7316 
    iprot.readStructBegin()
7317 
    while True:
7318 
      (fname, ftype, fid) = iprot.readFieldBegin()
7319 
      if ftype == TType.STOP:
7320 
        break
7321 
      if fid == 0:
3064 chandransh 7322 
        if ftype == TType.LIST:
7323 
          self.success = []
4133 chandransh 7324 
          (_etype115, _size112) = iprot.readListBegin()
7325 
          for _i116 in xrange(_size112):
7326 
            _elem117 = Alert()
7327 
            _elem117.read(iprot)
7328 
            self.success.append(_elem117)
3064 chandransh 7329 
          iprot.readListEnd()
94 ashish 7330 
        else:
7331 
          iprot.skip(ftype)
7332 
      else:
7333 
        iprot.skip(ftype)
7334 
      iprot.readFieldEnd()
7335 
    iprot.readStructEnd()
7336 
 
7337 
  def write(self, oprot):
7338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7340 
      return
3064 chandransh 7341 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7342 
    if self.success is not None:
3064 chandransh 7343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7345 
      for iter118 in self.success:
7346 
        iter118.write(oprot)
3064 chandransh 7347 
      oprot.writeListEnd()
94 ashish 7348 
      oprot.writeFieldEnd()
7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
3431 rajveer 7352 
  def validate(self):
7353 
    return
7354 
 
7355 
 
94 ashish 7356 
  def __repr__(self):
7357 
    L = ['%s=%r' % (key, value)
7358 
      for key, value in self.__dict__.iteritems()]
7359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7360 
 
7361 
  def __eq__(self, other):
7362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7363 
 
7364 
  def __ne__(self, other):
7365 
    return not (self == other)
7366 
 
3064 chandransh 7367 
class setAlert_args:
94 ashish 7368 
  """
7369 
  Attributes:
3064 chandransh 7370 
   - orderId
7371 
   - unset
7372 
   - type
7373 
   - comment
94 ashish 7374 
  """
7375 
 
7376 
  thrift_spec = (
7377 
    None, # 0
3064 chandransh 7378 
    (1, TType.I64, 'orderId', None, None, ), # 1
7379 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7380 
    (3, TType.I64, 'type', None, None, ), # 3
7381 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7382 
  )
7383 
 
3064 chandransh 7384 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7385 
    self.orderId = orderId
7386 
    self.unset = unset
7387 
    self.type = type
7388 
    self.comment = comment
94 ashish 7389 
 
7390 
  def read(self, iprot):
7391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7393 
      return
7394 
    iprot.readStructBegin()
7395 
    while True:
7396 
      (fname, ftype, fid) = iprot.readFieldBegin()
7397 
      if ftype == TType.STOP:
7398 
        break
7399 
      if fid == 1:
7400 
        if ftype == TType.I64:
3064 chandransh 7401 
          self.orderId = iprot.readI64();
94 ashish 7402 
        else:
7403 
          iprot.skip(ftype)
3064 chandransh 7404 
      elif fid == 2:
7405 
        if ftype == TType.BOOL:
7406 
          self.unset = iprot.readBool();
7407 
        else:
7408 
          iprot.skip(ftype)
7409 
      elif fid == 3:
7410 
        if ftype == TType.I64:
7411 
          self.type = iprot.readI64();
7412 
        else:
7413 
          iprot.skip(ftype)
7414 
      elif fid == 4:
7415 
        if ftype == TType.STRING:
7416 
          self.comment = iprot.readString();
7417 
        else:
7418 
          iprot.skip(ftype)
94 ashish 7419 
      else:
7420 
        iprot.skip(ftype)
7421 
      iprot.readFieldEnd()
7422 
    iprot.readStructEnd()
7423 
 
7424 
  def write(self, oprot):
7425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7427 
      return
3064 chandransh 7428 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7429 
    if self.orderId is not None:
3064 chandransh 7430 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7431 
      oprot.writeI64(self.orderId)
94 ashish 7432 
      oprot.writeFieldEnd()
3431 rajveer 7433 
    if self.unset is not None:
3064 chandransh 7434 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7435 
      oprot.writeBool(self.unset)
7436 
      oprot.writeFieldEnd()
3431 rajveer 7437 
    if self.type is not None:
3064 chandransh 7438 
      oprot.writeFieldBegin('type', TType.I64, 3)
7439 
      oprot.writeI64(self.type)
7440 
      oprot.writeFieldEnd()
3431 rajveer 7441 
    if self.comment is not None:
3064 chandransh 7442 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7443 
      oprot.writeString(self.comment)
7444 
      oprot.writeFieldEnd()
94 ashish 7445 
    oprot.writeFieldStop()
7446 
    oprot.writeStructEnd()
7447 
 
3431 rajveer 7448 
  def validate(self):
7449 
    return
7450 
 
7451 
 
94 ashish 7452 
  def __repr__(self):
7453 
    L = ['%s=%r' % (key, value)
7454 
      for key, value in self.__dict__.iteritems()]
7455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7456 
 
7457 
  def __eq__(self, other):
7458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7459 
 
7460 
  def __ne__(self, other):
7461 
    return not (self == other)
7462 
 
3064 chandransh 7463 
class setAlert_result:
7464 
 
7465 
  thrift_spec = (
7466 
  )
7467 
 
7468 
  def read(self, iprot):
7469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7471 
      return
7472 
    iprot.readStructBegin()
7473 
    while True:
7474 
      (fname, ftype, fid) = iprot.readFieldBegin()
7475 
      if ftype == TType.STOP:
7476 
        break
7477 
      else:
7478 
        iprot.skip(ftype)
7479 
      iprot.readFieldEnd()
7480 
    iprot.readStructEnd()
7481 
 
7482 
  def write(self, oprot):
7483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7485 
      return
7486 
    oprot.writeStructBegin('setAlert_result')
7487 
    oprot.writeFieldStop()
7488 
    oprot.writeStructEnd()
7489 
 
3431 rajveer 7490 
  def validate(self):
7491 
    return
7492 
 
7493 
 
3064 chandransh 7494 
  def __repr__(self):
7495 
    L = ['%s=%r' % (key, value)
7496 
      for key, value in self.__dict__.iteritems()]
7497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7498 
 
7499 
  def __eq__(self, other):
7500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7501 
 
7502 
  def __ne__(self, other):
7503 
    return not (self == other)
7504 
 
7505 
class getValidOrderCount_args:
7506 
 
7507 
  thrift_spec = (
7508 
  )
7509 
 
7510 
  def read(self, iprot):
7511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7513 
      return
7514 
    iprot.readStructBegin()
7515 
    while True:
7516 
      (fname, ftype, fid) = iprot.readFieldBegin()
7517 
      if ftype == TType.STOP:
7518 
        break
7519 
      else:
7520 
        iprot.skip(ftype)
7521 
      iprot.readFieldEnd()
7522 
    iprot.readStructEnd()
7523 
 
7524 
  def write(self, oprot):
7525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7527 
      return
7528 
    oprot.writeStructBegin('getValidOrderCount_args')
7529 
    oprot.writeFieldStop()
7530 
    oprot.writeStructEnd()
7531 
 
3431 rajveer 7532 
  def validate(self):
7533 
    return
7534 
 
7535 
 
3064 chandransh 7536 
  def __repr__(self):
7537 
    L = ['%s=%r' % (key, value)
7538 
      for key, value in self.__dict__.iteritems()]
7539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7540 
 
7541 
  def __eq__(self, other):
7542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7543 
 
7544 
  def __ne__(self, other):
7545 
    return not (self == other)
7546 
 
7547 
class getValidOrderCount_result:
94 ashish 7548 
  """
7549 
  Attributes:
7550 
   - success
7551 
  """
7552 
 
7553 
  thrift_spec = (
3064 chandransh 7554 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7555 
  )
7556 
 
3064 chandransh 7557 
  def __init__(self, success=None,):
94 ashish 7558 
    self.success = success
7559 
 
7560 
  def read(self, iprot):
7561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7563 
      return
7564 
    iprot.readStructBegin()
7565 
    while True:
7566 
      (fname, ftype, fid) = iprot.readFieldBegin()
7567 
      if ftype == TType.STOP:
7568 
        break
7569 
      if fid == 0:
3064 chandransh 7570 
        if ftype == TType.I64:
7571 
          self.success = iprot.readI64();
94 ashish 7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      else:
7575 
        iprot.skip(ftype)
7576 
      iprot.readFieldEnd()
7577 
    iprot.readStructEnd()
7578 
 
7579 
  def write(self, oprot):
7580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7582 
      return
3064 chandransh 7583 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7584 
    if self.success is not None:
3064 chandransh 7585 
      oprot.writeFieldBegin('success', TType.I64, 0)
7586 
      oprot.writeI64(self.success)
94 ashish 7587 
      oprot.writeFieldEnd()
7588 
    oprot.writeFieldStop()
7589 
    oprot.writeStructEnd()
7590 
 
3431 rajveer 7591 
  def validate(self):
7592 
    return
7593 
 
7594 
 
94 ashish 7595 
  def __repr__(self):
7596 
    L = ['%s=%r' % (key, value)
7597 
      for key, value in self.__dict__.iteritems()]
7598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7599 
 
7600 
  def __eq__(self, other):
7601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7602 
 
7603 
  def __ne__(self, other):
7604 
    return not (self == other)
7605 
 
3064 chandransh 7606 
class getNoOfCustomersWithSuccessfulTransaction_args:
7607 
 
7608 
  thrift_spec = (
7609 
  )
7610 
 
7611 
  def read(self, iprot):
7612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7614 
      return
7615 
    iprot.readStructBegin()
7616 
    while True:
7617 
      (fname, ftype, fid) = iprot.readFieldBegin()
7618 
      if ftype == TType.STOP:
7619 
        break
7620 
      else:
7621 
        iprot.skip(ftype)
7622 
      iprot.readFieldEnd()
7623 
    iprot.readStructEnd()
7624 
 
7625 
  def write(self, oprot):
7626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7628 
      return
7629 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7630 
    oprot.writeFieldStop()
7631 
    oprot.writeStructEnd()
7632 
 
3431 rajveer 7633 
  def validate(self):
7634 
    return
7635 
 
7636 
 
3064 chandransh 7637 
  def __repr__(self):
7638 
    L = ['%s=%r' % (key, value)
7639 
      for key, value in self.__dict__.iteritems()]
7640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7641 
 
7642 
  def __eq__(self, other):
7643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7644 
 
7645 
  def __ne__(self, other):
7646 
    return not (self == other)
7647 
 
7648 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7649 
  """
7650 
  Attributes:
3064 chandransh 7651 
   - success
94 ashish 7652 
  """
7653 
 
7654 
  thrift_spec = (
3064 chandransh 7655 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7656 
  )
7657 
 
3064 chandransh 7658 
  def __init__(self, success=None,):
7659 
    self.success = success
94 ashish 7660 
 
7661 
  def read(self, iprot):
7662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7664 
      return
7665 
    iprot.readStructBegin()
7666 
    while True:
7667 
      (fname, ftype, fid) = iprot.readFieldBegin()
7668 
      if ftype == TType.STOP:
7669 
        break
3064 chandransh 7670 
      if fid == 0:
94 ashish 7671 
        if ftype == TType.I64:
3064 chandransh 7672 
          self.success = iprot.readI64();
94 ashish 7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      else:
7676 
        iprot.skip(ftype)
7677 
      iprot.readFieldEnd()
7678 
    iprot.readStructEnd()
7679 
 
7680 
  def write(self, oprot):
7681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7683 
      return
3064 chandransh 7684 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7685 
    if self.success is not None:
3064 chandransh 7686 
      oprot.writeFieldBegin('success', TType.I64, 0)
7687 
      oprot.writeI64(self.success)
94 ashish 7688 
      oprot.writeFieldEnd()
7689 
    oprot.writeFieldStop()
7690 
    oprot.writeStructEnd()
7691 
 
3431 rajveer 7692 
  def validate(self):
7693 
    return
7694 
 
7695 
 
94 ashish 7696 
  def __repr__(self):
7697 
    L = ['%s=%r' % (key, value)
7698 
      for key, value in self.__dict__.iteritems()]
7699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7700 
 
7701 
  def __eq__(self, other):
7702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7703 
 
7704 
  def __ne__(self, other):
7705 
    return not (self == other)
7706 
 
3064 chandransh 7707 
class getValidOrdersAmountRange_args:
7708 
 
7709 
  thrift_spec = (
7710 
  )
7711 
 
7712 
  def read(self, iprot):
7713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7715 
      return
7716 
    iprot.readStructBegin()
7717 
    while True:
7718 
      (fname, ftype, fid) = iprot.readFieldBegin()
7719 
      if ftype == TType.STOP:
7720 
        break
7721 
      else:
7722 
        iprot.skip(ftype)
7723 
      iprot.readFieldEnd()
7724 
    iprot.readStructEnd()
7725 
 
7726 
  def write(self, oprot):
7727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7729 
      return
7730 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7731 
    oprot.writeFieldStop()
7732 
    oprot.writeStructEnd()
7733 
 
3431 rajveer 7734 
  def validate(self):
7735 
    return
7736 
 
7737 
 
3064 chandransh 7738 
  def __repr__(self):
7739 
    L = ['%s=%r' % (key, value)
7740 
      for key, value in self.__dict__.iteritems()]
7741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7742 
 
7743 
  def __eq__(self, other):
7744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7745 
 
7746 
  def __ne__(self, other):
7747 
    return not (self == other)
7748 
 
7749 
class getValidOrdersAmountRange_result:
94 ashish 7750 
  """
7751 
  Attributes:
7752 
   - success
7753 
  """
7754 
 
7755 
  thrift_spec = (
3064 chandransh 7756 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7757 
  )
7758 
 
3064 chandransh 7759 
  def __init__(self, success=None,):
94 ashish 7760 
    self.success = success
7761 
 
7762 
  def read(self, iprot):
7763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7765 
      return
7766 
    iprot.readStructBegin()
7767 
    while True:
7768 
      (fname, ftype, fid) = iprot.readFieldBegin()
7769 
      if ftype == TType.STOP:
7770 
        break
7771 
      if fid == 0:
483 rajveer 7772 
        if ftype == TType.LIST:
7773 
          self.success = []
4133 chandransh 7774 
          (_etype122, _size119) = iprot.readListBegin()
7775 
          for _i123 in xrange(_size119):
7776 
            _elem124 = iprot.readDouble();
7777 
            self.success.append(_elem124)
483 rajveer 7778 
          iprot.readListEnd()
94 ashish 7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      else:
7782 
        iprot.skip(ftype)
7783 
      iprot.readFieldEnd()
7784 
    iprot.readStructEnd()
7785 
 
7786 
  def write(self, oprot):
7787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7789 
      return
3064 chandransh 7790 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7791 
    if self.success is not None:
483 rajveer 7792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7793 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7794 
      for iter125 in self.success:
7795 
        oprot.writeDouble(iter125)
483 rajveer 7796 
      oprot.writeListEnd()
94 ashish 7797 
      oprot.writeFieldEnd()
7798 
    oprot.writeFieldStop()
7799 
    oprot.writeStructEnd()
7800 
 
3431 rajveer 7801 
  def validate(self):
7802 
    return
7803 
 
7804 
 
94 ashish 7805 
  def __repr__(self):
7806 
    L = ['%s=%r' % (key, value)
7807 
      for key, value in self.__dict__.iteritems()]
7808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7809 
 
7810 
  def __eq__(self, other):
7811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7812 
 
7813 
  def __ne__(self, other):
7814 
    return not (self == other)
7815 
 
3064 chandransh 7816 
class getValidOrders_args:
1528 ankur.sing 7817 
  """
7818 
  Attributes:
3064 chandransh 7819 
   - limit
1528 ankur.sing 7820 
  """
7821 
 
7822 
  thrift_spec = (
7823 
    None, # 0
3064 chandransh 7824 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7825 
  )
7826 
 
3064 chandransh 7827 
  def __init__(self, limit=None,):
7828 
    self.limit = limit
1528 ankur.sing 7829 
 
7830 
  def read(self, iprot):
7831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7833 
      return
7834 
    iprot.readStructBegin()
7835 
    while True:
7836 
      (fname, ftype, fid) = iprot.readFieldBegin()
7837 
      if ftype == TType.STOP:
7838 
        break
7839 
      if fid == 1:
7840 
        if ftype == TType.I64:
3064 chandransh 7841 
          self.limit = iprot.readI64();
1528 ankur.sing 7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      else:
7845 
        iprot.skip(ftype)
7846 
      iprot.readFieldEnd()
7847 
    iprot.readStructEnd()
7848 
 
7849 
  def write(self, oprot):
7850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7852 
      return
3064 chandransh 7853 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7854 
    if self.limit is not None:
3064 chandransh 7855 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7856 
      oprot.writeI64(self.limit)
1528 ankur.sing 7857 
      oprot.writeFieldEnd()
7858 
    oprot.writeFieldStop()
7859 
    oprot.writeStructEnd()
7860 
 
3431 rajveer 7861 
  def validate(self):
7862 
    return
7863 
 
7864 
 
1528 ankur.sing 7865 
  def __repr__(self):
7866 
    L = ['%s=%r' % (key, value)
7867 
      for key, value in self.__dict__.iteritems()]
7868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7869 
 
7870 
  def __eq__(self, other):
7871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7872 
 
7873 
  def __ne__(self, other):
7874 
    return not (self == other)
7875 
 
3064 chandransh 7876 
class getValidOrders_result:
1528 ankur.sing 7877 
  """
7878 
  Attributes:
7879 
   - success
7880 
  """
7881 
 
7882 
  thrift_spec = (
3064 chandransh 7883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7884 
  )
7885 
 
3064 chandransh 7886 
  def __init__(self, success=None,):
1528 ankur.sing 7887 
    self.success = success
7888 
 
7889 
  def read(self, iprot):
7890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7892 
      return
7893 
    iprot.readStructBegin()
7894 
    while True:
7895 
      (fname, ftype, fid) = iprot.readFieldBegin()
7896 
      if ftype == TType.STOP:
7897 
        break
7898 
      if fid == 0:
3064 chandransh 7899 
        if ftype == TType.LIST:
7900 
          self.success = []
4133 chandransh 7901 
          (_etype129, _size126) = iprot.readListBegin()
7902 
          for _i130 in xrange(_size126):
7903 
            _elem131 = Order()
7904 
            _elem131.read(iprot)
7905 
            self.success.append(_elem131)
3064 chandransh 7906 
          iprot.readListEnd()
1528 ankur.sing 7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
3064 chandransh 7918 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7919 
    if self.success is not None:
3064 chandransh 7920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7922 
      for iter132 in self.success:
7923 
        iter132.write(oprot)
3064 chandransh 7924 
      oprot.writeListEnd()
1528 ankur.sing 7925 
      oprot.writeFieldEnd()
7926 
    oprot.writeFieldStop()
7927 
    oprot.writeStructEnd()
7928 
 
3431 rajveer 7929 
  def validate(self):
7930 
    return
7931 
 
7932 
 
1528 ankur.sing 7933 
  def __repr__(self):
7934 
    L = ['%s=%r' % (key, value)
7935 
      for key, value in self.__dict__.iteritems()]
7936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7937 
 
7938 
  def __eq__(self, other):
7939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7940 
 
7941 
  def __ne__(self, other):
7942 
    return not (self == other)
7943 
 
1220 chandransh 7944 
class batchOrders_args:
7945 
  """
7946 
  Attributes:
7947 
   - warehouseId
7948 
  """
7949 
 
7950 
  thrift_spec = (
7951 
    None, # 0
7952 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
7953 
  )
7954 
 
7955 
  def __init__(self, warehouseId=None,):
7956 
    self.warehouseId = warehouseId
7957 
 
7958 
  def read(self, iprot):
7959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7961 
      return
7962 
    iprot.readStructBegin()
7963 
    while True:
7964 
      (fname, ftype, fid) = iprot.readFieldBegin()
7965 
      if ftype == TType.STOP:
7966 
        break
7967 
      if fid == 1:
7968 
        if ftype == TType.I64:
7969 
          self.warehouseId = iprot.readI64();
7970 
        else:
7971 
          iprot.skip(ftype)
7972 
      else:
7973 
        iprot.skip(ftype)
7974 
      iprot.readFieldEnd()
7975 
    iprot.readStructEnd()
7976 
 
7977 
  def write(self, oprot):
7978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7980 
      return
7981 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 7982 
    if self.warehouseId is not None:
1220 chandransh 7983 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7984 
      oprot.writeI64(self.warehouseId)
7985 
      oprot.writeFieldEnd()
7986 
    oprot.writeFieldStop()
7987 
    oprot.writeStructEnd()
7988 
 
3431 rajveer 7989 
  def validate(self):
7990 
    return
7991 
 
7992 
 
1220 chandransh 7993 
  def __repr__(self):
7994 
    L = ['%s=%r' % (key, value)
7995 
      for key, value in self.__dict__.iteritems()]
7996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7997 
 
7998 
  def __eq__(self, other):
7999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8000 
 
8001 
  def __ne__(self, other):
8002 
    return not (self == other)
8003 
 
8004 
class batchOrders_result:
8005 
  """
8006 
  Attributes:
8007 
   - success
8008 
   - ex
8009 
  """
8010 
 
8011 
  thrift_spec = (
8012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8014 
  )
8015 
 
8016 
  def __init__(self, success=None, ex=None,):
8017 
    self.success = success
8018 
    self.ex = ex
8019 
 
8020 
  def read(self, iprot):
8021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8023 
      return
8024 
    iprot.readStructBegin()
8025 
    while True:
8026 
      (fname, ftype, fid) = iprot.readFieldBegin()
8027 
      if ftype == TType.STOP:
8028 
        break
8029 
      if fid == 0:
8030 
        if ftype == TType.LIST:
8031 
          self.success = []
4133 chandransh 8032 
          (_etype136, _size133) = iprot.readListBegin()
8033 
          for _i137 in xrange(_size133):
8034 
            _elem138 = Order()
8035 
            _elem138.read(iprot)
8036 
            self.success.append(_elem138)
1220 chandransh 8037 
          iprot.readListEnd()
8038 
        else:
8039 
          iprot.skip(ftype)
8040 
      elif fid == 1:
8041 
        if ftype == TType.STRUCT:
8042 
          self.ex = TransactionServiceException()
8043 
          self.ex.read(iprot)
8044 
        else:
8045 
          iprot.skip(ftype)
8046 
      else:
8047 
        iprot.skip(ftype)
8048 
      iprot.readFieldEnd()
8049 
    iprot.readStructEnd()
8050 
 
8051 
  def write(self, oprot):
8052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8054 
      return
8055 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8056 
    if self.success is not None:
1220 chandransh 8057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8059 
      for iter139 in self.success:
8060 
        iter139.write(oprot)
1220 chandransh 8061 
      oprot.writeListEnd()
8062 
      oprot.writeFieldEnd()
3431 rajveer 8063 
    if self.ex is not None:
1220 chandransh 8064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8065 
      self.ex.write(oprot)
8066 
      oprot.writeFieldEnd()
8067 
    oprot.writeFieldStop()
8068 
    oprot.writeStructEnd()
8069 
 
3431 rajveer 8070 
  def validate(self):
8071 
    return
8072 
 
8073 
 
1220 chandransh 8074 
  def __repr__(self):
8075 
    L = ['%s=%r' % (key, value)
8076 
      for key, value in self.__dict__.iteritems()]
8077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8078 
 
8079 
  def __eq__(self, other):
8080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8081 
 
8082 
  def __ne__(self, other):
8083 
    return not (self == other)
8084 
 
1208 chandransh 8085 
class markOrderAsOutOfStock_args:
8086 
  """
8087 
  Attributes:
8088 
   - orderId
8089 
  """
8090 
 
8091 
  thrift_spec = (
8092 
    None, # 0
8093 
    (1, TType.I64, 'orderId', None, None, ), # 1
8094 
  )
8095 
 
8096 
  def __init__(self, orderId=None,):
8097 
    self.orderId = orderId
8098 
 
8099 
  def read(self, iprot):
8100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8102 
      return
8103 
    iprot.readStructBegin()
8104 
    while True:
8105 
      (fname, ftype, fid) = iprot.readFieldBegin()
8106 
      if ftype == TType.STOP:
8107 
        break
8108 
      if fid == 1:
8109 
        if ftype == TType.I64:
8110 
          self.orderId = iprot.readI64();
8111 
        else:
8112 
          iprot.skip(ftype)
8113 
      else:
8114 
        iprot.skip(ftype)
8115 
      iprot.readFieldEnd()
8116 
    iprot.readStructEnd()
8117 
 
8118 
  def write(self, oprot):
8119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8121 
      return
8122 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8123 
    if self.orderId is not None:
1208 chandransh 8124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8125 
      oprot.writeI64(self.orderId)
8126 
      oprot.writeFieldEnd()
8127 
    oprot.writeFieldStop()
8128 
    oprot.writeStructEnd()
8129 
 
3431 rajveer 8130 
  def validate(self):
8131 
    return
8132 
 
8133 
 
1208 chandransh 8134 
  def __repr__(self):
8135 
    L = ['%s=%r' % (key, value)
8136 
      for key, value in self.__dict__.iteritems()]
8137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8138 
 
8139 
  def __eq__(self, other):
8140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8141 
 
8142 
  def __ne__(self, other):
8143 
    return not (self == other)
8144 
 
8145 
class markOrderAsOutOfStock_result:
8146 
  """
8147 
  Attributes:
8148 
   - success
8149 
   - ex
8150 
  """
8151 
 
8152 
  thrift_spec = (
8153 
    (0, TType.BOOL, 'success', None, None, ), # 0
8154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8155 
  )
8156 
 
8157 
  def __init__(self, success=None, ex=None,):
8158 
    self.success = success
8159 
    self.ex = ex
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 0:
8171 
        if ftype == TType.BOOL:
8172 
          self.success = iprot.readBool();
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      elif fid == 1:
8176 
        if ftype == TType.STRUCT:
8177 
          self.ex = TransactionServiceException()
8178 
          self.ex.read(iprot)
8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      else:
8182 
        iprot.skip(ftype)
8183 
      iprot.readFieldEnd()
8184 
    iprot.readStructEnd()
8185 
 
8186 
  def write(self, oprot):
8187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8189 
      return
8190 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8191 
    if self.success is not None:
1208 chandransh 8192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8193 
      oprot.writeBool(self.success)
8194 
      oprot.writeFieldEnd()
3431 rajveer 8195 
    if self.ex is not None:
1208 chandransh 8196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8197 
      self.ex.write(oprot)
8198 
      oprot.writeFieldEnd()
8199 
    oprot.writeFieldStop()
8200 
    oprot.writeStructEnd()
8201 
 
3431 rajveer 8202 
  def validate(self):
8203 
    return
8204 
 
8205 
 
1208 chandransh 8206 
  def __repr__(self):
8207 
    L = ['%s=%r' % (key, value)
8208 
      for key, value in self.__dict__.iteritems()]
8209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8210 
 
8211 
  def __eq__(self, other):
8212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8213 
 
8214 
  def __ne__(self, other):
8215 
    return not (self == other)
8216 
 
3064 chandransh 8217 
class verifyOrder_args:
759 chandransh 8218 
  """
8219 
  Attributes:
3064 chandransh 8220 
   - orderId
759 chandransh 8221 
  """
8222 
 
8223 
  thrift_spec = (
8224 
    None, # 0
3064 chandransh 8225 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8226 
  )
8227 
 
3064 chandransh 8228 
  def __init__(self, orderId=None,):
8229 
    self.orderId = orderId
759 chandransh 8230 
 
8231 
  def read(self, iprot):
8232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8234 
      return
8235 
    iprot.readStructBegin()
8236 
    while True:
8237 
      (fname, ftype, fid) = iprot.readFieldBegin()
8238 
      if ftype == TType.STOP:
8239 
        break
8240 
      if fid == 1:
8241 
        if ftype == TType.I64:
3064 chandransh 8242 
          self.orderId = iprot.readI64();
759 chandransh 8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      else:
8246 
        iprot.skip(ftype)
8247 
      iprot.readFieldEnd()
8248 
    iprot.readStructEnd()
8249 
 
8250 
  def write(self, oprot):
8251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8253 
      return
3064 chandransh 8254 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8255 
    if self.orderId is not None:
3064 chandransh 8256 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8257 
      oprot.writeI64(self.orderId)
759 chandransh 8258 
      oprot.writeFieldEnd()
8259 
    oprot.writeFieldStop()
8260 
    oprot.writeStructEnd()
8261 
 
3431 rajveer 8262 
  def validate(self):
8263 
    return
8264 
 
8265 
 
759 chandransh 8266 
  def __repr__(self):
8267 
    L = ['%s=%r' % (key, value)
8268 
      for key, value in self.__dict__.iteritems()]
8269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8270 
 
8271 
  def __eq__(self, other):
8272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8273 
 
8274 
  def __ne__(self, other):
8275 
    return not (self == other)
8276 
 
3064 chandransh 8277 
class verifyOrder_result:
759 chandransh 8278 
  """
8279 
  Attributes:
8280 
   - success
8281 
   - ex
8282 
  """
8283 
 
8284 
  thrift_spec = (
8285 
    (0, TType.BOOL, 'success', None, None, ), # 0
8286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8287 
  )
8288 
 
8289 
  def __init__(self, success=None, ex=None,):
8290 
    self.success = success
8291 
    self.ex = ex
8292 
 
8293 
  def read(self, iprot):
8294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8296 
      return
8297 
    iprot.readStructBegin()
8298 
    while True:
8299 
      (fname, ftype, fid) = iprot.readFieldBegin()
8300 
      if ftype == TType.STOP:
8301 
        break
8302 
      if fid == 0:
8303 
        if ftype == TType.BOOL:
8304 
          self.success = iprot.readBool();
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      elif fid == 1:
8308 
        if ftype == TType.STRUCT:
8309 
          self.ex = TransactionServiceException()
8310 
          self.ex.read(iprot)
8311 
        else:
8312 
          iprot.skip(ftype)
8313 
      else:
8314 
        iprot.skip(ftype)
8315 
      iprot.readFieldEnd()
8316 
    iprot.readStructEnd()
8317 
 
8318 
  def write(self, oprot):
8319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8321 
      return
3064 chandransh 8322 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8323 
    if self.success is not None:
759 chandransh 8324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8325 
      oprot.writeBool(self.success)
8326 
      oprot.writeFieldEnd()
3431 rajveer 8327 
    if self.ex is not None:
759 chandransh 8328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8329 
      self.ex.write(oprot)
8330 
      oprot.writeFieldEnd()
8331 
    oprot.writeFieldStop()
8332 
    oprot.writeStructEnd()
8333 
 
3431 rajveer 8334 
  def validate(self):
8335 
    return
8336 
 
8337 
 
759 chandransh 8338 
  def __repr__(self):
8339 
    L = ['%s=%r' % (key, value)
8340 
      for key, value in self.__dict__.iteritems()]
8341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8342 
 
8343 
  def __eq__(self, other):
8344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8345 
 
8346 
  def __ne__(self, other):
8347 
    return not (self == other)
8348 
 
3064 chandransh 8349 
class acceptOrder_args:
1113 chandransh 8350 
  """
8351 
  Attributes:
3064 chandransh 8352 
   - orderId
1113 chandransh 8353 
  """
8354 
 
8355 
  thrift_spec = (
8356 
    None, # 0
3064 chandransh 8357 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8358 
  )
8359 
 
3064 chandransh 8360 
  def __init__(self, orderId=None,):
8361 
    self.orderId = orderId
1113 chandransh 8362 
 
8363 
  def read(self, iprot):
8364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8366 
      return
8367 
    iprot.readStructBegin()
8368 
    while True:
8369 
      (fname, ftype, fid) = iprot.readFieldBegin()
8370 
      if ftype == TType.STOP:
8371 
        break
8372 
      if fid == 1:
8373 
        if ftype == TType.I64:
3064 chandransh 8374 
          self.orderId = iprot.readI64();
1113 chandransh 8375 
        else:
8376 
          iprot.skip(ftype)
8377 
      else:
8378 
        iprot.skip(ftype)
8379 
      iprot.readFieldEnd()
8380 
    iprot.readStructEnd()
8381 
 
8382 
  def write(self, oprot):
8383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8385 
      return
3064 chandransh 8386 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8387 
    if self.orderId is not None:
3064 chandransh 8388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8389 
      oprot.writeI64(self.orderId)
1113 chandransh 8390 
      oprot.writeFieldEnd()
8391 
    oprot.writeFieldStop()
8392 
    oprot.writeStructEnd()
8393 
 
3431 rajveer 8394 
  def validate(self):
8395 
    return
8396 
 
8397 
 
1113 chandransh 8398 
  def __repr__(self):
8399 
    L = ['%s=%r' % (key, value)
8400 
      for key, value in self.__dict__.iteritems()]
8401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8402 
 
8403 
  def __eq__(self, other):
8404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8405 
 
8406 
  def __ne__(self, other):
8407 
    return not (self == other)
8408 
 
3064 chandransh 8409 
class acceptOrder_result:
1113 chandransh 8410 
  """
8411 
  Attributes:
8412 
   - success
8413 
   - ex
8414 
  """
8415 
 
8416 
  thrift_spec = (
3064 chandransh 8417 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8419 
  )
8420 
 
8421 
  def __init__(self, success=None, ex=None,):
8422 
    self.success = success
8423 
    self.ex = ex
8424 
 
8425 
  def read(self, iprot):
8426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8428 
      return
8429 
    iprot.readStructBegin()
8430 
    while True:
8431 
      (fname, ftype, fid) = iprot.readFieldBegin()
8432 
      if ftype == TType.STOP:
8433 
        break
8434 
      if fid == 0:
3064 chandransh 8435 
        if ftype == TType.BOOL:
8436 
          self.success = iprot.readBool();
1113 chandransh 8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      elif fid == 1:
8440 
        if ftype == TType.STRUCT:
8441 
          self.ex = TransactionServiceException()
8442 
          self.ex.read(iprot)
8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
3064 chandransh 8454 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8455 
    if self.success is not None:
3064 chandransh 8456 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8457 
      oprot.writeBool(self.success)
1113 chandransh 8458 
      oprot.writeFieldEnd()
3431 rajveer 8459 
    if self.ex is not None:
1113 chandransh 8460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8461 
      self.ex.write(oprot)
8462 
      oprot.writeFieldEnd()
8463 
    oprot.writeFieldStop()
8464 
    oprot.writeStructEnd()
8465 
 
3431 rajveer 8466 
  def validate(self):
8467 
    return
8468 
 
8469 
 
1113 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 
 
3064 chandransh 8481 
class addBillingDetails_args:
1135 chandransh 8482 
  """
8483 
  Attributes:
3064 chandransh 8484 
   - orderId
8485 
   - invoice_number
4283 anupam.sin 8486 
   - imeiNumber
8487 
   - itemNumber
3064 chandransh 8488 
   - billed_by
4264 rajveer 8489 
   - jacketNumber
4283 anupam.sin 8490 
   - billingType
8491 
   - vendorId
1135 chandransh 8492 
  """
8493 
 
8494 
  thrift_spec = (
8495 
    None, # 0
3064 chandransh 8496 
    (1, TType.I64, 'orderId', None, None, ), # 1
8497 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8498 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8499 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8500 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8501 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8502 
    (7, TType.I64, 'billingType', None, None, ), # 7
8503 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8504 
  )
8505 
 
4283 anupam.sin 8506 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8507 
    self.orderId = orderId
8508 
    self.invoice_number = invoice_number
4283 anupam.sin 8509 
    self.imeiNumber = imeiNumber
8510 
    self.itemNumber = itemNumber
3064 chandransh 8511 
    self.billed_by = billed_by
4264 rajveer 8512 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8513 
    self.billingType = billingType
8514 
    self.vendorId = vendorId
1135 chandransh 8515 
 
8516 
  def read(self, iprot):
8517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8519 
      return
8520 
    iprot.readStructBegin()
8521 
    while True:
8522 
      (fname, ftype, fid) = iprot.readFieldBegin()
8523 
      if ftype == TType.STOP:
8524 
        break
8525 
      if fid == 1:
8526 
        if ftype == TType.I64:
3064 chandransh 8527 
          self.orderId = iprot.readI64();
1135 chandransh 8528 
        else:
8529 
          iprot.skip(ftype)
8530 
      elif fid == 2:
3064 chandransh 8531 
        if ftype == TType.STRING:
8532 
          self.invoice_number = iprot.readString();
1135 chandransh 8533 
        else:
8534 
          iprot.skip(ftype)
3064 chandransh 8535 
      elif fid == 3:
4264 rajveer 8536 
        if ftype == TType.I64:
3064 chandransh 8537 
          self.imeiNumber = iprot.readI64();
8538 
        else:
8539 
          iprot.skip(ftype)
8540 
      elif fid == 4:
8541 
        if ftype == TType.STRING:
8542 
          self.itemNumber = iprot.readString();
8543 
        else:
8544 
          iprot.skip(ftype)
8545 
      elif fid == 5:
8546 
        if ftype == TType.STRING:
4283 anupam.sin 8547 
          self.billed_by = iprot.readString();
3064 chandransh 8548 
        else:
8549 
          iprot.skip(ftype)
8550 
      elif fid == 6:
8551 
        if ftype == TType.I64:
4283 anupam.sin 8552 
          self.jacketNumber = iprot.readI64();
8553 
        else:
8554 
          iprot.skip(ftype)
8555 
      elif fid == 7:
8556 
        if ftype == TType.I64:
3064 chandransh 8557 
          self.billingType = iprot.readI64();
8558 
        else:
8559 
          iprot.skip(ftype)
4283 anupam.sin 8560 
      elif fid == 8:
8561 
        if ftype == TType.I64:
8562 
          self.vendorId = iprot.readI64();
8563 
        else:
8564 
          iprot.skip(ftype)
1246 chandransh 8565 
      else:
8566 
        iprot.skip(ftype)
8567 
      iprot.readFieldEnd()
8568 
    iprot.readStructEnd()
8569 
 
8570 
  def write(self, oprot):
8571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8573 
      return
4283 anupam.sin 8574 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8575 
    if self.orderId is not None:
3064 chandransh 8576 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8577 
      oprot.writeI64(self.orderId)
1246 chandransh 8578 
      oprot.writeFieldEnd()
4283 anupam.sin 8579 
    if self.invoice_number is not None:
8580 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8581 
      oprot.writeString(self.invoice_number)
1246 chandransh 8582 
      oprot.writeFieldEnd()
3431 rajveer 8583 
    if self.imeiNumber is not None:
3064 chandransh 8584 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8585 
      oprot.writeI64(self.imeiNumber)
8586 
      oprot.writeFieldEnd()
3431 rajveer 8587 
    if self.itemNumber is not None:
3064 chandransh 8588 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8589 
      oprot.writeString(self.itemNumber)
8590 
      oprot.writeFieldEnd()
4283 anupam.sin 8591 
    if self.billed_by is not None:
8592 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8593 
      oprot.writeString(self.billed_by)
3064 chandransh 8594 
      oprot.writeFieldEnd()
4283 anupam.sin 8595 
    if self.jacketNumber is not None:
8596 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8597 
      oprot.writeI64(self.jacketNumber)
8598 
      oprot.writeFieldEnd()
3431 rajveer 8599 
    if self.billingType is not None:
4283 anupam.sin 8600 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8601 
      oprot.writeI64(self.billingType)
8602 
      oprot.writeFieldEnd()
4283 anupam.sin 8603 
    if self.vendorId is not None:
8604 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8605 
      oprot.writeI64(self.vendorId)
8606 
      oprot.writeFieldEnd()
1246 chandransh 8607 
    oprot.writeFieldStop()
8608 
    oprot.writeStructEnd()
8609 
 
3431 rajveer 8610 
  def validate(self):
8611 
    return
8612 
 
8613 
 
1246 chandransh 8614 
  def __repr__(self):
8615 
    L = ['%s=%r' % (key, value)
8616 
      for key, value in self.__dict__.iteritems()]
8617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8618 
 
8619 
  def __eq__(self, other):
8620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8621 
 
8622 
  def __ne__(self, other):
8623 
    return not (self == other)
8624 
 
4283 anupam.sin 8625 
class addBillingDetails_result:
1246 chandransh 8626 
  """
8627 
  Attributes:
3064 chandransh 8628 
   - success
1246 chandransh 8629 
   - ex
8630 
  """
8631 
 
8632 
  thrift_spec = (
3064 chandransh 8633 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8635 
  )
8636 
 
3064 chandransh 8637 
  def __init__(self, success=None, ex=None,):
8638 
    self.success = success
1246 chandransh 8639 
    self.ex = ex
8640 
 
8641 
  def read(self, iprot):
8642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8644 
      return
8645 
    iprot.readStructBegin()
8646 
    while True:
8647 
      (fname, ftype, fid) = iprot.readFieldBegin()
8648 
      if ftype == TType.STOP:
8649 
        break
3064 chandransh 8650 
      if fid == 0:
8651 
        if ftype == TType.BOOL:
8652 
          self.success = iprot.readBool();
8653 
        else:
8654 
          iprot.skip(ftype)
8655 
      elif fid == 1:
1246 chandransh 8656 
        if ftype == TType.STRUCT:
8657 
          self.ex = TransactionServiceException()
8658 
          self.ex.read(iprot)
8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      else:
8662 
        iprot.skip(ftype)
8663 
      iprot.readFieldEnd()
8664 
    iprot.readStructEnd()
8665 
 
8666 
  def write(self, oprot):
8667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8669 
      return
4283 anupam.sin 8670 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8671 
    if self.success is not None:
3064 chandransh 8672 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8673 
      oprot.writeBool(self.success)
8674 
      oprot.writeFieldEnd()
3431 rajveer 8675 
    if self.ex is not None:
1246 chandransh 8676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8677 
      self.ex.write(oprot)
8678 
      oprot.writeFieldEnd()
8679 
    oprot.writeFieldStop()
8680 
    oprot.writeStructEnd()
8681 
 
3431 rajveer 8682 
  def validate(self):
8683 
    return
8684 
 
8685 
 
1246 chandransh 8686 
  def __repr__(self):
8687 
    L = ['%s=%r' % (key, value)
8688 
      for key, value in self.__dict__.iteritems()]
8689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8690 
 
8691 
  def __eq__(self, other):
8692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8693 
 
8694 
  def __ne__(self, other):
8695 
    return not (self == other)
8696 
 
3064 chandransh 8697 
class markOrdersAsManifested_args:
1408 ankur.sing 8698 
  """
8699 
  Attributes:
3064 chandransh 8700 
   - warehouseId
1408 ankur.sing 8701 
   - providerId
3064 chandransh 8702 
   - cod
1408 ankur.sing 8703 
  """
8704 
 
8705 
  thrift_spec = (
8706 
    None, # 0
3064 chandransh 8707 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8708 
    (2, TType.I64, 'providerId', None, None, ), # 2
8709 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8710 
  )
8711 
 
3064 chandransh 8712 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8713 
    self.warehouseId = warehouseId
1408 ankur.sing 8714 
    self.providerId = providerId
3064 chandransh 8715 
    self.cod = cod
1408 ankur.sing 8716 
 
8717 
  def read(self, iprot):
8718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8720 
      return
8721 
    iprot.readStructBegin()
8722 
    while True:
8723 
      (fname, ftype, fid) = iprot.readFieldBegin()
8724 
      if ftype == TType.STOP:
8725 
        break
8726 
      if fid == 1:
8727 
        if ftype == TType.I64:
3064 chandransh 8728 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8729 
        else:
8730 
          iprot.skip(ftype)
8731 
      elif fid == 2:
8732 
        if ftype == TType.I64:
3064 chandransh 8733 
          self.providerId = iprot.readI64();
1408 ankur.sing 8734 
        else:
8735 
          iprot.skip(ftype)
3064 chandransh 8736 
      elif fid == 3:
8737 
        if ftype == TType.BOOL:
8738 
          self.cod = iprot.readBool();
8739 
        else:
8740 
          iprot.skip(ftype)
1408 ankur.sing 8741 
      else:
8742 
        iprot.skip(ftype)
8743 
      iprot.readFieldEnd()
8744 
    iprot.readStructEnd()
8745 
 
8746 
  def write(self, oprot):
8747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8749 
      return
3064 chandransh 8750 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 8751 
    if self.warehouseId is not None:
3064 chandransh 8752 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8753 
      oprot.writeI64(self.warehouseId)
8754 
      oprot.writeFieldEnd()
3431 rajveer 8755 
    if self.providerId is not None:
3064 chandransh 8756 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 8757 
      oprot.writeI64(self.providerId)
8758 
      oprot.writeFieldEnd()
3431 rajveer 8759 
    if self.cod is not None:
3064 chandransh 8760 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
8761 
      oprot.writeBool(self.cod)
1408 ankur.sing 8762 
      oprot.writeFieldEnd()
8763 
    oprot.writeFieldStop()
8764 
    oprot.writeStructEnd()
8765 
 
3431 rajveer 8766 
  def validate(self):
8767 
    return
8768 
 
8769 
 
1408 ankur.sing 8770 
  def __repr__(self):
8771 
    L = ['%s=%r' % (key, value)
8772 
      for key, value in self.__dict__.iteritems()]
8773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8774 
 
8775 
  def __eq__(self, other):
8776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8777 
 
8778 
  def __ne__(self, other):
8779 
    return not (self == other)
8780 
 
3064 chandransh 8781 
class markOrdersAsManifested_result:
1408 ankur.sing 8782 
  """
8783 
  Attributes:
8784 
   - success
3064 chandransh 8785 
   - ex
1408 ankur.sing 8786 
  """
8787 
 
8788 
  thrift_spec = (
3064 chandransh 8789 
    (0, TType.BOOL, 'success', None, None, ), # 0
8790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 8791 
  )
8792 
 
3064 chandransh 8793 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 8794 
    self.success = success
3064 chandransh 8795 
    self.ex = ex
1408 ankur.sing 8796 
 
8797 
  def read(self, iprot):
8798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8800 
      return
8801 
    iprot.readStructBegin()
8802 
    while True:
8803 
      (fname, ftype, fid) = iprot.readFieldBegin()
8804 
      if ftype == TType.STOP:
8805 
        break
8806 
      if fid == 0:
3064 chandransh 8807 
        if ftype == TType.BOOL:
8808 
          self.success = iprot.readBool();
1408 ankur.sing 8809 
        else:
8810 
          iprot.skip(ftype)
3064 chandransh 8811 
      elif fid == 1:
8812 
        if ftype == TType.STRUCT:
8813 
          self.ex = TransactionServiceException()
8814 
          self.ex.read(iprot)
8815 
        else:
8816 
          iprot.skip(ftype)
1408 ankur.sing 8817 
      else:
8818 
        iprot.skip(ftype)
8819 
      iprot.readFieldEnd()
8820 
    iprot.readStructEnd()
8821 
 
8822 
  def write(self, oprot):
8823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8825 
      return
3064 chandransh 8826 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 8827 
    if self.success is not None:
3064 chandransh 8828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8829 
      oprot.writeBool(self.success)
1408 ankur.sing 8830 
      oprot.writeFieldEnd()
3431 rajveer 8831 
    if self.ex is not None:
3064 chandransh 8832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8833 
      self.ex.write(oprot)
8834 
      oprot.writeFieldEnd()
1408 ankur.sing 8835 
    oprot.writeFieldStop()
8836 
    oprot.writeStructEnd()
8837 
 
3431 rajveer 8838 
  def validate(self):
8839 
    return
8840 
 
8841 
 
1408 ankur.sing 8842 
  def __repr__(self):
8843 
    L = ['%s=%r' % (key, value)
8844 
      for key, value in self.__dict__.iteritems()]
8845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8846 
 
8847 
  def __eq__(self, other):
8848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8849 
 
8850 
  def __ne__(self, other):
8851 
    return not (self == other)
8852 
 
3064 chandransh 8853 
class markOrdersAsPickedUp_args:
304 ashish 8854 
  """
8855 
  Attributes:
3064 chandransh 8856 
   - providerId
8857 
   - pickupDetails
304 ashish 8858 
  """
94 ashish 8859 
 
304 ashish 8860 
  thrift_spec = (
8861 
    None, # 0
3064 chandransh 8862 
    (1, TType.I64, 'providerId', None, None, ), # 1
8863 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8864 
  )
8865 
 
3064 chandransh 8866 
  def __init__(self, providerId=None, pickupDetails=None,):
8867 
    self.providerId = providerId
8868 
    self.pickupDetails = pickupDetails
304 ashish 8869 
 
8870 
  def read(self, iprot):
8871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8873 
      return
8874 
    iprot.readStructBegin()
8875 
    while True:
8876 
      (fname, ftype, fid) = iprot.readFieldBegin()
8877 
      if ftype == TType.STOP:
8878 
        break
8879 
      if fid == 1:
8880 
        if ftype == TType.I64:
3064 chandransh 8881 
          self.providerId = iprot.readI64();
304 ashish 8882 
        else:
8883 
          iprot.skip(ftype)
8884 
      elif fid == 2:
3064 chandransh 8885 
        if ftype == TType.MAP:
8886 
          self.pickupDetails = {}
4133 chandransh 8887 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
8888 
          for _i144 in xrange(_size140):
8889 
            _key145 = iprot.readString();
8890 
            _val146 = iprot.readString();
8891 
            self.pickupDetails[_key145] = _val146
3064 chandransh 8892 
          iprot.readMapEnd()
304 ashish 8893 
        else:
8894 
          iprot.skip(ftype)
8895 
      else:
8896 
        iprot.skip(ftype)
8897 
      iprot.readFieldEnd()
8898 
    iprot.readStructEnd()
8899 
 
8900 
  def write(self, oprot):
8901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8903 
      return
3064 chandransh 8904 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 8905 
    if self.providerId is not None:
3064 chandransh 8906 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8907 
      oprot.writeI64(self.providerId)
304 ashish 8908 
      oprot.writeFieldEnd()
3431 rajveer 8909 
    if self.pickupDetails is not None:
3064 chandransh 8910 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
8911 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 8912 
      for kiter147,viter148 in self.pickupDetails.items():
8913 
        oprot.writeString(kiter147)
8914 
        oprot.writeString(viter148)
3064 chandransh 8915 
      oprot.writeMapEnd()
304 ashish 8916 
      oprot.writeFieldEnd()
8917 
    oprot.writeFieldStop()
8918 
    oprot.writeStructEnd()
8919 
 
3431 rajveer 8920 
  def validate(self):
8921 
    return
8922 
 
8923 
 
304 ashish 8924 
  def __repr__(self):
8925 
    L = ['%s=%r' % (key, value)
8926 
      for key, value in self.__dict__.iteritems()]
8927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8928 
 
8929 
  def __eq__(self, other):
8930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8931 
 
8932 
  def __ne__(self, other):
8933 
    return not (self == other)
8934 
 
3064 chandransh 8935 
class markOrdersAsPickedUp_result:
304 ashish 8936 
  """
8937 
  Attributes:
8938 
   - success
3064 chandransh 8939 
   - ex
304 ashish 8940 
  """
8941 
 
8942 
  thrift_spec = (
3064 chandransh 8943 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 8945 
  )
8946 
 
3064 chandransh 8947 
  def __init__(self, success=None, ex=None,):
304 ashish 8948 
    self.success = success
3064 chandransh 8949 
    self.ex = ex
304 ashish 8950 
 
8951 
  def read(self, iprot):
8952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8954 
      return
8955 
    iprot.readStructBegin()
8956 
    while True:
8957 
      (fname, ftype, fid) = iprot.readFieldBegin()
8958 
      if ftype == TType.STOP:
8959 
        break
8960 
      if fid == 0:
8961 
        if ftype == TType.LIST:
8962 
          self.success = []
4133 chandransh 8963 
          (_etype152, _size149) = iprot.readListBegin()
8964 
          for _i153 in xrange(_size149):
8965 
            _elem154 = Order()
8966 
            _elem154.read(iprot)
8967 
            self.success.append(_elem154)
304 ashish 8968 
          iprot.readListEnd()
8969 
        else:
8970 
          iprot.skip(ftype)
3064 chandransh 8971 
      elif fid == 1:
8972 
        if ftype == TType.STRUCT:
8973 
          self.ex = TransactionServiceException()
8974 
          self.ex.read(iprot)
8975 
        else:
8976 
          iprot.skip(ftype)
304 ashish 8977 
      else:
8978 
        iprot.skip(ftype)
8979 
      iprot.readFieldEnd()
8980 
    iprot.readStructEnd()
8981 
 
8982 
  def write(self, oprot):
8983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8985 
      return
3064 chandransh 8986 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 8987 
    if self.success is not None:
304 ashish 8988 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8989 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8990 
      for iter155 in self.success:
8991 
        iter155.write(oprot)
304 ashish 8992 
      oprot.writeListEnd()
8993 
      oprot.writeFieldEnd()
3431 rajveer 8994 
    if self.ex is not None:
3064 chandransh 8995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8996 
      self.ex.write(oprot)
8997 
      oprot.writeFieldEnd()
304 ashish 8998 
    oprot.writeFieldStop()
8999 
    oprot.writeStructEnd()
9000 
 
3431 rajveer 9001 
  def validate(self):
9002 
    return
9003 
 
9004 
 
304 ashish 9005 
  def __repr__(self):
9006 
    L = ['%s=%r' % (key, value)
9007 
      for key, value in self.__dict__.iteritems()]
9008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9009 
 
9010 
  def __eq__(self, other):
9011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9012 
 
9013 
  def __ne__(self, other):
9014 
    return not (self == other)
9015 
 
3064 chandransh 9016 
class markOrdersAsDelivered_args:
304 ashish 9017 
  """
9018 
  Attributes:
3064 chandransh 9019 
   - providerId
9020 
   - deliveredOrders
304 ashish 9021 
  """
9022 
 
9023 
  thrift_spec = (
9024 
    None, # 0
3064 chandransh 9025 
    (1, TType.I64, 'providerId', None, None, ), # 1
9026 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9027 
  )
9028 
 
3064 chandransh 9029 
  def __init__(self, providerId=None, deliveredOrders=None,):
9030 
    self.providerId = providerId
9031 
    self.deliveredOrders = deliveredOrders
304 ashish 9032 
 
9033 
  def read(self, iprot):
9034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9036 
      return
9037 
    iprot.readStructBegin()
9038 
    while True:
9039 
      (fname, ftype, fid) = iprot.readFieldBegin()
9040 
      if ftype == TType.STOP:
9041 
        break
9042 
      if fid == 1:
9043 
        if ftype == TType.I64:
3064 chandransh 9044 
          self.providerId = iprot.readI64();
304 ashish 9045 
        else:
9046 
          iprot.skip(ftype)
9047 
      elif fid == 2:
3064 chandransh 9048 
        if ftype == TType.MAP:
9049 
          self.deliveredOrders = {}
4133 chandransh 9050 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9051 
          for _i160 in xrange(_size156):
9052 
            _key161 = iprot.readString();
9053 
            _val162 = iprot.readString();
9054 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9055 
          iprot.readMapEnd()
304 ashish 9056 
        else:
9057 
          iprot.skip(ftype)
9058 
      else:
9059 
        iprot.skip(ftype)
9060 
      iprot.readFieldEnd()
9061 
    iprot.readStructEnd()
9062 
 
9063 
  def write(self, oprot):
9064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9066 
      return
3064 chandransh 9067 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9068 
    if self.providerId is not None:
3064 chandransh 9069 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9070 
      oprot.writeI64(self.providerId)
304 ashish 9071 
      oprot.writeFieldEnd()
3431 rajveer 9072 
    if self.deliveredOrders is not None:
3064 chandransh 9073 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9074 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9075 
      for kiter163,viter164 in self.deliveredOrders.items():
9076 
        oprot.writeString(kiter163)
9077 
        oprot.writeString(viter164)
3064 chandransh 9078 
      oprot.writeMapEnd()
304 ashish 9079 
      oprot.writeFieldEnd()
9080 
    oprot.writeFieldStop()
9081 
    oprot.writeStructEnd()
9082 
 
3431 rajveer 9083 
  def validate(self):
9084 
    return
9085 
 
9086 
 
304 ashish 9087 
  def __repr__(self):
9088 
    L = ['%s=%r' % (key, value)
9089 
      for key, value in self.__dict__.iteritems()]
9090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9091 
 
9092 
  def __eq__(self, other):
9093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9094 
 
9095 
  def __ne__(self, other):
9096 
    return not (self == other)
9097 
 
3064 chandransh 9098 
class markOrdersAsDelivered_result:
9099 
  """
9100 
  Attributes:
9101 
   - ex
9102 
  """
304 ashish 9103 
 
9104 
  thrift_spec = (
3064 chandransh 9105 
    None, # 0
9106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9107 
  )
9108 
 
3064 chandransh 9109 
  def __init__(self, ex=None,):
9110 
    self.ex = ex
304 ashish 9111 
 
1596 ankur.sing 9112 
  def read(self, iprot):
9113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9115 
      return
9116 
    iprot.readStructBegin()
9117 
    while True:
9118 
      (fname, ftype, fid) = iprot.readFieldBegin()
9119 
      if ftype == TType.STOP:
9120 
        break
3064 chandransh 9121 
      if fid == 1:
9122 
        if ftype == TType.STRUCT:
9123 
          self.ex = TransactionServiceException()
9124 
          self.ex.read(iprot)
9125 
        else:
9126 
          iprot.skip(ftype)
1596 ankur.sing 9127 
      else:
9128 
        iprot.skip(ftype)
9129 
      iprot.readFieldEnd()
9130 
    iprot.readStructEnd()
9131 
 
9132 
  def write(self, oprot):
9133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9135 
      return
3064 chandransh 9136 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9137 
    if self.ex is not None:
3064 chandransh 9138 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9139 
      self.ex.write(oprot)
9140 
      oprot.writeFieldEnd()
1596 ankur.sing 9141 
    oprot.writeFieldStop()
9142 
    oprot.writeStructEnd()
9143 
 
3431 rajveer 9144 
  def validate(self):
9145 
    return
9146 
 
9147 
 
1596 ankur.sing 9148 
  def __repr__(self):
9149 
    L = ['%s=%r' % (key, value)
9150 
      for key, value in self.__dict__.iteritems()]
9151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9152 
 
9153 
  def __eq__(self, other):
9154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9155 
 
9156 
  def __ne__(self, other):
9157 
    return not (self == other)
9158 
 
3064 chandransh 9159 
class markOrdersAsFailed_args:
1596 ankur.sing 9160 
  """
9161 
  Attributes:
3064 chandransh 9162 
   - providerId
9163 
   - returnedOrders
1596 ankur.sing 9164 
  """
9165 
 
9166 
  thrift_spec = (
3064 chandransh 9167 
    None, # 0
9168 
    (1, TType.I64, 'providerId', None, None, ), # 1
9169 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9170 
  )
9171 
 
3064 chandransh 9172 
  def __init__(self, providerId=None, returnedOrders=None,):
9173 
    self.providerId = providerId
9174 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9175 
 
9176 
  def read(self, iprot):
9177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9179 
      return
9180 
    iprot.readStructBegin()
9181 
    while True:
9182 
      (fname, ftype, fid) = iprot.readFieldBegin()
9183 
      if ftype == TType.STOP:
9184 
        break
3064 chandransh 9185 
      if fid == 1:
1596 ankur.sing 9186 
        if ftype == TType.I64:
3064 chandransh 9187 
          self.providerId = iprot.readI64();
1596 ankur.sing 9188 
        else:
9189 
          iprot.skip(ftype)
3064 chandransh 9190 
      elif fid == 2:
9191 
        if ftype == TType.MAP:
9192 
          self.returnedOrders = {}
4133 chandransh 9193 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9194 
          for _i169 in xrange(_size165):
9195 
            _key170 = iprot.readString();
9196 
            _val171 = iprot.readString();
9197 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9198 
          iprot.readMapEnd()
9199 
        else:
9200 
          iprot.skip(ftype)
1596 ankur.sing 9201 
      else:
9202 
        iprot.skip(ftype)
9203 
      iprot.readFieldEnd()
9204 
    iprot.readStructEnd()
9205 
 
9206 
  def write(self, oprot):
9207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9209 
      return
3064 chandransh 9210 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9211 
    if self.providerId is not None:
3064 chandransh 9212 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9213 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9214 
      oprot.writeFieldEnd()
3431 rajveer 9215 
    if self.returnedOrders is not None:
3064 chandransh 9216 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9217 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9218 
      for kiter172,viter173 in self.returnedOrders.items():
9219 
        oprot.writeString(kiter172)
9220 
        oprot.writeString(viter173)
3064 chandransh 9221 
      oprot.writeMapEnd()
9222 
      oprot.writeFieldEnd()
1596 ankur.sing 9223 
    oprot.writeFieldStop()
9224 
    oprot.writeStructEnd()
9225 
 
3431 rajveer 9226 
  def validate(self):
9227 
    return
9228 
 
9229 
 
1596 ankur.sing 9230 
  def __repr__(self):
9231 
    L = ['%s=%r' % (key, value)
9232 
      for key, value in self.__dict__.iteritems()]
9233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9234 
 
9235 
  def __eq__(self, other):
9236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9237 
 
9238 
  def __ne__(self, other):
9239 
    return not (self == other)
9240 
 
3064 chandransh 9241 
class markOrdersAsFailed_result:
9242 
  """
9243 
  Attributes:
9244 
   - ex
9245 
  """
1596 ankur.sing 9246 
 
1627 ankur.sing 9247 
  thrift_spec = (
3064 chandransh 9248 
    None, # 0
9249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9250 
  )
9251 
 
3064 chandransh 9252 
  def __init__(self, ex=None,):
9253 
    self.ex = ex
9254 
 
1627 ankur.sing 9255 
  def read(self, iprot):
9256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9258 
      return
9259 
    iprot.readStructBegin()
9260 
    while True:
9261 
      (fname, ftype, fid) = iprot.readFieldBegin()
9262 
      if ftype == TType.STOP:
9263 
        break
3064 chandransh 9264 
      if fid == 1:
9265 
        if ftype == TType.STRUCT:
9266 
          self.ex = TransactionServiceException()
9267 
          self.ex.read(iprot)
9268 
        else:
9269 
          iprot.skip(ftype)
1627 ankur.sing 9270 
      else:
9271 
        iprot.skip(ftype)
9272 
      iprot.readFieldEnd()
9273 
    iprot.readStructEnd()
9274 
 
9275 
  def write(self, oprot):
9276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9278 
      return
3064 chandransh 9279 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9280 
    if self.ex is not None:
3064 chandransh 9281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9282 
      self.ex.write(oprot)
9283 
      oprot.writeFieldEnd()
1627 ankur.sing 9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
1627 ankur.sing 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
3064 chandransh 9302 
class updateNonDeliveryReason_args:
1627 ankur.sing 9303 
  """
9304 
  Attributes:
3064 chandransh 9305 
   - providerId
9306 
   - undeliveredOrders
1627 ankur.sing 9307 
  """
9308 
 
9309 
  thrift_spec = (
3064 chandransh 9310 
    None, # 0
9311 
    (1, TType.I64, 'providerId', None, None, ), # 1
9312 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9313 
  )
9314 
 
3064 chandransh 9315 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9316 
    self.providerId = providerId
9317 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9318 
 
9319 
  def read(self, iprot):
9320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9322 
      return
9323 
    iprot.readStructBegin()
9324 
    while True:
9325 
      (fname, ftype, fid) = iprot.readFieldBegin()
9326 
      if ftype == TType.STOP:
9327 
        break
3064 chandransh 9328 
      if fid == 1:
1627 ankur.sing 9329 
        if ftype == TType.I64:
3064 chandransh 9330 
          self.providerId = iprot.readI64();
1627 ankur.sing 9331 
        else:
9332 
          iprot.skip(ftype)
3064 chandransh 9333 
      elif fid == 2:
9334 
        if ftype == TType.MAP:
9335 
          self.undeliveredOrders = {}
4133 chandransh 9336 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9337 
          for _i178 in xrange(_size174):
9338 
            _key179 = iprot.readString();
9339 
            _val180 = iprot.readString();
9340 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9341 
          iprot.readMapEnd()
9342 
        else:
9343 
          iprot.skip(ftype)
1627 ankur.sing 9344 
      else:
9345 
        iprot.skip(ftype)
9346 
      iprot.readFieldEnd()
9347 
    iprot.readStructEnd()
9348 
 
9349 
  def write(self, oprot):
9350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9352 
      return
3064 chandransh 9353 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9354 
    if self.providerId is not None:
3064 chandransh 9355 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9356 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9357 
      oprot.writeFieldEnd()
3431 rajveer 9358 
    if self.undeliveredOrders is not None:
3064 chandransh 9359 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9360 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9361 
      for kiter181,viter182 in self.undeliveredOrders.items():
9362 
        oprot.writeString(kiter181)
9363 
        oprot.writeString(viter182)
3064 chandransh 9364 
      oprot.writeMapEnd()
9365 
      oprot.writeFieldEnd()
1627 ankur.sing 9366 
    oprot.writeFieldStop()
9367 
    oprot.writeStructEnd()
9368 
 
3431 rajveer 9369 
  def validate(self):
9370 
    return
9371 
 
9372 
 
1627 ankur.sing 9373 
  def __repr__(self):
9374 
    L = ['%s=%r' % (key, value)
9375 
      for key, value in self.__dict__.iteritems()]
9376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9377 
 
9378 
  def __eq__(self, other):
9379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9380 
 
9381 
  def __ne__(self, other):
9382 
    return not (self == other)
9383 
 
3064 chandransh 9384 
class updateNonDeliveryReason_result:
1627 ankur.sing 9385 
  """
9386 
  Attributes:
3064 chandransh 9387 
   - ex
1627 ankur.sing 9388 
  """
9389 
 
9390 
  thrift_spec = (
3064 chandransh 9391 
    None, # 0
9392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9393 
  )
9394 
 
3064 chandransh 9395 
  def __init__(self, ex=None,):
9396 
    self.ex = ex
1627 ankur.sing 9397 
 
9398 
  def read(self, iprot):
9399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9401 
      return
9402 
    iprot.readStructBegin()
9403 
    while True:
9404 
      (fname, ftype, fid) = iprot.readFieldBegin()
9405 
      if ftype == TType.STOP:
9406 
        break
3064 chandransh 9407 
      if fid == 1:
9408 
        if ftype == TType.STRUCT:
9409 
          self.ex = TransactionServiceException()
9410 
          self.ex.read(iprot)
1627 ankur.sing 9411 
        else:
9412 
          iprot.skip(ftype)
9413 
      else:
9414 
        iprot.skip(ftype)
9415 
      iprot.readFieldEnd()
9416 
    iprot.readStructEnd()
9417 
 
9418 
  def write(self, oprot):
9419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9421 
      return
3064 chandransh 9422 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9423 
    if self.ex is not None:
3064 chandransh 9424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9425 
      self.ex.write(oprot)
1627 ankur.sing 9426 
      oprot.writeFieldEnd()
9427 
    oprot.writeFieldStop()
9428 
    oprot.writeStructEnd()
9429 
 
3431 rajveer 9430 
  def validate(self):
9431 
    return
9432 
 
9433 
 
1627 ankur.sing 9434 
  def __repr__(self):
9435 
    L = ['%s=%r' % (key, value)
9436 
      for key, value in self.__dict__.iteritems()]
9437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9438 
 
9439 
  def __eq__(self, other):
9440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9441 
 
9442 
  def __ne__(self, other):
9443 
    return not (self == other)
9444 
 
3064 chandransh 9445 
class getUndeliveredOrders_args:
1886 ankur.sing 9446 
  """
9447 
  Attributes:
3064 chandransh 9448 
   - providerId
9449 
   - warehouseId
1886 ankur.sing 9450 
  """
1627 ankur.sing 9451 
 
1886 ankur.sing 9452 
  thrift_spec = (
9453 
    None, # 0
3064 chandransh 9454 
    (1, TType.I64, 'providerId', None, None, ), # 1
9455 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9456 
  )
9457 
 
3064 chandransh 9458 
  def __init__(self, providerId=None, warehouseId=None,):
9459 
    self.providerId = providerId
9460 
    self.warehouseId = warehouseId
1886 ankur.sing 9461 
 
9462 
  def read(self, iprot):
9463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9465 
      return
9466 
    iprot.readStructBegin()
9467 
    while True:
9468 
      (fname, ftype, fid) = iprot.readFieldBegin()
9469 
      if ftype == TType.STOP:
9470 
        break
9471 
      if fid == 1:
9472 
        if ftype == TType.I64:
3064 chandransh 9473 
          self.providerId = iprot.readI64();
1886 ankur.sing 9474 
        else:
9475 
          iprot.skip(ftype)
3064 chandransh 9476 
      elif fid == 2:
9477 
        if ftype == TType.I64:
9478 
          self.warehouseId = iprot.readI64();
9479 
        else:
9480 
          iprot.skip(ftype)
1886 ankur.sing 9481 
      else:
9482 
        iprot.skip(ftype)
9483 
      iprot.readFieldEnd()
9484 
    iprot.readStructEnd()
9485 
 
9486 
  def write(self, oprot):
9487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9489 
      return
3064 chandransh 9490 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9491 
    if self.providerId is not None:
3064 chandransh 9492 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9493 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9494 
      oprot.writeFieldEnd()
3431 rajveer 9495 
    if self.warehouseId is not None:
3064 chandransh 9496 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9497 
      oprot.writeI64(self.warehouseId)
9498 
      oprot.writeFieldEnd()
1886 ankur.sing 9499 
    oprot.writeFieldStop()
9500 
    oprot.writeStructEnd()
9501 
 
3431 rajveer 9502 
  def validate(self):
9503 
    return
9504 
 
9505 
 
1886 ankur.sing 9506 
  def __repr__(self):
9507 
    L = ['%s=%r' % (key, value)
9508 
      for key, value in self.__dict__.iteritems()]
9509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9510 
 
9511 
  def __eq__(self, other):
9512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9513 
 
9514 
  def __ne__(self, other):
9515 
    return not (self == other)
9516 
 
3064 chandransh 9517 
class getUndeliveredOrders_result:
1886 ankur.sing 9518 
  """
9519 
  Attributes:
9520 
   - success
9521 
  """
9522 
 
9523 
  thrift_spec = (
9524 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9525 
  )
9526 
 
9527 
  def __init__(self, success=None,):
9528 
    self.success = success
9529 
 
9530 
  def read(self, iprot):
9531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9533 
      return
9534 
    iprot.readStructBegin()
9535 
    while True:
9536 
      (fname, ftype, fid) = iprot.readFieldBegin()
9537 
      if ftype == TType.STOP:
9538 
        break
9539 
      if fid == 0:
9540 
        if ftype == TType.LIST:
9541 
          self.success = []
4133 chandransh 9542 
          (_etype186, _size183) = iprot.readListBegin()
9543 
          for _i187 in xrange(_size183):
9544 
            _elem188 = Order()
9545 
            _elem188.read(iprot)
9546 
            self.success.append(_elem188)
1886 ankur.sing 9547 
          iprot.readListEnd()
9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      else:
9551 
        iprot.skip(ftype)
9552 
      iprot.readFieldEnd()
9553 
    iprot.readStructEnd()
9554 
 
9555 
  def write(self, oprot):
9556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9558 
      return
3064 chandransh 9559 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9560 
    if self.success is not None:
1886 ankur.sing 9561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9563 
      for iter189 in self.success:
9564 
        iter189.write(oprot)
1886 ankur.sing 9565 
      oprot.writeListEnd()
9566 
      oprot.writeFieldEnd()
9567 
    oprot.writeFieldStop()
9568 
    oprot.writeStructEnd()
9569 
 
3431 rajveer 9570 
  def validate(self):
9571 
    return
9572 
 
9573 
 
1886 ankur.sing 9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
2536 chandransh 9585 
class toggleDOAFlag_args:
9586 
  """
9587 
  Attributes:
9588 
   - orderId
9589 
  """
1886 ankur.sing 9590 
 
2536 chandransh 9591 
  thrift_spec = (
9592 
    None, # 0
9593 
    (1, TType.I64, 'orderId', None, None, ), # 1
9594 
  )
9595 
 
9596 
  def __init__(self, orderId=None,):
9597 
    self.orderId = orderId
9598 
 
9599 
  def read(self, iprot):
9600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9602 
      return
9603 
    iprot.readStructBegin()
9604 
    while True:
9605 
      (fname, ftype, fid) = iprot.readFieldBegin()
9606 
      if ftype == TType.STOP:
9607 
        break
9608 
      if fid == 1:
9609 
        if ftype == TType.I64:
9610 
          self.orderId = iprot.readI64();
9611 
        else:
9612 
          iprot.skip(ftype)
9613 
      else:
9614 
        iprot.skip(ftype)
9615 
      iprot.readFieldEnd()
9616 
    iprot.readStructEnd()
9617 
 
9618 
  def write(self, oprot):
9619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9621 
      return
9622 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9623 
    if self.orderId is not None:
2536 chandransh 9624 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9625 
      oprot.writeI64(self.orderId)
9626 
      oprot.writeFieldEnd()
9627 
    oprot.writeFieldStop()
9628 
    oprot.writeStructEnd()
9629 
 
3431 rajveer 9630 
  def validate(self):
9631 
    return
9632 
 
9633 
 
2536 chandransh 9634 
  def __repr__(self):
9635 
    L = ['%s=%r' % (key, value)
9636 
      for key, value in self.__dict__.iteritems()]
9637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9638 
 
9639 
  def __eq__(self, other):
9640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9641 
 
9642 
  def __ne__(self, other):
9643 
    return not (self == other)
9644 
 
9645 
class toggleDOAFlag_result:
9646 
  """
9647 
  Attributes:
9648 
   - success
9649 
   - ex
9650 
  """
9651 
 
9652 
  thrift_spec = (
9653 
    (0, TType.BOOL, 'success', None, None, ), # 0
9654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9655 
  )
9656 
 
9657 
  def __init__(self, success=None, ex=None,):
9658 
    self.success = success
9659 
    self.ex = ex
9660 
 
9661 
  def read(self, iprot):
9662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9664 
      return
9665 
    iprot.readStructBegin()
9666 
    while True:
9667 
      (fname, ftype, fid) = iprot.readFieldBegin()
9668 
      if ftype == TType.STOP:
9669 
        break
9670 
      if fid == 0:
9671 
        if ftype == TType.BOOL:
9672 
          self.success = iprot.readBool();
9673 
        else:
9674 
          iprot.skip(ftype)
9675 
      elif fid == 1:
9676 
        if ftype == TType.STRUCT:
9677 
          self.ex = TransactionServiceException()
9678 
          self.ex.read(iprot)
9679 
        else:
9680 
          iprot.skip(ftype)
9681 
      else:
9682 
        iprot.skip(ftype)
9683 
      iprot.readFieldEnd()
9684 
    iprot.readStructEnd()
9685 
 
9686 
  def write(self, oprot):
9687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9689 
      return
9690 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9691 
    if self.success is not None:
2536 chandransh 9692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9693 
      oprot.writeBool(self.success)
9694 
      oprot.writeFieldEnd()
3431 rajveer 9695 
    if self.ex is not None:
2536 chandransh 9696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9697 
      self.ex.write(oprot)
9698 
      oprot.writeFieldEnd()
9699 
    oprot.writeFieldStop()
9700 
    oprot.writeStructEnd()
9701 
 
3431 rajveer 9702 
  def validate(self):
9703 
    return
9704 
 
9705 
 
2536 chandransh 9706 
  def __repr__(self):
9707 
    L = ['%s=%r' % (key, value)
9708 
      for key, value in self.__dict__.iteritems()]
9709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9710 
 
9711 
  def __eq__(self, other):
9712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9713 
 
9714 
  def __ne__(self, other):
9715 
    return not (self == other)
9716 
 
9717 
class requestPickupNumber_args:
9718 
  """
9719 
  Attributes:
9720 
   - orderId
9721 
  """
9722 
 
9723 
  thrift_spec = (
9724 
    None, # 0
9725 
    (1, TType.I64, 'orderId', None, None, ), # 1
9726 
  )
9727 
 
9728 
  def __init__(self, orderId=None,):
9729 
    self.orderId = orderId
9730 
 
9731 
  def read(self, iprot):
9732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9734 
      return
9735 
    iprot.readStructBegin()
9736 
    while True:
9737 
      (fname, ftype, fid) = iprot.readFieldBegin()
9738 
      if ftype == TType.STOP:
9739 
        break
9740 
      if fid == 1:
9741 
        if ftype == TType.I64:
9742 
          self.orderId = iprot.readI64();
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
9754 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 9755 
    if self.orderId is not None:
2536 chandransh 9756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9757 
      oprot.writeI64(self.orderId)
9758 
      oprot.writeFieldEnd()
9759 
    oprot.writeFieldStop()
9760 
    oprot.writeStructEnd()
9761 
 
3431 rajveer 9762 
  def validate(self):
9763 
    return
9764 
 
9765 
 
2536 chandransh 9766 
  def __repr__(self):
9767 
    L = ['%s=%r' % (key, value)
9768 
      for key, value in self.__dict__.iteritems()]
9769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9770 
 
9771 
  def __eq__(self, other):
9772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9773 
 
9774 
  def __ne__(self, other):
9775 
    return not (self == other)
9776 
 
9777 
class requestPickupNumber_result:
9778 
  """
9779 
  Attributes:
9780 
   - success
9781 
   - ex
9782 
  """
9783 
 
9784 
  thrift_spec = (
9785 
    (0, TType.BOOL, 'success', None, None, ), # 0
9786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9787 
  )
9788 
 
9789 
  def __init__(self, success=None, ex=None,):
9790 
    self.success = success
9791 
    self.ex = ex
9792 
 
9793 
  def read(self, iprot):
9794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9796 
      return
9797 
    iprot.readStructBegin()
9798 
    while True:
9799 
      (fname, ftype, fid) = iprot.readFieldBegin()
9800 
      if ftype == TType.STOP:
9801 
        break
9802 
      if fid == 0:
9803 
        if ftype == TType.BOOL:
9804 
          self.success = iprot.readBool();
9805 
        else:
9806 
          iprot.skip(ftype)
9807 
      elif fid == 1:
9808 
        if ftype == TType.STRUCT:
9809 
          self.ex = TransactionServiceException()
9810 
          self.ex.read(iprot)
9811 
        else:
9812 
          iprot.skip(ftype)
9813 
      else:
9814 
        iprot.skip(ftype)
9815 
      iprot.readFieldEnd()
9816 
    iprot.readStructEnd()
9817 
 
9818 
  def write(self, oprot):
9819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9821 
      return
9822 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 9823 
    if self.success is not None:
2536 chandransh 9824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9825 
      oprot.writeBool(self.success)
9826 
      oprot.writeFieldEnd()
3431 rajveer 9827 
    if self.ex is not None:
2536 chandransh 9828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9829 
      self.ex.write(oprot)
9830 
      oprot.writeFieldEnd()
9831 
    oprot.writeFieldStop()
9832 
    oprot.writeStructEnd()
9833 
 
3431 rajveer 9834 
  def validate(self):
9835 
    return
9836 
 
9837 
 
2536 chandransh 9838 
  def __repr__(self):
9839 
    L = ['%s=%r' % (key, value)
9840 
      for key, value in self.__dict__.iteritems()]
9841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9842 
 
9843 
  def __eq__(self, other):
9844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9845 
 
9846 
  def __ne__(self, other):
9847 
    return not (self == other)
9848 
 
9849 
class authorizePickup_args:
9850 
  """
9851 
  Attributes:
9852 
   - orderId
9853 
   - pickupNumber
9854 
  """
9855 
 
9856 
  thrift_spec = (
9857 
    None, # 0
9858 
    (1, TType.I64, 'orderId', None, None, ), # 1
9859 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
9860 
  )
9861 
 
9862 
  def __init__(self, orderId=None, pickupNumber=None,):
9863 
    self.orderId = orderId
9864 
    self.pickupNumber = pickupNumber
9865 
 
9866 
  def read(self, iprot):
9867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9869 
      return
9870 
    iprot.readStructBegin()
9871 
    while True:
9872 
      (fname, ftype, fid) = iprot.readFieldBegin()
9873 
      if ftype == TType.STOP:
9874 
        break
9875 
      if fid == 1:
9876 
        if ftype == TType.I64:
9877 
          self.orderId = iprot.readI64();
9878 
        else:
9879 
          iprot.skip(ftype)
9880 
      elif fid == 2:
9881 
        if ftype == TType.STRING:
9882 
          self.pickupNumber = iprot.readString();
9883 
        else:
9884 
          iprot.skip(ftype)
9885 
      else:
9886 
        iprot.skip(ftype)
9887 
      iprot.readFieldEnd()
9888 
    iprot.readStructEnd()
9889 
 
9890 
  def write(self, oprot):
9891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9893 
      return
9894 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 9895 
    if self.orderId is not None:
2536 chandransh 9896 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9897 
      oprot.writeI64(self.orderId)
9898 
      oprot.writeFieldEnd()
3431 rajveer 9899 
    if self.pickupNumber is not None:
2536 chandransh 9900 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
9901 
      oprot.writeString(self.pickupNumber)
9902 
      oprot.writeFieldEnd()
9903 
    oprot.writeFieldStop()
9904 
    oprot.writeStructEnd()
9905 
 
3431 rajveer 9906 
  def validate(self):
9907 
    return
9908 
 
9909 
 
2536 chandransh 9910 
  def __repr__(self):
9911 
    L = ['%s=%r' % (key, value)
9912 
      for key, value in self.__dict__.iteritems()]
9913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9914 
 
9915 
  def __eq__(self, other):
9916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9917 
 
9918 
  def __ne__(self, other):
9919 
    return not (self == other)
9920 
 
9921 
class authorizePickup_result:
9922 
  """
9923 
  Attributes:
9924 
   - success
9925 
   - ex
9926 
  """
9927 
 
9928 
  thrift_spec = (
9929 
    (0, TType.BOOL, 'success', None, None, ), # 0
9930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9931 
  )
9932 
 
9933 
  def __init__(self, success=None, ex=None,):
9934 
    self.success = success
9935 
    self.ex = ex
9936 
 
9937 
  def read(self, iprot):
9938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9940 
      return
9941 
    iprot.readStructBegin()
9942 
    while True:
9943 
      (fname, ftype, fid) = iprot.readFieldBegin()
9944 
      if ftype == TType.STOP:
9945 
        break
9946 
      if fid == 0:
9947 
        if ftype == TType.BOOL:
9948 
          self.success = iprot.readBool();
9949 
        else:
9950 
          iprot.skip(ftype)
9951 
      elif fid == 1:
9952 
        if ftype == TType.STRUCT:
9953 
          self.ex = TransactionServiceException()
9954 
          self.ex.read(iprot)
9955 
        else:
9956 
          iprot.skip(ftype)
9957 
      else:
9958 
        iprot.skip(ftype)
9959 
      iprot.readFieldEnd()
9960 
    iprot.readStructEnd()
9961 
 
9962 
  def write(self, oprot):
9963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9965 
      return
9966 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 9967 
    if self.success is not None:
2536 chandransh 9968 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9969 
      oprot.writeBool(self.success)
9970 
      oprot.writeFieldEnd()
3431 rajveer 9971 
    if self.ex is not None:
2536 chandransh 9972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9973 
      self.ex.write(oprot)
9974 
      oprot.writeFieldEnd()
9975 
    oprot.writeFieldStop()
9976 
    oprot.writeStructEnd()
9977 
 
3431 rajveer 9978 
  def validate(self):
9979 
    return
9980 
 
9981 
 
2536 chandransh 9982 
  def __repr__(self):
9983 
    L = ['%s=%r' % (key, value)
9984 
      for key, value in self.__dict__.iteritems()]
9985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9986 
 
9987 
  def __eq__(self, other):
9988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9989 
 
9990 
  def __ne__(self, other):
9991 
    return not (self == other)
9992 
 
2764 chandransh 9993 
class markDoasAsPickedUp_args:
9994 
  """
9995 
  Attributes:
9996 
   - providerId
9997 
   - pickupDetails
9998 
  """
9999 
 
10000 
  thrift_spec = (
10001 
    None, # 0
10002 
    (1, TType.I64, 'providerId', None, None, ), # 1
10003 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10004 
  )
10005 
 
10006 
  def __init__(self, providerId=None, pickupDetails=None,):
10007 
    self.providerId = providerId
10008 
    self.pickupDetails = pickupDetails
10009 
 
10010 
  def read(self, iprot):
10011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10013 
      return
10014 
    iprot.readStructBegin()
10015 
    while True:
10016 
      (fname, ftype, fid) = iprot.readFieldBegin()
10017 
      if ftype == TType.STOP:
10018 
        break
10019 
      if fid == 1:
10020 
        if ftype == TType.I64:
10021 
          self.providerId = iprot.readI64();
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 2:
10025 
        if ftype == TType.MAP:
10026 
          self.pickupDetails = {}
4133 chandransh 10027 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10028 
          for _i194 in xrange(_size190):
10029 
            _key195 = iprot.readString();
10030 
            _val196 = iprot.readString();
10031 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10032 
          iprot.readMapEnd()
10033 
        else:
10034 
          iprot.skip(ftype)
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
10044 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10045 
    if self.providerId is not None:
2764 chandransh 10046 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10047 
      oprot.writeI64(self.providerId)
10048 
      oprot.writeFieldEnd()
3431 rajveer 10049 
    if self.pickupDetails is not None:
2764 chandransh 10050 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10051 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10052 
      for kiter197,viter198 in self.pickupDetails.items():
10053 
        oprot.writeString(kiter197)
10054 
        oprot.writeString(viter198)
2764 chandransh 10055 
      oprot.writeMapEnd()
10056 
      oprot.writeFieldEnd()
10057 
    oprot.writeFieldStop()
10058 
    oprot.writeStructEnd()
10059 
 
3431 rajveer 10060 
  def validate(self):
10061 
    return
10062 
 
10063 
 
2764 chandransh 10064 
  def __repr__(self):
10065 
    L = ['%s=%r' % (key, value)
10066 
      for key, value in self.__dict__.iteritems()]
10067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10068 
 
10069 
  def __eq__(self, other):
10070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10071 
 
10072 
  def __ne__(self, other):
10073 
    return not (self == other)
10074 
 
10075 
class markDoasAsPickedUp_result:
10076 
  """
10077 
  Attributes:
10078 
   - success
10079 
  """
10080 
 
10081 
  thrift_spec = (
10082 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10083 
  )
10084 
 
10085 
  def __init__(self, success=None,):
10086 
    self.success = success
10087 
 
10088 
  def read(self, iprot):
10089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10091 
      return
10092 
    iprot.readStructBegin()
10093 
    while True:
10094 
      (fname, ftype, fid) = iprot.readFieldBegin()
10095 
      if ftype == TType.STOP:
10096 
        break
10097 
      if fid == 0:
10098 
        if ftype == TType.LIST:
10099 
          self.success = []
4133 chandransh 10100 
          (_etype202, _size199) = iprot.readListBegin()
10101 
          for _i203 in xrange(_size199):
10102 
            _elem204 = Order()
10103 
            _elem204.read(iprot)
10104 
            self.success.append(_elem204)
2764 chandransh 10105 
          iprot.readListEnd()
10106 
        else:
10107 
          iprot.skip(ftype)
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
10117 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10118 
    if self.success is not None:
2764 chandransh 10119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10120 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10121 
      for iter205 in self.success:
10122 
        iter205.write(oprot)
2764 chandransh 10123 
      oprot.writeListEnd()
10124 
      oprot.writeFieldEnd()
10125 
    oprot.writeFieldStop()
10126 
    oprot.writeStructEnd()
10127 
 
3431 rajveer 10128 
  def validate(self):
10129 
    return
10130 
 
10131 
 
2764 chandransh 10132 
  def __repr__(self):
10133 
    L = ['%s=%r' % (key, value)
10134 
      for key, value in self.__dict__.iteritems()]
10135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10136 
 
10137 
  def __eq__(self, other):
10138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10139 
 
10140 
  def __ne__(self, other):
10141 
    return not (self == other)
10142 
 
2616 chandransh 10143 
class receiveReturn_args:
2591 chandransh 10144 
  """
10145 
  Attributes:
10146 
   - orderId
10147 
  """
2536 chandransh 10148 
 
2591 chandransh 10149 
  thrift_spec = (
10150 
    None, # 0
10151 
    (1, TType.I64, 'orderId', None, None, ), # 1
10152 
  )
10153 
 
10154 
  def __init__(self, orderId=None,):
10155 
    self.orderId = orderId
10156 
 
10157 
  def read(self, iprot):
10158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10160 
      return
10161 
    iprot.readStructBegin()
10162 
    while True:
10163 
      (fname, ftype, fid) = iprot.readFieldBegin()
10164 
      if ftype == TType.STOP:
10165 
        break
10166 
      if fid == 1:
10167 
        if ftype == TType.I64:
10168 
          self.orderId = iprot.readI64();
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      else:
10172 
        iprot.skip(ftype)
10173 
      iprot.readFieldEnd()
10174 
    iprot.readStructEnd()
10175 
 
10176 
  def write(self, oprot):
10177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10179 
      return
2616 chandransh 10180 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10181 
    if self.orderId is not None:
2591 chandransh 10182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10183 
      oprot.writeI64(self.orderId)
10184 
      oprot.writeFieldEnd()
10185 
    oprot.writeFieldStop()
10186 
    oprot.writeStructEnd()
10187 
 
3431 rajveer 10188 
  def validate(self):
10189 
    return
10190 
 
10191 
 
2591 chandransh 10192 
  def __repr__(self):
10193 
    L = ['%s=%r' % (key, value)
10194 
      for key, value in self.__dict__.iteritems()]
10195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10196 
 
10197 
  def __eq__(self, other):
10198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10199 
 
10200 
  def __ne__(self, other):
10201 
    return not (self == other)
10202 
 
2616 chandransh 10203 
class receiveReturn_result:
2591 chandransh 10204 
  """
10205 
  Attributes:
10206 
   - success
10207 
   - ex
10208 
  """
10209 
 
10210 
  thrift_spec = (
10211 
    (0, TType.BOOL, 'success', None, None, ), # 0
10212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10213 
  )
10214 
 
10215 
  def __init__(self, success=None, ex=None,):
10216 
    self.success = success
10217 
    self.ex = ex
10218 
 
10219 
  def read(self, iprot):
10220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10222 
      return
10223 
    iprot.readStructBegin()
10224 
    while True:
10225 
      (fname, ftype, fid) = iprot.readFieldBegin()
10226 
      if ftype == TType.STOP:
10227 
        break
10228 
      if fid == 0:
10229 
        if ftype == TType.BOOL:
10230 
          self.success = iprot.readBool();
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      elif fid == 1:
10234 
        if ftype == TType.STRUCT:
10235 
          self.ex = TransactionServiceException()
10236 
          self.ex.read(iprot)
10237 
        else:
10238 
          iprot.skip(ftype)
10239 
      else:
10240 
        iprot.skip(ftype)
10241 
      iprot.readFieldEnd()
10242 
    iprot.readStructEnd()
10243 
 
10244 
  def write(self, oprot):
10245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10247 
      return
2616 chandransh 10248 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10249 
    if self.success is not None:
2591 chandransh 10250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10251 
      oprot.writeBool(self.success)
10252 
      oprot.writeFieldEnd()
3431 rajveer 10253 
    if self.ex is not None:
2591 chandransh 10254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10255 
      self.ex.write(oprot)
10256 
      oprot.writeFieldEnd()
10257 
    oprot.writeFieldStop()
10258 
    oprot.writeStructEnd()
10259 
 
3431 rajveer 10260 
  def validate(self):
10261 
    return
10262 
 
10263 
 
2591 chandransh 10264 
  def __repr__(self):
10265 
    L = ['%s=%r' % (key, value)
10266 
      for key, value in self.__dict__.iteritems()]
10267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10268 
 
10269 
  def __eq__(self, other):
10270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10271 
 
10272 
  def __ne__(self, other):
10273 
    return not (self == other)
10274 
 
10275 
class validateDoa_args:
10276 
  """
10277 
  Attributes:
10278 
   - orderId
10279 
   - isValid
10280 
  """
10281 
 
10282 
  thrift_spec = (
10283 
    None, # 0
10284 
    (1, TType.I64, 'orderId', None, None, ), # 1
10285 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10286 
  )
10287 
 
10288 
  def __init__(self, orderId=None, isValid=None,):
10289 
    self.orderId = orderId
10290 
    self.isValid = isValid
10291 
 
10292 
  def read(self, iprot):
10293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10295 
      return
10296 
    iprot.readStructBegin()
10297 
    while True:
10298 
      (fname, ftype, fid) = iprot.readFieldBegin()
10299 
      if ftype == TType.STOP:
10300 
        break
10301 
      if fid == 1:
10302 
        if ftype == TType.I64:
10303 
          self.orderId = iprot.readI64();
10304 
        else:
10305 
          iprot.skip(ftype)
10306 
      elif fid == 2:
10307 
        if ftype == TType.BOOL:
10308 
          self.isValid = iprot.readBool();
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
10320 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10321 
    if self.orderId is not None:
2591 chandransh 10322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10323 
      oprot.writeI64(self.orderId)
10324 
      oprot.writeFieldEnd()
3431 rajveer 10325 
    if self.isValid is not None:
2591 chandransh 10326 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10327 
      oprot.writeBool(self.isValid)
10328 
      oprot.writeFieldEnd()
10329 
    oprot.writeFieldStop()
10330 
    oprot.writeStructEnd()
10331 
 
3431 rajveer 10332 
  def validate(self):
10333 
    return
10334 
 
10335 
 
2591 chandransh 10336 
  def __repr__(self):
10337 
    L = ['%s=%r' % (key, value)
10338 
      for key, value in self.__dict__.iteritems()]
10339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10340 
 
10341 
  def __eq__(self, other):
10342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10343 
 
10344 
  def __ne__(self, other):
10345 
    return not (self == other)
10346 
 
10347 
class validateDoa_result:
10348 
  """
10349 
  Attributes:
10350 
   - success
10351 
   - ex
10352 
  """
10353 
 
10354 
  thrift_spec = (
10355 
    (0, TType.BOOL, 'success', None, None, ), # 0
10356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10357 
  )
10358 
 
10359 
  def __init__(self, success=None, ex=None,):
10360 
    self.success = success
10361 
    self.ex = ex
10362 
 
10363 
  def read(self, iprot):
10364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10366 
      return
10367 
    iprot.readStructBegin()
10368 
    while True:
10369 
      (fname, ftype, fid) = iprot.readFieldBegin()
10370 
      if ftype == TType.STOP:
10371 
        break
10372 
      if fid == 0:
10373 
        if ftype == TType.BOOL:
10374 
          self.success = iprot.readBool();
10375 
        else:
10376 
          iprot.skip(ftype)
10377 
      elif fid == 1:
10378 
        if ftype == TType.STRUCT:
10379 
          self.ex = TransactionServiceException()
10380 
          self.ex.read(iprot)
10381 
        else:
10382 
          iprot.skip(ftype)
10383 
      else:
10384 
        iprot.skip(ftype)
10385 
      iprot.readFieldEnd()
10386 
    iprot.readStructEnd()
10387 
 
10388 
  def write(self, oprot):
10389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10391 
      return
10392 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10393 
    if self.success is not None:
2591 chandransh 10394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10395 
      oprot.writeBool(self.success)
10396 
      oprot.writeFieldEnd()
3431 rajveer 10397 
    if self.ex is not None:
2591 chandransh 10398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10399 
      self.ex.write(oprot)
10400 
      oprot.writeFieldEnd()
10401 
    oprot.writeFieldStop()
10402 
    oprot.writeStructEnd()
10403 
 
3431 rajveer 10404 
  def validate(self):
10405 
    return
10406 
 
10407 
 
2591 chandransh 10408 
  def __repr__(self):
10409 
    L = ['%s=%r' % (key, value)
10410 
      for key, value in self.__dict__.iteritems()]
10411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10412 
 
10413 
  def __eq__(self, other):
10414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10415 
 
10416 
  def __ne__(self, other):
10417 
    return not (self == other)
10418 
 
2616 chandransh 10419 
class reshipOrder_args:
10420 
  """
10421 
  Attributes:
10422 
   - orderId
10423 
  """
2591 chandransh 10424 
 
2616 chandransh 10425 
  thrift_spec = (
10426 
    None, # 0
10427 
    (1, TType.I64, 'orderId', None, None, ), # 1
10428 
  )
10429 
 
10430 
  def __init__(self, orderId=None,):
10431 
    self.orderId = orderId
10432 
 
10433 
  def read(self, iprot):
10434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10436 
      return
10437 
    iprot.readStructBegin()
10438 
    while True:
10439 
      (fname, ftype, fid) = iprot.readFieldBegin()
10440 
      if ftype == TType.STOP:
10441 
        break
10442 
      if fid == 1:
10443 
        if ftype == TType.I64:
10444 
          self.orderId = iprot.readI64();
10445 
        else:
10446 
          iprot.skip(ftype)
10447 
      else:
10448 
        iprot.skip(ftype)
10449 
      iprot.readFieldEnd()
10450 
    iprot.readStructEnd()
10451 
 
10452 
  def write(self, oprot):
10453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10455 
      return
10456 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10457 
    if self.orderId is not None:
2616 chandransh 10458 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10459 
      oprot.writeI64(self.orderId)
10460 
      oprot.writeFieldEnd()
10461 
    oprot.writeFieldStop()
10462 
    oprot.writeStructEnd()
10463 
 
3431 rajveer 10464 
  def validate(self):
10465 
    return
10466 
 
10467 
 
2616 chandransh 10468 
  def __repr__(self):
10469 
    L = ['%s=%r' % (key, value)
10470 
      for key, value in self.__dict__.iteritems()]
10471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10472 
 
10473 
  def __eq__(self, other):
10474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10475 
 
10476 
  def __ne__(self, other):
10477 
    return not (self == other)
10478 
 
10479 
class reshipOrder_result:
10480 
  """
10481 
  Attributes:
10482 
   - success
10483 
   - ex
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    (0, TType.I64, 'success', None, None, ), # 0
10488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10489 
  )
10490 
 
10491 
  def __init__(self, success=None, ex=None,):
10492 
    self.success = success
10493 
    self.ex = ex
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 0:
10505 
        if ftype == TType.I64:
10506 
          self.success = iprot.readI64();
10507 
        else:
10508 
          iprot.skip(ftype)
10509 
      elif fid == 1:
10510 
        if ftype == TType.STRUCT:
10511 
          self.ex = TransactionServiceException()
10512 
          self.ex.read(iprot)
10513 
        else:
10514 
          iprot.skip(ftype)
10515 
      else:
10516 
        iprot.skip(ftype)
10517 
      iprot.readFieldEnd()
10518 
    iprot.readStructEnd()
10519 
 
10520 
  def write(self, oprot):
10521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10523 
      return
10524 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10525 
    if self.success is not None:
2616 chandransh 10526 
      oprot.writeFieldBegin('success', TType.I64, 0)
10527 
      oprot.writeI64(self.success)
10528 
      oprot.writeFieldEnd()
3431 rajveer 10529 
    if self.ex is not None:
2616 chandransh 10530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10531 
      self.ex.write(oprot)
10532 
      oprot.writeFieldEnd()
10533 
    oprot.writeFieldStop()
10534 
    oprot.writeStructEnd()
10535 
 
3431 rajveer 10536 
  def validate(self):
10537 
    return
10538 
 
10539 
 
2616 chandransh 10540 
  def __repr__(self):
10541 
    L = ['%s=%r' % (key, value)
10542 
      for key, value in self.__dict__.iteritems()]
10543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10544 
 
10545 
  def __eq__(self, other):
10546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10547 
 
10548 
  def __ne__(self, other):
10549 
    return not (self == other)
10550 
 
10551 
class refundOrder_args:
10552 
  """
10553 
  Attributes:
10554 
   - orderId
3226 chandransh 10555 
   - refundedBy
10556 
   - reason
2616 chandransh 10557 
  """
10558 
 
10559 
  thrift_spec = (
10560 
    None, # 0
10561 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10562 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10563 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10564 
  )
10565 
 
3226 chandransh 10566 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10567 
    self.orderId = orderId
3226 chandransh 10568 
    self.refundedBy = refundedBy
10569 
    self.reason = reason
2616 chandransh 10570 
 
10571 
  def read(self, iprot):
10572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10574 
      return
10575 
    iprot.readStructBegin()
10576 
    while True:
10577 
      (fname, ftype, fid) = iprot.readFieldBegin()
10578 
      if ftype == TType.STOP:
10579 
        break
10580 
      if fid == 1:
10581 
        if ftype == TType.I64:
10582 
          self.orderId = iprot.readI64();
10583 
        else:
10584 
          iprot.skip(ftype)
3226 chandransh 10585 
      elif fid == 2:
10586 
        if ftype == TType.STRING:
10587 
          self.refundedBy = iprot.readString();
10588 
        else:
10589 
          iprot.skip(ftype)
10590 
      elif fid == 3:
10591 
        if ftype == TType.STRING:
10592 
          self.reason = iprot.readString();
10593 
        else:
10594 
          iprot.skip(ftype)
2616 chandransh 10595 
      else:
10596 
        iprot.skip(ftype)
10597 
      iprot.readFieldEnd()
10598 
    iprot.readStructEnd()
10599 
 
10600 
  def write(self, oprot):
10601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10603 
      return
10604 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10605 
    if self.orderId is not None:
2616 chandransh 10606 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10607 
      oprot.writeI64(self.orderId)
10608 
      oprot.writeFieldEnd()
3431 rajveer 10609 
    if self.refundedBy is not None:
3226 chandransh 10610 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10611 
      oprot.writeString(self.refundedBy)
10612 
      oprot.writeFieldEnd()
3431 rajveer 10613 
    if self.reason is not None:
3226 chandransh 10614 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10615 
      oprot.writeString(self.reason)
10616 
      oprot.writeFieldEnd()
2616 chandransh 10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
3431 rajveer 10620 
  def validate(self):
10621 
    return
10622 
 
10623 
 
2616 chandransh 10624 
  def __repr__(self):
10625 
    L = ['%s=%r' % (key, value)
10626 
      for key, value in self.__dict__.iteritems()]
10627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10628 
 
10629 
  def __eq__(self, other):
10630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10631 
 
10632 
  def __ne__(self, other):
10633 
    return not (self == other)
10634 
 
10635 
class refundOrder_result:
10636 
  """
10637 
  Attributes:
10638 
   - success
10639 
   - ex
10640 
  """
10641 
 
10642 
  thrift_spec = (
10643 
    (0, TType.BOOL, 'success', None, None, ), # 0
10644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10645 
  )
10646 
 
10647 
  def __init__(self, success=None, ex=None,):
10648 
    self.success = success
10649 
    self.ex = ex
10650 
 
10651 
  def read(self, iprot):
10652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10654 
      return
10655 
    iprot.readStructBegin()
10656 
    while True:
10657 
      (fname, ftype, fid) = iprot.readFieldBegin()
10658 
      if ftype == TType.STOP:
10659 
        break
10660 
      if fid == 0:
10661 
        if ftype == TType.BOOL:
10662 
          self.success = iprot.readBool();
10663 
        else:
10664 
          iprot.skip(ftype)
10665 
      elif fid == 1:
10666 
        if ftype == TType.STRUCT:
10667 
          self.ex = TransactionServiceException()
10668 
          self.ex.read(iprot)
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      else:
10672 
        iprot.skip(ftype)
10673 
      iprot.readFieldEnd()
10674 
    iprot.readStructEnd()
10675 
 
10676 
  def write(self, oprot):
10677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10679 
      return
10680 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10681 
    if self.success is not None:
2616 chandransh 10682 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10683 
      oprot.writeBool(self.success)
10684 
      oprot.writeFieldEnd()
3431 rajveer 10685 
    if self.ex is not None:
2616 chandransh 10686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10687 
      self.ex.write(oprot)
10688 
      oprot.writeFieldEnd()
10689 
    oprot.writeFieldStop()
10690 
    oprot.writeStructEnd()
10691 
 
3431 rajveer 10692 
  def validate(self):
10693 
    return
10694 
 
10695 
 
2616 chandransh 10696 
  def __repr__(self):
10697 
    L = ['%s=%r' % (key, value)
10698 
      for key, value in self.__dict__.iteritems()]
10699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10700 
 
10701 
  def __eq__(self, other):
10702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10703 
 
10704 
  def __ne__(self, other):
10705 
    return not (self == other)
10706 
 
2690 chandransh 10707 
class getReturnOrders_args:
10708 
  """
10709 
  Attributes:
10710 
   - warehouseId
10711 
   - fromDate
10712 
   - toDate
10713 
  """
2616 chandransh 10714 
 
2690 chandransh 10715 
  thrift_spec = (
10716 
    None, # 0
10717 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10718 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10719 
    (3, TType.I64, 'toDate', None, None, ), # 3
10720 
  )
10721 
 
10722 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10723 
    self.warehouseId = warehouseId
10724 
    self.fromDate = fromDate
10725 
    self.toDate = toDate
10726 
 
10727 
  def read(self, iprot):
10728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10730 
      return
10731 
    iprot.readStructBegin()
10732 
    while True:
10733 
      (fname, ftype, fid) = iprot.readFieldBegin()
10734 
      if ftype == TType.STOP:
10735 
        break
10736 
      if fid == 1:
10737 
        if ftype == TType.I64:
10738 
          self.warehouseId = iprot.readI64();
10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      elif fid == 2:
10742 
        if ftype == TType.I64:
10743 
          self.fromDate = iprot.readI64();
10744 
        else:
10745 
          iprot.skip(ftype)
10746 
      elif fid == 3:
10747 
        if ftype == TType.I64:
10748 
          self.toDate = iprot.readI64();
10749 
        else:
10750 
          iprot.skip(ftype)
10751 
      else:
10752 
        iprot.skip(ftype)
10753 
      iprot.readFieldEnd()
10754 
    iprot.readStructEnd()
10755 
 
10756 
  def write(self, oprot):
10757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10759 
      return
10760 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 10761 
    if self.warehouseId is not None:
2690 chandransh 10762 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10763 
      oprot.writeI64(self.warehouseId)
10764 
      oprot.writeFieldEnd()
3431 rajveer 10765 
    if self.fromDate is not None:
2690 chandransh 10766 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
10767 
      oprot.writeI64(self.fromDate)
10768 
      oprot.writeFieldEnd()
3431 rajveer 10769 
    if self.toDate is not None:
2690 chandransh 10770 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
10771 
      oprot.writeI64(self.toDate)
10772 
      oprot.writeFieldEnd()
10773 
    oprot.writeFieldStop()
10774 
    oprot.writeStructEnd()
10775 
 
3431 rajveer 10776 
  def validate(self):
10777 
    return
10778 
 
10779 
 
2690 chandransh 10780 
  def __repr__(self):
10781 
    L = ['%s=%r' % (key, value)
10782 
      for key, value in self.__dict__.iteritems()]
10783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10784 
 
10785 
  def __eq__(self, other):
10786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10787 
 
10788 
  def __ne__(self, other):
10789 
    return not (self == other)
10790 
 
10791 
class getReturnOrders_result:
10792 
  """
10793 
  Attributes:
10794 
   - success
10795 
  """
10796 
 
10797 
  thrift_spec = (
10798 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
10799 
  )
10800 
 
10801 
  def __init__(self, success=None,):
10802 
    self.success = success
10803 
 
10804 
  def read(self, iprot):
10805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10807 
      return
10808 
    iprot.readStructBegin()
10809 
    while True:
10810 
      (fname, ftype, fid) = iprot.readFieldBegin()
10811 
      if ftype == TType.STOP:
10812 
        break
10813 
      if fid == 0:
10814 
        if ftype == TType.LIST:
10815 
          self.success = []
4133 chandransh 10816 
          (_etype209, _size206) = iprot.readListBegin()
10817 
          for _i210 in xrange(_size206):
10818 
            _elem211 = ReturnOrder()
10819 
            _elem211.read(iprot)
10820 
            self.success.append(_elem211)
2690 chandransh 10821 
          iprot.readListEnd()
10822 
        else:
10823 
          iprot.skip(ftype)
10824 
      else:
10825 
        iprot.skip(ftype)
10826 
      iprot.readFieldEnd()
10827 
    iprot.readStructEnd()
10828 
 
10829 
  def write(self, oprot):
10830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10832 
      return
10833 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 10834 
    if self.success is not None:
2690 chandransh 10835 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10836 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10837 
      for iter212 in self.success:
10838 
        iter212.write(oprot)
2690 chandransh 10839 
      oprot.writeListEnd()
10840 
      oprot.writeFieldEnd()
10841 
    oprot.writeFieldStop()
10842 
    oprot.writeStructEnd()
10843 
 
3431 rajveer 10844 
  def validate(self):
10845 
    return
10846 
 
10847 
 
2690 chandransh 10848 
  def __repr__(self):
10849 
    L = ['%s=%r' % (key, value)
10850 
      for key, value in self.__dict__.iteritems()]
10851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10852 
 
10853 
  def __eq__(self, other):
10854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10855 
 
10856 
  def __ne__(self, other):
10857 
    return not (self == other)
10858 
 
2700 chandransh 10859 
class getReturnOrder_args:
10860 
  """
10861 
  Attributes:
10862 
   - id
10863 
  """
10864 
 
10865 
  thrift_spec = (
10866 
    None, # 0
10867 
    (1, TType.I64, 'id', None, None, ), # 1
10868 
  )
10869 
 
10870 
  def __init__(self, id=None,):
10871 
    self.id = id
10872 
 
10873 
  def read(self, iprot):
10874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10876 
      return
10877 
    iprot.readStructBegin()
10878 
    while True:
10879 
      (fname, ftype, fid) = iprot.readFieldBegin()
10880 
      if ftype == TType.STOP:
10881 
        break
10882 
      if fid == 1:
10883 
        if ftype == TType.I64:
10884 
          self.id = iprot.readI64();
10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      else:
10888 
        iprot.skip(ftype)
10889 
      iprot.readFieldEnd()
10890 
    iprot.readStructEnd()
10891 
 
10892 
  def write(self, oprot):
10893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10895 
      return
10896 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 10897 
    if self.id is not None:
2700 chandransh 10898 
      oprot.writeFieldBegin('id', TType.I64, 1)
10899 
      oprot.writeI64(self.id)
10900 
      oprot.writeFieldEnd()
10901 
    oprot.writeFieldStop()
10902 
    oprot.writeStructEnd()
10903 
 
3431 rajveer 10904 
  def validate(self):
10905 
    return
10906 
 
10907 
 
2700 chandransh 10908 
  def __repr__(self):
10909 
    L = ['%s=%r' % (key, value)
10910 
      for key, value in self.__dict__.iteritems()]
10911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10912 
 
10913 
  def __eq__(self, other):
10914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10915 
 
10916 
  def __ne__(self, other):
10917 
    return not (self == other)
10918 
 
10919 
class getReturnOrder_result:
10920 
  """
10921 
  Attributes:
10922 
   - success
10923 
   - ex
10924 
  """
10925 
 
10926 
  thrift_spec = (
10927 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
10928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10929 
  )
10930 
 
10931 
  def __init__(self, success=None, ex=None,):
10932 
    self.success = success
10933 
    self.ex = ex
10934 
 
10935 
  def read(self, iprot):
10936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10938 
      return
10939 
    iprot.readStructBegin()
10940 
    while True:
10941 
      (fname, ftype, fid) = iprot.readFieldBegin()
10942 
      if ftype == TType.STOP:
10943 
        break
10944 
      if fid == 0:
10945 
        if ftype == TType.STRUCT:
10946 
          self.success = ReturnOrder()
10947 
          self.success.read(iprot)
10948 
        else:
10949 
          iprot.skip(ftype)
10950 
      elif fid == 1:
10951 
        if ftype == TType.STRUCT:
10952 
          self.ex = TransactionServiceException()
10953 
          self.ex.read(iprot)
10954 
        else:
10955 
          iprot.skip(ftype)
10956 
      else:
10957 
        iprot.skip(ftype)
10958 
      iprot.readFieldEnd()
10959 
    iprot.readStructEnd()
10960 
 
10961 
  def write(self, oprot):
10962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10964 
      return
10965 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 10966 
    if self.success is not None:
2700 chandransh 10967 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10968 
      self.success.write(oprot)
10969 
      oprot.writeFieldEnd()
3431 rajveer 10970 
    if self.ex is not None:
2700 chandransh 10971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10972 
      self.ex.write(oprot)
10973 
      oprot.writeFieldEnd()
10974 
    oprot.writeFieldStop()
10975 
    oprot.writeStructEnd()
10976 
 
3431 rajveer 10977 
  def validate(self):
10978 
    return
10979 
 
10980 
 
2700 chandransh 10981 
  def __repr__(self):
10982 
    L = ['%s=%r' % (key, value)
10983 
      for key, value in self.__dict__.iteritems()]
10984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10985 
 
10986 
  def __eq__(self, other):
10987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10988 
 
10989 
  def __ne__(self, other):
10990 
    return not (self == other)
10991 
 
2690 chandransh 10992 
class processReturn_args:
10993 
  """
10994 
  Attributes:
10995 
   - returnOrderId
10996 
  """
10997 
 
10998 
  thrift_spec = (
10999 
    None, # 0
11000 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11001 
  )
11002 
 
11003 
  def __init__(self, returnOrderId=None,):
11004 
    self.returnOrderId = returnOrderId
11005 
 
11006 
  def read(self, iprot):
11007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11009 
      return
11010 
    iprot.readStructBegin()
11011 
    while True:
11012 
      (fname, ftype, fid) = iprot.readFieldBegin()
11013 
      if ftype == TType.STOP:
11014 
        break
11015 
      if fid == 1:
11016 
        if ftype == TType.I64:
11017 
          self.returnOrderId = iprot.readI64();
11018 
        else:
11019 
          iprot.skip(ftype)
11020 
      else:
11021 
        iprot.skip(ftype)
11022 
      iprot.readFieldEnd()
11023 
    iprot.readStructEnd()
11024 
 
11025 
  def write(self, oprot):
11026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11028 
      return
11029 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11030 
    if self.returnOrderId is not None:
2690 chandransh 11031 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11032 
      oprot.writeI64(self.returnOrderId)
11033 
      oprot.writeFieldEnd()
11034 
    oprot.writeFieldStop()
11035 
    oprot.writeStructEnd()
11036 
 
3431 rajveer 11037 
  def validate(self):
11038 
    return
11039 
 
11040 
 
2690 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 
 
11052 
class processReturn_result:
11053 
  """
11054 
  Attributes:
11055 
   - ex
11056 
  """
11057 
 
11058 
  thrift_spec = (
11059 
    None, # 0
11060 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11061 
  )
11062 
 
11063 
  def __init__(self, ex=None,):
11064 
    self.ex = ex
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.STRUCT:
11077 
          self.ex = TransactionServiceException()
11078 
          self.ex.read(iprot)
11079 
        else:
11080 
          iprot.skip(ftype)
11081 
      else:
11082 
        iprot.skip(ftype)
11083 
      iprot.readFieldEnd()
11084 
    iprot.readStructEnd()
11085 
 
11086 
  def write(self, oprot):
11087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11089 
      return
11090 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11091 
    if self.ex is not None:
2690 chandransh 11092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11093 
      self.ex.write(oprot)
11094 
      oprot.writeFieldEnd()
11095 
    oprot.writeFieldStop()
11096 
    oprot.writeStructEnd()
11097 
 
3431 rajveer 11098 
  def validate(self):
11099 
    return
11100 
 
11101 
 
2690 chandransh 11102 
  def __repr__(self):
11103 
    L = ['%s=%r' % (key, value)
11104 
      for key, value in self.__dict__.iteritems()]
11105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11106 
 
11107 
  def __eq__(self, other):
11108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11109 
 
11110 
  def __ne__(self, other):
11111 
    return not (self == other)
11112 
 
2819 chandransh 11113 
class createPurchaseOrder_args:
11114 
  """
11115 
  Attributes:
11116 
   - warehouseId
11117 
  """
2690 chandransh 11118 
 
2819 chandransh 11119 
  thrift_spec = (
11120 
    None, # 0
11121 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11122 
  )
11123 
 
11124 
  def __init__(self, warehouseId=None,):
11125 
    self.warehouseId = warehouseId
11126 
 
11127 
  def read(self, iprot):
11128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11130 
      return
11131 
    iprot.readStructBegin()
11132 
    while True:
11133 
      (fname, ftype, fid) = iprot.readFieldBegin()
11134 
      if ftype == TType.STOP:
11135 
        break
11136 
      if fid == 1:
11137 
        if ftype == TType.I64:
11138 
          self.warehouseId = iprot.readI64();
11139 
        else:
11140 
          iprot.skip(ftype)
11141 
      else:
11142 
        iprot.skip(ftype)
11143 
      iprot.readFieldEnd()
11144 
    iprot.readStructEnd()
11145 
 
11146 
  def write(self, oprot):
11147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11149 
      return
11150 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11151 
    if self.warehouseId is not None:
2819 chandransh 11152 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11153 
      oprot.writeI64(self.warehouseId)
11154 
      oprot.writeFieldEnd()
11155 
    oprot.writeFieldStop()
11156 
    oprot.writeStructEnd()
11157 
 
3431 rajveer 11158 
  def validate(self):
11159 
    return
11160 
 
11161 
 
2819 chandransh 11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
11173 
class createPurchaseOrder_result:
11174 
  """
11175 
  Attributes:
11176 
   - success
11177 
   - ex
11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    (0, TType.I64, 'success', None, None, ), # 0
11182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11183 
  )
11184 
 
11185 
  def __init__(self, success=None, ex=None,):
11186 
    self.success = success
11187 
    self.ex = ex
11188 
 
11189 
  def read(self, iprot):
11190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11192 
      return
11193 
    iprot.readStructBegin()
11194 
    while True:
11195 
      (fname, ftype, fid) = iprot.readFieldBegin()
11196 
      if ftype == TType.STOP:
11197 
        break
11198 
      if fid == 0:
11199 
        if ftype == TType.I64:
11200 
          self.success = iprot.readI64();
11201 
        else:
11202 
          iprot.skip(ftype)
11203 
      elif fid == 1:
11204 
        if ftype == TType.STRUCT:
11205 
          self.ex = TransactionServiceException()
11206 
          self.ex.read(iprot)
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
11218 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11219 
    if self.success is not None:
2819 chandransh 11220 
      oprot.writeFieldBegin('success', TType.I64, 0)
11221 
      oprot.writeI64(self.success)
11222 
      oprot.writeFieldEnd()
3431 rajveer 11223 
    if self.ex is not None:
2819 chandransh 11224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11225 
      self.ex.write(oprot)
11226 
      oprot.writeFieldEnd()
11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
3431 rajveer 11230 
  def validate(self):
11231 
    return
11232 
 
11233 
 
2819 chandransh 11234 
  def __repr__(self):
11235 
    L = ['%s=%r' % (key, value)
11236 
      for key, value in self.__dict__.iteritems()]
11237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11238 
 
11239 
  def __eq__(self, other):
11240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11241 
 
11242 
  def __ne__(self, other):
11243 
    return not (self == other)
3451 chandransh 11244 
 
11245 
class updateWeight_args:
11246 
  """
11247 
  Attributes:
11248 
   - orderId
11249 
   - weight
11250 
  """
11251 
 
11252 
  thrift_spec = (
11253 
    None, # 0
11254 
    (1, TType.I64, 'orderId', None, None, ), # 1
11255 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11256 
  )
11257 
 
11258 
  def __init__(self, orderId=None, weight=None,):
11259 
    self.orderId = orderId
11260 
    self.weight = weight
11261 
 
11262 
  def read(self, iprot):
11263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11265 
      return
11266 
    iprot.readStructBegin()
11267 
    while True:
11268 
      (fname, ftype, fid) = iprot.readFieldBegin()
11269 
      if ftype == TType.STOP:
11270 
        break
11271 
      if fid == 1:
11272 
        if ftype == TType.I64:
11273 
          self.orderId = iprot.readI64();
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      elif fid == 2:
11277 
        if ftype == TType.DOUBLE:
11278 
          self.weight = iprot.readDouble();
11279 
        else:
11280 
          iprot.skip(ftype)
11281 
      else:
11282 
        iprot.skip(ftype)
11283 
      iprot.readFieldEnd()
11284 
    iprot.readStructEnd()
11285 
 
11286 
  def write(self, oprot):
11287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11289 
      return
11290 
    oprot.writeStructBegin('updateWeight_args')
11291 
    if self.orderId is not None:
11292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11293 
      oprot.writeI64(self.orderId)
11294 
      oprot.writeFieldEnd()
11295 
    if self.weight is not None:
11296 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11297 
      oprot.writeDouble(self.weight)
11298 
      oprot.writeFieldEnd()
11299 
    oprot.writeFieldStop()
11300 
    oprot.writeStructEnd()
11301 
 
11302 
  def validate(self):
11303 
    return
11304 
 
11305 
 
11306 
  def __repr__(self):
11307 
    L = ['%s=%r' % (key, value)
11308 
      for key, value in self.__dict__.iteritems()]
11309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11310 
 
11311 
  def __eq__(self, other):
11312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11313 
 
11314 
  def __ne__(self, other):
11315 
    return not (self == other)
11316 
 
11317 
class updateWeight_result:
11318 
  """
11319 
  Attributes:
11320 
   - success
11321 
   - ex
11322 
  """
11323 
 
11324 
  thrift_spec = (
11325 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11327 
  )
11328 
 
11329 
  def __init__(self, success=None, ex=None,):
11330 
    self.success = success
11331 
    self.ex = ex
11332 
 
11333 
  def read(self, iprot):
11334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11336 
      return
11337 
    iprot.readStructBegin()
11338 
    while True:
11339 
      (fname, ftype, fid) = iprot.readFieldBegin()
11340 
      if ftype == TType.STOP:
11341 
        break
11342 
      if fid == 0:
11343 
        if ftype == TType.STRUCT:
11344 
          self.success = Order()
11345 
          self.success.read(iprot)
11346 
        else:
11347 
          iprot.skip(ftype)
11348 
      elif fid == 1:
11349 
        if ftype == TType.STRUCT:
11350 
          self.ex = TransactionServiceException()
11351 
          self.ex.read(iprot)
11352 
        else:
11353 
          iprot.skip(ftype)
11354 
      else:
11355 
        iprot.skip(ftype)
11356 
      iprot.readFieldEnd()
11357 
    iprot.readStructEnd()
11358 
 
11359 
  def write(self, oprot):
11360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11362 
      return
11363 
    oprot.writeStructBegin('updateWeight_result')
11364 
    if self.success is not None:
11365 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11366 
      self.success.write(oprot)
11367 
      oprot.writeFieldEnd()
11368 
    if self.ex is not None:
11369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11370 
      self.ex.write(oprot)
11371 
      oprot.writeFieldEnd()
11372 
    oprot.writeFieldStop()
11373 
    oprot.writeStructEnd()
11374 
 
11375 
  def validate(self):
11376 
    return
11377 
 
11378 
 
11379 
  def __repr__(self):
11380 
    L = ['%s=%r' % (key, value)
11381 
      for key, value in self.__dict__.iteritems()]
11382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11383 
 
11384 
  def __eq__(self, other):
11385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11386 
 
11387 
  def __ne__(self, other):
11388 
    return not (self == other)
3469 chandransh 11389 
 
11390 
class changeItem_args:
11391 
  """
11392 
  Attributes:
11393 
   - orderId
11394 
   - itemId
11395 
  """
11396 
 
11397 
  thrift_spec = (
11398 
    None, # 0
11399 
    (1, TType.I64, 'orderId', None, None, ), # 1
11400 
    (2, TType.I64, 'itemId', None, None, ), # 2
11401 
  )
11402 
 
11403 
  def __init__(self, orderId=None, itemId=None,):
11404 
    self.orderId = orderId
11405 
    self.itemId = itemId
11406 
 
11407 
  def read(self, iprot):
11408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11410 
      return
11411 
    iprot.readStructBegin()
11412 
    while True:
11413 
      (fname, ftype, fid) = iprot.readFieldBegin()
11414 
      if ftype == TType.STOP:
11415 
        break
11416 
      if fid == 1:
11417 
        if ftype == TType.I64:
11418 
          self.orderId = iprot.readI64();
11419 
        else:
11420 
          iprot.skip(ftype)
11421 
      elif fid == 2:
11422 
        if ftype == TType.I64:
11423 
          self.itemId = iprot.readI64();
11424 
        else:
11425 
          iprot.skip(ftype)
11426 
      else:
11427 
        iprot.skip(ftype)
11428 
      iprot.readFieldEnd()
11429 
    iprot.readStructEnd()
11430 
 
11431 
  def write(self, oprot):
11432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11434 
      return
11435 
    oprot.writeStructBegin('changeItem_args')
11436 
    if self.orderId is not None:
11437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11438 
      oprot.writeI64(self.orderId)
11439 
      oprot.writeFieldEnd()
11440 
    if self.itemId is not None:
11441 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11442 
      oprot.writeI64(self.itemId)
11443 
      oprot.writeFieldEnd()
11444 
    oprot.writeFieldStop()
11445 
    oprot.writeStructEnd()
11446 
 
11447 
  def validate(self):
11448 
    return
11449 
 
11450 
 
11451 
  def __repr__(self):
11452 
    L = ['%s=%r' % (key, value)
11453 
      for key, value in self.__dict__.iteritems()]
11454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11455 
 
11456 
  def __eq__(self, other):
11457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11458 
 
11459 
  def __ne__(self, other):
11460 
    return not (self == other)
11461 
 
11462 
class changeItem_result:
11463 
  """
11464 
  Attributes:
11465 
   - success
11466 
   - ex
11467 
  """
11468 
 
11469 
  thrift_spec = (
11470 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11472 
  )
11473 
 
11474 
  def __init__(self, success=None, ex=None,):
11475 
    self.success = success
11476 
    self.ex = ex
11477 
 
11478 
  def read(self, iprot):
11479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11481 
      return
11482 
    iprot.readStructBegin()
11483 
    while True:
11484 
      (fname, ftype, fid) = iprot.readFieldBegin()
11485 
      if ftype == TType.STOP:
11486 
        break
11487 
      if fid == 0:
11488 
        if ftype == TType.STRUCT:
11489 
          self.success = Order()
11490 
          self.success.read(iprot)
11491 
        else:
11492 
          iprot.skip(ftype)
11493 
      elif fid == 1:
11494 
        if ftype == TType.STRUCT:
11495 
          self.ex = TransactionServiceException()
11496 
          self.ex.read(iprot)
11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      else:
11500 
        iprot.skip(ftype)
11501 
      iprot.readFieldEnd()
11502 
    iprot.readStructEnd()
11503 
 
11504 
  def write(self, oprot):
11505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11507 
      return
11508 
    oprot.writeStructBegin('changeItem_result')
11509 
    if self.success is not None:
11510 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11511 
      self.success.write(oprot)
11512 
      oprot.writeFieldEnd()
11513 
    if self.ex is not None:
11514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11515 
      self.ex.write(oprot)
11516 
      oprot.writeFieldEnd()
11517 
    oprot.writeFieldStop()
11518 
    oprot.writeStructEnd()
11519 
 
11520 
  def validate(self):
11521 
    return
11522 
 
11523 
 
11524 
  def __repr__(self):
11525 
    L = ['%s=%r' % (key, value)
11526 
      for key, value in self.__dict__.iteritems()]
11527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11528 
 
11529 
  def __eq__(self, other):
11530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11531 
 
11532 
  def __ne__(self, other):
11533 
    return not (self == other)
11534 
 
11535 
class shiftToWarehouse_args:
11536 
  """
11537 
  Attributes:
11538 
   - orderId
11539 
   - warehouseId
11540 
  """
11541 
 
11542 
  thrift_spec = (
11543 
    None, # 0
11544 
    (1, TType.I64, 'orderId', None, None, ), # 1
11545 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11546 
  )
11547 
 
11548 
  def __init__(self, orderId=None, warehouseId=None,):
11549 
    self.orderId = orderId
11550 
    self.warehouseId = warehouseId
11551 
 
11552 
  def read(self, iprot):
11553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11555 
      return
11556 
    iprot.readStructBegin()
11557 
    while True:
11558 
      (fname, ftype, fid) = iprot.readFieldBegin()
11559 
      if ftype == TType.STOP:
11560 
        break
11561 
      if fid == 1:
11562 
        if ftype == TType.I64:
11563 
          self.orderId = iprot.readI64();
11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      elif fid == 2:
11567 
        if ftype == TType.I64:
11568 
          self.warehouseId = iprot.readI64();
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      else:
11572 
        iprot.skip(ftype)
11573 
      iprot.readFieldEnd()
11574 
    iprot.readStructEnd()
11575 
 
11576 
  def write(self, oprot):
11577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11579 
      return
11580 
    oprot.writeStructBegin('shiftToWarehouse_args')
11581 
    if self.orderId is not None:
11582 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11583 
      oprot.writeI64(self.orderId)
11584 
      oprot.writeFieldEnd()
11585 
    if self.warehouseId is not None:
11586 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11587 
      oprot.writeI64(self.warehouseId)
11588 
      oprot.writeFieldEnd()
11589 
    oprot.writeFieldStop()
11590 
    oprot.writeStructEnd()
11591 
 
11592 
  def validate(self):
11593 
    return
11594 
 
11595 
 
11596 
  def __repr__(self):
11597 
    L = ['%s=%r' % (key, value)
11598 
      for key, value in self.__dict__.iteritems()]
11599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11600 
 
11601 
  def __eq__(self, other):
11602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11603 
 
11604 
  def __ne__(self, other):
11605 
    return not (self == other)
11606 
 
11607 
class shiftToWarehouse_result:
11608 
  """
11609 
  Attributes:
11610 
   - success
11611 
   - ex
11612 
  """
11613 
 
11614 
  thrift_spec = (
11615 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11617 
  )
11618 
 
11619 
  def __init__(self, success=None, ex=None,):
11620 
    self.success = success
11621 
    self.ex = ex
11622 
 
11623 
  def read(self, iprot):
11624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11626 
      return
11627 
    iprot.readStructBegin()
11628 
    while True:
11629 
      (fname, ftype, fid) = iprot.readFieldBegin()
11630 
      if ftype == TType.STOP:
11631 
        break
11632 
      if fid == 0:
11633 
        if ftype == TType.STRUCT:
11634 
          self.success = Order()
11635 
          self.success.read(iprot)
11636 
        else:
11637 
          iprot.skip(ftype)
11638 
      elif fid == 1:
11639 
        if ftype == TType.STRUCT:
11640 
          self.ex = TransactionServiceException()
11641 
          self.ex.read(iprot)
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('shiftToWarehouse_result')
11654 
    if self.success is not None:
11655 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11656 
      self.success.write(oprot)
11657 
      oprot.writeFieldEnd()
11658 
    if self.ex is not None:
11659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11660 
      self.ex.write(oprot)
11661 
      oprot.writeFieldEnd()
11662 
    oprot.writeFieldStop()
11663 
    oprot.writeStructEnd()
11664 
 
11665 
  def validate(self):
11666 
    return
11667 
 
11668 
 
11669 
  def __repr__(self):
11670 
    L = ['%s=%r' % (key, value)
11671 
      for key, value in self.__dict__.iteritems()]
11672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11673 
 
11674 
  def __eq__(self, other):
11675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11676 
 
11677 
  def __ne__(self, other):
11678 
    return not (self == other)
3553 chandransh 11679 
 
11680 
class addDelayReason_args:
11681 
  """
11682 
  Attributes:
11683 
   - orderId
11684 
   - delayReason
3986 chandransh 11685 
   - furtherDelay
3553 chandransh 11686 
  """
11687 
 
11688 
  thrift_spec = (
11689 
    None, # 0
11690 
    (1, TType.I64, 'orderId', None, None, ), # 1
11691 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11692 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11693 
  )
11694 
 
3986 chandransh 11695 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 11696 
    self.orderId = orderId
11697 
    self.delayReason = delayReason
3986 chandransh 11698 
    self.furtherDelay = furtherDelay
3553 chandransh 11699 
 
11700 
  def read(self, iprot):
11701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11703 
      return
11704 
    iprot.readStructBegin()
11705 
    while True:
11706 
      (fname, ftype, fid) = iprot.readFieldBegin()
11707 
      if ftype == TType.STOP:
11708 
        break
11709 
      if fid == 1:
11710 
        if ftype == TType.I64:
11711 
          self.orderId = iprot.readI64();
11712 
        else:
11713 
          iprot.skip(ftype)
11714 
      elif fid == 2:
11715 
        if ftype == TType.I32:
11716 
          self.delayReason = iprot.readI32();
11717 
        else:
11718 
          iprot.skip(ftype)
3986 chandransh 11719 
      elif fid == 3:
11720 
        if ftype == TType.I64:
11721 
          self.furtherDelay = iprot.readI64();
11722 
        else:
11723 
          iprot.skip(ftype)
3553 chandransh 11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
11733 
    oprot.writeStructBegin('addDelayReason_args')
11734 
    if self.orderId is not None:
11735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11736 
      oprot.writeI64(self.orderId)
11737 
      oprot.writeFieldEnd()
11738 
    if self.delayReason is not None:
11739 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11740 
      oprot.writeI32(self.delayReason)
11741 
      oprot.writeFieldEnd()
3986 chandransh 11742 
    if self.furtherDelay is not None:
11743 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
11744 
      oprot.writeI64(self.furtherDelay)
11745 
      oprot.writeFieldEnd()
3553 chandransh 11746 
    oprot.writeFieldStop()
11747 
    oprot.writeStructEnd()
11748 
 
11749 
  def validate(self):
11750 
    return
11751 
 
11752 
 
11753 
  def __repr__(self):
11754 
    L = ['%s=%r' % (key, value)
11755 
      for key, value in self.__dict__.iteritems()]
11756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11757 
 
11758 
  def __eq__(self, other):
11759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11760 
 
11761 
  def __ne__(self, other):
11762 
    return not (self == other)
11763 
 
11764 
class addDelayReason_result:
11765 
  """
11766 
  Attributes:
11767 
   - success
11768 
   - ex
11769 
  """
11770 
 
11771 
  thrift_spec = (
11772 
    (0, TType.BOOL, 'success', None, None, ), # 0
11773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11774 
  )
11775 
 
11776 
  def __init__(self, success=None, ex=None,):
11777 
    self.success = success
11778 
    self.ex = ex
11779 
 
11780 
  def read(self, iprot):
11781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11783 
      return
11784 
    iprot.readStructBegin()
11785 
    while True:
11786 
      (fname, ftype, fid) = iprot.readFieldBegin()
11787 
      if ftype == TType.STOP:
11788 
        break
11789 
      if fid == 0:
11790 
        if ftype == TType.BOOL:
11791 
          self.success = iprot.readBool();
11792 
        else:
11793 
          iprot.skip(ftype)
11794 
      elif fid == 1:
11795 
        if ftype == TType.STRUCT:
11796 
          self.ex = TransactionServiceException()
11797 
          self.ex.read(iprot)
11798 
        else:
11799 
          iprot.skip(ftype)
11800 
      else:
11801 
        iprot.skip(ftype)
11802 
      iprot.readFieldEnd()
11803 
    iprot.readStructEnd()
11804 
 
11805 
  def write(self, oprot):
11806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11808 
      return
11809 
    oprot.writeStructBegin('addDelayReason_result')
11810 
    if self.success is not None:
11811 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11812 
      oprot.writeBool(self.success)
11813 
      oprot.writeFieldEnd()
11814 
    if self.ex is not None:
11815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11816 
      self.ex.write(oprot)
11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
3956 chandransh 11835 
 
11836 
class reconcileCodCollection_args:
11837 
  """
11838 
  Attributes:
11839 
   - collectedAmountMap
11840 
   - xferBy
11841 
   - xferTxnId
11842 
   - xferDate
11843 
  """
11844 
 
11845 
  thrift_spec = (
11846 
    None, # 0
11847 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
11848 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
11849 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
11850 
    (4, TType.I64, 'xferDate', None, None, ), # 4
11851 
  )
11852 
 
11853 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
11854 
    self.collectedAmountMap = collectedAmountMap
11855 
    self.xferBy = xferBy
11856 
    self.xferTxnId = xferTxnId
11857 
    self.xferDate = xferDate
11858 
 
11859 
  def read(self, iprot):
11860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11862 
      return
11863 
    iprot.readStructBegin()
11864 
    while True:
11865 
      (fname, ftype, fid) = iprot.readFieldBegin()
11866 
      if ftype == TType.STOP:
11867 
        break
11868 
      if fid == 1:
11869 
        if ftype == TType.MAP:
11870 
          self.collectedAmountMap = {}
4133 chandransh 11871 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
11872 
          for _i217 in xrange(_size213):
11873 
            _key218 = iprot.readString();
11874 
            _val219 = iprot.readDouble();
11875 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 11876 
          iprot.readMapEnd()
11877 
        else:
11878 
          iprot.skip(ftype)
11879 
      elif fid == 2:
11880 
        if ftype == TType.STRING:
11881 
          self.xferBy = iprot.readString();
11882 
        else:
11883 
          iprot.skip(ftype)
11884 
      elif fid == 3:
11885 
        if ftype == TType.STRING:
11886 
          self.xferTxnId = iprot.readString();
11887 
        else:
11888 
          iprot.skip(ftype)
11889 
      elif fid == 4:
11890 
        if ftype == TType.I64:
11891 
          self.xferDate = iprot.readI64();
11892 
        else:
11893 
          iprot.skip(ftype)
11894 
      else:
11895 
        iprot.skip(ftype)
11896 
      iprot.readFieldEnd()
11897 
    iprot.readStructEnd()
11898 
 
11899 
  def write(self, oprot):
11900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11902 
      return
11903 
    oprot.writeStructBegin('reconcileCodCollection_args')
11904 
    if self.collectedAmountMap is not None:
11905 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
11906 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 11907 
      for kiter220,viter221 in self.collectedAmountMap.items():
11908 
        oprot.writeString(kiter220)
11909 
        oprot.writeDouble(viter221)
3956 chandransh 11910 
      oprot.writeMapEnd()
11911 
      oprot.writeFieldEnd()
11912 
    if self.xferBy is not None:
11913 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
11914 
      oprot.writeString(self.xferBy)
11915 
      oprot.writeFieldEnd()
11916 
    if self.xferTxnId is not None:
11917 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
11918 
      oprot.writeString(self.xferTxnId)
11919 
      oprot.writeFieldEnd()
11920 
    if self.xferDate is not None:
11921 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
11922 
      oprot.writeI64(self.xferDate)
11923 
      oprot.writeFieldEnd()
11924 
    oprot.writeFieldStop()
11925 
    oprot.writeStructEnd()
11926 
 
11927 
  def validate(self):
11928 
    return
11929 
 
11930 
 
11931 
  def __repr__(self):
11932 
    L = ['%s=%r' % (key, value)
11933 
      for key, value in self.__dict__.iteritems()]
11934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11935 
 
11936 
  def __eq__(self, other):
11937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11938 
 
11939 
  def __ne__(self, other):
11940 
    return not (self == other)
11941 
 
11942 
class reconcileCodCollection_result:
11943 
  """
11944 
  Attributes:
11945 
   - success
11946 
   - ex
11947 
  """
11948 
 
11949 
  thrift_spec = (
11950 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
11951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11952 
  )
11953 
 
11954 
  def __init__(self, success=None, ex=None,):
11955 
    self.success = success
11956 
    self.ex = ex
11957 
 
11958 
  def read(self, iprot):
11959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11961 
      return
11962 
    iprot.readStructBegin()
11963 
    while True:
11964 
      (fname, ftype, fid) = iprot.readFieldBegin()
11965 
      if ftype == TType.STOP:
11966 
        break
11967 
      if fid == 0:
11968 
        if ftype == TType.MAP:
11969 
          self.success = {}
4133 chandransh 11970 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
11971 
          for _i226 in xrange(_size222):
11972 
            _key227 = iprot.readString();
11973 
            _val228 = iprot.readString();
11974 
            self.success[_key227] = _val228
3956 chandransh 11975 
          iprot.readMapEnd()
11976 
        else:
11977 
          iprot.skip(ftype)
11978 
      elif fid == 1:
11979 
        if ftype == TType.STRUCT:
11980 
          self.ex = TransactionServiceException()
11981 
          self.ex.read(iprot)
11982 
        else:
11983 
          iprot.skip(ftype)
11984 
      else:
11985 
        iprot.skip(ftype)
11986 
      iprot.readFieldEnd()
11987 
    iprot.readStructEnd()
11988 
 
11989 
  def write(self, oprot):
11990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11992 
      return
11993 
    oprot.writeStructBegin('reconcileCodCollection_result')
11994 
    if self.success is not None:
11995 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11996 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 11997 
      for kiter229,viter230 in self.success.items():
11998 
        oprot.writeString(kiter229)
11999 
        oprot.writeString(viter230)
3956 chandransh 12000 
      oprot.writeMapEnd()
12001 
      oprot.writeFieldEnd()
12002 
    if self.ex is not None:
12003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12004 
      self.ex.write(oprot)
12005 
      oprot.writeFieldEnd()
12006 
    oprot.writeFieldStop()
12007 
    oprot.writeStructEnd()
12008 
 
12009 
  def validate(self):
12010 
    return
12011 
 
12012 
 
12013 
  def __repr__(self):
12014 
    L = ['%s=%r' % (key, value)
12015 
      for key, value in self.__dict__.iteritems()]
12016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12017 
 
12018 
  def __eq__(self, other):
12019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12020 
 
12021 
  def __ne__(self, other):
12022 
    return not (self == other)
4008 mandeep.dh 12023 
 
12024 
class getTransactionsRequiringExtraProcessing_args:
12025 
  """
12026 
  Attributes:
12027 
   - category
12028 
  """
12029 
 
12030 
  thrift_spec = (
12031 
    None, # 0
12032 
    (1, TType.I32, 'category', None, None, ), # 1
12033 
  )
12034 
 
12035 
  def __init__(self, category=None,):
12036 
    self.category = category
12037 
 
12038 
  def read(self, iprot):
12039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12041 
      return
12042 
    iprot.readStructBegin()
12043 
    while True:
12044 
      (fname, ftype, fid) = iprot.readFieldBegin()
12045 
      if ftype == TType.STOP:
12046 
        break
12047 
      if fid == 1:
12048 
        if ftype == TType.I32:
12049 
          self.category = iprot.readI32();
12050 
        else:
12051 
          iprot.skip(ftype)
12052 
      else:
12053 
        iprot.skip(ftype)
12054 
      iprot.readFieldEnd()
12055 
    iprot.readStructEnd()
12056 
 
12057 
  def write(self, oprot):
12058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12060 
      return
12061 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12062 
    if self.category is not None:
12063 
      oprot.writeFieldBegin('category', TType.I32, 1)
12064 
      oprot.writeI32(self.category)
12065 
      oprot.writeFieldEnd()
12066 
    oprot.writeFieldStop()
12067 
    oprot.writeStructEnd()
12068 
 
12069 
  def validate(self):
12070 
    return
12071 
 
12072 
 
12073 
  def __repr__(self):
12074 
    L = ['%s=%r' % (key, value)
12075 
      for key, value in self.__dict__.iteritems()]
12076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12077 
 
12078 
  def __eq__(self, other):
12079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12080 
 
12081 
  def __ne__(self, other):
12082 
    return not (self == other)
12083 
 
12084 
class getTransactionsRequiringExtraProcessing_result:
12085 
  """
12086 
  Attributes:
12087 
   - success
12088 
  """
12089 
 
12090 
  thrift_spec = (
12091 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12092 
  )
12093 
 
12094 
  def __init__(self, success=None,):
12095 
    self.success = success
12096 
 
12097 
  def read(self, iprot):
12098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12100 
      return
12101 
    iprot.readStructBegin()
12102 
    while True:
12103 
      (fname, ftype, fid) = iprot.readFieldBegin()
12104 
      if ftype == TType.STOP:
12105 
        break
12106 
      if fid == 0:
12107 
        if ftype == TType.LIST:
12108 
          self.success = []
4133 chandransh 12109 
          (_etype234, _size231) = iprot.readListBegin()
12110 
          for _i235 in xrange(_size231):
12111 
            _elem236 = iprot.readI64();
12112 
            self.success.append(_elem236)
4008 mandeep.dh 12113 
          iprot.readListEnd()
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      else:
12117 
        iprot.skip(ftype)
12118 
      iprot.readFieldEnd()
12119 
    iprot.readStructEnd()
12120 
 
12121 
  def write(self, oprot):
12122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12124 
      return
12125 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12126 
    if self.success is not None:
12127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12128 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12129 
      for iter237 in self.success:
12130 
        oprot.writeI64(iter237)
4008 mandeep.dh 12131 
      oprot.writeListEnd()
12132 
      oprot.writeFieldEnd()
12133 
    oprot.writeFieldStop()
12134 
    oprot.writeStructEnd()
12135 
 
12136 
  def validate(self):
12137 
    return
12138 
 
12139 
 
12140 
  def __repr__(self):
12141 
    L = ['%s=%r' % (key, value)
12142 
      for key, value in self.__dict__.iteritems()]
12143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12144 
 
12145 
  def __eq__(self, other):
12146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12147 
 
12148 
  def __ne__(self, other):
12149 
    return not (self == other)
12150 
 
12151 
class markTransactionAsProcessed_args:
12152 
  """
12153 
  Attributes:
12154 
   - transactionId
12155 
   - category
12156 
  """
12157 
 
12158 
  thrift_spec = (
12159 
    None, # 0
12160 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12161 
    (2, TType.I32, 'category', None, None, ), # 2
12162 
  )
12163 
 
12164 
  def __init__(self, transactionId=None, category=None,):
12165 
    self.transactionId = transactionId
12166 
    self.category = category
12167 
 
12168 
  def read(self, iprot):
12169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12171 
      return
12172 
    iprot.readStructBegin()
12173 
    while True:
12174 
      (fname, ftype, fid) = iprot.readFieldBegin()
12175 
      if ftype == TType.STOP:
12176 
        break
12177 
      if fid == 1:
12178 
        if ftype == TType.I64:
12179 
          self.transactionId = iprot.readI64();
12180 
        else:
12181 
          iprot.skip(ftype)
12182 
      elif fid == 2:
12183 
        if ftype == TType.I32:
12184 
          self.category = iprot.readI32();
12185 
        else:
12186 
          iprot.skip(ftype)
12187 
      else:
12188 
        iprot.skip(ftype)
12189 
      iprot.readFieldEnd()
12190 
    iprot.readStructEnd()
12191 
 
12192 
  def write(self, oprot):
12193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12195 
      return
12196 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12197 
    if self.transactionId is not None:
12198 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12199 
      oprot.writeI64(self.transactionId)
12200 
      oprot.writeFieldEnd()
12201 
    if self.category is not None:
12202 
      oprot.writeFieldBegin('category', TType.I32, 2)
12203 
      oprot.writeI32(self.category)
12204 
      oprot.writeFieldEnd()
12205 
    oprot.writeFieldStop()
12206 
    oprot.writeStructEnd()
12207 
 
12208 
  def validate(self):
12209 
    return
12210 
 
12211 
 
12212 
  def __repr__(self):
12213 
    L = ['%s=%r' % (key, value)
12214 
      for key, value in self.__dict__.iteritems()]
12215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12216 
 
12217 
  def __eq__(self, other):
12218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12219 
 
12220 
  def __ne__(self, other):
12221 
    return not (self == other)
12222 
 
12223 
class markTransactionAsProcessed_result:
12224 
 
12225 
  thrift_spec = (
12226 
  )
12227 
 
12228 
  def read(self, iprot):
12229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12231 
      return
12232 
    iprot.readStructBegin()
12233 
    while True:
12234 
      (fname, ftype, fid) = iprot.readFieldBegin()
12235 
      if ftype == TType.STOP:
12236 
        break
12237 
      else:
12238 
        iprot.skip(ftype)
12239 
      iprot.readFieldEnd()
12240 
    iprot.readStructEnd()
12241 
 
12242 
  def write(self, oprot):
12243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12245 
      return
12246 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12247 
    oprot.writeFieldStop()
12248 
    oprot.writeStructEnd()
12249 
 
12250 
  def validate(self):
12251 
    return
12252 
 
12253 
 
12254 
  def __repr__(self):
12255 
    L = ['%s=%r' % (key, value)
12256 
      for key, value in self.__dict__.iteritems()]
12257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12258 
 
12259 
  def __eq__(self, other):
12260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12261 
 
12262 
  def __ne__(self, other):
12263 
    return not (self == other)
4018 chandransh 12264 
 
12265 
class getItemWiseRiskyOrdersCount_args:
12266 
 
12267 
  thrift_spec = (
12268 
  )
12269 
 
12270 
  def read(self, iprot):
12271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12273 
      return
12274 
    iprot.readStructBegin()
12275 
    while True:
12276 
      (fname, ftype, fid) = iprot.readFieldBegin()
12277 
      if ftype == TType.STOP:
12278 
        break
12279 
      else:
12280 
        iprot.skip(ftype)
12281 
      iprot.readFieldEnd()
12282 
    iprot.readStructEnd()
12283 
 
12284 
  def write(self, oprot):
12285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12287 
      return
12288 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
12307 
class getItemWiseRiskyOrdersCount_result:
12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
  """
12312 
 
12313 
  thrift_spec = (
12314 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12315 
  )
12316 
 
12317 
  def __init__(self, success=None,):
12318 
    self.success = success
12319 
 
12320 
  def read(self, iprot):
12321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12323 
      return
12324 
    iprot.readStructBegin()
12325 
    while True:
12326 
      (fname, ftype, fid) = iprot.readFieldBegin()
12327 
      if ftype == TType.STOP:
12328 
        break
12329 
      if fid == 0:
12330 
        if ftype == TType.MAP:
12331 
          self.success = {}
4133 chandransh 12332 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12333 
          for _i242 in xrange(_size238):
12334 
            _key243 = iprot.readI64();
12335 
            _val244 = iprot.readI64();
12336 
            self.success[_key243] = _val244
4018 chandransh 12337 
          iprot.readMapEnd()
12338 
        else:
12339 
          iprot.skip(ftype)
12340 
      else:
12341 
        iprot.skip(ftype)
12342 
      iprot.readFieldEnd()
12343 
    iprot.readStructEnd()
12344 
 
12345 
  def write(self, oprot):
12346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12348 
      return
12349 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12350 
    if self.success is not None:
12351 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12352 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12353 
      for kiter245,viter246 in self.success.items():
12354 
        oprot.writeI64(kiter245)
12355 
        oprot.writeI64(viter246)
4018 chandransh 12356 
      oprot.writeMapEnd()
12357 
      oprot.writeFieldEnd()
12358 
    oprot.writeFieldStop()
12359 
    oprot.writeStructEnd()
12360 
 
12361 
  def validate(self):
12362 
    return
12363 
 
12364 
 
12365 
  def __repr__(self):
12366 
    L = ['%s=%r' % (key, value)
12367 
      for key, value in self.__dict__.iteritems()]
12368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12369 
 
12370 
  def __eq__(self, other):
12371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12372 
 
12373 
  def __ne__(self, other):
12374 
    return not (self == other)
4247 rajveer 12375 
 
12376 
class markOrderCancellationRequestReceived_args:
12377 
  """
12378 
  Attributes:
12379 
   - orderId
12380 
  """
12381 
 
12382 
  thrift_spec = (
12383 
    None, # 0
12384 
    (1, TType.I64, 'orderId', None, None, ), # 1
12385 
  )
12386 
 
12387 
  def __init__(self, orderId=None,):
12388 
    self.orderId = orderId
12389 
 
12390 
  def read(self, iprot):
12391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12393 
      return
12394 
    iprot.readStructBegin()
12395 
    while True:
12396 
      (fname, ftype, fid) = iprot.readFieldBegin()
12397 
      if ftype == TType.STOP:
12398 
        break
12399 
      if fid == 1:
12400 
        if ftype == TType.I64:
12401 
          self.orderId = iprot.readI64();
12402 
        else:
12403 
          iprot.skip(ftype)
12404 
      else:
12405 
        iprot.skip(ftype)
12406 
      iprot.readFieldEnd()
12407 
    iprot.readStructEnd()
12408 
 
12409 
  def write(self, oprot):
12410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12412 
      return
12413 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12414 
    if self.orderId is not None:
12415 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12416 
      oprot.writeI64(self.orderId)
12417 
      oprot.writeFieldEnd()
12418 
    oprot.writeFieldStop()
12419 
    oprot.writeStructEnd()
12420 
 
12421 
  def validate(self):
12422 
    return
12423 
 
12424 
 
12425 
  def __repr__(self):
12426 
    L = ['%s=%r' % (key, value)
12427 
      for key, value in self.__dict__.iteritems()]
12428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12429 
 
12430 
  def __eq__(self, other):
12431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12432 
 
12433 
  def __ne__(self, other):
12434 
    return not (self == other)
12435 
 
12436 
class markOrderCancellationRequestReceived_result:
12437 
  """
12438 
  Attributes:
12439 
   - ex
12440 
  """
12441 
 
12442 
  thrift_spec = (
12443 
    None, # 0
12444 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12445 
  )
12446 
 
12447 
  def __init__(self, ex=None,):
12448 
    self.ex = ex
12449 
 
12450 
  def read(self, iprot):
12451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12453 
      return
12454 
    iprot.readStructBegin()
12455 
    while True:
12456 
      (fname, ftype, fid) = iprot.readFieldBegin()
12457 
      if ftype == TType.STOP:
12458 
        break
12459 
      if fid == 1:
12460 
        if ftype == TType.STRUCT:
12461 
          self.ex = TransactionServiceException()
12462 
          self.ex.read(iprot)
12463 
        else:
12464 
          iprot.skip(ftype)
12465 
      else:
12466 
        iprot.skip(ftype)
12467 
      iprot.readFieldEnd()
12468 
    iprot.readStructEnd()
12469 
 
12470 
  def write(self, oprot):
12471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12473 
      return
12474 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12475 
    if self.ex is not None:
12476 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12477 
      self.ex.write(oprot)
12478 
      oprot.writeFieldEnd()
12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def validate(self):
12483 
    return
12484 
 
12485 
 
12486 
  def __repr__(self):
12487 
    L = ['%s=%r' % (key, value)
12488 
      for key, value in self.__dict__.iteritems()]
12489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12490 
 
12491 
  def __eq__(self, other):
12492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12493 
 
12494 
  def __ne__(self, other):
12495 
    return not (self == other)
12496 
 
12497 
class markOrderCancellationRequestConfirmed_args:
12498 
  """
12499 
  Attributes:
12500 
   - orderId
12501 
  """
12502 
 
12503 
  thrift_spec = (
12504 
    None, # 0
12505 
    (1, TType.I64, 'orderId', None, None, ), # 1
12506 
  )
12507 
 
12508 
  def __init__(self, orderId=None,):
12509 
    self.orderId = orderId
12510 
 
12511 
  def read(self, iprot):
12512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12514 
      return
12515 
    iprot.readStructBegin()
12516 
    while True:
12517 
      (fname, ftype, fid) = iprot.readFieldBegin()
12518 
      if ftype == TType.STOP:
12519 
        break
12520 
      if fid == 1:
12521 
        if ftype == TType.I64:
12522 
          self.orderId = iprot.readI64();
12523 
        else:
12524 
          iprot.skip(ftype)
12525 
      else:
12526 
        iprot.skip(ftype)
12527 
      iprot.readFieldEnd()
12528 
    iprot.readStructEnd()
12529 
 
12530 
  def write(self, oprot):
12531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12533 
      return
12534 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12535 
    if self.orderId is not None:
12536 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12537 
      oprot.writeI64(self.orderId)
12538 
      oprot.writeFieldEnd()
12539 
    oprot.writeFieldStop()
12540 
    oprot.writeStructEnd()
12541 
 
12542 
  def validate(self):
12543 
    return
12544 
 
12545 
 
12546 
  def __repr__(self):
12547 
    L = ['%s=%r' % (key, value)
12548 
      for key, value in self.__dict__.iteritems()]
12549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12550 
 
12551 
  def __eq__(self, other):
12552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12553 
 
12554 
  def __ne__(self, other):
12555 
    return not (self == other)
12556 
 
12557 
class markOrderCancellationRequestConfirmed_result:
12558 
  """
12559 
  Attributes:
12560 
   - ex
12561 
  """
12562 
 
12563 
  thrift_spec = (
12564 
    None, # 0
12565 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12566 
  )
12567 
 
12568 
  def __init__(self, ex=None,):
12569 
    self.ex = ex
12570 
 
12571 
  def read(self, iprot):
12572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12574 
      return
12575 
    iprot.readStructBegin()
12576 
    while True:
12577 
      (fname, ftype, fid) = iprot.readFieldBegin()
12578 
      if ftype == TType.STOP:
12579 
        break
12580 
      if fid == 1:
12581 
        if ftype == TType.STRUCT:
12582 
          self.ex = TransactionServiceException()
12583 
          self.ex.read(iprot)
12584 
        else:
12585 
          iprot.skip(ftype)
12586 
      else:
12587 
        iprot.skip(ftype)
12588 
      iprot.readFieldEnd()
12589 
    iprot.readStructEnd()
12590 
 
12591 
  def write(self, oprot):
12592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12594 
      return
12595 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12596 
    if self.ex is not None:
12597 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12598 
      self.ex.write(oprot)
12599 
      oprot.writeFieldEnd()
12600 
    oprot.writeFieldStop()
12601 
    oprot.writeStructEnd()
12602 
 
12603 
  def validate(self):
12604 
    return
12605 
 
12606 
 
12607 
  def __repr__(self):
12608 
    L = ['%s=%r' % (key, value)
12609 
      for key, value in self.__dict__.iteritems()]
12610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12611 
 
12612 
  def __eq__(self, other):
12613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12614 
 
12615 
  def __ne__(self, other):
12616 
    return not (self == other)
12617 
 
12618 
class markOrderCancellationRequestDenied_args:
12619 
  """
12620 
  Attributes:
12621 
   - orderId
12622 
  """
12623 
 
12624 
  thrift_spec = (
12625 
    None, # 0
12626 
    (1, TType.I64, 'orderId', None, None, ), # 1
12627 
  )
12628 
 
12629 
  def __init__(self, orderId=None,):
12630 
    self.orderId = orderId
12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 1:
12642 
        if ftype == TType.I64:
12643 
          self.orderId = iprot.readI64();
12644 
        else:
12645 
          iprot.skip(ftype)
12646 
      else:
12647 
        iprot.skip(ftype)
12648 
      iprot.readFieldEnd()
12649 
    iprot.readStructEnd()
12650 
 
12651 
  def write(self, oprot):
12652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12654 
      return
12655 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12656 
    if self.orderId is not None:
12657 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12658 
      oprot.writeI64(self.orderId)
12659 
      oprot.writeFieldEnd()
12660 
    oprot.writeFieldStop()
12661 
    oprot.writeStructEnd()
12662 
 
12663 
  def validate(self):
12664 
    return
12665 
 
12666 
 
12667 
  def __repr__(self):
12668 
    L = ['%s=%r' % (key, value)
12669 
      for key, value in self.__dict__.iteritems()]
12670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12671 
 
12672 
  def __eq__(self, other):
12673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12674 
 
12675 
  def __ne__(self, other):
12676 
    return not (self == other)
12677 
 
12678 
class markOrderCancellationRequestDenied_result:
12679 
  """
12680 
  Attributes:
12681 
   - ex
12682 
  """
12683 
 
12684 
  thrift_spec = (
12685 
    None, # 0
12686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12687 
  )
12688 
 
12689 
  def __init__(self, ex=None,):
12690 
    self.ex = ex
12691 
 
12692 
  def read(self, iprot):
12693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12695 
      return
12696 
    iprot.readStructBegin()
12697 
    while True:
12698 
      (fname, ftype, fid) = iprot.readFieldBegin()
12699 
      if ftype == TType.STOP:
12700 
        break
12701 
      if fid == 1:
12702 
        if ftype == TType.STRUCT:
12703 
          self.ex = TransactionServiceException()
12704 
          self.ex.read(iprot)
12705 
        else:
12706 
          iprot.skip(ftype)
12707 
      else:
12708 
        iprot.skip(ftype)
12709 
      iprot.readFieldEnd()
12710 
    iprot.readStructEnd()
12711 
 
12712 
  def write(self, oprot):
12713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12715 
      return
12716 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
12717 
    if self.ex is not None:
12718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12719 
      self.ex.write(oprot)
12720 
      oprot.writeFieldEnd()
12721 
    oprot.writeFieldStop()
12722 
    oprot.writeStructEnd()
12723 
 
12724 
  def validate(self):
12725 
    return
12726 
 
12727 
 
12728 
  def __repr__(self):
12729 
    L = ['%s=%r' % (key, value)
12730 
      for key, value in self.__dict__.iteritems()]
12731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12732 
 
12733 
  def __eq__(self, other):
12734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12735 
 
12736 
  def __ne__(self, other):
12737 
    return not (self == other)
12738 
 
4258 rajveer 12739 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 12740 
  """
12741 
  Attributes:
4258 rajveer 12742 
   - transactionId
4247 rajveer 12743 
  """
12744 
 
12745 
  thrift_spec = (
12746 
    None, # 0
4258 rajveer 12747 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 12748 
  )
12749 
 
4258 rajveer 12750 
  def __init__(self, transactionId=None,):
12751 
    self.transactionId = transactionId
4247 rajveer 12752 
 
12753 
  def read(self, iprot):
12754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12756 
      return
12757 
    iprot.readStructBegin()
12758 
    while True:
12759 
      (fname, ftype, fid) = iprot.readFieldBegin()
12760 
      if ftype == TType.STOP:
12761 
        break
12762 
      if fid == 1:
12763 
        if ftype == TType.I64:
4258 rajveer 12764 
          self.transactionId = iprot.readI64();
4247 rajveer 12765 
        else:
12766 
          iprot.skip(ftype)
12767 
      else:
12768 
        iprot.skip(ftype)
12769 
      iprot.readFieldEnd()
12770 
    iprot.readStructEnd()
12771 
 
12772 
  def write(self, oprot):
12773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12775 
      return
4258 rajveer 12776 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
12777 
    if self.transactionId is not None:
12778 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12779 
      oprot.writeI64(self.transactionId)
4247 rajveer 12780 
      oprot.writeFieldEnd()
12781 
    oprot.writeFieldStop()
12782 
    oprot.writeStructEnd()
12783 
 
12784 
  def validate(self):
12785 
    return
12786 
 
12787 
 
12788 
  def __repr__(self):
12789 
    L = ['%s=%r' % (key, value)
12790 
      for key, value in self.__dict__.iteritems()]
12791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12792 
 
12793 
  def __eq__(self, other):
12794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12795 
 
12796 
  def __ne__(self, other):
12797 
    return not (self == other)
12798 
 
4258 rajveer 12799 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 12800 
  """
12801 
  Attributes:
12802 
   - ex
12803 
  """
12804 
 
12805 
  thrift_spec = (
12806 
    None, # 0
12807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12808 
  )
12809 
 
12810 
  def __init__(self, ex=None,):
12811 
    self.ex = ex
12812 
 
12813 
  def read(self, iprot):
12814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12816 
      return
12817 
    iprot.readStructBegin()
12818 
    while True:
12819 
      (fname, ftype, fid) = iprot.readFieldBegin()
12820 
      if ftype == TType.STOP:
12821 
        break
12822 
      if fid == 1:
12823 
        if ftype == TType.STRUCT:
12824 
          self.ex = TransactionServiceException()
12825 
          self.ex.read(iprot)
12826 
        else:
12827 
          iprot.skip(ftype)
12828 
      else:
12829 
        iprot.skip(ftype)
12830 
      iprot.readFieldEnd()
12831 
    iprot.readStructEnd()
12832 
 
12833 
  def write(self, oprot):
12834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12836 
      return
4258 rajveer 12837 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 12838 
    if self.ex is not None:
12839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12840 
      self.ex.write(oprot)
12841 
      oprot.writeFieldEnd()
12842 
    oprot.writeFieldStop()
12843 
    oprot.writeStructEnd()
12844 
 
12845 
  def validate(self):
12846 
    return
12847 
 
12848 
 
12849 
  def __repr__(self):
12850 
    L = ['%s=%r' % (key, value)
12851 
      for key, value in self.__dict__.iteritems()]
12852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12853 
 
12854 
  def __eq__(self, other):
12855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12856 
 
12857 
  def __ne__(self, other):
12858 
    return not (self == other)
4259 anupam.sin 12859 
 
12860 
class refundTransaction_args:
12861 
  """
12862 
  Attributes:
12863 
   - transactionId
12864 
   - refundedBy
12865 
   - reason
12866 
  """
12867 
 
12868 
  thrift_spec = (
12869 
    None, # 0
12870 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12871 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12872 
    (3, TType.STRING, 'reason', None, None, ), # 3
12873 
  )
12874 
 
12875 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
12876 
    self.transactionId = transactionId
12877 
    self.refundedBy = refundedBy
12878 
    self.reason = reason
12879 
 
12880 
  def read(self, iprot):
12881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12883 
      return
12884 
    iprot.readStructBegin()
12885 
    while True:
12886 
      (fname, ftype, fid) = iprot.readFieldBegin()
12887 
      if ftype == TType.STOP:
12888 
        break
12889 
      if fid == 1:
12890 
        if ftype == TType.I64:
12891 
          self.transactionId = iprot.readI64();
12892 
        else:
12893 
          iprot.skip(ftype)
12894 
      elif fid == 2:
12895 
        if ftype == TType.STRING:
12896 
          self.refundedBy = iprot.readString();
12897 
        else:
12898 
          iprot.skip(ftype)
12899 
      elif fid == 3:
12900 
        if ftype == TType.STRING:
12901 
          self.reason = iprot.readString();
12902 
        else:
12903 
          iprot.skip(ftype)
12904 
      else:
12905 
        iprot.skip(ftype)
12906 
      iprot.readFieldEnd()
12907 
    iprot.readStructEnd()
12908 
 
12909 
  def write(self, oprot):
12910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12912 
      return
12913 
    oprot.writeStructBegin('refundTransaction_args')
12914 
    if self.transactionId is not None:
12915 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12916 
      oprot.writeI64(self.transactionId)
12917 
      oprot.writeFieldEnd()
12918 
    if self.refundedBy is not None:
12919 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12920 
      oprot.writeString(self.refundedBy)
12921 
      oprot.writeFieldEnd()
12922 
    if self.reason is not None:
12923 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12924 
      oprot.writeString(self.reason)
12925 
      oprot.writeFieldEnd()
12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
12944 
class refundTransaction_result:
12945 
  """
12946 
  Attributes:
12947 
   - ex
12948 
  """
12949 
 
12950 
  thrift_spec = (
12951 
    None, # 0
12952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12953 
  )
12954 
 
12955 
  def __init__(self, ex=None,):
12956 
    self.ex = ex
12957 
 
12958 
  def read(self, iprot):
12959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12961 
      return
12962 
    iprot.readStructBegin()
12963 
    while True:
12964 
      (fname, ftype, fid) = iprot.readFieldBegin()
12965 
      if ftype == TType.STOP:
12966 
        break
12967 
      if fid == 1:
12968 
        if ftype == TType.STRUCT:
12969 
          self.ex = TransactionServiceException()
12970 
          self.ex.read(iprot)
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('refundTransaction_result')
12983 
    if self.ex is not None:
12984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12985 
      self.ex.write(oprot)
12986 
      oprot.writeFieldEnd()
12987 
    oprot.writeFieldStop()
12988 
    oprot.writeStructEnd()
12989 
 
12990 
  def validate(self):
12991 
    return
12992 
 
12993 
 
12994 
  def __repr__(self):
12995 
    L = ['%s=%r' % (key, value)
12996 
      for key, value in self.__dict__.iteritems()]
12997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12998 
 
12999 
  def __eq__(self, other):
13000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13001 
 
13002 
  def __ne__(self, other):
13003 
    return not (self == other)
4285 rajveer 13004 
 
13005 
class acceptOrdersForItemId_args:
13006 
  """
13007 
  Attributes:
13008 
   - itemId
13009 
   - inventory
13010 
  """
13011 
 
13012 
  thrift_spec = (
13013 
    None, # 0
13014 
    (1, TType.I64, 'itemId', None, None, ), # 1
13015 
    (2, TType.I64, 'inventory', None, None, ), # 2
13016 
  )
13017 
 
13018 
  def __init__(self, itemId=None, inventory=None,):
13019 
    self.itemId = itemId
13020 
    self.inventory = inventory
13021 
 
13022 
  def read(self, iprot):
13023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13025 
      return
13026 
    iprot.readStructBegin()
13027 
    while True:
13028 
      (fname, ftype, fid) = iprot.readFieldBegin()
13029 
      if ftype == TType.STOP:
13030 
        break
13031 
      if fid == 1:
13032 
        if ftype == TType.I64:
13033 
          self.itemId = iprot.readI64();
13034 
        else:
13035 
          iprot.skip(ftype)
13036 
      elif fid == 2:
13037 
        if ftype == TType.I64:
13038 
          self.inventory = iprot.readI64();
13039 
        else:
13040 
          iprot.skip(ftype)
13041 
      else:
13042 
        iprot.skip(ftype)
13043 
      iprot.readFieldEnd()
13044 
    iprot.readStructEnd()
13045 
 
13046 
  def write(self, oprot):
13047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13049 
      return
13050 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13051 
    if self.itemId is not None:
13052 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13053 
      oprot.writeI64(self.itemId)
13054 
      oprot.writeFieldEnd()
13055 
    if self.inventory is not None:
13056 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13057 
      oprot.writeI64(self.inventory)
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 acceptOrdersForItemId_result:
13078 
  """
13079 
  Attributes:
13080 
   - success
13081 
   - ex
13082 
  """
13083 
 
13084 
  thrift_spec = (
13085 
    (0, TType.BOOL, 'success', None, None, ), # 0
13086 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13087 
  )
13088 
 
13089 
  def __init__(self, success=None, ex=None,):
13090 
    self.success = success
13091 
    self.ex = ex
13092 
 
13093 
  def read(self, iprot):
13094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13096 
      return
13097 
    iprot.readStructBegin()
13098 
    while True:
13099 
      (fname, ftype, fid) = iprot.readFieldBegin()
13100 
      if ftype == TType.STOP:
13101 
        break
13102 
      if fid == 0:
13103 
        if ftype == TType.BOOL:
13104 
          self.success = iprot.readBool();
13105 
        else:
13106 
          iprot.skip(ftype)
13107 
      elif fid == 1:
13108 
        if ftype == TType.STRUCT:
13109 
          self.ex = TransactionServiceException()
13110 
          self.ex.read(iprot)
13111 
        else:
13112 
          iprot.skip(ftype)
13113 
      else:
13114 
        iprot.skip(ftype)
13115 
      iprot.readFieldEnd()
13116 
    iprot.readStructEnd()
13117 
 
13118 
  def write(self, oprot):
13119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13121 
      return
13122 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13123 
    if self.success is not None:
13124 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13125 
      oprot.writeBool(self.success)
13126 
      oprot.writeFieldEnd()
13127 
    if self.ex is not None:
13128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13129 
      self.ex.write(oprot)
13130 
      oprot.writeFieldEnd()
13131 
    oprot.writeFieldStop()
13132 
    oprot.writeStructEnd()
13133 
 
13134 
  def validate(self):
13135 
    return
13136 
 
13137 
 
13138 
  def __repr__(self):
13139 
    L = ['%s=%r' % (key, value)
13140 
      for key, value in self.__dict__.iteritems()]
13141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13142 
 
13143 
  def __eq__(self, other):
13144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13145 
 
13146 
  def __ne__(self, other):
13147 
    return not (self == other)