Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
404 
    Returns the final flag status.
405 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4295 varun.gupt 659 
  def getOrdersForItemIds(self, itemIds):
660 
    """
661 
    Returns a list of all orders which have items with given id
662 
 
663 
    Parameters:
664 
     - itemIds
665 
    """
666 
    pass
667 
 
4247 rajveer 668 
  def markOrderCancellationRequestReceived(self, orderId):
669 
    """
670 
    Mark order as cancellation request received. If customer sends request of cancellation of
671 
    a particular order, this method will be called. It will just change status of the order
672 
    depending on its current status. It also records the previous status, so that we can move
673 
    back to that status if cancellation request is denied.
4018 chandransh 674 
 
4247 rajveer 675 
    Parameters:
676 
     - orderId
677 
    """
678 
    pass
679 
 
680 
  def markOrderCancellationRequestConfirmed(self, orderId):
681 
    """
682 
    If we decide to to cancel order, CRM will call this method to move the status of order to
683 
    cancellation request confirmed. After this OM will be able to cancel the order.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
690 
  def markOrderCancellationRequestDenied(self, orderId):
691 
    """
692 
    If we decide to not to cancel order, we will move the order ro previous status.
693 
 
694 
    Parameters:
695 
     - orderId
696 
    """
697 
    pass
698 
 
4258 rajveer 699 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 700 
    """
4258 rajveer 701 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
702 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 703 
 
704 
    Parameters:
4258 rajveer 705 
     - transactionId
4247 rajveer 706 
    """
707 
    pass
708 
 
4259 anupam.sin 709 
  def refundTransaction(self, transactionId, refundedBy, reason):
710 
    """
711 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
712 
    need to be cancelled
4247 rajveer 713 
 
4259 anupam.sin 714 
    Parameters:
715 
     - transactionId
716 
     - refundedBy
717 
     - reason
718 
    """
719 
    pass
720 
 
4285 rajveer 721 
  def acceptOrdersForItemId(self, itemId, inventory):
722 
    """
723 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
724 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 725 
 
4285 rajveer 726 
    Parameters:
727 
     - itemId
728 
     - inventory
729 
    """
730 
    pass
731 
 
4303 rajveer 732 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
733 
    """
734 
    Parameters:
735 
     - vendorId
736 
     - itemId
737 
     - quantity
738 
     - estimate
739 
    """
740 
    pass
4285 rajveer 741 
 
4303 rajveer 742 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
743 
    """
744 
    Parameters:
745 
     - vendorId
746 
     - itemId
747 
     - quantity
748 
     - estimate
749 
    """
750 
    pass
751 
 
752 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
753 
    """
754 
    Parameters:
755 
     - vendorId
756 
     - itemId
757 
     - quantity
758 
     - estimate
759 
    """
760 
    pass
761 
 
762 
 
3376 rajveer 763 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 764 
  def __init__(self, iprot, oprot=None):
3376 rajveer 765 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 766 
 
767 
  def createTransaction(self, transaction):
768 
    """
769 
    Parameters:
770 
     - transaction
771 
    """
772 
    self.send_createTransaction(transaction)
132 ashish 773 
    return self.recv_createTransaction()
94 ashish 774 
 
775 
  def send_createTransaction(self, transaction):
776 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
777 
    args = createTransaction_args()
778 
    args.transaction = transaction
779 
    args.write(self._oprot)
780 
    self._oprot.writeMessageEnd()
781 
    self._oprot.trans.flush()
782 
 
783 
  def recv_createTransaction(self, ):
784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
785 
    if mtype == TMessageType.EXCEPTION:
786 
      x = TApplicationException()
787 
      x.read(self._iprot)
788 
      self._iprot.readMessageEnd()
789 
      raise x
790 
    result = createTransaction_result()
791 
    result.read(self._iprot)
792 
    self._iprot.readMessageEnd()
3431 rajveer 793 
    if result.success is not None:
132 ashish 794 
      return result.success
3431 rajveer 795 
    if result.ex is not None:
94 ashish 796 
      raise result.ex
132 ashish 797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 798 
 
799 
  def getTransaction(self, id):
800 
    """
801 
    Parameters:
802 
     - id
803 
    """
804 
    self.send_getTransaction(id)
805 
    return self.recv_getTransaction()
806 
 
807 
  def send_getTransaction(self, id):
808 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
809 
    args = getTransaction_args()
810 
    args.id = id
811 
    args.write(self._oprot)
812 
    self._oprot.writeMessageEnd()
813 
    self._oprot.trans.flush()
814 
 
815 
  def recv_getTransaction(self, ):
816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
817 
    if mtype == TMessageType.EXCEPTION:
818 
      x = TApplicationException()
819 
      x.read(self._iprot)
820 
      self._iprot.readMessageEnd()
821 
      raise x
822 
    result = getTransaction_result()
823 
    result.read(self._iprot)
824 
    self._iprot.readMessageEnd()
3431 rajveer 825 
    if result.success is not None:
94 ashish 826 
      return result.success
3431 rajveer 827 
    if result.ex is not None:
94 ashish 828 
      raise result.ex
829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
830 
 
831 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
832 
    """
833 
    Parameters:
834 
     - customerId
835 
     - from_date
836 
     - to_date
837 
     - status
838 
    """
839 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
840 
    return self.recv_getTransactionsForCustomer()
841 
 
842 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
843 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
844 
    args = getTransactionsForCustomer_args()
845 
    args.customerId = customerId
846 
    args.from_date = from_date
847 
    args.to_date = to_date
848 
    args.status = status
849 
    args.write(self._oprot)
850 
    self._oprot.writeMessageEnd()
851 
    self._oprot.trans.flush()
852 
 
853 
  def recv_getTransactionsForCustomer(self, ):
854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
855 
    if mtype == TMessageType.EXCEPTION:
856 
      x = TApplicationException()
857 
      x.read(self._iprot)
858 
      self._iprot.readMessageEnd()
859 
      raise x
860 
    result = getTransactionsForCustomer_result()
861 
    result.read(self._iprot)
862 
    self._iprot.readMessageEnd()
3431 rajveer 863 
    if result.success is not None:
94 ashish 864 
      return result.success
3431 rajveer 865 
    if result.ex is not None:
94 ashish 866 
      raise result.ex
867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
868 
 
132 ashish 869 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
870 
    """
871 
    Parameters:
872 
     - shoppingCartId
873 
    """
874 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
875 
    return self.recv_getTransactionsForShoppingCartId()
876 
 
877 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
878 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
879 
    args = getTransactionsForShoppingCartId_args()
880 
    args.shoppingCartId = shoppingCartId
881 
    args.write(self._oprot)
882 
    self._oprot.writeMessageEnd()
883 
    self._oprot.trans.flush()
884 
 
885 
  def recv_getTransactionsForShoppingCartId(self, ):
886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
887 
    if mtype == TMessageType.EXCEPTION:
888 
      x = TApplicationException()
889 
      x.read(self._iprot)
890 
      self._iprot.readMessageEnd()
891 
      raise x
892 
    result = getTransactionsForShoppingCartId_result()
893 
    result.read(self._iprot)
894 
    self._iprot.readMessageEnd()
3431 rajveer 895 
    if result.success is not None:
132 ashish 896 
      return result.success
3431 rajveer 897 
    if result.ex is not None:
132 ashish 898 
      raise result.ex
899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
900 
 
94 ashish 901 
  def getTransactionStatus(self, transactionId):
902 
    """
903 
    Parameters:
904 
     - transactionId
905 
    """
906 
    self.send_getTransactionStatus(transactionId)
907 
    return self.recv_getTransactionStatus()
908 
 
909 
  def send_getTransactionStatus(self, transactionId):
910 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
911 
    args = getTransactionStatus_args()
912 
    args.transactionId = transactionId
913 
    args.write(self._oprot)
914 
    self._oprot.writeMessageEnd()
915 
    self._oprot.trans.flush()
916 
 
917 
  def recv_getTransactionStatus(self, ):
918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
919 
    if mtype == TMessageType.EXCEPTION:
920 
      x = TApplicationException()
921 
      x.read(self._iprot)
922 
      self._iprot.readMessageEnd()
923 
      raise x
924 
    result = getTransactionStatus_result()
925 
    result.read(self._iprot)
926 
    self._iprot.readMessageEnd()
3431 rajveer 927 
    if result.success is not None:
94 ashish 928 
      return result.success
3431 rajveer 929 
    if result.ex is not None:
94 ashish 930 
      raise result.ex
931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
932 
 
933 
  def changeTransactionStatus(self, transactionId, status, description):
934 
    """
935 
    Parameters:
936 
     - transactionId
937 
     - status
938 
     - description
939 
    """
940 
    self.send_changeTransactionStatus(transactionId, status, description)
941 
    return self.recv_changeTransactionStatus()
942 
 
943 
  def send_changeTransactionStatus(self, transactionId, status, description):
944 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
945 
    args = changeTransactionStatus_args()
946 
    args.transactionId = transactionId
947 
    args.status = status
948 
    args.description = description
949 
    args.write(self._oprot)
950 
    self._oprot.writeMessageEnd()
951 
    self._oprot.trans.flush()
952 
 
953 
  def recv_changeTransactionStatus(self, ):
954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
955 
    if mtype == TMessageType.EXCEPTION:
956 
      x = TApplicationException()
957 
      x.read(self._iprot)
958 
      self._iprot.readMessageEnd()
959 
      raise x
960 
    result = changeTransactionStatus_result()
961 
    result.read(self._iprot)
962 
    self._iprot.readMessageEnd()
3431 rajveer 963 
    if result.success is not None:
94 ashish 964 
      return result.success
3431 rajveer 965 
    if result.ex is not None:
94 ashish 966 
      raise result.ex
967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
968 
 
1398 varun.gupt 969 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 970 
    """
971 
    Parameters:
972 
     - transactionId
973 
    """
1398 varun.gupt 974 
    self.send_enqueueTransactionInfoEmail(transactionId)
975 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 976 
 
1398 varun.gupt 977 
  def send_enqueueTransactionInfoEmail(self, transactionId):
978 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
979 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 980 
    args.transactionId = transactionId
981 
    args.write(self._oprot)
982 
    self._oprot.writeMessageEnd()
983 
    self._oprot.trans.flush()
984 
 
1398 varun.gupt 985 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
987 
    if mtype == TMessageType.EXCEPTION:
988 
      x = TApplicationException()
989 
      x.read(self._iprot)
990 
      self._iprot.readMessageEnd()
991 
      raise x
1398 varun.gupt 992 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 993 
    result.read(self._iprot)
994 
    self._iprot.readMessageEnd()
3431 rajveer 995 
    if result.success is not None:
1382 varun.gupt 996 
      return result.success
3431 rajveer 997 
    if result.ex is not None:
1382 varun.gupt 998 
      raise result.ex
1398 varun.gupt 999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1000 
 
483 rajveer 1001 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1002 
    """
1003 
    Parameters:
483 rajveer 1004 
     - status
1005 
     - from_date
1006 
     - to_date
1007 
     - warehouse_id
94 ashish 1008 
    """
483 rajveer 1009 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1010 
    return self.recv_getAllOrders()
94 ashish 1011 
 
483 rajveer 1012 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1013 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1014 
    args = getAllOrders_args()
1015 
    args.status = status
1016 
    args.from_date = from_date
1017 
    args.to_date = to_date
1018 
    args.warehouse_id = warehouse_id
94 ashish 1019 
    args.write(self._oprot)
1020 
    self._oprot.writeMessageEnd()
1021 
    self._oprot.trans.flush()
1022 
 
483 rajveer 1023 
  def recv_getAllOrders(self, ):
94 ashish 1024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1025 
    if mtype == TMessageType.EXCEPTION:
1026 
      x = TApplicationException()
1027 
      x.read(self._iprot)
1028 
      self._iprot.readMessageEnd()
1029 
      raise x
483 rajveer 1030 
    result = getAllOrders_result()
94 ashish 1031 
    result.read(self._iprot)
1032 
    self._iprot.readMessageEnd()
3431 rajveer 1033 
    if result.success is not None:
94 ashish 1034 
      return result.success
3431 rajveer 1035 
    if result.ex is not None:
94 ashish 1036 
      raise result.ex
483 rajveer 1037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1038 
 
4133 chandransh 1039 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1040 
    """
1041 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1042 
    Pass the status as null and the limit as 0 to ignore them.
1043 
 
1044 
    Parameters:
1045 
     - statuses
1046 
     - offset
1047 
     - limit
1048 
     - warehouse_id
1049 
    """
1050 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1051 
    return self.recv_getOrdersInBatch()
1052 
 
1053 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1054 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1055 
    args = getOrdersInBatch_args()
1056 
    args.statuses = statuses
1057 
    args.offset = offset
1058 
    args.limit = limit
1059 
    args.warehouse_id = warehouse_id
1060 
    args.write(self._oprot)
1061 
    self._oprot.writeMessageEnd()
1062 
    self._oprot.trans.flush()
1063 
 
1064 
  def recv_getOrdersInBatch(self, ):
1065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1066 
    if mtype == TMessageType.EXCEPTION:
1067 
      x = TApplicationException()
1068 
      x.read(self._iprot)
1069 
      self._iprot.readMessageEnd()
1070 
      raise x
1071 
    result = getOrdersInBatch_result()
1072 
    result.read(self._iprot)
1073 
    self._iprot.readMessageEnd()
1074 
    if result.success is not None:
1075 
      return result.success
1076 
    if result.ex is not None:
1077 
      raise result.ex
1078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1079 
 
1080 
  def getOrderCount(self, statuses, warehouseId):
1081 
    """
1082 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1083 
 
1084 
    Parameters:
1085 
     - statuses
1086 
     - warehouseId
1087 
    """
1088 
    self.send_getOrderCount(statuses, warehouseId)
1089 
    return self.recv_getOrderCount()
1090 
 
1091 
  def send_getOrderCount(self, statuses, warehouseId):
1092 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1093 
    args = getOrderCount_args()
1094 
    args.statuses = statuses
1095 
    args.warehouseId = warehouseId
1096 
    args.write(self._oprot)
1097 
    self._oprot.writeMessageEnd()
1098 
    self._oprot.trans.flush()
1099 
 
1100 
  def recv_getOrderCount(self, ):
1101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1102 
    if mtype == TMessageType.EXCEPTION:
1103 
      x = TApplicationException()
1104 
      x.read(self._iprot)
1105 
      self._iprot.readMessageEnd()
1106 
      raise x
1107 
    result = getOrderCount_result()
1108 
    result.read(self._iprot)
1109 
    self._iprot.readMessageEnd()
1110 
    if result.success is not None:
1111 
      return result.success
1112 
    if result.ex is not None:
1113 
      raise result.ex
1114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1115 
 
999 varun.gupt 1116 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1117 
    """
1132 chandransh 1118 
    Returns orders within a range of their billing dates
3431 rajveer 1119 
 
999 varun.gupt 1120 
    Parameters:
1121 
     - status
1122 
     - start_billing_date
1123 
     - end_billing_date
1124 
     - warehouse_id
1125 
    """
1126 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1127 
    return self.recv_getOrdersByBillingDate()
1128 
 
1129 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1130 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1131 
    args = getOrdersByBillingDate_args()
1132 
    args.status = status
1133 
    args.start_billing_date = start_billing_date
1134 
    args.end_billing_date = end_billing_date
1135 
    args.warehouse_id = warehouse_id
1136 
    args.write(self._oprot)
1137 
    self._oprot.writeMessageEnd()
1138 
    self._oprot.trans.flush()
1139 
 
1140 
  def recv_getOrdersByBillingDate(self, ):
1141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1142 
    if mtype == TMessageType.EXCEPTION:
1143 
      x = TApplicationException()
1144 
      x.read(self._iprot)
1145 
      self._iprot.readMessageEnd()
1146 
      raise x
1147 
    result = getOrdersByBillingDate_result()
1148 
    result.read(self._iprot)
1149 
    self._iprot.readMessageEnd()
3431 rajveer 1150 
    if result.success is not None:
999 varun.gupt 1151 
      return result.success
3431 rajveer 1152 
    if result.ex is not None:
999 varun.gupt 1153 
      raise result.ex
1154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1155 
 
3451 chandransh 1156 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1157 
    """
1158 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1159 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1160 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1161 
 
3427 chandransh 1162 
    Parameters:
1163 
     - fromShippingDate
1164 
     - toShippingDate
1165 
     - providerId
1166 
     - warehouseId
3451 chandransh 1167 
     - cod
3427 chandransh 1168 
    """
3451 chandransh 1169 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1170 
    return self.recv_getOrdersByShippingDate()
1171 
 
3451 chandransh 1172 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1173 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1174 
    args = getOrdersByShippingDate_args()
1175 
    args.fromShippingDate = fromShippingDate
1176 
    args.toShippingDate = toShippingDate
1177 
    args.providerId = providerId
1178 
    args.warehouseId = warehouseId
3451 chandransh 1179 
    args.cod = cod
3427 chandransh 1180 
    args.write(self._oprot)
1181 
    self._oprot.writeMessageEnd()
1182 
    self._oprot.trans.flush()
1183 
 
1184 
  def recv_getOrdersByShippingDate(self, ):
1185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1186 
    if mtype == TMessageType.EXCEPTION:
1187 
      x = TApplicationException()
1188 
      x.read(self._iprot)
1189 
      self._iprot.readMessageEnd()
1190 
      raise x
1191 
    result = getOrdersByShippingDate_result()
1192 
    result.read(self._iprot)
1193 
    self._iprot.readMessageEnd()
3431 rajveer 1194 
    if result.success is not None:
3427 chandransh 1195 
      return result.success
3431 rajveer 1196 
    if result.ex is not None:
3427 chandransh 1197 
      raise result.ex
1198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1199 
 
1382 varun.gupt 1200 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1201 
    """
1202 
    Returns order ids for orders which can be returned
3431 rajveer 1203 
 
1382 varun.gupt 1204 
    Parameters:
1205 
     - customer_id
1206 
     - limit
1207 
    """
1208 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1209 
    return self.recv_getReturnableOrdersForCustomer()
1210 
 
1211 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1212 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1213 
    args = getReturnableOrdersForCustomer_args()
1214 
    args.customer_id = customer_id
1215 
    args.limit = limit
1216 
    args.write(self._oprot)
1217 
    self._oprot.writeMessageEnd()
1218 
    self._oprot.trans.flush()
1219 
 
1220 
  def recv_getReturnableOrdersForCustomer(self, ):
1221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1222 
    if mtype == TMessageType.EXCEPTION:
1223 
      x = TApplicationException()
1224 
      x.read(self._iprot)
1225 
      self._iprot.readMessageEnd()
1226 
      raise x
1227 
    result = getReturnableOrdersForCustomer_result()
1228 
    result.read(self._iprot)
1229 
    self._iprot.readMessageEnd()
3431 rajveer 1230 
    if result.success is not None:
1382 varun.gupt 1231 
      return result.success
3431 rajveer 1232 
    if result.ex is not None:
1382 varun.gupt 1233 
      raise result.ex
1234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1235 
 
1236 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1237 
    """
1238 
    Returns order ids for orders which can be cancelled
3431 rajveer 1239 
 
1382 varun.gupt 1240 
    Parameters:
1241 
     - customer_id
1242 
     - limit
1243 
    """
1244 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1245 
    return self.recv_getCancellableOrdersForCustomer()
1246 
 
1247 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1248 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1249 
    args = getCancellableOrdersForCustomer_args()
1250 
    args.customer_id = customer_id
1251 
    args.limit = limit
1252 
    args.write(self._oprot)
1253 
    self._oprot.writeMessageEnd()
1254 
    self._oprot.trans.flush()
1255 
 
1256 
  def recv_getCancellableOrdersForCustomer(self, ):
1257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1258 
    if mtype == TMessageType.EXCEPTION:
1259 
      x = TApplicationException()
1260 
      x.read(self._iprot)
1261 
      self._iprot.readMessageEnd()
1262 
      raise x
1263 
    result = getCancellableOrdersForCustomer_result()
1264 
    result.read(self._iprot)
1265 
    self._iprot.readMessageEnd()
3431 rajveer 1266 
    if result.success is not None:
1382 varun.gupt 1267 
      return result.success
3431 rajveer 1268 
    if result.ex is not None:
1382 varun.gupt 1269 
      raise result.ex
1270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1271 
 
483 rajveer 1272 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1273 
    """
1274 
    Parameters:
483 rajveer 1275 
     - orderId
1276 
     - status
1277 
     - description
94 ashish 1278 
    """
483 rajveer 1279 
    self.send_changeOrderStatus(orderId, status, description)
1280 
    return self.recv_changeOrderStatus()
94 ashish 1281 
 
483 rajveer 1282 
  def send_changeOrderStatus(self, orderId, status, description):
1283 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1284 
    args = changeOrderStatus_args()
1285 
    args.orderId = orderId
1286 
    args.status = status
1287 
    args.description = description
94 ashish 1288 
    args.write(self._oprot)
1289 
    self._oprot.writeMessageEnd()
1290 
    self._oprot.trans.flush()
1291 
 
483 rajveer 1292 
  def recv_changeOrderStatus(self, ):
94 ashish 1293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1294 
    if mtype == TMessageType.EXCEPTION:
1295 
      x = TApplicationException()
1296 
      x.read(self._iprot)
1297 
      self._iprot.readMessageEnd()
1298 
      raise x
483 rajveer 1299 
    result = changeOrderStatus_result()
94 ashish 1300 
    result.read(self._iprot)
1301 
    self._iprot.readMessageEnd()
3431 rajveer 1302 
    if result.success is not None:
94 ashish 1303 
      return result.success
3431 rajveer 1304 
    if result.ex is not None:
94 ashish 1305 
      raise result.ex
483 rajveer 1306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1307 
 
1528 ankur.sing 1308 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1309 
    """
1528 ankur.sing 1310 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1311 
    only user who owns the transaction can view its order details.
3431 rajveer 1312 
 
94 ashish 1313 
    Parameters:
1314 
     - transactionId
1528 ankur.sing 1315 
     - customerId
94 ashish 1316 
    """
1528 ankur.sing 1317 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1318 
    return self.recv_getOrdersForTransaction()
94 ashish 1319 
 
1528 ankur.sing 1320 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1321 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1322 
    args = getOrdersForTransaction_args()
94 ashish 1323 
    args.transactionId = transactionId
1528 ankur.sing 1324 
    args.customerId = customerId
94 ashish 1325 
    args.write(self._oprot)
1326 
    self._oprot.writeMessageEnd()
1327 
    self._oprot.trans.flush()
1328 
 
483 rajveer 1329 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1331 
    if mtype == TMessageType.EXCEPTION:
1332 
      x = TApplicationException()
1333 
      x.read(self._iprot)
1334 
      self._iprot.readMessageEnd()
1335 
      raise x
483 rajveer 1336 
    result = getOrdersForTransaction_result()
94 ashish 1337 
    result.read(self._iprot)
1338 
    self._iprot.readMessageEnd()
3431 rajveer 1339 
    if result.success is not None:
94 ashish 1340 
      return result.success
3431 rajveer 1341 
    if result.ex is not None:
94 ashish 1342 
      raise result.ex
483 rajveer 1343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1344 
 
3014 chandransh 1345 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1346 
    """
3014 chandransh 1347 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1348 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1349 
 
94 ashish 1350 
    Parameters:
483 rajveer 1351 
     - customerId
1352 
     - from_date
1353 
     - to_date
3014 chandransh 1354 
     - statuses
94 ashish 1355 
    """
3014 chandransh 1356 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1357 
    return self.recv_getOrdersForCustomer()
94 ashish 1358 
 
3014 chandransh 1359 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1360 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1361 
    args = getOrdersForCustomer_args()
1362 
    args.customerId = customerId
1363 
    args.from_date = from_date
1364 
    args.to_date = to_date
3014 chandransh 1365 
    args.statuses = statuses
94 ashish 1366 
    args.write(self._oprot)
1367 
    self._oprot.writeMessageEnd()
1368 
    self._oprot.trans.flush()
1369 
 
483 rajveer 1370 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1372 
    if mtype == TMessageType.EXCEPTION:
1373 
      x = TApplicationException()
1374 
      x.read(self._iprot)
1375 
      self._iprot.readMessageEnd()
1376 
      raise x
483 rajveer 1377 
    result = getOrdersForCustomer_result()
94 ashish 1378 
    result.read(self._iprot)
1379 
    self._iprot.readMessageEnd()
3431 rajveer 1380 
    if result.success is not None:
94 ashish 1381 
      return result.success
3431 rajveer 1382 
    if result.ex is not None:
94 ashish 1383 
      raise result.ex
483 rajveer 1384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1385 
 
483 rajveer 1386 
  def createOrder(self, order):
94 ashish 1387 
    """
1388 
    Parameters:
483 rajveer 1389 
     - order
94 ashish 1390 
    """
483 rajveer 1391 
    self.send_createOrder(order)
1392 
    return self.recv_createOrder()
94 ashish 1393 
 
483 rajveer 1394 
  def send_createOrder(self, order):
1395 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1396 
    args = createOrder_args()
1397 
    args.order = order
94 ashish 1398 
    args.write(self._oprot)
1399 
    self._oprot.writeMessageEnd()
1400 
    self._oprot.trans.flush()
1401 
 
483 rajveer 1402 
  def recv_createOrder(self, ):
94 ashish 1403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1404 
    if mtype == TMessageType.EXCEPTION:
1405 
      x = TApplicationException()
1406 
      x.read(self._iprot)
1407 
      self._iprot.readMessageEnd()
1408 
      raise x
483 rajveer 1409 
    result = createOrder_result()
94 ashish 1410 
    result.read(self._iprot)
1411 
    self._iprot.readMessageEnd()
3431 rajveer 1412 
    if result.success is not None:
94 ashish 1413 
      return result.success
3431 rajveer 1414 
    if result.ex is not None:
94 ashish 1415 
      raise result.ex
483 rajveer 1416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1417 
 
483 rajveer 1418 
  def getOrder(self, id):
94 ashish 1419 
    """
1420 
    Parameters:
483 rajveer 1421 
     - id
94 ashish 1422 
    """
483 rajveer 1423 
    self.send_getOrder(id)
1424 
    return self.recv_getOrder()
94 ashish 1425 
 
483 rajveer 1426 
  def send_getOrder(self, id):
1427 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1428 
    args = getOrder_args()
1429 
    args.id = id
94 ashish 1430 
    args.write(self._oprot)
1431 
    self._oprot.writeMessageEnd()
1432 
    self._oprot.trans.flush()
1433 
 
483 rajveer 1434 
  def recv_getOrder(self, ):
94 ashish 1435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1436 
    if mtype == TMessageType.EXCEPTION:
1437 
      x = TApplicationException()
1438 
      x.read(self._iprot)
1439 
      self._iprot.readMessageEnd()
1440 
      raise x
483 rajveer 1441 
    result = getOrder_result()
94 ashish 1442 
    result.read(self._iprot)
1443 
    self._iprot.readMessageEnd()
3431 rajveer 1444 
    if result.success is not None:
94 ashish 1445 
      return result.success
3431 rajveer 1446 
    if result.ex is not None:
94 ashish 1447 
      raise result.ex
483 rajveer 1448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1449 
 
483 rajveer 1450 
  def getLineItemsForOrder(self, orderId):
94 ashish 1451 
    """
1452 
    Parameters:
483 rajveer 1453 
     - orderId
94 ashish 1454 
    """
483 rajveer 1455 
    self.send_getLineItemsForOrder(orderId)
1456 
    return self.recv_getLineItemsForOrder()
94 ashish 1457 
 
483 rajveer 1458 
  def send_getLineItemsForOrder(self, orderId):
1459 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1460 
    args = getLineItemsForOrder_args()
1461 
    args.orderId = orderId
94 ashish 1462 
    args.write(self._oprot)
1463 
    self._oprot.writeMessageEnd()
1464 
    self._oprot.trans.flush()
1465 
 
483 rajveer 1466 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1468 
    if mtype == TMessageType.EXCEPTION:
1469 
      x = TApplicationException()
1470 
      x.read(self._iprot)
1471 
      self._iprot.readMessageEnd()
1472 
      raise x
483 rajveer 1473 
    result = getLineItemsForOrder_result()
94 ashish 1474 
    result.read(self._iprot)
1475 
    self._iprot.readMessageEnd()
3431 rajveer 1476 
    if result.success is not None:
94 ashish 1477 
      return result.success
3431 rajveer 1478 
    if result.ex is not None:
94 ashish 1479 
      raise result.ex
483 rajveer 1480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1481 
 
1528 ankur.sing 1482 
  def getOrderForCustomer(self, orderId, customerId):
1483 
    """
1484 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1485 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1486 
 
1528 ankur.sing 1487 
    Parameters:
1488 
     - orderId
1489 
     - customerId
1490 
    """
1491 
    self.send_getOrderForCustomer(orderId, customerId)
1492 
    return self.recv_getOrderForCustomer()
1493 
 
1494 
  def send_getOrderForCustomer(self, orderId, customerId):
1495 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1496 
    args = getOrderForCustomer_args()
1497 
    args.orderId = orderId
1498 
    args.customerId = customerId
1499 
    args.write(self._oprot)
1500 
    self._oprot.writeMessageEnd()
1501 
    self._oprot.trans.flush()
1502 
 
1503 
  def recv_getOrderForCustomer(self, ):
1504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1505 
    if mtype == TMessageType.EXCEPTION:
1506 
      x = TApplicationException()
1507 
      x.read(self._iprot)
1508 
      self._iprot.readMessageEnd()
1509 
      raise x
1510 
    result = getOrderForCustomer_result()
1511 
    result.read(self._iprot)
1512 
    self._iprot.readMessageEnd()
3431 rajveer 1513 
    if result.success is not None:
1528 ankur.sing 1514 
      return result.success
3431 rajveer 1515 
    if result.ex is not None:
1528 ankur.sing 1516 
      raise result.ex
1517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1518 
 
3064 chandransh 1519 
  def getAlerts(self, orderId, valid):
1520 
    """
1521 
    Parameters:
1522 
     - orderId
1523 
     - valid
1524 
    """
1525 
    self.send_getAlerts(orderId, valid)
1526 
    return self.recv_getAlerts()
1527 
 
1528 
  def send_getAlerts(self, orderId, valid):
1529 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1530 
    args = getAlerts_args()
1531 
    args.orderId = orderId
1532 
    args.valid = valid
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getAlerts(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getAlerts_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
3431 rajveer 1547 
    if result.success is not None:
3064 chandransh 1548 
      return result.success
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1550 
 
1551 
  def setAlert(self, orderId, unset, type, comment):
1552 
    """
1553 
    Parameters:
1554 
     - orderId
1555 
     - unset
1556 
     - type
1557 
     - comment
1558 
    """
1559 
    self.send_setAlert(orderId, unset, type, comment)
1560 
    self.recv_setAlert()
1561 
 
1562 
  def send_setAlert(self, orderId, unset, type, comment):
1563 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1564 
    args = setAlert_args()
1565 
    args.orderId = orderId
1566 
    args.unset = unset
1567 
    args.type = type
1568 
    args.comment = comment
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_setAlert(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = setAlert_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
1583 
    return
1584 
 
1585 
  def getValidOrderCount(self, ):
1586 
    """
1587 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1588 
    """
1589 
    self.send_getValidOrderCount()
1590 
    return self.recv_getValidOrderCount()
1591 
 
1592 
  def send_getValidOrderCount(self, ):
1593 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1594 
    args = getValidOrderCount_args()
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_getValidOrderCount(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = getValidOrderCount_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
3431 rajveer 1609 
    if result.success is not None:
3064 chandransh 1610 
      return result.success
1611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1612 
 
1613 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1614 
    """
1615 
    Returns the number of distinct customers who have done successful transactions
1616 
    """
1617 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1618 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1619 
 
1620 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1621 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1622 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1623 
    args.write(self._oprot)
1624 
    self._oprot.writeMessageEnd()
1625 
    self._oprot.trans.flush()
1626 
 
1627 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1629 
    if mtype == TMessageType.EXCEPTION:
1630 
      x = TApplicationException()
1631 
      x.read(self._iprot)
1632 
      self._iprot.readMessageEnd()
1633 
      raise x
1634 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1635 
    result.read(self._iprot)
1636 
    self._iprot.readMessageEnd()
3431 rajveer 1637 
    if result.success is not None:
3064 chandransh 1638 
      return result.success
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1640 
 
1641 
  def getValidOrdersAmountRange(self, ):
1642 
    """
1643 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1644 
    List contains two values, first minimum amount and second maximum amount.
1645 
    """
1646 
    self.send_getValidOrdersAmountRange()
1647 
    return self.recv_getValidOrdersAmountRange()
1648 
 
1649 
  def send_getValidOrdersAmountRange(self, ):
1650 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1651 
    args = getValidOrdersAmountRange_args()
1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
1656 
  def recv_getValidOrdersAmountRange(self, ):
1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
1663 
    result = getValidOrdersAmountRange_result()
1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
3431 rajveer 1666 
    if result.success is not None:
3064 chandransh 1667 
      return result.success
1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1669 
 
1670 
  def getValidOrders(self, limit):
1671 
    """
1672 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1673 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1674 
 
3064 chandransh 1675 
    Parameters:
1676 
     - limit
1677 
    """
1678 
    self.send_getValidOrders(limit)
1679 
    return self.recv_getValidOrders()
1680 
 
1681 
  def send_getValidOrders(self, limit):
1682 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1683 
    args = getValidOrders_args()
1684 
    args.limit = limit
1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1689 
  def recv_getValidOrders(self, ):
1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1696 
    result = getValidOrders_result()
1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
3431 rajveer 1699 
    if result.success is not None:
3064 chandransh 1700 
      return result.success
1701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1702 
 
1220 chandransh 1703 
  def batchOrders(self, warehouseId):
1704 
    """
1705 
    Create a batch of all the pending orders for the given warehouse.
1706 
    The returned list is orderd by created_timestamp.
1707 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1708 
 
1220 chandransh 1709 
    Parameters:
1710 
     - warehouseId
1711 
    """
1712 
    self.send_batchOrders(warehouseId)
1713 
    return self.recv_batchOrders()
1714 
 
1715 
  def send_batchOrders(self, warehouseId):
1716 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1717 
    args = batchOrders_args()
1718 
    args.warehouseId = warehouseId
1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1723 
  def recv_batchOrders(self, ):
1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1730 
    result = batchOrders_result()
1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
1220 chandransh 1734 
      return result.success
3431 rajveer 1735 
    if result.ex is not None:
1220 chandransh 1736 
      raise result.ex
1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1738 
 
1208 chandransh 1739 
  def markOrderAsOutOfStock(self, orderId):
1740 
    """
1741 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1742 
 
1208 chandransh 1743 
    Parameters:
1744 
     - orderId
1745 
    """
1746 
    self.send_markOrderAsOutOfStock(orderId)
1747 
    return self.recv_markOrderAsOutOfStock()
1748 
 
1749 
  def send_markOrderAsOutOfStock(self, orderId):
1750 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1751 
    args = markOrderAsOutOfStock_args()
1752 
    args.orderId = orderId
1753 
    args.write(self._oprot)
1754 
    self._oprot.writeMessageEnd()
1755 
    self._oprot.trans.flush()
1756 
 
1757 
  def recv_markOrderAsOutOfStock(self, ):
1758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1759 
    if mtype == TMessageType.EXCEPTION:
1760 
      x = TApplicationException()
1761 
      x.read(self._iprot)
1762 
      self._iprot.readMessageEnd()
1763 
      raise x
1764 
    result = markOrderAsOutOfStock_result()
1765 
    result.read(self._iprot)
1766 
    self._iprot.readMessageEnd()
3431 rajveer 1767 
    if result.success is not None:
1208 chandransh 1768 
      return result.success
3431 rajveer 1769 
    if result.ex is not None:
1208 chandransh 1770 
      raise result.ex
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1772 
 
3064 chandransh 1773 
  def verifyOrder(self, orderId):
759 chandransh 1774 
    """
3064 chandransh 1775 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1776 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1777 
    used for all other orders as well.
1778 
    Throws an exception if no such order exists.
3431 rajveer 1779 
 
759 chandransh 1780 
    Parameters:
3064 chandransh 1781 
     - orderId
759 chandransh 1782 
    """
3064 chandransh 1783 
    self.send_verifyOrder(orderId)
1784 
    return self.recv_verifyOrder()
759 chandransh 1785 
 
3064 chandransh 1786 
  def send_verifyOrder(self, orderId):
1787 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1788 
    args = verifyOrder_args()
1789 
    args.orderId = orderId
759 chandransh 1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
3064 chandransh 1794 
  def recv_verifyOrder(self, ):
759 chandransh 1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
3064 chandransh 1801 
    result = verifyOrder_result()
759 chandransh 1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
3431 rajveer 1804 
    if result.success is not None:
759 chandransh 1805 
      return result.success
3431 rajveer 1806 
    if result.ex is not None:
759 chandransh 1807 
      raise result.ex
3064 chandransh 1808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1809 
 
3064 chandransh 1810 
  def acceptOrder(self, orderId):
1113 chandransh 1811 
    """
3064 chandransh 1812 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1813 
    given order is not a COD order, it also captures the payment if the same has
1814 
    not been captured.
1815 
    Throws an exception if no such order exists.
3431 rajveer 1816 
 
1113 chandransh 1817 
    Parameters:
3064 chandransh 1818 
     - orderId
1113 chandransh 1819 
    """
3064 chandransh 1820 
    self.send_acceptOrder(orderId)
1821 
    return self.recv_acceptOrder()
1113 chandransh 1822 
 
3064 chandransh 1823 
  def send_acceptOrder(self, orderId):
1824 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1825 
    args = acceptOrder_args()
1826 
    args.orderId = orderId
1113 chandransh 1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
3064 chandransh 1831 
  def recv_acceptOrder(self, ):
1113 chandransh 1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
3064 chandransh 1838 
    result = acceptOrder_result()
1113 chandransh 1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
3431 rajveer 1841 
    if result.success is not None:
1113 chandransh 1842 
      return result.success
3431 rajveer 1843 
    if result.ex is not None:
1113 chandransh 1844 
      raise result.ex
3064 chandransh 1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1846 
 
4283 anupam.sin 1847 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1848 
    """
3064 chandransh 1849 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1850 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1851 
    the IMEI no. if a -1 is supplied.
1852 
    Also, it generates an invoice number for the order, marks the order as
1853 
    BILLED and sets the billing timestamp.
1854 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1855 
 
1135 chandransh 1856 
    Parameters:
3064 chandransh 1857 
     - orderId
1858 
     - invoice_number
4283 anupam.sin 1859 
     - imeiNumber
1860 
     - itemNumber
3064 chandransh 1861 
     - billed_by
4264 rajveer 1862 
     - jacketNumber
4283 anupam.sin 1863 
     - billingType
1864 
     - vendorId
1135 chandransh 1865 
    """
4283 anupam.sin 1866 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1867 
    return self.recv_addBillingDetails()
1135 chandransh 1868 
 
4283 anupam.sin 1869 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1870 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1871 
    args = addBillingDetails_args()
1872 
    args.orderId = orderId
1873 
    args.invoice_number = invoice_number
4283 anupam.sin 1874 
    args.imeiNumber = imeiNumber
1875 
    args.itemNumber = itemNumber
3064 chandransh 1876 
    args.billed_by = billed_by
4264 rajveer 1877 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1878 
    args.billingType = billingType
1879 
    args.vendorId = vendorId
1135 chandransh 1880 
    args.write(self._oprot)
1881 
    self._oprot.writeMessageEnd()
1882 
    self._oprot.trans.flush()
1883 
 
3064 chandransh 1884 
  def recv_addBillingDetails(self, ):
1135 chandransh 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 = addBillingDetails_result()
1135 chandransh 1892 
    result.read(self._iprot)
1893 
    self._iprot.readMessageEnd()
3431 rajveer 1894 
    if result.success is not None:
3064 chandransh 1895 
      return result.success
3431 rajveer 1896 
    if result.ex is not None:
1135 chandransh 1897 
      raise result.ex
3064 chandransh 1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1899 
 
3064 chandransh 1900 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1901 
    """
3064 chandransh 1902 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1903 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1904 
 
1408 ankur.sing 1905 
    Parameters:
3064 chandransh 1906 
     - warehouseId
1408 ankur.sing 1907 
     - providerId
3064 chandransh 1908 
     - cod
1408 ankur.sing 1909 
    """
3064 chandransh 1910 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1911 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1912 
 
3064 chandransh 1913 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1914 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1915 
    args = markOrdersAsManifested_args()
1916 
    args.warehouseId = warehouseId
1408 ankur.sing 1917 
    args.providerId = providerId
3064 chandransh 1918 
    args.cod = cod
1408 ankur.sing 1919 
    args.write(self._oprot)
1920 
    self._oprot.writeMessageEnd()
1921 
    self._oprot.trans.flush()
1922 
 
3064 chandransh 1923 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1925 
    if mtype == TMessageType.EXCEPTION:
1926 
      x = TApplicationException()
1927 
      x.read(self._iprot)
1928 
      self._iprot.readMessageEnd()
1929 
      raise x
3064 chandransh 1930 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1931 
    result.read(self._iprot)
1932 
    self._iprot.readMessageEnd()
3431 rajveer 1933 
    if result.success is not None:
1408 ankur.sing 1934 
      return result.success
3431 rajveer 1935 
    if result.ex is not None:
3064 chandransh 1936 
      raise result.ex
1937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1938 
 
3064 chandransh 1939 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1940 
    """
3064 chandransh 1941 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1942 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1943 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1944 
 
94 ashish 1945 
    Parameters:
3064 chandransh 1946 
     - providerId
1947 
     - pickupDetails
304 ashish 1948 
    """
3064 chandransh 1949 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1950 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1951 
 
3064 chandransh 1952 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1953 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1954 
    args = markOrdersAsPickedUp_args()
1955 
    args.providerId = providerId
1956 
    args.pickupDetails = pickupDetails
304 ashish 1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
3064 chandransh 1961 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
3064 chandransh 1968 
    result = markOrdersAsPickedUp_result()
304 ashish 1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
304 ashish 1972 
      return result.success
3431 rajveer 1973 
    if result.ex is not None:
3064 chandransh 1974 
      raise result.ex
1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1976 
 
3064 chandransh 1977 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1978 
    """
3064 chandransh 1979 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1980 
    the name of the receiver.
1981 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1982 
 
304 ashish 1983 
    Parameters:
3064 chandransh 1984 
     - providerId
1985 
     - deliveredOrders
304 ashish 1986 
    """
3064 chandransh 1987 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1988 
    self.recv_markOrdersAsDelivered()
304 ashish 1989 
 
3064 chandransh 1990 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1991 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1992 
    args = markOrdersAsDelivered_args()
1993 
    args.providerId = providerId
1994 
    args.deliveredOrders = deliveredOrders
304 ashish 1995 
    args.write(self._oprot)
1996 
    self._oprot.writeMessageEnd()
1997 
    self._oprot.trans.flush()
1998 
 
3064 chandransh 1999 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2001 
    if mtype == TMessageType.EXCEPTION:
2002 
      x = TApplicationException()
2003 
      x.read(self._iprot)
2004 
      self._iprot.readMessageEnd()
2005 
      raise x
3064 chandransh 2006 
    result = markOrdersAsDelivered_result()
304 ashish 2007 
    result.read(self._iprot)
2008 
    self._iprot.readMessageEnd()
3431 rajveer 2009 
    if result.ex is not None:
3064 chandransh 2010 
      raise result.ex
304 ashish 2011 
    return
2012 
 
3064 chandransh 2013 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2014 
    """
3064 chandransh 2015 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2016 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2017 
 
3064 chandransh 2018 
    Parameters:
2019 
     - providerId
2020 
     - returnedOrders
1596 ankur.sing 2021 
    """
3064 chandransh 2022 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2023 
    self.recv_markOrdersAsFailed()
304 ashish 2024 
 
3064 chandransh 2025 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2026 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2027 
    args = markOrdersAsFailed_args()
2028 
    args.providerId = providerId
2029 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2030 
    args.write(self._oprot)
2031 
    self._oprot.writeMessageEnd()
2032 
    self._oprot.trans.flush()
2033 
 
3064 chandransh 2034 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2036 
    if mtype == TMessageType.EXCEPTION:
2037 
      x = TApplicationException()
2038 
      x.read(self._iprot)
2039 
      self._iprot.readMessageEnd()
2040 
      raise x
3064 chandransh 2041 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2042 
    result.read(self._iprot)
2043 
    self._iprot.readMessageEnd()
3431 rajveer 2044 
    if result.ex is not None:
3064 chandransh 2045 
      raise result.ex
2046 
    return
1596 ankur.sing 2047 
 
3064 chandransh 2048 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2049 
    """
3064 chandransh 2050 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2051 
 
3064 chandransh 2052 
    Parameters:
2053 
     - providerId
2054 
     - undeliveredOrders
1627 ankur.sing 2055 
    """
3064 chandransh 2056 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2057 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2058 
 
3064 chandransh 2059 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2060 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2061 
    args = updateNonDeliveryReason_args()
2062 
    args.providerId = providerId
2063 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
3064 chandransh 2068 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
3064 chandransh 2075 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
3431 rajveer 2078 
    if result.ex is not None:
3064 chandransh 2079 
      raise result.ex
2080 
    return
1627 ankur.sing 2081 
 
3064 chandransh 2082 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2083 
    """
3064 chandransh 2084 
    Returns the list of orders whose delivery time has passed but have not been
2085 
    delivered yet for the given provider and warehouse. To get a complete list of
2086 
    undelivered orders, pass them as -1.
2087 
    Returns an empty list if no such orders exist.
3431 rajveer 2088 
 
1886 ankur.sing 2089 
    Parameters:
3064 chandransh 2090 
     - providerId
2091 
     - warehouseId
1886 ankur.sing 2092 
    """
3064 chandransh 2093 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2094 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2095 
 
3064 chandransh 2096 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2097 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2098 
    args = getUndeliveredOrders_args()
2099 
    args.providerId = providerId
2100 
    args.warehouseId = warehouseId
1886 ankur.sing 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
3064 chandransh 2105 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
3064 chandransh 2112 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
1886 ankur.sing 2116 
      return result.success
3064 chandransh 2117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2118 
 
2536 chandransh 2119 
  def toggleDOAFlag(self, orderId):
2120 
    """
2121 
    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.
2122 
    Returns the final flag status.
2123 
    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 2124 
 
2536 chandransh 2125 
    Parameters:
2126 
     - orderId
2127 
    """
2128 
    self.send_toggleDOAFlag(orderId)
2129 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2130 
 
2536 chandransh 2131 
  def send_toggleDOAFlag(self, orderId):
2132 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2133 
    args = toggleDOAFlag_args()
2134 
    args.orderId = orderId
2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
2139 
  def recv_toggleDOAFlag(self, ):
2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
2146 
    result = toggleDOAFlag_result()
2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
3431 rajveer 2149 
    if result.success is not None:
2536 chandransh 2150 
      return result.success
3431 rajveer 2151 
    if result.ex is not None:
2536 chandransh 2152 
      raise result.ex
2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2154 
 
2155 
  def requestPickupNumber(self, orderId):
2156 
    """
2157 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2158 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2159 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2160 
    For any other status, it returns false.
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 
    """
2166 
    self.send_requestPickupNumber(orderId)
2167 
    return self.recv_requestPickupNumber()
2168 
 
2169 
  def send_requestPickupNumber(self, orderId):
2170 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2171 
    args = requestPickupNumber_args()
2172 
    args.orderId = orderId
2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
2177 
  def recv_requestPickupNumber(self, ):
2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
2184 
    result = requestPickupNumber_result()
2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
3431 rajveer 2187 
    if result.success is not None:
2536 chandransh 2188 
      return result.success
3431 rajveer 2189 
    if result.ex is not None:
2536 chandransh 2190 
      raise result.ex
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2192 
 
2193 
  def authorizePickup(self, orderId, pickupNumber):
2194 
    """
2195 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2196 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2197 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2198 
    	3. Returns true
2591 chandransh 2199 
    If the order is in any other status, it returns false.
2536 chandransh 2200 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2201 
 
2536 chandransh 2202 
    Parameters:
2203 
     - orderId
2204 
     - pickupNumber
2205 
    """
2206 
    self.send_authorizePickup(orderId, pickupNumber)
2207 
    return self.recv_authorizePickup()
2208 
 
2209 
  def send_authorizePickup(self, orderId, pickupNumber):
2210 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2211 
    args = authorizePickup_args()
2212 
    args.orderId = orderId
2213 
    args.pickupNumber = pickupNumber
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_authorizePickup(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = authorizePickup_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
3431 rajveer 2228 
    if result.success is not None:
2536 chandransh 2229 
      return result.success
3431 rajveer 2230 
    if result.ex is not None:
2536 chandransh 2231 
      raise result.ex
2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2233 
 
2764 chandransh 2234 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2235 
    """
2236 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2237 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2238 
 
2764 chandransh 2239 
    Parameters:
2240 
     - providerId
2241 
     - pickupDetails
2242 
    """
2243 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2244 
    return self.recv_markDoasAsPickedUp()
2245 
 
2246 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2247 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2248 
    args = markDoasAsPickedUp_args()
2249 
    args.providerId = providerId
2250 
    args.pickupDetails = pickupDetails
2251 
    args.write(self._oprot)
2252 
    self._oprot.writeMessageEnd()
2253 
    self._oprot.trans.flush()
2254 
 
2255 
  def recv_markDoasAsPickedUp(self, ):
2256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2257 
    if mtype == TMessageType.EXCEPTION:
2258 
      x = TApplicationException()
2259 
      x.read(self._iprot)
2260 
      self._iprot.readMessageEnd()
2261 
      raise x
2262 
    result = markDoasAsPickedUp_result()
2263 
    result.read(self._iprot)
2264 
    self._iprot.readMessageEnd()
3431 rajveer 2265 
    if result.success is not None:
2764 chandransh 2266 
      return result.success
2267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2268 
 
2616 chandransh 2269 
  def receiveReturn(self, orderId):
2591 chandransh 2270 
    """
2599 chandransh 2271 
    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 2272 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2273 
    If the order is in any other state, it returns false.
2274 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2275 
 
2591 chandransh 2276 
    Parameters:
2277 
     - orderId
2278 
    """
2616 chandransh 2279 
    self.send_receiveReturn(orderId)
2280 
    return self.recv_receiveReturn()
2536 chandransh 2281 
 
2616 chandransh 2282 
  def send_receiveReturn(self, orderId):
2283 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2284 
    args = receiveReturn_args()
2591 chandransh 2285 
    args.orderId = orderId
2286 
    args.write(self._oprot)
2287 
    self._oprot.writeMessageEnd()
2288 
    self._oprot.trans.flush()
2289 
 
2616 chandransh 2290 
  def recv_receiveReturn(self, ):
2591 chandransh 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
2616 chandransh 2297 
    result = receiveReturn_result()
2591 chandransh 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
2616 chandransh 2304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2305 
 
2306 
  def validateDoa(self, orderId, isValid):
2307 
    """
2599 chandransh 2308 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2309 
    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 2310 
    If the order is in any other state, it returns false.
2311 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2312 
 
2591 chandransh 2313 
    Parameters:
2314 
     - orderId
2315 
     - isValid
2316 
    """
2317 
    self.send_validateDoa(orderId, isValid)
2318 
    return self.recv_validateDoa()
2319 
 
2320 
  def send_validateDoa(self, orderId, isValid):
2321 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2322 
    args = validateDoa_args()
2323 
    args.orderId = orderId
2324 
    args.isValid = isValid
2325 
    args.write(self._oprot)
2326 
    self._oprot.writeMessageEnd()
2327 
    self._oprot.trans.flush()
2328 
 
2329 
  def recv_validateDoa(self, ):
2330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2331 
    if mtype == TMessageType.EXCEPTION:
2332 
      x = TApplicationException()
2333 
      x.read(self._iprot)
2334 
      self._iprot.readMessageEnd()
2335 
      raise x
2336 
    result = validateDoa_result()
2337 
    result.read(self._iprot)
2338 
    self._iprot.readMessageEnd()
3431 rajveer 2339 
    if result.success is not None:
2591 chandransh 2340 
      return result.success
3431 rajveer 2341 
    if result.ex is not None:
2591 chandransh 2342 
      raise result.ex
2343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2344 
 
2616 chandransh 2345 
  def reshipOrder(self, orderId):
2346 
    """
2347 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2348 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2349 
    	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.
2350 
 
2351 
    If the order is in DOA_CERT_VALID state, it does the following:
2352 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2353 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2354 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2355 
 
2616 chandransh 2356 
    Returns the id of the newly created order.
3431 rajveer 2357 
 
2616 chandransh 2358 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2359 
 
2616 chandransh 2360 
    Parameters:
2361 
     - orderId
2362 
    """
2363 
    self.send_reshipOrder(orderId)
2364 
    return self.recv_reshipOrder()
2591 chandransh 2365 
 
2616 chandransh 2366 
  def send_reshipOrder(self, orderId):
2367 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2368 
    args = reshipOrder_args()
2369 
    args.orderId = orderId
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_reshipOrder(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = reshipOrder_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
3431 rajveer 2384 
    if result.success is not None:
2616 chandransh 2385 
      return result.success
3431 rajveer 2386 
    if result.ex is not None:
2616 chandransh 2387 
      raise result.ex
2388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2389 
 
3226 chandransh 2390 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2391 
    """
2392 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2393 
    	1. Creates a refund request for batch processing.
2394 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2395 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2396 
 
2616 chandransh 2397 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2398 
    	1. Creates a refund request for batch processing.
3226 chandransh 2399 
    	2. Cancels the reservation of the item in the warehouse.
2400 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2401 
 
3226 chandransh 2402 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2403 
    	1. Cancels the reservation of the item in the warehouse.
2404 
    	2. Marks the current order as CANCELED.
2405 
 
2406 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2407 
 
2616 chandransh 2408 
    Returns True if it is successful, False otherwise.
3431 rajveer 2409 
 
2616 chandransh 2410 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2411 
 
2616 chandransh 2412 
    Parameters:
2413 
     - orderId
3226 chandransh 2414 
     - refundedBy
2415 
     - reason
2616 chandransh 2416 
    """
3226 chandransh 2417 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2418 
    return self.recv_refundOrder()
2419 
 
3226 chandransh 2420 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2421 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2422 
    args = refundOrder_args()
2423 
    args.orderId = orderId
3226 chandransh 2424 
    args.refundedBy = refundedBy
2425 
    args.reason = reason
2616 chandransh 2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_refundOrder(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 = refundOrder_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
3431 rajveer 2440 
    if result.success is not None:
2616 chandransh 2441 
      return result.success
3431 rajveer 2442 
    if result.ex is not None:
2616 chandransh 2443 
      raise result.ex
2444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2445 
 
2690 chandransh 2446 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2447 
    """
2448 
    Get all return orders created between the from and to dates for the given warehouse.
2449 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2450 
 
2690 chandransh 2451 
    Parameters:
2452 
     - warehouseId
2453 
     - fromDate
2454 
     - toDate
2455 
    """
2456 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2457 
    return self.recv_getReturnOrders()
2616 chandransh 2458 
 
2690 chandransh 2459 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2460 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2461 
    args = getReturnOrders_args()
2462 
    args.warehouseId = warehouseId
2463 
    args.fromDate = fromDate
2464 
    args.toDate = toDate
2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
2469 
  def recv_getReturnOrders(self, ):
2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
2476 
    result = getReturnOrders_result()
2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
3431 rajveer 2479 
    if result.success is not None:
2690 chandransh 2480 
      return result.success
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2482 
 
2700 chandransh 2483 
  def getReturnOrder(self, id):
2484 
    """
2485 
    Returns the ReturnOrder corresponding to the given id.
2486 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2487 
 
2700 chandransh 2488 
    Parameters:
2489 
     - id
2490 
    """
2491 
    self.send_getReturnOrder(id)
2492 
    return self.recv_getReturnOrder()
2493 
 
2494 
  def send_getReturnOrder(self, id):
2495 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2496 
    args = getReturnOrder_args()
2497 
    args.id = id
2498 
    args.write(self._oprot)
2499 
    self._oprot.writeMessageEnd()
2500 
    self._oprot.trans.flush()
2501 
 
2502 
  def recv_getReturnOrder(self, ):
2503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2504 
    if mtype == TMessageType.EXCEPTION:
2505 
      x = TApplicationException()
2506 
      x.read(self._iprot)
2507 
      self._iprot.readMessageEnd()
2508 
      raise x
2509 
    result = getReturnOrder_result()
2510 
    result.read(self._iprot)
2511 
    self._iprot.readMessageEnd()
3431 rajveer 2512 
    if result.success is not None:
2700 chandransh 2513 
      return result.success
3431 rajveer 2514 
    if result.ex is not None:
2700 chandransh 2515 
      raise result.ex
2516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2517 
 
2690 chandransh 2518 
  def processReturn(self, returnOrderId):
2519 
    """
2520 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2521 
 
2690 chandransh 2522 
    Parameters:
2523 
     - returnOrderId
2524 
    """
2525 
    self.send_processReturn(returnOrderId)
2526 
    self.recv_processReturn()
2527 
 
2528 
  def send_processReturn(self, returnOrderId):
2529 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2530 
    args = processReturn_args()
2531 
    args.returnOrderId = returnOrderId
2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
2536 
  def recv_processReturn(self, ):
2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
2543 
    result = processReturn_result()
2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
3431 rajveer 2546 
    if result.ex is not None:
2690 chandransh 2547 
      raise result.ex
2548 
    return
2549 
 
2819 chandransh 2550 
  def createPurchaseOrder(self, warehouseId):
2551 
    """
2552 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2553 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2554 
 
2819 chandransh 2555 
    Parameters:
2556 
     - warehouseId
2557 
    """
2558 
    self.send_createPurchaseOrder(warehouseId)
2559 
    return self.recv_createPurchaseOrder()
2690 chandransh 2560 
 
2819 chandransh 2561 
  def send_createPurchaseOrder(self, warehouseId):
2562 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2563 
    args = createPurchaseOrder_args()
2564 
    args.warehouseId = warehouseId
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_createPurchaseOrder(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = createPurchaseOrder_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
3431 rajveer 2579 
    if result.success is not None:
2819 chandransh 2580 
      return result.success
3431 rajveer 2581 
    if result.ex is not None:
2819 chandransh 2582 
      raise result.ex
2583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2584 
 
3451 chandransh 2585 
  def updateWeight(self, orderId, weight):
2586 
    """
2587 
    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 2588 
 
3451 chandransh 2589 
    Parameters:
2590 
     - orderId
2591 
     - weight
2592 
    """
2593 
    self.send_updateWeight(orderId, weight)
2594 
    return self.recv_updateWeight()
2595 
 
2596 
  def send_updateWeight(self, orderId, weight):
2597 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2598 
    args = updateWeight_args()
2599 
    args.orderId = orderId
2600 
    args.weight = weight
2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
2605 
  def recv_updateWeight(self, ):
2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
2612 
    result = updateWeight_result()
2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
2615 
    if result.success is not None:
2616 
      return result.success
2617 
    if result.ex is not None:
2618 
      raise result.ex
2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2620 
 
3469 chandransh 2621 
  def changeItem(self, orderId, itemId):
2622 
    """
2623 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2624 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2625 
 
3469 chandransh 2626 
    Parameters:
2627 
     - orderId
2628 
     - itemId
2629 
    """
2630 
    self.send_changeItem(orderId, itemId)
2631 
    return self.recv_changeItem()
2632 
 
2633 
  def send_changeItem(self, orderId, itemId):
2634 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2635 
    args = changeItem_args()
2636 
    args.orderId = orderId
2637 
    args.itemId = itemId
2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
2642 
  def recv_changeItem(self, ):
2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
2649 
    result = changeItem_result()
2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
2652 
    if result.success is not None:
2653 
      return result.success
2654 
    if result.ex is not None:
2655 
      raise result.ex
2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2657 
 
2658 
  def shiftToWarehouse(self, orderId, warehouseId):
2659 
    """
2660 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2661 
 
2662 
    Parameters:
2663 
     - orderId
2664 
     - warehouseId
2665 
    """
2666 
    self.send_shiftToWarehouse(orderId, warehouseId)
2667 
    return self.recv_shiftToWarehouse()
2668 
 
2669 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2670 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2671 
    args = shiftToWarehouse_args()
2672 
    args.orderId = orderId
2673 
    args.warehouseId = warehouseId
2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2678 
  def recv_shiftToWarehouse(self, ):
2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2685 
    result = shiftToWarehouse_result()
2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
2688 
    if result.success is not None:
2689 
      return result.success
2690 
    if result.ex is not None:
2691 
      raise result.ex
2692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2693 
 
3986 chandransh 2694 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2695 
    """
2696 
    Adds the given delay reason to the given order.
3986 chandransh 2697 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2698 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2699 
 
3553 chandransh 2700 
    Parameters:
2701 
     - orderId
2702 
     - delayReason
3986 chandransh 2703 
     - furtherDelay
3553 chandransh 2704 
    """
3986 chandransh 2705 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2706 
    return self.recv_addDelayReason()
2707 
 
3986 chandransh 2708 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2709 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2710 
    args = addDelayReason_args()
2711 
    args.orderId = orderId
2712 
    args.delayReason = delayReason
3986 chandransh 2713 
    args.furtherDelay = furtherDelay
3553 chandransh 2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2718 
  def recv_addDelayReason(self, ):
2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2725 
    result = addDelayReason_result()
2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success is not None:
2729 
      return result.success
2730 
    if result.ex is not None:
2731 
      raise result.ex
2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2733 
 
3956 chandransh 2734 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2735 
    """
2736 
    Marks the COD orders with given AWB nos. as having been processed.
2737 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2738 
 
3956 chandransh 2739 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2740 
    1. There is no order corresponding to an AWB number.
2741 
    2. The captured amount for a payment exceeds the total payment.
2742 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2743 
 
2744 
    Parameters:
2745 
     - collectedAmountMap
2746 
     - xferBy
2747 
     - xferTxnId
2748 
     - xferDate
2749 
    """
2750 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2751 
    return self.recv_reconcileCodCollection()
2752 
 
2753 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2754 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2755 
    args = reconcileCodCollection_args()
2756 
    args.collectedAmountMap = collectedAmountMap
2757 
    args.xferBy = xferBy
2758 
    args.xferTxnId = xferTxnId
2759 
    args.xferDate = xferDate
2760 
    args.write(self._oprot)
2761 
    self._oprot.writeMessageEnd()
2762 
    self._oprot.trans.flush()
2763 
 
2764 
  def recv_reconcileCodCollection(self, ):
2765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2766 
    if mtype == TMessageType.EXCEPTION:
2767 
      x = TApplicationException()
2768 
      x.read(self._iprot)
2769 
      self._iprot.readMessageEnd()
2770 
      raise x
2771 
    result = reconcileCodCollection_result()
2772 
    result.read(self._iprot)
2773 
    self._iprot.readMessageEnd()
2774 
    if result.success is not None:
2775 
      return result.success
2776 
    if result.ex is not None:
2777 
      raise result.ex
2778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2779 
 
4008 mandeep.dh 2780 
  def getTransactionsRequiringExtraProcessing(self, category):
2781 
    """
4065 mandeep.dh 2782 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2783 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2784 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2785 
 
4008 mandeep.dh 2786 
    Parameters:
2787 
     - category
2788 
    """
2789 
    self.send_getTransactionsRequiringExtraProcessing(category)
2790 
    return self.recv_getTransactionsRequiringExtraProcessing()
2791 
 
2792 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2793 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2794 
    args = getTransactionsRequiringExtraProcessing_args()
2795 
    args.category = category
2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
2800 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
2807 
    result = getTransactionsRequiringExtraProcessing_result()
2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
2810 
    if result.success is not None:
2811 
      return result.success
2812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2813 
 
2814 
  def markTransactionAsProcessed(self, transactionId, category):
2815 
    """
2816 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2817 
    It essentially deletes the transaction id record for a particular
2818 
    processing type category (if present) from DB.
2819 
    This is currently used by CRM application.
4008 mandeep.dh 2820 
 
2821 
    Parameters:
2822 
     - transactionId
2823 
     - category
2824 
    """
2825 
    self.send_markTransactionAsProcessed(transactionId, category)
2826 
    self.recv_markTransactionAsProcessed()
2827 
 
2828 
  def send_markTransactionAsProcessed(self, transactionId, category):
2829 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2830 
    args = markTransactionAsProcessed_args()
2831 
    args.transactionId = transactionId
2832 
    args.category = category
2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
2837 
  def recv_markTransactionAsProcessed(self, ):
2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
2844 
    result = markTransactionAsProcessed_result()
2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
2847 
    return
2848 
 
4018 chandransh 2849 
  def getItemWiseRiskyOrdersCount(self, ):
2850 
    """
2851 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2852 
    is defined as one whose shipping date is about to expire.
2853 
    """
2854 
    self.send_getItemWiseRiskyOrdersCount()
2855 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2856 
 
4018 chandransh 2857 
  def send_getItemWiseRiskyOrdersCount(self, ):
2858 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2859 
    args = getItemWiseRiskyOrdersCount_args()
2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2864 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2871 
    result = getItemWiseRiskyOrdersCount_result()
2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
2874 
    if result.success is not None:
2875 
      return result.success
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2877 
 
4295 varun.gupt 2878 
  def getOrdersForItemIds(self, itemIds):
2879 
    """
2880 
    Returns a list of all orders which have items with given id
2881 
 
2882 
    Parameters:
2883 
     - itemIds
2884 
    """
2885 
    self.send_getOrdersForItemIds(itemIds)
2886 
    return self.recv_getOrdersForItemIds()
2887 
 
2888 
  def send_getOrdersForItemIds(self, itemIds):
2889 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2890 
    args = getOrdersForItemIds_args()
2891 
    args.itemIds = itemIds
2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2896 
  def recv_getOrdersForItemIds(self, ):
2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2903 
    result = getOrdersForItemIds_result()
2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
2906 
    if result.success is not None:
2907 
      return result.success
2908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2909 
 
4247 rajveer 2910 
  def markOrderCancellationRequestReceived(self, orderId):
2911 
    """
2912 
    Mark order as cancellation request received. If customer sends request of cancellation of
2913 
    a particular order, this method will be called. It will just change status of the order
2914 
    depending on its current status. It also records the previous status, so that we can move
2915 
    back to that status if cancellation request is denied.
4018 chandransh 2916 
 
4247 rajveer 2917 
    Parameters:
2918 
     - orderId
2919 
    """
2920 
    self.send_markOrderCancellationRequestReceived(orderId)
2921 
    self.recv_markOrderCancellationRequestReceived()
2922 
 
2923 
  def send_markOrderCancellationRequestReceived(self, orderId):
2924 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2925 
    args = markOrderCancellationRequestReceived_args()
2926 
    args.orderId = orderId
2927 
    args.write(self._oprot)
2928 
    self._oprot.writeMessageEnd()
2929 
    self._oprot.trans.flush()
2930 
 
2931 
  def recv_markOrderCancellationRequestReceived(self, ):
2932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2933 
    if mtype == TMessageType.EXCEPTION:
2934 
      x = TApplicationException()
2935 
      x.read(self._iprot)
2936 
      self._iprot.readMessageEnd()
2937 
      raise x
2938 
    result = markOrderCancellationRequestReceived_result()
2939 
    result.read(self._iprot)
2940 
    self._iprot.readMessageEnd()
2941 
    if result.ex is not None:
2942 
      raise result.ex
2943 
    return
2944 
 
2945 
  def markOrderCancellationRequestConfirmed(self, orderId):
2946 
    """
2947 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2948 
    cancellation request confirmed. After this OM will be able to cancel the order.
2949 
 
2950 
    Parameters:
2951 
     - orderId
2952 
    """
2953 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2954 
    self.recv_markOrderCancellationRequestConfirmed()
2955 
 
2956 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2957 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2958 
    args = markOrderCancellationRequestConfirmed_args()
2959 
    args.orderId = orderId
2960 
    args.write(self._oprot)
2961 
    self._oprot.writeMessageEnd()
2962 
    self._oprot.trans.flush()
2963 
 
2964 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2966 
    if mtype == TMessageType.EXCEPTION:
2967 
      x = TApplicationException()
2968 
      x.read(self._iprot)
2969 
      self._iprot.readMessageEnd()
2970 
      raise x
2971 
    result = markOrderCancellationRequestConfirmed_result()
2972 
    result.read(self._iprot)
2973 
    self._iprot.readMessageEnd()
2974 
    if result.ex is not None:
2975 
      raise result.ex
2976 
    return
2977 
 
2978 
  def markOrderCancellationRequestDenied(self, orderId):
2979 
    """
2980 
    If we decide to not to cancel order, we will move the order ro previous status.
2981 
 
2982 
    Parameters:
2983 
     - orderId
2984 
    """
2985 
    self.send_markOrderCancellationRequestDenied(orderId)
2986 
    self.recv_markOrderCancellationRequestDenied()
2987 
 
2988 
  def send_markOrderCancellationRequestDenied(self, orderId):
2989 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2990 
    args = markOrderCancellationRequestDenied_args()
2991 
    args.orderId = orderId
2992 
    args.write(self._oprot)
2993 
    self._oprot.writeMessageEnd()
2994 
    self._oprot.trans.flush()
2995 
 
2996 
  def recv_markOrderCancellationRequestDenied(self, ):
2997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2998 
    if mtype == TMessageType.EXCEPTION:
2999 
      x = TApplicationException()
3000 
      x.read(self._iprot)
3001 
      self._iprot.readMessageEnd()
3002 
      raise x
3003 
    result = markOrderCancellationRequestDenied_result()
3004 
    result.read(self._iprot)
3005 
    self._iprot.readMessageEnd()
3006 
    if result.ex is not None:
3007 
      raise result.ex
3008 
    return
3009 
 
4258 rajveer 3010 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3011 
    """
4258 rajveer 3012 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3013 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3014 
 
3015 
    Parameters:
4258 rajveer 3016 
     - transactionId
4247 rajveer 3017 
    """
4258 rajveer 3018 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3019 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3020 
 
4258 rajveer 3021 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3022 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3023 
    args = markTransactionAsPaymentFlagRemoved_args()
3024 
    args.transactionId = transactionId
4247 rajveer 3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
4258 rajveer 3029 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
4258 rajveer 3036 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3039 
    if result.ex is not None:
3040 
      raise result.ex
3041 
    return
3042 
 
4259 anupam.sin 3043 
  def refundTransaction(self, transactionId, refundedBy, reason):
3044 
    """
3045 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3046 
    need to be cancelled
4247 rajveer 3047 
 
4259 anupam.sin 3048 
    Parameters:
3049 
     - transactionId
3050 
     - refundedBy
3051 
     - reason
3052 
    """
3053 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3054 
    self.recv_refundTransaction()
3055 
 
3056 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3057 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3058 
    args = refundTransaction_args()
3059 
    args.transactionId = transactionId
3060 
    args.refundedBy = refundedBy
3061 
    args.reason = reason
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_refundTransaction(self, ):
3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
3073 
    result = refundTransaction_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3076 
    if result.ex is not None:
3077 
      raise result.ex
3078 
    return
3079 
 
4285 rajveer 3080 
  def acceptOrdersForItemId(self, itemId, inventory):
3081 
    """
3082 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3083 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3084 
 
4285 rajveer 3085 
    Parameters:
3086 
     - itemId
3087 
     - inventory
3088 
    """
3089 
    self.send_acceptOrdersForItemId(itemId, inventory)
3090 
    return self.recv_acceptOrdersForItemId()
3091 
 
3092 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3093 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3094 
    args = acceptOrdersForItemId_args()
3095 
    args.itemId = itemId
3096 
    args.inventory = inventory
3097 
    args.write(self._oprot)
3098 
    self._oprot.writeMessageEnd()
3099 
    self._oprot.trans.flush()
3100 
 
3101 
  def recv_acceptOrdersForItemId(self, ):
3102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3103 
    if mtype == TMessageType.EXCEPTION:
3104 
      x = TApplicationException()
3105 
      x.read(self._iprot)
3106 
      self._iprot.readMessageEnd()
3107 
      raise x
3108 
    result = acceptOrdersForItemId_result()
3109 
    result.read(self._iprot)
3110 
    self._iprot.readMessageEnd()
3111 
    if result.success is not None:
3112 
      return result.success
3113 
    if result.ex is not None:
3114 
      raise result.ex
3115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3116 
 
4303 rajveer 3117 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
3118 
    """
3119 
    Parameters:
3120 
     - vendorId
3121 
     - itemId
3122 
     - quantity
3123 
     - estimate
3124 
    """
3125 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate)
3126 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3127 
 
4303 rajveer 3128 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
3129 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3130 
    args = markOrdersAsPORaised_args()
3131 
    args.vendorId = vendorId
3132 
    args.itemId = itemId
3133 
    args.quantity = quantity
3134 
    args.estimate = estimate
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_markOrdersAsPORaised(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = markOrdersAsPORaised_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.ex is not None:
3150 
      raise result.ex
3151 
    return
3152 
 
3153 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
3154 
    """
3155 
    Parameters:
3156 
     - vendorId
3157 
     - itemId
3158 
     - quantity
3159 
     - estimate
3160 
    """
3161 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate)
3162 
    self.recv_markOrdersAsReversalInitiated()
3163 
 
3164 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
3165 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3166 
    args = markOrdersAsReversalInitiated_args()
3167 
    args.vendorId = vendorId
3168 
    args.itemId = itemId
3169 
    args.quantity = quantity
3170 
    args.estimate = estimate
3171 
    args.write(self._oprot)
3172 
    self._oprot.writeMessageEnd()
3173 
    self._oprot.trans.flush()
3174 
 
3175 
  def recv_markOrdersAsReversalInitiated(self, ):
3176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3177 
    if mtype == TMessageType.EXCEPTION:
3178 
      x = TApplicationException()
3179 
      x.read(self._iprot)
3180 
      self._iprot.readMessageEnd()
3181 
      raise x
3182 
    result = markOrdersAsReversalInitiated_result()
3183 
    result.read(self._iprot)
3184 
    self._iprot.readMessageEnd()
3185 
    if result.ex is not None:
3186 
      raise result.ex
3187 
    return
3188 
 
3189 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
3190 
    """
3191 
    Parameters:
3192 
     - vendorId
3193 
     - itemId
3194 
     - quantity
3195 
     - estimate
3196 
    """
3197 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate)
3198 
    self.recv_markOrdersAsNotAvailabke()
3199 
 
3200 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
3201 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3202 
    args = markOrdersAsNotAvailabke_args()
3203 
    args.vendorId = vendorId
3204 
    args.itemId = itemId
3205 
    args.quantity = quantity
3206 
    args.estimate = estimate
3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_markOrdersAsNotAvailabke(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = markOrdersAsNotAvailabke_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.ex is not None:
3222 
      raise result.ex
3223 
    return
3224 
 
3225 
 
3376 rajveer 3226 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3227 
  def __init__(self, handler):
3376 rajveer 3228 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3229 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3230 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3231 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3232 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3233 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3234 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3235 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3236 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3237 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3238 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3239 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3240 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3241 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3242 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3243 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3244 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3245 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3246 
    self._processMap["createOrder"] = Processor.process_createOrder
3247 
    self._processMap["getOrder"] = Processor.process_getOrder
3248 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3249 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3250 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3251 
    self._processMap["setAlert"] = Processor.process_setAlert
3252 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3253 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3254 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3255 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3256 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3257 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3258 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3259 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3260 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3261 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3262 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3263 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3264 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3265 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3266 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3267 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3268 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3269 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3270 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3271 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3272 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3273 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3274 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3275 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3276 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3277 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3278 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3279 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3280 
    self._processMap["changeItem"] = Processor.process_changeItem
3281 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3282 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3283 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3284 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3285 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3286 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3287 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3288 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3289 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3290 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3291 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3292 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4285 rajveer 3293 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3294 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3295 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3296 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
94 ashish 3297 
 
3298 
  def process(self, iprot, oprot):
3299 
    (name, type, seqid) = iprot.readMessageBegin()
3300 
    if name not in self._processMap:
3301 
      iprot.skip(TType.STRUCT)
3302 
      iprot.readMessageEnd()
3303 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3304 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3305 
      x.write(oprot)
3306 
      oprot.writeMessageEnd()
3307 
      oprot.trans.flush()
3308 
      return
3309 
    else:
3310 
      self._processMap[name](self, seqid, iprot, oprot)
3311 
    return True
3312 
 
3313 
  def process_createTransaction(self, seqid, iprot, oprot):
3314 
    args = createTransaction_args()
3315 
    args.read(iprot)
3316 
    iprot.readMessageEnd()
3317 
    result = createTransaction_result()
3318 
    try:
132 ashish 3319 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3320 
    except TransactionServiceException, ex:
3321 
      result.ex = ex
3322 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3323 
    result.write(oprot)
3324 
    oprot.writeMessageEnd()
3325 
    oprot.trans.flush()
3326 
 
3327 
  def process_getTransaction(self, seqid, iprot, oprot):
3328 
    args = getTransaction_args()
3329 
    args.read(iprot)
3330 
    iprot.readMessageEnd()
3331 
    result = getTransaction_result()
3332 
    try:
3333 
      result.success = self._handler.getTransaction(args.id)
3334 
    except TransactionServiceException, ex:
3335 
      result.ex = ex
3336 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3337 
    result.write(oprot)
3338 
    oprot.writeMessageEnd()
3339 
    oprot.trans.flush()
3340 
 
3341 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3342 
    args = getTransactionsForCustomer_args()
3343 
    args.read(iprot)
3344 
    iprot.readMessageEnd()
3345 
    result = getTransactionsForCustomer_result()
3346 
    try:
3347 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3348 
    except TransactionServiceException, ex:
3349 
      result.ex = ex
3350 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3351 
    result.write(oprot)
3352 
    oprot.writeMessageEnd()
3353 
    oprot.trans.flush()
3354 
 
132 ashish 3355 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3356 
    args = getTransactionsForShoppingCartId_args()
3357 
    args.read(iprot)
3358 
    iprot.readMessageEnd()
3359 
    result = getTransactionsForShoppingCartId_result()
3360 
    try:
3361 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3362 
    except TransactionServiceException, ex:
3363 
      result.ex = ex
3364 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3365 
    result.write(oprot)
3366 
    oprot.writeMessageEnd()
3367 
    oprot.trans.flush()
3368 
 
94 ashish 3369 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3370 
    args = getTransactionStatus_args()
3371 
    args.read(iprot)
3372 
    iprot.readMessageEnd()
3373 
    result = getTransactionStatus_result()
3374 
    try:
3375 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3376 
    except TransactionServiceException, ex:
3377 
      result.ex = ex
3378 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3379 
    result.write(oprot)
3380 
    oprot.writeMessageEnd()
3381 
    oprot.trans.flush()
3382 
 
3383 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3384 
    args = changeTransactionStatus_args()
3385 
    args.read(iprot)
3386 
    iprot.readMessageEnd()
3387 
    result = changeTransactionStatus_result()
3388 
    try:
3389 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3390 
    except TransactionServiceException, ex:
3391 
      result.ex = ex
3392 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3393 
    result.write(oprot)
3394 
    oprot.writeMessageEnd()
3395 
    oprot.trans.flush()
3396 
 
1398 varun.gupt 3397 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3398 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3399 
    args.read(iprot)
3400 
    iprot.readMessageEnd()
1398 varun.gupt 3401 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3402 
    try:
1398 varun.gupt 3403 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3404 
    except TransactionServiceException, ex:
3405 
      result.ex = ex
1398 varun.gupt 3406 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3407 
    result.write(oprot)
3408 
    oprot.writeMessageEnd()
3409 
    oprot.trans.flush()
3410 
 
483 rajveer 3411 
  def process_getAllOrders(self, seqid, iprot, oprot):
3412 
    args = getAllOrders_args()
94 ashish 3413 
    args.read(iprot)
3414 
    iprot.readMessageEnd()
483 rajveer 3415 
    result = getAllOrders_result()
94 ashish 3416 
    try:
483 rajveer 3417 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3418 
    except TransactionServiceException, ex:
3419 
      result.ex = ex
483 rajveer 3420 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3421 
    result.write(oprot)
3422 
    oprot.writeMessageEnd()
3423 
    oprot.trans.flush()
3424 
 
4133 chandransh 3425 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3426 
    args = getOrdersInBatch_args()
3427 
    args.read(iprot)
3428 
    iprot.readMessageEnd()
3429 
    result = getOrdersInBatch_result()
3430 
    try:
3431 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3432 
    except TransactionServiceException, ex:
3433 
      result.ex = ex
3434 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3435 
    result.write(oprot)
3436 
    oprot.writeMessageEnd()
3437 
    oprot.trans.flush()
3438 
 
3439 
  def process_getOrderCount(self, seqid, iprot, oprot):
3440 
    args = getOrderCount_args()
3441 
    args.read(iprot)
3442 
    iprot.readMessageEnd()
3443 
    result = getOrderCount_result()
3444 
    try:
3445 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3446 
    except TransactionServiceException, ex:
3447 
      result.ex = ex
3448 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3449 
    result.write(oprot)
3450 
    oprot.writeMessageEnd()
3451 
    oprot.trans.flush()
3452 
 
999 varun.gupt 3453 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3454 
    args = getOrdersByBillingDate_args()
3455 
    args.read(iprot)
3456 
    iprot.readMessageEnd()
3457 
    result = getOrdersByBillingDate_result()
3458 
    try:
3459 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3460 
    except TransactionServiceException, ex:
3461 
      result.ex = ex
3462 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3463 
    result.write(oprot)
3464 
    oprot.writeMessageEnd()
3465 
    oprot.trans.flush()
3466 
 
3427 chandransh 3467 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3468 
    args = getOrdersByShippingDate_args()
3469 
    args.read(iprot)
3470 
    iprot.readMessageEnd()
3471 
    result = getOrdersByShippingDate_result()
3472 
    try:
3451 chandransh 3473 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3474 
    except TransactionServiceException, ex:
3475 
      result.ex = ex
3476 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3477 
    result.write(oprot)
3478 
    oprot.writeMessageEnd()
3479 
    oprot.trans.flush()
3480 
 
1382 varun.gupt 3481 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3482 
    args = getReturnableOrdersForCustomer_args()
3483 
    args.read(iprot)
3484 
    iprot.readMessageEnd()
3485 
    result = getReturnableOrdersForCustomer_result()
3486 
    try:
3487 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3488 
    except TransactionServiceException, ex:
3489 
      result.ex = ex
3490 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3491 
    result.write(oprot)
3492 
    oprot.writeMessageEnd()
3493 
    oprot.trans.flush()
3494 
 
3495 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3496 
    args = getCancellableOrdersForCustomer_args()
3497 
    args.read(iprot)
3498 
    iprot.readMessageEnd()
3499 
    result = getCancellableOrdersForCustomer_result()
3500 
    try:
3501 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3502 
    except TransactionServiceException, ex:
3503 
      result.ex = ex
3504 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3505 
    result.write(oprot)
3506 
    oprot.writeMessageEnd()
3507 
    oprot.trans.flush()
3508 
 
483 rajveer 3509 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3510 
    args = changeOrderStatus_args()
94 ashish 3511 
    args.read(iprot)
3512 
    iprot.readMessageEnd()
483 rajveer 3513 
    result = changeOrderStatus_result()
94 ashish 3514 
    try:
483 rajveer 3515 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3516 
    except TransactionServiceException, ex:
3517 
      result.ex = ex
483 rajveer 3518 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3519 
    result.write(oprot)
3520 
    oprot.writeMessageEnd()
3521 
    oprot.trans.flush()
3522 
 
483 rajveer 3523 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3524 
    args = getOrdersForTransaction_args()
94 ashish 3525 
    args.read(iprot)
3526 
    iprot.readMessageEnd()
483 rajveer 3527 
    result = getOrdersForTransaction_result()
94 ashish 3528 
    try:
1528 ankur.sing 3529 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3530 
    except TransactionServiceException, ex:
3531 
      result.ex = ex
483 rajveer 3532 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3533 
    result.write(oprot)
3534 
    oprot.writeMessageEnd()
3535 
    oprot.trans.flush()
3536 
 
483 rajveer 3537 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3538 
    args = getOrdersForCustomer_args()
94 ashish 3539 
    args.read(iprot)
3540 
    iprot.readMessageEnd()
483 rajveer 3541 
    result = getOrdersForCustomer_result()
94 ashish 3542 
    try:
3014 chandransh 3543 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3544 
    except TransactionServiceException, ex:
3545 
      result.ex = ex
483 rajveer 3546 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3547 
    result.write(oprot)
3548 
    oprot.writeMessageEnd()
3549 
    oprot.trans.flush()
3550 
 
483 rajveer 3551 
  def process_createOrder(self, seqid, iprot, oprot):
3552 
    args = createOrder_args()
94 ashish 3553 
    args.read(iprot)
3554 
    iprot.readMessageEnd()
483 rajveer 3555 
    result = createOrder_result()
94 ashish 3556 
    try:
483 rajveer 3557 
      result.success = self._handler.createOrder(args.order)
94 ashish 3558 
    except TransactionServiceException, ex:
3559 
      result.ex = ex
483 rajveer 3560 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3561 
    result.write(oprot)
3562 
    oprot.writeMessageEnd()
3563 
    oprot.trans.flush()
3564 
 
483 rajveer 3565 
  def process_getOrder(self, seqid, iprot, oprot):
3566 
    args = getOrder_args()
94 ashish 3567 
    args.read(iprot)
3568 
    iprot.readMessageEnd()
483 rajveer 3569 
    result = getOrder_result()
94 ashish 3570 
    try:
483 rajveer 3571 
      result.success = self._handler.getOrder(args.id)
94 ashish 3572 
    except TransactionServiceException, ex:
3573 
      result.ex = ex
483 rajveer 3574 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3575 
    result.write(oprot)
3576 
    oprot.writeMessageEnd()
3577 
    oprot.trans.flush()
3578 
 
483 rajveer 3579 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3580 
    args = getLineItemsForOrder_args()
94 ashish 3581 
    args.read(iprot)
3582 
    iprot.readMessageEnd()
483 rajveer 3583 
    result = getLineItemsForOrder_result()
94 ashish 3584 
    try:
483 rajveer 3585 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3586 
    except TransactionServiceException, ex:
3587 
      result.ex = ex
483 rajveer 3588 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3589 
    result.write(oprot)
3590 
    oprot.writeMessageEnd()
3591 
    oprot.trans.flush()
3592 
 
1528 ankur.sing 3593 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3594 
    args = getOrderForCustomer_args()
3595 
    args.read(iprot)
3596 
    iprot.readMessageEnd()
3597 
    result = getOrderForCustomer_result()
3598 
    try:
3599 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3600 
    except TransactionServiceException, ex:
3601 
      result.ex = ex
3602 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3603 
    result.write(oprot)
3604 
    oprot.writeMessageEnd()
3605 
    oprot.trans.flush()
3606 
 
3064 chandransh 3607 
  def process_getAlerts(self, seqid, iprot, oprot):
3608 
    args = getAlerts_args()
3609 
    args.read(iprot)
3610 
    iprot.readMessageEnd()
3611 
    result = getAlerts_result()
3612 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3613 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3614 
    result.write(oprot)
3615 
    oprot.writeMessageEnd()
3616 
    oprot.trans.flush()
3617 
 
3618 
  def process_setAlert(self, seqid, iprot, oprot):
3619 
    args = setAlert_args()
3620 
    args.read(iprot)
3621 
    iprot.readMessageEnd()
3622 
    result = setAlert_result()
3623 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3624 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3625 
    result.write(oprot)
3626 
    oprot.writeMessageEnd()
3627 
    oprot.trans.flush()
3628 
 
3629 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3630 
    args = getValidOrderCount_args()
3631 
    args.read(iprot)
3632 
    iprot.readMessageEnd()
3633 
    result = getValidOrderCount_result()
3634 
    result.success = self._handler.getValidOrderCount()
3635 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3636 
    result.write(oprot)
3637 
    oprot.writeMessageEnd()
3638 
    oprot.trans.flush()
3639 
 
3640 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3641 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3642 
    args.read(iprot)
3643 
    iprot.readMessageEnd()
3644 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3645 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3646 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3647 
    result.write(oprot)
3648 
    oprot.writeMessageEnd()
3649 
    oprot.trans.flush()
3650 
 
3651 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3652 
    args = getValidOrdersAmountRange_args()
3653 
    args.read(iprot)
3654 
    iprot.readMessageEnd()
3655 
    result = getValidOrdersAmountRange_result()
3656 
    result.success = self._handler.getValidOrdersAmountRange()
3657 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3658 
    result.write(oprot)
3659 
    oprot.writeMessageEnd()
3660 
    oprot.trans.flush()
3661 
 
3662 
  def process_getValidOrders(self, seqid, iprot, oprot):
3663 
    args = getValidOrders_args()
3664 
    args.read(iprot)
3665 
    iprot.readMessageEnd()
3666 
    result = getValidOrders_result()
3667 
    result.success = self._handler.getValidOrders(args.limit)
3668 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3669 
    result.write(oprot)
3670 
    oprot.writeMessageEnd()
3671 
    oprot.trans.flush()
3672 
 
1220 chandransh 3673 
  def process_batchOrders(self, seqid, iprot, oprot):
3674 
    args = batchOrders_args()
3675 
    args.read(iprot)
3676 
    iprot.readMessageEnd()
3677 
    result = batchOrders_result()
3678 
    try:
3679 
      result.success = self._handler.batchOrders(args.warehouseId)
3680 
    except TransactionServiceException, ex:
3681 
      result.ex = ex
3682 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3683 
    result.write(oprot)
3684 
    oprot.writeMessageEnd()
3685 
    oprot.trans.flush()
3686 
 
1208 chandransh 3687 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3688 
    args = markOrderAsOutOfStock_args()
3689 
    args.read(iprot)
3690 
    iprot.readMessageEnd()
3691 
    result = markOrderAsOutOfStock_result()
3692 
    try:
3693 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3694 
    except TransactionServiceException, ex:
3695 
      result.ex = ex
3696 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3697 
    result.write(oprot)
3698 
    oprot.writeMessageEnd()
3699 
    oprot.trans.flush()
3700 
 
3064 chandransh 3701 
  def process_verifyOrder(self, seqid, iprot, oprot):
3702 
    args = verifyOrder_args()
759 chandransh 3703 
    args.read(iprot)
3704 
    iprot.readMessageEnd()
3064 chandransh 3705 
    result = verifyOrder_result()
759 chandransh 3706 
    try:
3064 chandransh 3707 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3708 
    except TransactionServiceException, ex:
3709 
      result.ex = ex
3064 chandransh 3710 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3711 
    result.write(oprot)
3712 
    oprot.writeMessageEnd()
3713 
    oprot.trans.flush()
3714 
 
3064 chandransh 3715 
  def process_acceptOrder(self, seqid, iprot, oprot):
3716 
    args = acceptOrder_args()
1113 chandransh 3717 
    args.read(iprot)
3718 
    iprot.readMessageEnd()
3064 chandransh 3719 
    result = acceptOrder_result()
1113 chandransh 3720 
    try:
3064 chandransh 3721 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3722 
    except TransactionServiceException, ex:
3723 
      result.ex = ex
3064 chandransh 3724 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3725 
    result.write(oprot)
3726 
    oprot.writeMessageEnd()
3727 
    oprot.trans.flush()
3728 
 
3064 chandransh 3729 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3730 
    args = addBillingDetails_args()
1135 chandransh 3731 
    args.read(iprot)
3732 
    iprot.readMessageEnd()
3064 chandransh 3733 
    result = addBillingDetails_result()
1135 chandransh 3734 
    try:
4283 anupam.sin 3735 
      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 3736 
    except TransactionServiceException, ex:
3737 
      result.ex = ex
3064 chandransh 3738 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3739 
    result.write(oprot)
3740 
    oprot.writeMessageEnd()
3741 
    oprot.trans.flush()
3742 
 
3064 chandransh 3743 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3744 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3745 
    args.read(iprot)
3746 
    iprot.readMessageEnd()
3064 chandransh 3747 
    result = markOrdersAsManifested_result()
3748 
    try:
3749 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3750 
    except TransactionServiceException, ex:
3751 
      result.ex = ex
3752 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3753 
    result.write(oprot)
3754 
    oprot.writeMessageEnd()
3755 
    oprot.trans.flush()
3756 
 
3064 chandransh 3757 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3758 
    args = markOrdersAsPickedUp_args()
304 ashish 3759 
    args.read(iprot)
3760 
    iprot.readMessageEnd()
3064 chandransh 3761 
    result = markOrdersAsPickedUp_result()
3762 
    try:
3763 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3764 
    except TransactionServiceException, ex:
3765 
      result.ex = ex
3766 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3767 
    result.write(oprot)
3768 
    oprot.writeMessageEnd()
3769 
    oprot.trans.flush()
94 ashish 3770 
 
3064 chandransh 3771 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3772 
    args = markOrdersAsDelivered_args()
304 ashish 3773 
    args.read(iprot)
3774 
    iprot.readMessageEnd()
3064 chandransh 3775 
    result = markOrdersAsDelivered_result()
3776 
    try:
3777 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3778 
    except TransactionServiceException, ex:
3779 
      result.ex = ex
3780 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3781 
    result.write(oprot)
3782 
    oprot.writeMessageEnd()
3783 
    oprot.trans.flush()
3784 
 
3064 chandransh 3785 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3786 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3787 
    args.read(iprot)
3788 
    iprot.readMessageEnd()
3064 chandransh 3789 
    result = markOrdersAsFailed_result()
3790 
    try:
3791 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3792 
    except TransactionServiceException, ex:
3793 
      result.ex = ex
3794 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3795 
    result.write(oprot)
3796 
    oprot.writeMessageEnd()
3797 
    oprot.trans.flush()
304 ashish 3798 
 
3064 chandransh 3799 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3800 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3801 
    args.read(iprot)
3802 
    iprot.readMessageEnd()
3064 chandransh 3803 
    result = updateNonDeliveryReason_result()
3804 
    try:
3805 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3806 
    except TransactionServiceException, ex:
3807 
      result.ex = ex
3808 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3809 
    result.write(oprot)
3810 
    oprot.writeMessageEnd()
3811 
    oprot.trans.flush()
1596 ankur.sing 3812 
 
3064 chandransh 3813 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3814 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3815 
    args.read(iprot)
3816 
    iprot.readMessageEnd()
3064 chandransh 3817 
    result = getUndeliveredOrders_result()
3818 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3819 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3820 
    result.write(oprot)
3821 
    oprot.writeMessageEnd()
3822 
    oprot.trans.flush()
3823 
 
2536 chandransh 3824 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3825 
    args = toggleDOAFlag_args()
3826 
    args.read(iprot)
3827 
    iprot.readMessageEnd()
3828 
    result = toggleDOAFlag_result()
3829 
    try:
3830 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3831 
    except TransactionServiceException, ex:
3832 
      result.ex = ex
3833 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3834 
    result.write(oprot)
3835 
    oprot.writeMessageEnd()
3836 
    oprot.trans.flush()
1886 ankur.sing 3837 
 
2536 chandransh 3838 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3839 
    args = requestPickupNumber_args()
3840 
    args.read(iprot)
3841 
    iprot.readMessageEnd()
3842 
    result = requestPickupNumber_result()
3843 
    try:
3844 
      result.success = self._handler.requestPickupNumber(args.orderId)
3845 
    except TransactionServiceException, ex:
3846 
      result.ex = ex
3847 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3848 
    result.write(oprot)
3849 
    oprot.writeMessageEnd()
3850 
    oprot.trans.flush()
3851 
 
3852 
  def process_authorizePickup(self, seqid, iprot, oprot):
3853 
    args = authorizePickup_args()
3854 
    args.read(iprot)
3855 
    iprot.readMessageEnd()
3856 
    result = authorizePickup_result()
3857 
    try:
3858 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3859 
    except TransactionServiceException, ex:
3860 
      result.ex = ex
3861 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3862 
    result.write(oprot)
3863 
    oprot.writeMessageEnd()
3864 
    oprot.trans.flush()
3865 
 
2764 chandransh 3866 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3867 
    args = markDoasAsPickedUp_args()
3868 
    args.read(iprot)
3869 
    iprot.readMessageEnd()
3870 
    result = markDoasAsPickedUp_result()
3871 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3872 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3873 
    result.write(oprot)
3874 
    oprot.writeMessageEnd()
3875 
    oprot.trans.flush()
3876 
 
2616 chandransh 3877 
  def process_receiveReturn(self, seqid, iprot, oprot):
3878 
    args = receiveReturn_args()
2591 chandransh 3879 
    args.read(iprot)
3880 
    iprot.readMessageEnd()
2616 chandransh 3881 
    result = receiveReturn_result()
2591 chandransh 3882 
    try:
2616 chandransh 3883 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3884 
    except TransactionServiceException, ex:
3885 
      result.ex = ex
2616 chandransh 3886 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3887 
    result.write(oprot)
3888 
    oprot.writeMessageEnd()
3889 
    oprot.trans.flush()
2536 chandransh 3890 
 
2591 chandransh 3891 
  def process_validateDoa(self, seqid, iprot, oprot):
3892 
    args = validateDoa_args()
3893 
    args.read(iprot)
3894 
    iprot.readMessageEnd()
3895 
    result = validateDoa_result()
3896 
    try:
3897 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3898 
    except TransactionServiceException, ex:
3899 
      result.ex = ex
3900 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3901 
    result.write(oprot)
3902 
    oprot.writeMessageEnd()
3903 
    oprot.trans.flush()
3904 
 
2616 chandransh 3905 
  def process_reshipOrder(self, seqid, iprot, oprot):
3906 
    args = reshipOrder_args()
3907 
    args.read(iprot)
3908 
    iprot.readMessageEnd()
3909 
    result = reshipOrder_result()
3910 
    try:
3911 
      result.success = self._handler.reshipOrder(args.orderId)
3912 
    except TransactionServiceException, ex:
3913 
      result.ex = ex
3914 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3915 
    result.write(oprot)
3916 
    oprot.writeMessageEnd()
3917 
    oprot.trans.flush()
2591 chandransh 3918 
 
2616 chandransh 3919 
  def process_refundOrder(self, seqid, iprot, oprot):
3920 
    args = refundOrder_args()
3921 
    args.read(iprot)
3922 
    iprot.readMessageEnd()
3923 
    result = refundOrder_result()
3924 
    try:
3226 chandransh 3925 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3926 
    except TransactionServiceException, ex:
3927 
      result.ex = ex
3928 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3929 
    result.write(oprot)
3930 
    oprot.writeMessageEnd()
3931 
    oprot.trans.flush()
3932 
 
2690 chandransh 3933 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3934 
    args = getReturnOrders_args()
3935 
    args.read(iprot)
3936 
    iprot.readMessageEnd()
3937 
    result = getReturnOrders_result()
3938 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3939 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3940 
    result.write(oprot)
3941 
    oprot.writeMessageEnd()
3942 
    oprot.trans.flush()
2616 chandransh 3943 
 
2700 chandransh 3944 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3945 
    args = getReturnOrder_args()
3946 
    args.read(iprot)
3947 
    iprot.readMessageEnd()
3948 
    result = getReturnOrder_result()
3949 
    try:
3950 
      result.success = self._handler.getReturnOrder(args.id)
3951 
    except TransactionServiceException, ex:
3952 
      result.ex = ex
3953 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3954 
    result.write(oprot)
3955 
    oprot.writeMessageEnd()
3956 
    oprot.trans.flush()
3957 
 
2690 chandransh 3958 
  def process_processReturn(self, seqid, iprot, oprot):
3959 
    args = processReturn_args()
3960 
    args.read(iprot)
3961 
    iprot.readMessageEnd()
3962 
    result = processReturn_result()
3963 
    try:
3964 
      self._handler.processReturn(args.returnOrderId)
3965 
    except TransactionServiceException, ex:
3966 
      result.ex = ex
3967 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3968 
    result.write(oprot)
3969 
    oprot.writeMessageEnd()
3970 
    oprot.trans.flush()
3971 
 
2819 chandransh 3972 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3973 
    args = createPurchaseOrder_args()
3974 
    args.read(iprot)
3975 
    iprot.readMessageEnd()
3976 
    result = createPurchaseOrder_result()
3977 
    try:
3978 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3979 
    except TransactionServiceException, ex:
3980 
      result.ex = ex
3981 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3982 
    result.write(oprot)
3983 
    oprot.writeMessageEnd()
3984 
    oprot.trans.flush()
2690 chandransh 3985 
 
3451 chandransh 3986 
  def process_updateWeight(self, seqid, iprot, oprot):
3987 
    args = updateWeight_args()
3988 
    args.read(iprot)
3989 
    iprot.readMessageEnd()
3990 
    result = updateWeight_result()
3991 
    try:
3992 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3993 
    except TransactionServiceException, ex:
3994 
      result.ex = ex
3995 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3996 
    result.write(oprot)
3997 
    oprot.writeMessageEnd()
3998 
    oprot.trans.flush()
2819 chandransh 3999 
 
3469 chandransh 4000 
  def process_changeItem(self, seqid, iprot, oprot):
4001 
    args = changeItem_args()
4002 
    args.read(iprot)
4003 
    iprot.readMessageEnd()
4004 
    result = changeItem_result()
4005 
    try:
4006 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4007 
    except TransactionServiceException, ex:
4008 
      result.ex = ex
4009 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4010 
    result.write(oprot)
4011 
    oprot.writeMessageEnd()
4012 
    oprot.trans.flush()
3451 chandransh 4013 
 
3469 chandransh 4014 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4015 
    args = shiftToWarehouse_args()
4016 
    args.read(iprot)
4017 
    iprot.readMessageEnd()
4018 
    result = shiftToWarehouse_result()
4019 
    try:
4020 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4021 
    except TransactionServiceException, ex:
4022 
      result.ex = ex
4023 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4024 
    result.write(oprot)
4025 
    oprot.writeMessageEnd()
4026 
    oprot.trans.flush()
4027 
 
3553 chandransh 4028 
  def process_addDelayReason(self, seqid, iprot, oprot):
4029 
    args = addDelayReason_args()
4030 
    args.read(iprot)
4031 
    iprot.readMessageEnd()
4032 
    result = addDelayReason_result()
4033 
    try:
3986 chandransh 4034 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4035 
    except TransactionServiceException, ex:
4036 
      result.ex = ex
4037 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4038 
    result.write(oprot)
4039 
    oprot.writeMessageEnd()
4040 
    oprot.trans.flush()
3469 chandransh 4041 
 
3956 chandransh 4042 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4043 
    args = reconcileCodCollection_args()
4044 
    args.read(iprot)
4045 
    iprot.readMessageEnd()
4046 
    result = reconcileCodCollection_result()
4047 
    try:
4048 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4049 
    except TransactionServiceException, ex:
4050 
      result.ex = ex
4051 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4052 
    result.write(oprot)
4053 
    oprot.writeMessageEnd()
4054 
    oprot.trans.flush()
3553 chandransh 4055 
 
4008 mandeep.dh 4056 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4057 
    args = getTransactionsRequiringExtraProcessing_args()
4058 
    args.read(iprot)
4059 
    iprot.readMessageEnd()
4060 
    result = getTransactionsRequiringExtraProcessing_result()
4061 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4062 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
3956 chandransh 4066 
 
4008 mandeep.dh 4067 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4068 
    args = markTransactionAsProcessed_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = markTransactionAsProcessed_result()
4072 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4073 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4074 
    result.write(oprot)
4075 
    oprot.writeMessageEnd()
4076 
    oprot.trans.flush()
4077 
 
4018 chandransh 4078 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4079 
    args = getItemWiseRiskyOrdersCount_args()
4080 
    args.read(iprot)
4081 
    iprot.readMessageEnd()
4082 
    result = getItemWiseRiskyOrdersCount_result()
4083 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4084 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4008 mandeep.dh 4088 
 
4295 varun.gupt 4089 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4090 
    args = getOrdersForItemIds_args()
4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4093 
    result = getOrdersForItemIds_result()
4094 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4095 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4096 
    result.write(oprot)
4097 
    oprot.writeMessageEnd()
4098 
    oprot.trans.flush()
4099 
 
4247 rajveer 4100 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4101 
    args = markOrderCancellationRequestReceived_args()
4102 
    args.read(iprot)
4103 
    iprot.readMessageEnd()
4104 
    result = markOrderCancellationRequestReceived_result()
4105 
    try:
4106 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4107 
    except TransactionServiceException, ex:
4108 
      result.ex = ex
4109 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4110 
    result.write(oprot)
4111 
    oprot.writeMessageEnd()
4112 
    oprot.trans.flush()
4018 chandransh 4113 
 
4247 rajveer 4114 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4115 
    args = markOrderCancellationRequestConfirmed_args()
4116 
    args.read(iprot)
4117 
    iprot.readMessageEnd()
4118 
    result = markOrderCancellationRequestConfirmed_result()
4119 
    try:
4120 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4121 
    except TransactionServiceException, ex:
4122 
      result.ex = ex
4123 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4124 
    result.write(oprot)
4125 
    oprot.writeMessageEnd()
4126 
    oprot.trans.flush()
4127 
 
4128 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4129 
    args = markOrderCancellationRequestDenied_args()
4130 
    args.read(iprot)
4131 
    iprot.readMessageEnd()
4132 
    result = markOrderCancellationRequestDenied_result()
4133 
    try:
4134 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4135 
    except TransactionServiceException, ex:
4136 
      result.ex = ex
4137 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4138 
    result.write(oprot)
4139 
    oprot.writeMessageEnd()
4140 
    oprot.trans.flush()
4141 
 
4258 rajveer 4142 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4143 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4144 
    args.read(iprot)
4145 
    iprot.readMessageEnd()
4258 rajveer 4146 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4147 
    try:
4258 rajveer 4148 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4149 
    except TransactionServiceException, ex:
4150 
      result.ex = ex
4258 rajveer 4151 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4152 
    result.write(oprot)
4153 
    oprot.writeMessageEnd()
4154 
    oprot.trans.flush()
4155 
 
4259 anupam.sin 4156 
  def process_refundTransaction(self, seqid, iprot, oprot):
4157 
    args = refundTransaction_args()
4158 
    args.read(iprot)
4159 
    iprot.readMessageEnd()
4160 
    result = refundTransaction_result()
4161 
    try:
4162 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4163 
    except TransactionServiceException, ex:
4164 
      result.ex = ex
4165 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4166 
    result.write(oprot)
4167 
    oprot.writeMessageEnd()
4168 
    oprot.trans.flush()
4247 rajveer 4169 
 
4285 rajveer 4170 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4171 
    args = acceptOrdersForItemId_args()
4172 
    args.read(iprot)
4173 
    iprot.readMessageEnd()
4174 
    result = acceptOrdersForItemId_result()
4175 
    try:
4176 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4177 
    except TransactionServiceException, ex:
4178 
      result.ex = ex
4179 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4180 
    result.write(oprot)
4181 
    oprot.writeMessageEnd()
4182 
    oprot.trans.flush()
4259 anupam.sin 4183 
 
4303 rajveer 4184 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4185 
    args = markOrdersAsPORaised_args()
4186 
    args.read(iprot)
4187 
    iprot.readMessageEnd()
4188 
    result = markOrdersAsPORaised_result()
4189 
    try:
4190 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate)
4191 
    except TransactionServiceException, ex:
4192 
      result.ex = ex
4193 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4194 
    result.write(oprot)
4195 
    oprot.writeMessageEnd()
4196 
    oprot.trans.flush()
4285 rajveer 4197 
 
4303 rajveer 4198 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4199 
    args = markOrdersAsReversalInitiated_args()
4200 
    args.read(iprot)
4201 
    iprot.readMessageEnd()
4202 
    result = markOrdersAsReversalInitiated_result()
4203 
    try:
4204 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate)
4205 
    except TransactionServiceException, ex:
4206 
      result.ex = ex
4207 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
4212 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4213 
    args = markOrdersAsNotAvailabke_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = markOrdersAsNotAvailabke_result()
4217 
    try:
4218 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate)
4219 
    except TransactionServiceException, ex:
4220 
      result.ex = ex
4221 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
4225 
 
4226 
 
94 ashish 4227 
# HELPER FUNCTIONS AND STRUCTURES
4228 
 
4229 
class createTransaction_args:
4230 
  """
4231 
  Attributes:
4232 
   - transaction
4233 
  """
4234 
 
4235 
  thrift_spec = (
4236 
    None, # 0
4237 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4238 
  )
4239 
 
4240 
  def __init__(self, transaction=None,):
4241 
    self.transaction = transaction
4242 
 
4243 
  def read(self, iprot):
4244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4246 
      return
4247 
    iprot.readStructBegin()
4248 
    while True:
4249 
      (fname, ftype, fid) = iprot.readFieldBegin()
4250 
      if ftype == TType.STOP:
4251 
        break
4252 
      if fid == 1:
4253 
        if ftype == TType.STRUCT:
4254 
          self.transaction = Transaction()
4255 
          self.transaction.read(iprot)
4256 
        else:
4257 
          iprot.skip(ftype)
4258 
      else:
4259 
        iprot.skip(ftype)
4260 
      iprot.readFieldEnd()
4261 
    iprot.readStructEnd()
4262 
 
4263 
  def write(self, oprot):
4264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4266 
      return
4267 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4268 
    if self.transaction is not None:
94 ashish 4269 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4270 
      self.transaction.write(oprot)
4271 
      oprot.writeFieldEnd()
4272 
    oprot.writeFieldStop()
4273 
    oprot.writeStructEnd()
4274 
 
3431 rajveer 4275 
  def validate(self):
4276 
    return
4277 
 
4278 
 
94 ashish 4279 
  def __repr__(self):
4280 
    L = ['%s=%r' % (key, value)
4281 
      for key, value in self.__dict__.iteritems()]
4282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4283 
 
4284 
  def __eq__(self, other):
4285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4286 
 
4287 
  def __ne__(self, other):
4288 
    return not (self == other)
4289 
 
4290 
class createTransaction_result:
4291 
  """
4292 
  Attributes:
132 ashish 4293 
   - success
94 ashish 4294 
   - ex
4295 
  """
4296 
 
4297 
  thrift_spec = (
132 ashish 4298 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4299 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4300 
  )
4301 
 
132 ashish 4302 
  def __init__(self, success=None, ex=None,):
4303 
    self.success = success
94 ashish 4304 
    self.ex = ex
4305 
 
4306 
  def read(self, iprot):
4307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4309 
      return
4310 
    iprot.readStructBegin()
4311 
    while True:
4312 
      (fname, ftype, fid) = iprot.readFieldBegin()
4313 
      if ftype == TType.STOP:
4314 
        break
132 ashish 4315 
      if fid == 0:
4316 
        if ftype == TType.I64:
4317 
          self.success = iprot.readI64();
4318 
        else:
4319 
          iprot.skip(ftype)
4320 
      elif fid == 1:
94 ashish 4321 
        if ftype == TType.STRUCT:
4322 
          self.ex = TransactionServiceException()
4323 
          self.ex.read(iprot)
4324 
        else:
4325 
          iprot.skip(ftype)
4326 
      else:
4327 
        iprot.skip(ftype)
4328 
      iprot.readFieldEnd()
4329 
    iprot.readStructEnd()
4330 
 
4331 
  def write(self, oprot):
4332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4334 
      return
4335 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4336 
    if self.success is not None:
132 ashish 4337 
      oprot.writeFieldBegin('success', TType.I64, 0)
4338 
      oprot.writeI64(self.success)
4339 
      oprot.writeFieldEnd()
3431 rajveer 4340 
    if self.ex is not None:
94 ashish 4341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4342 
      self.ex.write(oprot)
4343 
      oprot.writeFieldEnd()
4344 
    oprot.writeFieldStop()
4345 
    oprot.writeStructEnd()
4346 
 
3431 rajveer 4347 
  def validate(self):
4348 
    return
4349 
 
4350 
 
94 ashish 4351 
  def __repr__(self):
4352 
    L = ['%s=%r' % (key, value)
4353 
      for key, value in self.__dict__.iteritems()]
4354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4355 
 
4356 
  def __eq__(self, other):
4357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4358 
 
4359 
  def __ne__(self, other):
4360 
    return not (self == other)
4361 
 
4362 
class getTransaction_args:
4363 
  """
4364 
  Attributes:
4365 
   - id
4366 
  """
4367 
 
4368 
  thrift_spec = (
4369 
    None, # 0
4370 
    (1, TType.I64, 'id', None, None, ), # 1
4371 
  )
4372 
 
4373 
  def __init__(self, id=None,):
4374 
    self.id = id
4375 
 
4376 
  def read(self, iprot):
4377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4379 
      return
4380 
    iprot.readStructBegin()
4381 
    while True:
4382 
      (fname, ftype, fid) = iprot.readFieldBegin()
4383 
      if ftype == TType.STOP:
4384 
        break
4385 
      if fid == 1:
4386 
        if ftype == TType.I64:
4387 
          self.id = iprot.readI64();
4388 
        else:
4389 
          iprot.skip(ftype)
4390 
      else:
4391 
        iprot.skip(ftype)
4392 
      iprot.readFieldEnd()
4393 
    iprot.readStructEnd()
4394 
 
4395 
  def write(self, oprot):
4396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4398 
      return
4399 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4400 
    if self.id is not None:
94 ashish 4401 
      oprot.writeFieldBegin('id', TType.I64, 1)
4402 
      oprot.writeI64(self.id)
4403 
      oprot.writeFieldEnd()
4404 
    oprot.writeFieldStop()
4405 
    oprot.writeStructEnd()
4406 
 
3431 rajveer 4407 
  def validate(self):
4408 
    return
4409 
 
4410 
 
94 ashish 4411 
  def __repr__(self):
4412 
    L = ['%s=%r' % (key, value)
4413 
      for key, value in self.__dict__.iteritems()]
4414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4415 
 
4416 
  def __eq__(self, other):
4417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4418 
 
4419 
  def __ne__(self, other):
4420 
    return not (self == other)
4421 
 
4422 
class getTransaction_result:
4423 
  """
4424 
  Attributes:
4425 
   - success
4426 
   - ex
4427 
  """
4428 
 
4429 
  thrift_spec = (
4430 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4432 
  )
4433 
 
4434 
  def __init__(self, success=None, ex=None,):
4435 
    self.success = success
4436 
    self.ex = ex
4437 
 
4438 
  def read(self, iprot):
4439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4441 
      return
4442 
    iprot.readStructBegin()
4443 
    while True:
4444 
      (fname, ftype, fid) = iprot.readFieldBegin()
4445 
      if ftype == TType.STOP:
4446 
        break
4447 
      if fid == 0:
4448 
        if ftype == TType.STRUCT:
4449 
          self.success = Transaction()
4450 
          self.success.read(iprot)
4451 
        else:
4452 
          iprot.skip(ftype)
4453 
      elif fid == 1:
4454 
        if ftype == TType.STRUCT:
4455 
          self.ex = TransactionServiceException()
4456 
          self.ex.read(iprot)
4457 
        else:
4458 
          iprot.skip(ftype)
4459 
      else:
4460 
        iprot.skip(ftype)
4461 
      iprot.readFieldEnd()
4462 
    iprot.readStructEnd()
4463 
 
4464 
  def write(self, oprot):
4465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4467 
      return
4468 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4469 
    if self.success is not None:
94 ashish 4470 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4471 
      self.success.write(oprot)
4472 
      oprot.writeFieldEnd()
3431 rajveer 4473 
    if self.ex is not None:
94 ashish 4474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4475 
      self.ex.write(oprot)
4476 
      oprot.writeFieldEnd()
4477 
    oprot.writeFieldStop()
4478 
    oprot.writeStructEnd()
4479 
 
3431 rajveer 4480 
  def validate(self):
4481 
    return
4482 
 
4483 
 
94 ashish 4484 
  def __repr__(self):
4485 
    L = ['%s=%r' % (key, value)
4486 
      for key, value in self.__dict__.iteritems()]
4487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4488 
 
4489 
  def __eq__(self, other):
4490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4491 
 
4492 
  def __ne__(self, other):
4493 
    return not (self == other)
4494 
 
4495 
class getTransactionsForCustomer_args:
4496 
  """
4497 
  Attributes:
4498 
   - customerId
4499 
   - from_date
4500 
   - to_date
4501 
   - status
4502 
  """
4503 
 
4504 
  thrift_spec = (
4505 
    None, # 0
4506 
    (1, TType.I64, 'customerId', None, None, ), # 1
4507 
    (2, TType.I64, 'from_date', None, None, ), # 2
4508 
    (3, TType.I64, 'to_date', None, None, ), # 3
4509 
    (4, TType.I32, 'status', None, None, ), # 4
4510 
  )
4511 
 
4512 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4513 
    self.customerId = customerId
4514 
    self.from_date = from_date
4515 
    self.to_date = to_date
4516 
    self.status = status
4517 
 
4518 
  def read(self, iprot):
4519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4521 
      return
4522 
    iprot.readStructBegin()
4523 
    while True:
4524 
      (fname, ftype, fid) = iprot.readFieldBegin()
4525 
      if ftype == TType.STOP:
4526 
        break
4527 
      if fid == 1:
4528 
        if ftype == TType.I64:
4529 
          self.customerId = iprot.readI64();
4530 
        else:
4531 
          iprot.skip(ftype)
4532 
      elif fid == 2:
4533 
        if ftype == TType.I64:
4534 
          self.from_date = iprot.readI64();
4535 
        else:
4536 
          iprot.skip(ftype)
4537 
      elif fid == 3:
4538 
        if ftype == TType.I64:
4539 
          self.to_date = iprot.readI64();
4540 
        else:
4541 
          iprot.skip(ftype)
4542 
      elif fid == 4:
4543 
        if ftype == TType.I32:
4544 
          self.status = iprot.readI32();
4545 
        else:
4546 
          iprot.skip(ftype)
4547 
      else:
4548 
        iprot.skip(ftype)
4549 
      iprot.readFieldEnd()
4550 
    iprot.readStructEnd()
4551 
 
4552 
  def write(self, oprot):
4553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4555 
      return
4556 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4557 
    if self.customerId is not None:
94 ashish 4558 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4559 
      oprot.writeI64(self.customerId)
4560 
      oprot.writeFieldEnd()
3431 rajveer 4561 
    if self.from_date is not None:
94 ashish 4562 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4563 
      oprot.writeI64(self.from_date)
4564 
      oprot.writeFieldEnd()
3431 rajveer 4565 
    if self.to_date is not None:
94 ashish 4566 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4567 
      oprot.writeI64(self.to_date)
4568 
      oprot.writeFieldEnd()
3431 rajveer 4569 
    if self.status is not None:
94 ashish 4570 
      oprot.writeFieldBegin('status', TType.I32, 4)
4571 
      oprot.writeI32(self.status)
4572 
      oprot.writeFieldEnd()
4573 
    oprot.writeFieldStop()
4574 
    oprot.writeStructEnd()
4575 
 
3431 rajveer 4576 
  def validate(self):
4577 
    return
4578 
 
4579 
 
94 ashish 4580 
  def __repr__(self):
4581 
    L = ['%s=%r' % (key, value)
4582 
      for key, value in self.__dict__.iteritems()]
4583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4584 
 
4585 
  def __eq__(self, other):
4586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4587 
 
4588 
  def __ne__(self, other):
4589 
    return not (self == other)
4590 
 
4591 
class getTransactionsForCustomer_result:
4592 
  """
4593 
  Attributes:
4594 
   - success
4595 
   - ex
4596 
  """
4597 
 
4598 
  thrift_spec = (
4599 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4601 
  )
4602 
 
4603 
  def __init__(self, success=None, ex=None,):
4604 
    self.success = success
4605 
    self.ex = ex
4606 
 
4607 
  def read(self, iprot):
4608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4610 
      return
4611 
    iprot.readStructBegin()
4612 
    while True:
4613 
      (fname, ftype, fid) = iprot.readFieldBegin()
4614 
      if ftype == TType.STOP:
4615 
        break
4616 
      if fid == 0:
4617 
        if ftype == TType.LIST:
4618 
          self.success = []
685 chandransh 4619 
          (_etype17, _size14) = iprot.readListBegin()
4620 
          for _i18 in xrange(_size14):
4621 
            _elem19 = Transaction()
4622 
            _elem19.read(iprot)
4623 
            self.success.append(_elem19)
94 ashish 4624 
          iprot.readListEnd()
4625 
        else:
4626 
          iprot.skip(ftype)
4627 
      elif fid == 1:
4628 
        if ftype == TType.STRUCT:
4629 
          self.ex = TransactionServiceException()
4630 
          self.ex.read(iprot)
4631 
        else:
4632 
          iprot.skip(ftype)
4633 
      else:
4634 
        iprot.skip(ftype)
4635 
      iprot.readFieldEnd()
4636 
    iprot.readStructEnd()
4637 
 
4638 
  def write(self, oprot):
4639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4641 
      return
4642 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4643 
    if self.success is not None:
94 ashish 4644 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4645 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4646 
      for iter20 in self.success:
4647 
        iter20.write(oprot)
94 ashish 4648 
      oprot.writeListEnd()
4649 
      oprot.writeFieldEnd()
3431 rajveer 4650 
    if self.ex is not None:
94 ashish 4651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4652 
      self.ex.write(oprot)
4653 
      oprot.writeFieldEnd()
4654 
    oprot.writeFieldStop()
4655 
    oprot.writeStructEnd()
4656 
 
3431 rajveer 4657 
  def validate(self):
4658 
    return
4659 
 
4660 
 
94 ashish 4661 
  def __repr__(self):
4662 
    L = ['%s=%r' % (key, value)
4663 
      for key, value in self.__dict__.iteritems()]
4664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4665 
 
4666 
  def __eq__(self, other):
4667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4668 
 
4669 
  def __ne__(self, other):
4670 
    return not (self == other)
4671 
 
132 ashish 4672 
class getTransactionsForShoppingCartId_args:
4673 
  """
4674 
  Attributes:
4675 
   - shoppingCartId
4676 
  """
4677 
 
4678 
  thrift_spec = (
4679 
    None, # 0
4680 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4681 
  )
4682 
 
4683 
  def __init__(self, shoppingCartId=None,):
4684 
    self.shoppingCartId = shoppingCartId
4685 
 
4686 
  def read(self, iprot):
4687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4689 
      return
4690 
    iprot.readStructBegin()
4691 
    while True:
4692 
      (fname, ftype, fid) = iprot.readFieldBegin()
4693 
      if ftype == TType.STOP:
4694 
        break
4695 
      if fid == 1:
4696 
        if ftype == TType.I64:
4697 
          self.shoppingCartId = iprot.readI64();
4698 
        else:
4699 
          iprot.skip(ftype)
4700 
      else:
4701 
        iprot.skip(ftype)
4702 
      iprot.readFieldEnd()
4703 
    iprot.readStructEnd()
4704 
 
4705 
  def write(self, oprot):
4706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4708 
      return
4709 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4710 
    if self.shoppingCartId is not None:
132 ashish 4711 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4712 
      oprot.writeI64(self.shoppingCartId)
4713 
      oprot.writeFieldEnd()
4714 
    oprot.writeFieldStop()
4715 
    oprot.writeStructEnd()
4716 
 
3431 rajveer 4717 
  def validate(self):
4718 
    return
4719 
 
4720 
 
132 ashish 4721 
  def __repr__(self):
4722 
    L = ['%s=%r' % (key, value)
4723 
      for key, value in self.__dict__.iteritems()]
4724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4725 
 
4726 
  def __eq__(self, other):
4727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4728 
 
4729 
  def __ne__(self, other):
4730 
    return not (self == other)
4731 
 
4732 
class getTransactionsForShoppingCartId_result:
4733 
  """
4734 
  Attributes:
4735 
   - success
4736 
   - ex
4737 
  """
4738 
 
4739 
  thrift_spec = (
4740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4742 
  )
4743 
 
4744 
  def __init__(self, success=None, ex=None,):
4745 
    self.success = success
4746 
    self.ex = ex
4747 
 
4748 
  def read(self, iprot):
4749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4751 
      return
4752 
    iprot.readStructBegin()
4753 
    while True:
4754 
      (fname, ftype, fid) = iprot.readFieldBegin()
4755 
      if ftype == TType.STOP:
4756 
        break
4757 
      if fid == 0:
4758 
        if ftype == TType.LIST:
4759 
          self.success = []
685 chandransh 4760 
          (_etype24, _size21) = iprot.readListBegin()
4761 
          for _i25 in xrange(_size21):
4762 
            _elem26 = Transaction()
4763 
            _elem26.read(iprot)
4764 
            self.success.append(_elem26)
132 ashish 4765 
          iprot.readListEnd()
4766 
        else:
4767 
          iprot.skip(ftype)
4768 
      elif fid == 1:
4769 
        if ftype == TType.STRUCT:
4770 
          self.ex = TransactionServiceException()
4771 
          self.ex.read(iprot)
4772 
        else:
4773 
          iprot.skip(ftype)
4774 
      else:
4775 
        iprot.skip(ftype)
4776 
      iprot.readFieldEnd()
4777 
    iprot.readStructEnd()
4778 
 
4779 
  def write(self, oprot):
4780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4782 
      return
4783 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4784 
    if self.success is not None:
132 ashish 4785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4787 
      for iter27 in self.success:
4788 
        iter27.write(oprot)
132 ashish 4789 
      oprot.writeListEnd()
4790 
      oprot.writeFieldEnd()
3431 rajveer 4791 
    if self.ex is not None:
132 ashish 4792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4793 
      self.ex.write(oprot)
4794 
      oprot.writeFieldEnd()
4795 
    oprot.writeFieldStop()
4796 
    oprot.writeStructEnd()
4797 
 
3431 rajveer 4798 
  def validate(self):
4799 
    return
4800 
 
4801 
 
132 ashish 4802 
  def __repr__(self):
4803 
    L = ['%s=%r' % (key, value)
4804 
      for key, value in self.__dict__.iteritems()]
4805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4806 
 
4807 
  def __eq__(self, other):
4808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4809 
 
4810 
  def __ne__(self, other):
4811 
    return not (self == other)
4812 
 
94 ashish 4813 
class getTransactionStatus_args:
4814 
  """
4815 
  Attributes:
4816 
   - transactionId
4817 
  """
4818 
 
4819 
  thrift_spec = (
4820 
    None, # 0
4821 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4822 
  )
4823 
 
4824 
  def __init__(self, transactionId=None,):
4825 
    self.transactionId = transactionId
4826 
 
4827 
  def read(self, iprot):
4828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4830 
      return
4831 
    iprot.readStructBegin()
4832 
    while True:
4833 
      (fname, ftype, fid) = iprot.readFieldBegin()
4834 
      if ftype == TType.STOP:
4835 
        break
4836 
      if fid == 1:
4837 
        if ftype == TType.I64:
4838 
          self.transactionId = iprot.readI64();
4839 
        else:
4840 
          iprot.skip(ftype)
4841 
      else:
4842 
        iprot.skip(ftype)
4843 
      iprot.readFieldEnd()
4844 
    iprot.readStructEnd()
4845 
 
4846 
  def write(self, oprot):
4847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4849 
      return
4850 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4851 
    if self.transactionId is not None:
94 ashish 4852 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4853 
      oprot.writeI64(self.transactionId)
4854 
      oprot.writeFieldEnd()
4855 
    oprot.writeFieldStop()
4856 
    oprot.writeStructEnd()
4857 
 
3431 rajveer 4858 
  def validate(self):
4859 
    return
4860 
 
4861 
 
94 ashish 4862 
  def __repr__(self):
4863 
    L = ['%s=%r' % (key, value)
4864 
      for key, value in self.__dict__.iteritems()]
4865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4866 
 
4867 
  def __eq__(self, other):
4868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4869 
 
4870 
  def __ne__(self, other):
4871 
    return not (self == other)
4872 
 
4873 
class getTransactionStatus_result:
4874 
  """
4875 
  Attributes:
4876 
   - success
4877 
   - ex
4878 
  """
4879 
 
4880 
  thrift_spec = (
4881 
    (0, TType.I32, 'success', None, None, ), # 0
4882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4883 
  )
4884 
 
4885 
  def __init__(self, success=None, ex=None,):
4886 
    self.success = success
4887 
    self.ex = ex
4888 
 
4889 
  def read(self, iprot):
4890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4892 
      return
4893 
    iprot.readStructBegin()
4894 
    while True:
4895 
      (fname, ftype, fid) = iprot.readFieldBegin()
4896 
      if ftype == TType.STOP:
4897 
        break
4898 
      if fid == 0:
4899 
        if ftype == TType.I32:
4900 
          self.success = iprot.readI32();
4901 
        else:
4902 
          iprot.skip(ftype)
4903 
      elif fid == 1:
4904 
        if ftype == TType.STRUCT:
4905 
          self.ex = TransactionServiceException()
4906 
          self.ex.read(iprot)
4907 
        else:
4908 
          iprot.skip(ftype)
4909 
      else:
4910 
        iprot.skip(ftype)
4911 
      iprot.readFieldEnd()
4912 
    iprot.readStructEnd()
4913 
 
4914 
  def write(self, oprot):
4915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4917 
      return
4918 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4919 
    if self.success is not None:
94 ashish 4920 
      oprot.writeFieldBegin('success', TType.I32, 0)
4921 
      oprot.writeI32(self.success)
4922 
      oprot.writeFieldEnd()
3431 rajveer 4923 
    if self.ex is not None:
94 ashish 4924 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4925 
      self.ex.write(oprot)
4926 
      oprot.writeFieldEnd()
4927 
    oprot.writeFieldStop()
4928 
    oprot.writeStructEnd()
4929 
 
3431 rajveer 4930 
  def validate(self):
4931 
    return
4932 
 
4933 
 
94 ashish 4934 
  def __repr__(self):
4935 
    L = ['%s=%r' % (key, value)
4936 
      for key, value in self.__dict__.iteritems()]
4937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4938 
 
4939 
  def __eq__(self, other):
4940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4941 
 
4942 
  def __ne__(self, other):
4943 
    return not (self == other)
4944 
 
4945 
class changeTransactionStatus_args:
4946 
  """
4947 
  Attributes:
4948 
   - transactionId
4949 
   - status
4950 
   - description
4951 
  """
4952 
 
4953 
  thrift_spec = (
4954 
    None, # 0
4955 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4956 
    (2, TType.I32, 'status', None, None, ), # 2
4957 
    (3, TType.STRING, 'description', None, None, ), # 3
4958 
  )
4959 
 
4960 
  def __init__(self, transactionId=None, status=None, description=None,):
4961 
    self.transactionId = transactionId
4962 
    self.status = status
4963 
    self.description = description
4964 
 
4965 
  def read(self, iprot):
4966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4968 
      return
4969 
    iprot.readStructBegin()
4970 
    while True:
4971 
      (fname, ftype, fid) = iprot.readFieldBegin()
4972 
      if ftype == TType.STOP:
4973 
        break
4974 
      if fid == 1:
4975 
        if ftype == TType.I64:
4976 
          self.transactionId = iprot.readI64();
4977 
        else:
4978 
          iprot.skip(ftype)
4979 
      elif fid == 2:
4980 
        if ftype == TType.I32:
4981 
          self.status = iprot.readI32();
4982 
        else:
4983 
          iprot.skip(ftype)
4984 
      elif fid == 3:
4985 
        if ftype == TType.STRING:
4986 
          self.description = iprot.readString();
4987 
        else:
4988 
          iprot.skip(ftype)
4989 
      else:
4990 
        iprot.skip(ftype)
4991 
      iprot.readFieldEnd()
4992 
    iprot.readStructEnd()
4993 
 
4994 
  def write(self, oprot):
4995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4997 
      return
4998 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4999 
    if self.transactionId is not None:
94 ashish 5000 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5001 
      oprot.writeI64(self.transactionId)
5002 
      oprot.writeFieldEnd()
3431 rajveer 5003 
    if self.status is not None:
94 ashish 5004 
      oprot.writeFieldBegin('status', TType.I32, 2)
5005 
      oprot.writeI32(self.status)
5006 
      oprot.writeFieldEnd()
3431 rajveer 5007 
    if self.description is not None:
94 ashish 5008 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5009 
      oprot.writeString(self.description)
5010 
      oprot.writeFieldEnd()
5011 
    oprot.writeFieldStop()
5012 
    oprot.writeStructEnd()
5013 
 
3431 rajveer 5014 
  def validate(self):
5015 
    return
5016 
 
5017 
 
94 ashish 5018 
  def __repr__(self):
5019 
    L = ['%s=%r' % (key, value)
5020 
      for key, value in self.__dict__.iteritems()]
5021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5022 
 
5023 
  def __eq__(self, other):
5024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5025 
 
5026 
  def __ne__(self, other):
5027 
    return not (self == other)
5028 
 
5029 
class changeTransactionStatus_result:
5030 
  """
5031 
  Attributes:
5032 
   - success
5033 
   - ex
5034 
  """
5035 
 
5036 
  thrift_spec = (
5037 
    (0, TType.BOOL, 'success', None, None, ), # 0
5038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5039 
  )
5040 
 
5041 
  def __init__(self, success=None, ex=None,):
5042 
    self.success = success
5043 
    self.ex = ex
5044 
 
5045 
  def read(self, iprot):
5046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5048 
      return
5049 
    iprot.readStructBegin()
5050 
    while True:
5051 
      (fname, ftype, fid) = iprot.readFieldBegin()
5052 
      if ftype == TType.STOP:
5053 
        break
5054 
      if fid == 0:
5055 
        if ftype == TType.BOOL:
5056 
          self.success = iprot.readBool();
5057 
        else:
5058 
          iprot.skip(ftype)
5059 
      elif fid == 1:
5060 
        if ftype == TType.STRUCT:
5061 
          self.ex = TransactionServiceException()
5062 
          self.ex.read(iprot)
5063 
        else:
5064 
          iprot.skip(ftype)
5065 
      else:
5066 
        iprot.skip(ftype)
5067 
      iprot.readFieldEnd()
5068 
    iprot.readStructEnd()
5069 
 
5070 
  def write(self, oprot):
5071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5073 
      return
5074 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5075 
    if self.success is not None:
94 ashish 5076 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5077 
      oprot.writeBool(self.success)
5078 
      oprot.writeFieldEnd()
3431 rajveer 5079 
    if self.ex is not None:
94 ashish 5080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5081 
      self.ex.write(oprot)
5082 
      oprot.writeFieldEnd()
5083 
    oprot.writeFieldStop()
5084 
    oprot.writeStructEnd()
5085 
 
3431 rajveer 5086 
  def validate(self):
5087 
    return
5088 
 
5089 
 
94 ashish 5090 
  def __repr__(self):
5091 
    L = ['%s=%r' % (key, value)
5092 
      for key, value in self.__dict__.iteritems()]
5093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5094 
 
5095 
  def __eq__(self, other):
5096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5097 
 
5098 
  def __ne__(self, other):
5099 
    return not (self == other)
5100 
 
1398 varun.gupt 5101 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5102 
  """
5103 
  Attributes:
5104 
   - transactionId
5105 
  """
5106 
 
5107 
  thrift_spec = (
5108 
    None, # 0
5109 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5110 
  )
5111 
 
5112 
  def __init__(self, transactionId=None,):
5113 
    self.transactionId = transactionId
5114 
 
5115 
  def read(self, iprot):
5116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5118 
      return
5119 
    iprot.readStructBegin()
5120 
    while True:
5121 
      (fname, ftype, fid) = iprot.readFieldBegin()
5122 
      if ftype == TType.STOP:
5123 
        break
5124 
      if fid == 1:
5125 
        if ftype == TType.I64:
5126 
          self.transactionId = iprot.readI64();
5127 
        else:
5128 
          iprot.skip(ftype)
5129 
      else:
5130 
        iprot.skip(ftype)
5131 
      iprot.readFieldEnd()
5132 
    iprot.readStructEnd()
5133 
 
5134 
  def write(self, oprot):
5135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5137 
      return
1398 varun.gupt 5138 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5139 
    if self.transactionId is not None:
1382 varun.gupt 5140 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5141 
      oprot.writeI64(self.transactionId)
5142 
      oprot.writeFieldEnd()
5143 
    oprot.writeFieldStop()
5144 
    oprot.writeStructEnd()
5145 
 
3431 rajveer 5146 
  def validate(self):
5147 
    return
5148 
 
5149 
 
1382 varun.gupt 5150 
  def __repr__(self):
5151 
    L = ['%s=%r' % (key, value)
5152 
      for key, value in self.__dict__.iteritems()]
5153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5154 
 
5155 
  def __eq__(self, other):
5156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5157 
 
5158 
  def __ne__(self, other):
5159 
    return not (self == other)
5160 
 
1398 varun.gupt 5161 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5162 
  """
5163 
  Attributes:
5164 
   - success
5165 
   - ex
5166 
  """
5167 
 
5168 
  thrift_spec = (
5169 
    (0, TType.BOOL, 'success', None, None, ), # 0
5170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5171 
  )
5172 
 
5173 
  def __init__(self, success=None, ex=None,):
5174 
    self.success = success
5175 
    self.ex = ex
5176 
 
5177 
  def read(self, iprot):
5178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5180 
      return
5181 
    iprot.readStructBegin()
5182 
    while True:
5183 
      (fname, ftype, fid) = iprot.readFieldBegin()
5184 
      if ftype == TType.STOP:
5185 
        break
5186 
      if fid == 0:
5187 
        if ftype == TType.BOOL:
5188 
          self.success = iprot.readBool();
5189 
        else:
5190 
          iprot.skip(ftype)
5191 
      elif fid == 1:
5192 
        if ftype == TType.STRUCT:
5193 
          self.ex = TransactionServiceException()
5194 
          self.ex.read(iprot)
5195 
        else:
5196 
          iprot.skip(ftype)
5197 
      else:
5198 
        iprot.skip(ftype)
5199 
      iprot.readFieldEnd()
5200 
    iprot.readStructEnd()
5201 
 
5202 
  def write(self, oprot):
5203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5205 
      return
1398 varun.gupt 5206 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5207 
    if self.success is not None:
1382 varun.gupt 5208 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5209 
      oprot.writeBool(self.success)
5210 
      oprot.writeFieldEnd()
3431 rajveer 5211 
    if self.ex is not None:
1382 varun.gupt 5212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5213 
      self.ex.write(oprot)
5214 
      oprot.writeFieldEnd()
5215 
    oprot.writeFieldStop()
5216 
    oprot.writeStructEnd()
5217 
 
3431 rajveer 5218 
  def validate(self):
5219 
    return
5220 
 
5221 
 
1382 varun.gupt 5222 
  def __repr__(self):
5223 
    L = ['%s=%r' % (key, value)
5224 
      for key, value in self.__dict__.iteritems()]
5225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5226 
 
5227 
  def __eq__(self, other):
5228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5229 
 
5230 
  def __ne__(self, other):
5231 
    return not (self == other)
5232 
 
483 rajveer 5233 
class getAllOrders_args:
94 ashish 5234 
  """
5235 
  Attributes:
483 rajveer 5236 
   - status
5237 
   - from_date
5238 
   - to_date
5239 
   - warehouse_id
94 ashish 5240 
  """
5241 
 
5242 
  thrift_spec = (
5243 
    None, # 0
483 rajveer 5244 
    (1, TType.I32, 'status', None, None, ), # 1
5245 
    (2, TType.I64, 'from_date', None, None, ), # 2
5246 
    (3, TType.I64, 'to_date', None, None, ), # 3
5247 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5248 
  )
5249 
 
483 rajveer 5250 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5251 
    self.status = status
5252 
    self.from_date = from_date
5253 
    self.to_date = to_date
5254 
    self.warehouse_id = warehouse_id
94 ashish 5255 
 
5256 
  def read(self, iprot):
5257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5259 
      return
5260 
    iprot.readStructBegin()
5261 
    while True:
5262 
      (fname, ftype, fid) = iprot.readFieldBegin()
5263 
      if ftype == TType.STOP:
5264 
        break
5265 
      if fid == 1:
483 rajveer 5266 
        if ftype == TType.I32:
5267 
          self.status = iprot.readI32();
94 ashish 5268 
        else:
5269 
          iprot.skip(ftype)
483 rajveer 5270 
      elif fid == 2:
5271 
        if ftype == TType.I64:
5272 
          self.from_date = iprot.readI64();
94 ashish 5273 
        else:
5274 
          iprot.skip(ftype)
483 rajveer 5275 
      elif fid == 3:
5276 
        if ftype == TType.I64:
5277 
          self.to_date = iprot.readI64();
94 ashish 5278 
        else:
5279 
          iprot.skip(ftype)
483 rajveer 5280 
      elif fid == 4:
94 ashish 5281 
        if ftype == TType.I64:
483 rajveer 5282 
          self.warehouse_id = iprot.readI64();
94 ashish 5283 
        else:
5284 
          iprot.skip(ftype)
5285 
      else:
5286 
        iprot.skip(ftype)
5287 
      iprot.readFieldEnd()
5288 
    iprot.readStructEnd()
5289 
 
5290 
  def write(self, oprot):
5291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5293 
      return
483 rajveer 5294 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5295 
    if self.status is not None:
483 rajveer 5296 
      oprot.writeFieldBegin('status', TType.I32, 1)
5297 
      oprot.writeI32(self.status)
94 ashish 5298 
      oprot.writeFieldEnd()
3431 rajveer 5299 
    if self.from_date is not None:
483 rajveer 5300 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5301 
      oprot.writeI64(self.from_date)
94 ashish 5302 
      oprot.writeFieldEnd()
3431 rajveer 5303 
    if self.to_date is not None:
483 rajveer 5304 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5305 
      oprot.writeI64(self.to_date)
94 ashish 5306 
      oprot.writeFieldEnd()
3431 rajveer 5307 
    if self.warehouse_id is not None:
483 rajveer 5308 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5309 
      oprot.writeI64(self.warehouse_id)
94 ashish 5310 
      oprot.writeFieldEnd()
5311 
    oprot.writeFieldStop()
5312 
    oprot.writeStructEnd()
5313 
 
3431 rajveer 5314 
  def validate(self):
5315 
    return
5316 
 
5317 
 
94 ashish 5318 
  def __repr__(self):
5319 
    L = ['%s=%r' % (key, value)
5320 
      for key, value in self.__dict__.iteritems()]
5321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5322 
 
5323 
  def __eq__(self, other):
5324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5325 
 
5326 
  def __ne__(self, other):
5327 
    return not (self == other)
5328 
 
483 rajveer 5329 
class getAllOrders_result:
94 ashish 5330 
  """
5331 
  Attributes:
5332 
   - success
5333 
   - ex
5334 
  """
5335 
 
5336 
  thrift_spec = (
483 rajveer 5337 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5339 
  )
5340 
 
5341 
  def __init__(self, success=None, ex=None,):
5342 
    self.success = success
5343 
    self.ex = ex
5344 
 
5345 
  def read(self, iprot):
5346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5348 
      return
5349 
    iprot.readStructBegin()
5350 
    while True:
5351 
      (fname, ftype, fid) = iprot.readFieldBegin()
5352 
      if ftype == TType.STOP:
5353 
        break
5354 
      if fid == 0:
483 rajveer 5355 
        if ftype == TType.LIST:
5356 
          self.success = []
685 chandransh 5357 
          (_etype31, _size28) = iprot.readListBegin()
5358 
          for _i32 in xrange(_size28):
5359 
            _elem33 = Order()
5360 
            _elem33.read(iprot)
5361 
            self.success.append(_elem33)
483 rajveer 5362 
          iprot.readListEnd()
94 ashish 5363 
        else:
5364 
          iprot.skip(ftype)
5365 
      elif fid == 1:
5366 
        if ftype == TType.STRUCT:
5367 
          self.ex = TransactionServiceException()
5368 
          self.ex.read(iprot)
5369 
        else:
5370 
          iprot.skip(ftype)
5371 
      else:
5372 
        iprot.skip(ftype)
5373 
      iprot.readFieldEnd()
5374 
    iprot.readStructEnd()
5375 
 
5376 
  def write(self, oprot):
5377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5379 
      return
483 rajveer 5380 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5381 
    if self.success is not None:
483 rajveer 5382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5384 
      for iter34 in self.success:
5385 
        iter34.write(oprot)
483 rajveer 5386 
      oprot.writeListEnd()
94 ashish 5387 
      oprot.writeFieldEnd()
3431 rajveer 5388 
    if self.ex is not None:
94 ashish 5389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5390 
      self.ex.write(oprot)
5391 
      oprot.writeFieldEnd()
5392 
    oprot.writeFieldStop()
5393 
    oprot.writeStructEnd()
5394 
 
3431 rajveer 5395 
  def validate(self):
5396 
    return
5397 
 
5398 
 
94 ashish 5399 
  def __repr__(self):
5400 
    L = ['%s=%r' % (key, value)
5401 
      for key, value in self.__dict__.iteritems()]
5402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5403 
 
5404 
  def __eq__(self, other):
5405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5406 
 
5407 
  def __ne__(self, other):
5408 
    return not (self == other)
5409 
 
4133 chandransh 5410 
class getOrdersInBatch_args:
5411 
  """
5412 
  Attributes:
5413 
   - statuses
5414 
   - offset
5415 
   - limit
5416 
   - warehouse_id
5417 
  """
5418 
 
5419 
  thrift_spec = (
5420 
    None, # 0
5421 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5422 
    (2, TType.I64, 'offset', None, None, ), # 2
5423 
    (3, TType.I64, 'limit', None, None, ), # 3
5424 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5425 
  )
5426 
 
5427 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5428 
    self.statuses = statuses
5429 
    self.offset = offset
5430 
    self.limit = limit
5431 
    self.warehouse_id = warehouse_id
5432 
 
5433 
  def read(self, iprot):
5434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5436 
      return
5437 
    iprot.readStructBegin()
5438 
    while True:
5439 
      (fname, ftype, fid) = iprot.readFieldBegin()
5440 
      if ftype == TType.STOP:
5441 
        break
5442 
      if fid == 1:
5443 
        if ftype == TType.LIST:
5444 
          self.statuses = []
5445 
          (_etype38, _size35) = iprot.readListBegin()
5446 
          for _i39 in xrange(_size35):
5447 
            _elem40 = iprot.readI32();
5448 
            self.statuses.append(_elem40)
5449 
          iprot.readListEnd()
5450 
        else:
5451 
          iprot.skip(ftype)
5452 
      elif fid == 2:
5453 
        if ftype == TType.I64:
5454 
          self.offset = iprot.readI64();
5455 
        else:
5456 
          iprot.skip(ftype)
5457 
      elif fid == 3:
5458 
        if ftype == TType.I64:
5459 
          self.limit = iprot.readI64();
5460 
        else:
5461 
          iprot.skip(ftype)
5462 
      elif fid == 4:
5463 
        if ftype == TType.I64:
5464 
          self.warehouse_id = iprot.readI64();
5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      else:
5468 
        iprot.skip(ftype)
5469 
      iprot.readFieldEnd()
5470 
    iprot.readStructEnd()
5471 
 
5472 
  def write(self, oprot):
5473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5475 
      return
5476 
    oprot.writeStructBegin('getOrdersInBatch_args')
5477 
    if self.statuses is not None:
5478 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5479 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5480 
      for iter41 in self.statuses:
5481 
        oprot.writeI32(iter41)
5482 
      oprot.writeListEnd()
5483 
      oprot.writeFieldEnd()
5484 
    if self.offset is not None:
5485 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5486 
      oprot.writeI64(self.offset)
5487 
      oprot.writeFieldEnd()
5488 
    if self.limit is not None:
5489 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5490 
      oprot.writeI64(self.limit)
5491 
      oprot.writeFieldEnd()
5492 
    if self.warehouse_id is not None:
5493 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5494 
      oprot.writeI64(self.warehouse_id)
5495 
      oprot.writeFieldEnd()
5496 
    oprot.writeFieldStop()
5497 
    oprot.writeStructEnd()
5498 
 
5499 
  def validate(self):
5500 
    return
5501 
 
5502 
 
5503 
  def __repr__(self):
5504 
    L = ['%s=%r' % (key, value)
5505 
      for key, value in self.__dict__.iteritems()]
5506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5507 
 
5508 
  def __eq__(self, other):
5509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5510 
 
5511 
  def __ne__(self, other):
5512 
    return not (self == other)
5513 
 
5514 
class getOrdersInBatch_result:
5515 
  """
5516 
  Attributes:
5517 
   - success
5518 
   - ex
5519 
  """
5520 
 
5521 
  thrift_spec = (
5522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5524 
  )
5525 
 
5526 
  def __init__(self, success=None, ex=None,):
5527 
    self.success = success
5528 
    self.ex = ex
5529 
 
5530 
  def read(self, iprot):
5531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5533 
      return
5534 
    iprot.readStructBegin()
5535 
    while True:
5536 
      (fname, ftype, fid) = iprot.readFieldBegin()
5537 
      if ftype == TType.STOP:
5538 
        break
5539 
      if fid == 0:
5540 
        if ftype == TType.LIST:
5541 
          self.success = []
5542 
          (_etype45, _size42) = iprot.readListBegin()
5543 
          for _i46 in xrange(_size42):
5544 
            _elem47 = Order()
5545 
            _elem47.read(iprot)
5546 
            self.success.append(_elem47)
5547 
          iprot.readListEnd()
5548 
        else:
5549 
          iprot.skip(ftype)
5550 
      elif fid == 1:
5551 
        if ftype == TType.STRUCT:
5552 
          self.ex = TransactionServiceException()
5553 
          self.ex.read(iprot)
5554 
        else:
5555 
          iprot.skip(ftype)
5556 
      else:
5557 
        iprot.skip(ftype)
5558 
      iprot.readFieldEnd()
5559 
    iprot.readStructEnd()
5560 
 
5561 
  def write(self, oprot):
5562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5564 
      return
5565 
    oprot.writeStructBegin('getOrdersInBatch_result')
5566 
    if self.success is not None:
5567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5568 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5569 
      for iter48 in self.success:
5570 
        iter48.write(oprot)
5571 
      oprot.writeListEnd()
5572 
      oprot.writeFieldEnd()
5573 
    if self.ex is not None:
5574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5575 
      self.ex.write(oprot)
5576 
      oprot.writeFieldEnd()
5577 
    oprot.writeFieldStop()
5578 
    oprot.writeStructEnd()
5579 
 
5580 
  def validate(self):
5581 
    return
5582 
 
5583 
 
5584 
  def __repr__(self):
5585 
    L = ['%s=%r' % (key, value)
5586 
      for key, value in self.__dict__.iteritems()]
5587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5588 
 
5589 
  def __eq__(self, other):
5590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5591 
 
5592 
  def __ne__(self, other):
5593 
    return not (self == other)
5594 
 
5595 
class getOrderCount_args:
5596 
  """
5597 
  Attributes:
5598 
   - statuses
5599 
   - warehouseId
5600 
  """
5601 
 
5602 
  thrift_spec = (
5603 
    None, # 0
5604 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5605 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5606 
  )
5607 
 
5608 
  def __init__(self, statuses=None, warehouseId=None,):
5609 
    self.statuses = statuses
5610 
    self.warehouseId = warehouseId
5611 
 
5612 
  def read(self, iprot):
5613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5615 
      return
5616 
    iprot.readStructBegin()
5617 
    while True:
5618 
      (fname, ftype, fid) = iprot.readFieldBegin()
5619 
      if ftype == TType.STOP:
5620 
        break
5621 
      if fid == 1:
5622 
        if ftype == TType.LIST:
5623 
          self.statuses = []
5624 
          (_etype52, _size49) = iprot.readListBegin()
5625 
          for _i53 in xrange(_size49):
5626 
            _elem54 = iprot.readI32();
5627 
            self.statuses.append(_elem54)
5628 
          iprot.readListEnd()
5629 
        else:
5630 
          iprot.skip(ftype)
5631 
      elif fid == 2:
5632 
        if ftype == TType.I64:
5633 
          self.warehouseId = iprot.readI64();
5634 
        else:
5635 
          iprot.skip(ftype)
5636 
      else:
5637 
        iprot.skip(ftype)
5638 
      iprot.readFieldEnd()
5639 
    iprot.readStructEnd()
5640 
 
5641 
  def write(self, oprot):
5642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5644 
      return
5645 
    oprot.writeStructBegin('getOrderCount_args')
5646 
    if self.statuses is not None:
5647 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5648 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5649 
      for iter55 in self.statuses:
5650 
        oprot.writeI32(iter55)
5651 
      oprot.writeListEnd()
5652 
      oprot.writeFieldEnd()
5653 
    if self.warehouseId is not None:
5654 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5655 
      oprot.writeI64(self.warehouseId)
5656 
      oprot.writeFieldEnd()
5657 
    oprot.writeFieldStop()
5658 
    oprot.writeStructEnd()
5659 
 
5660 
  def validate(self):
5661 
    return
5662 
 
5663 
 
5664 
  def __repr__(self):
5665 
    L = ['%s=%r' % (key, value)
5666 
      for key, value in self.__dict__.iteritems()]
5667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5668 
 
5669 
  def __eq__(self, other):
5670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5671 
 
5672 
  def __ne__(self, other):
5673 
    return not (self == other)
5674 
 
5675 
class getOrderCount_result:
5676 
  """
5677 
  Attributes:
5678 
   - success
5679 
   - ex
5680 
  """
5681 
 
5682 
  thrift_spec = (
5683 
    (0, TType.I32, 'success', None, None, ), # 0
5684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5685 
  )
5686 
 
5687 
  def __init__(self, success=None, ex=None,):
5688 
    self.success = success
5689 
    self.ex = ex
5690 
 
5691 
  def read(self, iprot):
5692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5694 
      return
5695 
    iprot.readStructBegin()
5696 
    while True:
5697 
      (fname, ftype, fid) = iprot.readFieldBegin()
5698 
      if ftype == TType.STOP:
5699 
        break
5700 
      if fid == 0:
5701 
        if ftype == TType.I32:
5702 
          self.success = iprot.readI32();
5703 
        else:
5704 
          iprot.skip(ftype)
5705 
      elif fid == 1:
5706 
        if ftype == TType.STRUCT:
5707 
          self.ex = TransactionServiceException()
5708 
          self.ex.read(iprot)
5709 
        else:
5710 
          iprot.skip(ftype)
5711 
      else:
5712 
        iprot.skip(ftype)
5713 
      iprot.readFieldEnd()
5714 
    iprot.readStructEnd()
5715 
 
5716 
  def write(self, oprot):
5717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5719 
      return
5720 
    oprot.writeStructBegin('getOrderCount_result')
5721 
    if self.success is not None:
5722 
      oprot.writeFieldBegin('success', TType.I32, 0)
5723 
      oprot.writeI32(self.success)
5724 
      oprot.writeFieldEnd()
5725 
    if self.ex is not None:
5726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5727 
      self.ex.write(oprot)
5728 
      oprot.writeFieldEnd()
5729 
    oprot.writeFieldStop()
5730 
    oprot.writeStructEnd()
5731 
 
5732 
  def validate(self):
5733 
    return
5734 
 
5735 
 
5736 
  def __repr__(self):
5737 
    L = ['%s=%r' % (key, value)
5738 
      for key, value in self.__dict__.iteritems()]
5739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5740 
 
5741 
  def __eq__(self, other):
5742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5743 
 
5744 
  def __ne__(self, other):
5745 
    return not (self == other)
5746 
 
999 varun.gupt 5747 
class getOrdersByBillingDate_args:
5748 
  """
5749 
  Attributes:
5750 
   - status
5751 
   - start_billing_date
5752 
   - end_billing_date
5753 
   - warehouse_id
5754 
  """
5755 
 
5756 
  thrift_spec = (
5757 
    None, # 0
5758 
    (1, TType.I32, 'status', None, None, ), # 1
5759 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5760 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5761 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5762 
  )
5763 
 
5764 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5765 
    self.status = status
5766 
    self.start_billing_date = start_billing_date
5767 
    self.end_billing_date = end_billing_date
5768 
    self.warehouse_id = warehouse_id
5769 
 
5770 
  def read(self, iprot):
5771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5773 
      return
5774 
    iprot.readStructBegin()
5775 
    while True:
5776 
      (fname, ftype, fid) = iprot.readFieldBegin()
5777 
      if ftype == TType.STOP:
5778 
        break
5779 
      if fid == 1:
5780 
        if ftype == TType.I32:
5781 
          self.status = iprot.readI32();
5782 
        else:
5783 
          iprot.skip(ftype)
5784 
      elif fid == 2:
5785 
        if ftype == TType.I64:
5786 
          self.start_billing_date = iprot.readI64();
5787 
        else:
5788 
          iprot.skip(ftype)
5789 
      elif fid == 3:
5790 
        if ftype == TType.I64:
5791 
          self.end_billing_date = iprot.readI64();
5792 
        else:
5793 
          iprot.skip(ftype)
5794 
      elif fid == 4:
5795 
        if ftype == TType.I64:
5796 
          self.warehouse_id = iprot.readI64();
5797 
        else:
5798 
          iprot.skip(ftype)
5799 
      else:
5800 
        iprot.skip(ftype)
5801 
      iprot.readFieldEnd()
5802 
    iprot.readStructEnd()
5803 
 
5804 
  def write(self, oprot):
5805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5807 
      return
5808 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5809 
    if self.status is not None:
999 varun.gupt 5810 
      oprot.writeFieldBegin('status', TType.I32, 1)
5811 
      oprot.writeI32(self.status)
5812 
      oprot.writeFieldEnd()
3431 rajveer 5813 
    if self.start_billing_date is not None:
999 varun.gupt 5814 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5815 
      oprot.writeI64(self.start_billing_date)
5816 
      oprot.writeFieldEnd()
3431 rajveer 5817 
    if self.end_billing_date is not None:
999 varun.gupt 5818 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5819 
      oprot.writeI64(self.end_billing_date)
5820 
      oprot.writeFieldEnd()
3431 rajveer 5821 
    if self.warehouse_id is not None:
999 varun.gupt 5822 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5823 
      oprot.writeI64(self.warehouse_id)
5824 
      oprot.writeFieldEnd()
5825 
    oprot.writeFieldStop()
5826 
    oprot.writeStructEnd()
5827 
 
3431 rajveer 5828 
  def validate(self):
5829 
    return
5830 
 
5831 
 
999 varun.gupt 5832 
  def __repr__(self):
5833 
    L = ['%s=%r' % (key, value)
5834 
      for key, value in self.__dict__.iteritems()]
5835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5836 
 
5837 
  def __eq__(self, other):
5838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5839 
 
5840 
  def __ne__(self, other):
5841 
    return not (self == other)
5842 
 
5843 
class getOrdersByBillingDate_result:
5844 
  """
5845 
  Attributes:
5846 
   - success
5847 
   - ex
5848 
  """
5849 
 
5850 
  thrift_spec = (
5851 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5853 
  )
5854 
 
5855 
  def __init__(self, success=None, ex=None,):
5856 
    self.success = success
5857 
    self.ex = ex
5858 
 
5859 
  def read(self, iprot):
5860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5862 
      return
5863 
    iprot.readStructBegin()
5864 
    while True:
5865 
      (fname, ftype, fid) = iprot.readFieldBegin()
5866 
      if ftype == TType.STOP:
5867 
        break
5868 
      if fid == 0:
5869 
        if ftype == TType.LIST:
5870 
          self.success = []
4133 chandransh 5871 
          (_etype59, _size56) = iprot.readListBegin()
5872 
          for _i60 in xrange(_size56):
5873 
            _elem61 = Order()
5874 
            _elem61.read(iprot)
5875 
            self.success.append(_elem61)
999 varun.gupt 5876 
          iprot.readListEnd()
5877 
        else:
5878 
          iprot.skip(ftype)
5879 
      elif fid == 1:
5880 
        if ftype == TType.STRUCT:
5881 
          self.ex = TransactionServiceException()
5882 
          self.ex.read(iprot)
5883 
        else:
5884 
          iprot.skip(ftype)
5885 
      else:
5886 
        iprot.skip(ftype)
5887 
      iprot.readFieldEnd()
5888 
    iprot.readStructEnd()
5889 
 
5890 
  def write(self, oprot):
5891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5893 
      return
5894 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5895 
    if self.success is not None:
999 varun.gupt 5896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5898 
      for iter62 in self.success:
5899 
        iter62.write(oprot)
999 varun.gupt 5900 
      oprot.writeListEnd()
5901 
      oprot.writeFieldEnd()
3431 rajveer 5902 
    if self.ex is not None:
999 varun.gupt 5903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5904 
      self.ex.write(oprot)
5905 
      oprot.writeFieldEnd()
5906 
    oprot.writeFieldStop()
5907 
    oprot.writeStructEnd()
5908 
 
3431 rajveer 5909 
  def validate(self):
5910 
    return
5911 
 
5912 
 
999 varun.gupt 5913 
  def __repr__(self):
5914 
    L = ['%s=%r' % (key, value)
5915 
      for key, value in self.__dict__.iteritems()]
5916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5917 
 
5918 
  def __eq__(self, other):
5919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5920 
 
5921 
  def __ne__(self, other):
5922 
    return not (self == other)
5923 
 
3427 chandransh 5924 
class getOrdersByShippingDate_args:
5925 
  """
5926 
  Attributes:
5927 
   - fromShippingDate
5928 
   - toShippingDate
5929 
   - providerId
5930 
   - warehouseId
3451 chandransh 5931 
   - cod
3427 chandransh 5932 
  """
5933 
 
5934 
  thrift_spec = (
5935 
    None, # 0
5936 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5937 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5938 
    (3, TType.I64, 'providerId', None, None, ), # 3
5939 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5940 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5941 
  )
5942 
 
3451 chandransh 5943 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5944 
    self.fromShippingDate = fromShippingDate
5945 
    self.toShippingDate = toShippingDate
5946 
    self.providerId = providerId
5947 
    self.warehouseId = warehouseId
3451 chandransh 5948 
    self.cod = cod
3427 chandransh 5949 
 
5950 
  def read(self, iprot):
5951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5953 
      return
5954 
    iprot.readStructBegin()
5955 
    while True:
5956 
      (fname, ftype, fid) = iprot.readFieldBegin()
5957 
      if ftype == TType.STOP:
5958 
        break
5959 
      if fid == 1:
5960 
        if ftype == TType.I64:
5961 
          self.fromShippingDate = iprot.readI64();
5962 
        else:
5963 
          iprot.skip(ftype)
5964 
      elif fid == 2:
5965 
        if ftype == TType.I64:
5966 
          self.toShippingDate = iprot.readI64();
5967 
        else:
5968 
          iprot.skip(ftype)
5969 
      elif fid == 3:
5970 
        if ftype == TType.I64:
5971 
          self.providerId = iprot.readI64();
5972 
        else:
5973 
          iprot.skip(ftype)
5974 
      elif fid == 4:
5975 
        if ftype == TType.I64:
5976 
          self.warehouseId = iprot.readI64();
5977 
        else:
5978 
          iprot.skip(ftype)
3451 chandransh 5979 
      elif fid == 5:
5980 
        if ftype == TType.BOOL:
5981 
          self.cod = iprot.readBool();
5982 
        else:
5983 
          iprot.skip(ftype)
3427 chandransh 5984 
      else:
5985 
        iprot.skip(ftype)
5986 
      iprot.readFieldEnd()
5987 
    iprot.readStructEnd()
5988 
 
5989 
  def write(self, oprot):
5990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5992 
      return
5993 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5994 
    if self.fromShippingDate is not None:
3427 chandransh 5995 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5996 
      oprot.writeI64(self.fromShippingDate)
5997 
      oprot.writeFieldEnd()
3431 rajveer 5998 
    if self.toShippingDate is not None:
3427 chandransh 5999 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6000 
      oprot.writeI64(self.toShippingDate)
6001 
      oprot.writeFieldEnd()
3431 rajveer 6002 
    if self.providerId is not None:
3427 chandransh 6003 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6004 
      oprot.writeI64(self.providerId)
6005 
      oprot.writeFieldEnd()
3431 rajveer 6006 
    if self.warehouseId is not None:
3427 chandransh 6007 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6008 
      oprot.writeI64(self.warehouseId)
6009 
      oprot.writeFieldEnd()
3451 chandransh 6010 
    if self.cod is not None:
6011 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6012 
      oprot.writeBool(self.cod)
6013 
      oprot.writeFieldEnd()
3427 chandransh 6014 
    oprot.writeFieldStop()
6015 
    oprot.writeStructEnd()
6016 
 
3431 rajveer 6017 
  def validate(self):
6018 
    return
6019 
 
6020 
 
3427 chandransh 6021 
  def __repr__(self):
6022 
    L = ['%s=%r' % (key, value)
6023 
      for key, value in self.__dict__.iteritems()]
6024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6025 
 
6026 
  def __eq__(self, other):
6027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6028 
 
6029 
  def __ne__(self, other):
6030 
    return not (self == other)
6031 
 
6032 
class getOrdersByShippingDate_result:
6033 
  """
6034 
  Attributes:
6035 
   - success
6036 
   - ex
6037 
  """
6038 
 
6039 
  thrift_spec = (
6040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6042 
  )
6043 
 
6044 
  def __init__(self, success=None, ex=None,):
6045 
    self.success = success
6046 
    self.ex = ex
6047 
 
6048 
  def read(self, iprot):
6049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6051 
      return
6052 
    iprot.readStructBegin()
6053 
    while True:
6054 
      (fname, ftype, fid) = iprot.readFieldBegin()
6055 
      if ftype == TType.STOP:
6056 
        break
6057 
      if fid == 0:
6058 
        if ftype == TType.LIST:
6059 
          self.success = []
4133 chandransh 6060 
          (_etype66, _size63) = iprot.readListBegin()
6061 
          for _i67 in xrange(_size63):
6062 
            _elem68 = Order()
6063 
            _elem68.read(iprot)
6064 
            self.success.append(_elem68)
3427 chandransh 6065 
          iprot.readListEnd()
6066 
        else:
6067 
          iprot.skip(ftype)
6068 
      elif fid == 1:
6069 
        if ftype == TType.STRUCT:
6070 
          self.ex = TransactionServiceException()
6071 
          self.ex.read(iprot)
6072 
        else:
6073 
          iprot.skip(ftype)
6074 
      else:
6075 
        iprot.skip(ftype)
6076 
      iprot.readFieldEnd()
6077 
    iprot.readStructEnd()
6078 
 
6079 
  def write(self, oprot):
6080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6082 
      return
6083 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6084 
    if self.success is not None:
3427 chandransh 6085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6087 
      for iter69 in self.success:
6088 
        iter69.write(oprot)
3427 chandransh 6089 
      oprot.writeListEnd()
6090 
      oprot.writeFieldEnd()
3431 rajveer 6091 
    if self.ex is not None:
3427 chandransh 6092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6093 
      self.ex.write(oprot)
6094 
      oprot.writeFieldEnd()
6095 
    oprot.writeFieldStop()
6096 
    oprot.writeStructEnd()
6097 
 
3431 rajveer 6098 
  def validate(self):
6099 
    return
6100 
 
6101 
 
3427 chandransh 6102 
  def __repr__(self):
6103 
    L = ['%s=%r' % (key, value)
6104 
      for key, value in self.__dict__.iteritems()]
6105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6106 
 
6107 
  def __eq__(self, other):
6108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6109 
 
6110 
  def __ne__(self, other):
6111 
    return not (self == other)
6112 
 
1382 varun.gupt 6113 
class getReturnableOrdersForCustomer_args:
6114 
  """
6115 
  Attributes:
6116 
   - customer_id
6117 
   - limit
6118 
  """
6119 
 
6120 
  thrift_spec = (
6121 
    None, # 0
6122 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6123 
    (2, TType.I64, 'limit', None, None, ), # 2
6124 
  )
6125 
 
6126 
  def __init__(self, customer_id=None, limit=None,):
6127 
    self.customer_id = customer_id
6128 
    self.limit = limit
6129 
 
6130 
  def read(self, iprot):
6131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6133 
      return
6134 
    iprot.readStructBegin()
6135 
    while True:
6136 
      (fname, ftype, fid) = iprot.readFieldBegin()
6137 
      if ftype == TType.STOP:
6138 
        break
6139 
      if fid == 1:
6140 
        if ftype == TType.I64:
6141 
          self.customer_id = iprot.readI64();
6142 
        else:
6143 
          iprot.skip(ftype)
6144 
      elif fid == 2:
6145 
        if ftype == TType.I64:
6146 
          self.limit = iprot.readI64();
6147 
        else:
6148 
          iprot.skip(ftype)
6149 
      else:
6150 
        iprot.skip(ftype)
6151 
      iprot.readFieldEnd()
6152 
    iprot.readStructEnd()
6153 
 
6154 
  def write(self, oprot):
6155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6157 
      return
6158 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6159 
    if self.customer_id is not None:
1382 varun.gupt 6160 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6161 
      oprot.writeI64(self.customer_id)
6162 
      oprot.writeFieldEnd()
3431 rajveer 6163 
    if self.limit is not None:
1382 varun.gupt 6164 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6165 
      oprot.writeI64(self.limit)
6166 
      oprot.writeFieldEnd()
6167 
    oprot.writeFieldStop()
6168 
    oprot.writeStructEnd()
6169 
 
3431 rajveer 6170 
  def validate(self):
6171 
    return
6172 
 
6173 
 
1382 varun.gupt 6174 
  def __repr__(self):
6175 
    L = ['%s=%r' % (key, value)
6176 
      for key, value in self.__dict__.iteritems()]
6177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6178 
 
6179 
  def __eq__(self, other):
6180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6181 
 
6182 
  def __ne__(self, other):
6183 
    return not (self == other)
6184 
 
6185 
class getReturnableOrdersForCustomer_result:
6186 
  """
6187 
  Attributes:
6188 
   - success
6189 
   - ex
6190 
  """
6191 
 
6192 
  thrift_spec = (
6193 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6195 
  )
6196 
 
6197 
  def __init__(self, success=None, ex=None,):
6198 
    self.success = success
6199 
    self.ex = ex
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 == 0:
6211 
        if ftype == TType.LIST:
6212 
          self.success = []
4133 chandransh 6213 
          (_etype73, _size70) = iprot.readListBegin()
6214 
          for _i74 in xrange(_size70):
6215 
            _elem75 = iprot.readI64();
6216 
            self.success.append(_elem75)
1382 varun.gupt 6217 
          iprot.readListEnd()
6218 
        else:
6219 
          iprot.skip(ftype)
6220 
      elif fid == 1:
6221 
        if ftype == TType.STRUCT:
6222 
          self.ex = TransactionServiceException()
6223 
          self.ex.read(iprot)
6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      else:
6227 
        iprot.skip(ftype)
6228 
      iprot.readFieldEnd()
6229 
    iprot.readStructEnd()
6230 
 
6231 
  def write(self, oprot):
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6234 
      return
6235 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6236 
    if self.success is not None:
1382 varun.gupt 6237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6238 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6239 
      for iter76 in self.success:
6240 
        oprot.writeI64(iter76)
1382 varun.gupt 6241 
      oprot.writeListEnd()
6242 
      oprot.writeFieldEnd()
3431 rajveer 6243 
    if self.ex is not None:
1382 varun.gupt 6244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6245 
      self.ex.write(oprot)
6246 
      oprot.writeFieldEnd()
6247 
    oprot.writeFieldStop()
6248 
    oprot.writeStructEnd()
6249 
 
3431 rajveer 6250 
  def validate(self):
6251 
    return
6252 
 
6253 
 
1382 varun.gupt 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 
 
6265 
class getCancellableOrdersForCustomer_args:
6266 
  """
6267 
  Attributes:
6268 
   - customer_id
6269 
   - limit
6270 
  """
6271 
 
6272 
  thrift_spec = (
6273 
    None, # 0
6274 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6275 
    (2, TType.I64, 'limit', None, None, ), # 2
6276 
  )
6277 
 
6278 
  def __init__(self, customer_id=None, limit=None,):
6279 
    self.customer_id = customer_id
6280 
    self.limit = limit
6281 
 
6282 
  def read(self, iprot):
6283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6285 
      return
6286 
    iprot.readStructBegin()
6287 
    while True:
6288 
      (fname, ftype, fid) = iprot.readFieldBegin()
6289 
      if ftype == TType.STOP:
6290 
        break
6291 
      if fid == 1:
6292 
        if ftype == TType.I64:
6293 
          self.customer_id = iprot.readI64();
6294 
        else:
6295 
          iprot.skip(ftype)
6296 
      elif fid == 2:
6297 
        if ftype == TType.I64:
6298 
          self.limit = iprot.readI64();
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
6310 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6311 
    if self.customer_id is not None:
1382 varun.gupt 6312 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6313 
      oprot.writeI64(self.customer_id)
6314 
      oprot.writeFieldEnd()
3431 rajveer 6315 
    if self.limit is not None:
1382 varun.gupt 6316 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6317 
      oprot.writeI64(self.limit)
6318 
      oprot.writeFieldEnd()
6319 
    oprot.writeFieldStop()
6320 
    oprot.writeStructEnd()
6321 
 
3431 rajveer 6322 
  def validate(self):
6323 
    return
6324 
 
6325 
 
1382 varun.gupt 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 
 
6337 
class getCancellableOrdersForCustomer_result:
6338 
  """
6339 
  Attributes:
6340 
   - success
6341 
   - ex
6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6347 
  )
6348 
 
6349 
  def __init__(self, success=None, ex=None,):
6350 
    self.success = success
6351 
    self.ex = ex
6352 
 
6353 
  def read(self, iprot):
6354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6356 
      return
6357 
    iprot.readStructBegin()
6358 
    while True:
6359 
      (fname, ftype, fid) = iprot.readFieldBegin()
6360 
      if ftype == TType.STOP:
6361 
        break
6362 
      if fid == 0:
6363 
        if ftype == TType.LIST:
6364 
          self.success = []
4133 chandransh 6365 
          (_etype80, _size77) = iprot.readListBegin()
6366 
          for _i81 in xrange(_size77):
6367 
            _elem82 = iprot.readI64();
6368 
            self.success.append(_elem82)
1382 varun.gupt 6369 
          iprot.readListEnd()
6370 
        else:
6371 
          iprot.skip(ftype)
6372 
      elif fid == 1:
6373 
        if ftype == TType.STRUCT:
6374 
          self.ex = TransactionServiceException()
6375 
          self.ex.read(iprot)
6376 
        else:
6377 
          iprot.skip(ftype)
6378 
      else:
6379 
        iprot.skip(ftype)
6380 
      iprot.readFieldEnd()
6381 
    iprot.readStructEnd()
6382 
 
6383 
  def write(self, oprot):
6384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6386 
      return
6387 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6388 
    if self.success is not None:
1382 varun.gupt 6389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6390 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6391 
      for iter83 in self.success:
6392 
        oprot.writeI64(iter83)
1382 varun.gupt 6393 
      oprot.writeListEnd()
6394 
      oprot.writeFieldEnd()
3431 rajveer 6395 
    if self.ex is not None:
1382 varun.gupt 6396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6397 
      self.ex.write(oprot)
6398 
      oprot.writeFieldEnd()
6399 
    oprot.writeFieldStop()
6400 
    oprot.writeStructEnd()
6401 
 
3431 rajveer 6402 
  def validate(self):
6403 
    return
6404 
 
6405 
 
1382 varun.gupt 6406 
  def __repr__(self):
6407 
    L = ['%s=%r' % (key, value)
6408 
      for key, value in self.__dict__.iteritems()]
6409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6410 
 
6411 
  def __eq__(self, other):
6412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6413 
 
6414 
  def __ne__(self, other):
6415 
    return not (self == other)
6416 
 
483 rajveer 6417 
class changeOrderStatus_args:
94 ashish 6418 
  """
6419 
  Attributes:
483 rajveer 6420 
   - orderId
6421 
   - status
6422 
   - description
94 ashish 6423 
  """
6424 
 
6425 
  thrift_spec = (
6426 
    None, # 0
483 rajveer 6427 
    (1, TType.I64, 'orderId', None, None, ), # 1
6428 
    (2, TType.I32, 'status', None, None, ), # 2
6429 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6430 
  )
6431 
 
483 rajveer 6432 
  def __init__(self, orderId=None, status=None, description=None,):
6433 
    self.orderId = orderId
6434 
    self.status = status
6435 
    self.description = description
94 ashish 6436 
 
6437 
  def read(self, iprot):
6438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6440 
      return
6441 
    iprot.readStructBegin()
6442 
    while True:
6443 
      (fname, ftype, fid) = iprot.readFieldBegin()
6444 
      if ftype == TType.STOP:
6445 
        break
6446 
      if fid == 1:
6447 
        if ftype == TType.I64:
483 rajveer 6448 
          self.orderId = iprot.readI64();
94 ashish 6449 
        else:
6450 
          iprot.skip(ftype)
6451 
      elif fid == 2:
483 rajveer 6452 
        if ftype == TType.I32:
6453 
          self.status = iprot.readI32();
94 ashish 6454 
        else:
6455 
          iprot.skip(ftype)
483 rajveer 6456 
      elif fid == 3:
6457 
        if ftype == TType.STRING:
6458 
          self.description = iprot.readString();
6459 
        else:
6460 
          iprot.skip(ftype)
94 ashish 6461 
      else:
6462 
        iprot.skip(ftype)
6463 
      iprot.readFieldEnd()
6464 
    iprot.readStructEnd()
6465 
 
6466 
  def write(self, oprot):
6467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6469 
      return
483 rajveer 6470 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6471 
    if self.orderId is not None:
483 rajveer 6472 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6473 
      oprot.writeI64(self.orderId)
94 ashish 6474 
      oprot.writeFieldEnd()
3431 rajveer 6475 
    if self.status is not None:
483 rajveer 6476 
      oprot.writeFieldBegin('status', TType.I32, 2)
6477 
      oprot.writeI32(self.status)
94 ashish 6478 
      oprot.writeFieldEnd()
3431 rajveer 6479 
    if self.description is not None:
483 rajveer 6480 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6481 
      oprot.writeString(self.description)
6482 
      oprot.writeFieldEnd()
94 ashish 6483 
    oprot.writeFieldStop()
6484 
    oprot.writeStructEnd()
6485 
 
3431 rajveer 6486 
  def validate(self):
6487 
    return
6488 
 
6489 
 
94 ashish 6490 
  def __repr__(self):
6491 
    L = ['%s=%r' % (key, value)
6492 
      for key, value in self.__dict__.iteritems()]
6493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6494 
 
6495 
  def __eq__(self, other):
6496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6497 
 
6498 
  def __ne__(self, other):
6499 
    return not (self == other)
6500 
 
483 rajveer 6501 
class changeOrderStatus_result:
94 ashish 6502 
  """
6503 
  Attributes:
6504 
   - success
6505 
   - ex
6506 
  """
6507 
 
6508 
  thrift_spec = (
6509 
    (0, TType.BOOL, 'success', None, None, ), # 0
6510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6511 
  )
6512 
 
6513 
  def __init__(self, success=None, ex=None,):
6514 
    self.success = success
6515 
    self.ex = ex
6516 
 
6517 
  def read(self, iprot):
6518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6520 
      return
6521 
    iprot.readStructBegin()
6522 
    while True:
6523 
      (fname, ftype, fid) = iprot.readFieldBegin()
6524 
      if ftype == TType.STOP:
6525 
        break
6526 
      if fid == 0:
6527 
        if ftype == TType.BOOL:
6528 
          self.success = iprot.readBool();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      elif fid == 1:
6532 
        if ftype == TType.STRUCT:
6533 
          self.ex = TransactionServiceException()
6534 
          self.ex.read(iprot)
6535 
        else:
6536 
          iprot.skip(ftype)
6537 
      else:
6538 
        iprot.skip(ftype)
6539 
      iprot.readFieldEnd()
6540 
    iprot.readStructEnd()
6541 
 
6542 
  def write(self, oprot):
6543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6545 
      return
483 rajveer 6546 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6547 
    if self.success is not None:
94 ashish 6548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6549 
      oprot.writeBool(self.success)
6550 
      oprot.writeFieldEnd()
3431 rajveer 6551 
    if self.ex is not None:
94 ashish 6552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6553 
      self.ex.write(oprot)
6554 
      oprot.writeFieldEnd()
6555 
    oprot.writeFieldStop()
6556 
    oprot.writeStructEnd()
6557 
 
3431 rajveer 6558 
  def validate(self):
6559 
    return
6560 
 
6561 
 
94 ashish 6562 
  def __repr__(self):
6563 
    L = ['%s=%r' % (key, value)
6564 
      for key, value in self.__dict__.iteritems()]
6565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6566 
 
6567 
  def __eq__(self, other):
6568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6569 
 
6570 
  def __ne__(self, other):
6571 
    return not (self == other)
6572 
 
3064 chandransh 6573 
class getOrdersForTransaction_args:
494 rajveer 6574 
  """
6575 
  Attributes:
3064 chandransh 6576 
   - transactionId
6577 
   - customerId
494 rajveer 6578 
  """
6579 
 
6580 
  thrift_spec = (
6581 
    None, # 0
3064 chandransh 6582 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6583 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6584 
  )
6585 
 
3064 chandransh 6586 
  def __init__(self, transactionId=None, customerId=None,):
6587 
    self.transactionId = transactionId
6588 
    self.customerId = customerId
494 rajveer 6589 
 
6590 
  def read(self, iprot):
6591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6593 
      return
6594 
    iprot.readStructBegin()
6595 
    while True:
6596 
      (fname, ftype, fid) = iprot.readFieldBegin()
6597 
      if ftype == TType.STOP:
6598 
        break
6599 
      if fid == 1:
6600 
        if ftype == TType.I64:
3064 chandransh 6601 
          self.transactionId = iprot.readI64();
494 rajveer 6602 
        else:
6603 
          iprot.skip(ftype)
6604 
      elif fid == 2:
3064 chandransh 6605 
        if ftype == TType.I64:
6606 
          self.customerId = iprot.readI64();
494 rajveer 6607 
        else:
6608 
          iprot.skip(ftype)
6609 
      else:
6610 
        iprot.skip(ftype)
6611 
      iprot.readFieldEnd()
6612 
    iprot.readStructEnd()
6613 
 
6614 
  def write(self, oprot):
6615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6617 
      return
3064 chandransh 6618 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6619 
    if self.transactionId is not None:
3064 chandransh 6620 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6621 
      oprot.writeI64(self.transactionId)
494 rajveer 6622 
      oprot.writeFieldEnd()
3431 rajveer 6623 
    if self.customerId is not None:
3064 chandransh 6624 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6625 
      oprot.writeI64(self.customerId)
494 rajveer 6626 
      oprot.writeFieldEnd()
6627 
    oprot.writeFieldStop()
6628 
    oprot.writeStructEnd()
6629 
 
3431 rajveer 6630 
  def validate(self):
6631 
    return
6632 
 
6633 
 
494 rajveer 6634 
  def __repr__(self):
6635 
    L = ['%s=%r' % (key, value)
6636 
      for key, value in self.__dict__.iteritems()]
6637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6638 
 
6639 
  def __eq__(self, other):
6640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6641 
 
6642 
  def __ne__(self, other):
6643 
    return not (self == other)
6644 
 
3064 chandransh 6645 
class getOrdersForTransaction_result:
494 rajveer 6646 
  """
6647 
  Attributes:
6648 
   - success
6649 
   - ex
6650 
  """
6651 
 
6652 
  thrift_spec = (
3064 chandransh 6653 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6655 
  )
6656 
 
6657 
  def __init__(self, success=None, ex=None,):
6658 
    self.success = success
6659 
    self.ex = ex
6660 
 
6661 
  def read(self, iprot):
6662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6664 
      return
6665 
    iprot.readStructBegin()
6666 
    while True:
6667 
      (fname, ftype, fid) = iprot.readFieldBegin()
6668 
      if ftype == TType.STOP:
6669 
        break
6670 
      if fid == 0:
3064 chandransh 6671 
        if ftype == TType.LIST:
6672 
          self.success = []
4133 chandransh 6673 
          (_etype87, _size84) = iprot.readListBegin()
6674 
          for _i88 in xrange(_size84):
6675 
            _elem89 = Order()
6676 
            _elem89.read(iprot)
6677 
            self.success.append(_elem89)
3064 chandransh 6678 
          iprot.readListEnd()
494 rajveer 6679 
        else:
6680 
          iprot.skip(ftype)
6681 
      elif fid == 1:
6682 
        if ftype == TType.STRUCT:
6683 
          self.ex = TransactionServiceException()
6684 
          self.ex.read(iprot)
6685 
        else:
6686 
          iprot.skip(ftype)
6687 
      else:
6688 
        iprot.skip(ftype)
6689 
      iprot.readFieldEnd()
6690 
    iprot.readStructEnd()
6691 
 
6692 
  def write(self, oprot):
6693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6695 
      return
3064 chandransh 6696 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6697 
    if self.success is not None:
3064 chandransh 6698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6700 
      for iter90 in self.success:
6701 
        iter90.write(oprot)
3064 chandransh 6702 
      oprot.writeListEnd()
494 rajveer 6703 
      oprot.writeFieldEnd()
3431 rajveer 6704 
    if self.ex is not None:
494 rajveer 6705 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6706 
      self.ex.write(oprot)
6707 
      oprot.writeFieldEnd()
6708 
    oprot.writeFieldStop()
6709 
    oprot.writeStructEnd()
6710 
 
3431 rajveer 6711 
  def validate(self):
6712 
    return
6713 
 
6714 
 
494 rajveer 6715 
  def __repr__(self):
6716 
    L = ['%s=%r' % (key, value)
6717 
      for key, value in self.__dict__.iteritems()]
6718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6719 
 
6720 
  def __eq__(self, other):
6721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6722 
 
6723 
  def __ne__(self, other):
6724 
    return not (self == other)
6725 
 
3064 chandransh 6726 
class getOrdersForCustomer_args:
1149 chandransh 6727 
  """
6728 
  Attributes:
3064 chandransh 6729 
   - customerId
6730 
   - from_date
6731 
   - to_date
6732 
   - statuses
1149 chandransh 6733 
  """
6734 
 
6735 
  thrift_spec = (
6736 
    None, # 0
3064 chandransh 6737 
    (1, TType.I64, 'customerId', None, None, ), # 1
6738 
    (2, TType.I64, 'from_date', None, None, ), # 2
6739 
    (3, TType.I64, 'to_date', None, None, ), # 3
6740 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6741 
  )
6742 
 
3064 chandransh 6743 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6744 
    self.customerId = customerId
6745 
    self.from_date = from_date
6746 
    self.to_date = to_date
6747 
    self.statuses = statuses
1149 chandransh 6748 
 
6749 
  def read(self, iprot):
6750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6752 
      return
6753 
    iprot.readStructBegin()
6754 
    while True:
6755 
      (fname, ftype, fid) = iprot.readFieldBegin()
6756 
      if ftype == TType.STOP:
6757 
        break
6758 
      if fid == 1:
6759 
        if ftype == TType.I64:
3064 chandransh 6760 
          self.customerId = iprot.readI64();
1149 chandransh 6761 
        else:
6762 
          iprot.skip(ftype)
6763 
      elif fid == 2:
6764 
        if ftype == TType.I64:
3064 chandransh 6765 
          self.from_date = iprot.readI64();
1149 chandransh 6766 
        else:
6767 
          iprot.skip(ftype)
2783 chandransh 6768 
      elif fid == 3:
6769 
        if ftype == TType.I64:
3064 chandransh 6770 
          self.to_date = iprot.readI64();
2783 chandransh 6771 
        else:
6772 
          iprot.skip(ftype)
6773 
      elif fid == 4:
3064 chandransh 6774 
        if ftype == TType.LIST:
6775 
          self.statuses = []
4133 chandransh 6776 
          (_etype94, _size91) = iprot.readListBegin()
6777 
          for _i95 in xrange(_size91):
6778 
            _elem96 = iprot.readI32();
6779 
            self.statuses.append(_elem96)
3064 chandransh 6780 
          iprot.readListEnd()
2783 chandransh 6781 
        else:
6782 
          iprot.skip(ftype)
1149 chandransh 6783 
      else:
6784 
        iprot.skip(ftype)
6785 
      iprot.readFieldEnd()
6786 
    iprot.readStructEnd()
6787 
 
6788 
  def write(self, oprot):
6789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6791 
      return
3064 chandransh 6792 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6793 
    if self.customerId is not None:
3064 chandransh 6794 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6795 
      oprot.writeI64(self.customerId)
1149 chandransh 6796 
      oprot.writeFieldEnd()
3431 rajveer 6797 
    if self.from_date is not None:
3064 chandransh 6798 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6799 
      oprot.writeI64(self.from_date)
1149 chandransh 6800 
      oprot.writeFieldEnd()
3431 rajveer 6801 
    if self.to_date is not None:
3064 chandransh 6802 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6803 
      oprot.writeI64(self.to_date)
2783 chandransh 6804 
      oprot.writeFieldEnd()
3431 rajveer 6805 
    if self.statuses is not None:
3064 chandransh 6806 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6807 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6808 
      for iter97 in self.statuses:
6809 
        oprot.writeI32(iter97)
3064 chandransh 6810 
      oprot.writeListEnd()
2783 chandransh 6811 
      oprot.writeFieldEnd()
1149 chandransh 6812 
    oprot.writeFieldStop()
6813 
    oprot.writeStructEnd()
6814 
 
3431 rajveer 6815 
  def validate(self):
6816 
    return
6817 
 
6818 
 
1149 chandransh 6819 
  def __repr__(self):
6820 
    L = ['%s=%r' % (key, value)
6821 
      for key, value in self.__dict__.iteritems()]
6822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6823 
 
6824 
  def __eq__(self, other):
6825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6826 
 
6827 
  def __ne__(self, other):
6828 
    return not (self == other)
6829 
 
3064 chandransh 6830 
class getOrdersForCustomer_result:
1149 chandransh 6831 
  """
6832 
  Attributes:
6833 
   - success
6834 
   - ex
6835 
  """
6836 
 
6837 
  thrift_spec = (
3064 chandransh 6838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6840 
  )
6841 
 
6842 
  def __init__(self, success=None, ex=None,):
6843 
    self.success = success
6844 
    self.ex = ex
6845 
 
6846 
  def read(self, iprot):
6847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6849 
      return
6850 
    iprot.readStructBegin()
6851 
    while True:
6852 
      (fname, ftype, fid) = iprot.readFieldBegin()
6853 
      if ftype == TType.STOP:
6854 
        break
6855 
      if fid == 0:
3064 chandransh 6856 
        if ftype == TType.LIST:
6857 
          self.success = []
4133 chandransh 6858 
          (_etype101, _size98) = iprot.readListBegin()
6859 
          for _i102 in xrange(_size98):
6860 
            _elem103 = Order()
6861 
            _elem103.read(iprot)
6862 
            self.success.append(_elem103)
3064 chandransh 6863 
          iprot.readListEnd()
1149 chandransh 6864 
        else:
6865 
          iprot.skip(ftype)
6866 
      elif fid == 1:
6867 
        if ftype == TType.STRUCT:
6868 
          self.ex = TransactionServiceException()
6869 
          self.ex.read(iprot)
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      else:
6873 
        iprot.skip(ftype)
6874 
      iprot.readFieldEnd()
6875 
    iprot.readStructEnd()
6876 
 
6877 
  def write(self, oprot):
6878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6880 
      return
3064 chandransh 6881 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6882 
    if self.success is not None:
3064 chandransh 6883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6885 
      for iter104 in self.success:
6886 
        iter104.write(oprot)
3064 chandransh 6887 
      oprot.writeListEnd()
1149 chandransh 6888 
      oprot.writeFieldEnd()
3431 rajveer 6889 
    if self.ex is not None:
1149 chandransh 6890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6891 
      self.ex.write(oprot)
6892 
      oprot.writeFieldEnd()
6893 
    oprot.writeFieldStop()
6894 
    oprot.writeStructEnd()
6895 
 
3431 rajveer 6896 
  def validate(self):
6897 
    return
6898 
 
6899 
 
1149 chandransh 6900 
  def __repr__(self):
6901 
    L = ['%s=%r' % (key, value)
6902 
      for key, value in self.__dict__.iteritems()]
6903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6904 
 
6905 
  def __eq__(self, other):
6906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6907 
 
6908 
  def __ne__(self, other):
6909 
    return not (self == other)
6910 
 
3064 chandransh 6911 
class createOrder_args:
921 rajveer 6912 
  """
6913 
  Attributes:
3064 chandransh 6914 
   - order
921 rajveer 6915 
  """
6916 
 
6917 
  thrift_spec = (
6918 
    None, # 0
3064 chandransh 6919 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6920 
  )
6921 
 
3064 chandransh 6922 
  def __init__(self, order=None,):
6923 
    self.order = order
921 rajveer 6924 
 
6925 
  def read(self, iprot):
6926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6928 
      return
6929 
    iprot.readStructBegin()
6930 
    while True:
6931 
      (fname, ftype, fid) = iprot.readFieldBegin()
6932 
      if ftype == TType.STOP:
6933 
        break
6934 
      if fid == 1:
3064 chandransh 6935 
        if ftype == TType.STRUCT:
6936 
          self.order = Order()
6937 
          self.order.read(iprot)
921 rajveer 6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
3064 chandransh 6949 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6950 
    if self.order is not None:
3064 chandransh 6951 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6952 
      self.order.write(oprot)
921 rajveer 6953 
      oprot.writeFieldEnd()
6954 
    oprot.writeFieldStop()
6955 
    oprot.writeStructEnd()
6956 
 
3431 rajveer 6957 
  def validate(self):
6958 
    return
6959 
 
6960 
 
921 rajveer 6961 
  def __repr__(self):
6962 
    L = ['%s=%r' % (key, value)
6963 
      for key, value in self.__dict__.iteritems()]
6964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6965 
 
6966 
  def __eq__(self, other):
6967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6968 
 
6969 
  def __ne__(self, other):
6970 
    return not (self == other)
6971 
 
3064 chandransh 6972 
class createOrder_result:
921 rajveer 6973 
  """
6974 
  Attributes:
6975 
   - success
6976 
   - ex
6977 
  """
6978 
 
6979 
  thrift_spec = (
3064 chandransh 6980 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6982 
  )
6983 
 
6984 
  def __init__(self, success=None, ex=None,):
6985 
    self.success = success
6986 
    self.ex = ex
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 0:
3064 chandransh 6998 
        if ftype == TType.I64:
6999 
          self.success = iprot.readI64();
921 rajveer 7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      elif fid == 1:
7003 
        if ftype == TType.STRUCT:
7004 
          self.ex = TransactionServiceException()
7005 
          self.ex.read(iprot)
7006 
        else:
7007 
          iprot.skip(ftype)
7008 
      else:
7009 
        iprot.skip(ftype)
7010 
      iprot.readFieldEnd()
7011 
    iprot.readStructEnd()
7012 
 
7013 
  def write(self, oprot):
7014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7016 
      return
3064 chandransh 7017 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7018 
    if self.success is not None:
3064 chandransh 7019 
      oprot.writeFieldBegin('success', TType.I64, 0)
7020 
      oprot.writeI64(self.success)
921 rajveer 7021 
      oprot.writeFieldEnd()
3431 rajveer 7022 
    if self.ex is not None:
921 rajveer 7023 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7024 
      self.ex.write(oprot)
7025 
      oprot.writeFieldEnd()
7026 
    oprot.writeFieldStop()
7027 
    oprot.writeStructEnd()
7028 
 
3431 rajveer 7029 
  def validate(self):
7030 
    return
7031 
 
7032 
 
921 rajveer 7033 
  def __repr__(self):
7034 
    L = ['%s=%r' % (key, value)
7035 
      for key, value in self.__dict__.iteritems()]
7036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7037 
 
7038 
  def __eq__(self, other):
7039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7040 
 
7041 
  def __ne__(self, other):
7042 
    return not (self == other)
7043 
 
3064 chandransh 7044 
class getOrder_args:
921 rajveer 7045 
  """
7046 
  Attributes:
3064 chandransh 7047 
   - id
921 rajveer 7048 
  """
7049 
 
7050 
  thrift_spec = (
7051 
    None, # 0
3064 chandransh 7052 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7053 
  )
7054 
 
3064 chandransh 7055 
  def __init__(self, id=None,):
7056 
    self.id = id
921 rajveer 7057 
 
7058 
  def read(self, iprot):
7059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7061 
      return
7062 
    iprot.readStructBegin()
7063 
    while True:
7064 
      (fname, ftype, fid) = iprot.readFieldBegin()
7065 
      if ftype == TType.STOP:
7066 
        break
7067 
      if fid == 1:
7068 
        if ftype == TType.I64:
3064 chandransh 7069 
          self.id = iprot.readI64();
921 rajveer 7070 
        else:
7071 
          iprot.skip(ftype)
7072 
      else:
7073 
        iprot.skip(ftype)
7074 
      iprot.readFieldEnd()
7075 
    iprot.readStructEnd()
7076 
 
7077 
  def write(self, oprot):
7078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7080 
      return
3064 chandransh 7081 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7082 
    if self.id is not None:
3064 chandransh 7083 
      oprot.writeFieldBegin('id', TType.I64, 1)
7084 
      oprot.writeI64(self.id)
921 rajveer 7085 
      oprot.writeFieldEnd()
7086 
    oprot.writeFieldStop()
7087 
    oprot.writeStructEnd()
7088 
 
3431 rajveer 7089 
  def validate(self):
7090 
    return
7091 
 
7092 
 
921 rajveer 7093 
  def __repr__(self):
7094 
    L = ['%s=%r' % (key, value)
7095 
      for key, value in self.__dict__.iteritems()]
7096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7097 
 
7098 
  def __eq__(self, other):
7099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7100 
 
7101 
  def __ne__(self, other):
7102 
    return not (self == other)
7103 
 
3064 chandransh 7104 
class getOrder_result:
921 rajveer 7105 
  """
7106 
  Attributes:
7107 
   - success
7108 
   - ex
7109 
  """
7110 
 
7111 
  thrift_spec = (
3064 chandransh 7112 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7114 
  )
7115 
 
7116 
  def __init__(self, success=None, ex=None,):
7117 
    self.success = success
7118 
    self.ex = ex
7119 
 
7120 
  def read(self, iprot):
7121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7123 
      return
7124 
    iprot.readStructBegin()
7125 
    while True:
7126 
      (fname, ftype, fid) = iprot.readFieldBegin()
7127 
      if ftype == TType.STOP:
7128 
        break
7129 
      if fid == 0:
3064 chandransh 7130 
        if ftype == TType.STRUCT:
7131 
          self.success = Order()
7132 
          self.success.read(iprot)
921 rajveer 7133 
        else:
7134 
          iprot.skip(ftype)
7135 
      elif fid == 1:
7136 
        if ftype == TType.STRUCT:
7137 
          self.ex = TransactionServiceException()
7138 
          self.ex.read(iprot)
7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      else:
7142 
        iprot.skip(ftype)
7143 
      iprot.readFieldEnd()
7144 
    iprot.readStructEnd()
7145 
 
7146 
  def write(self, oprot):
7147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7149 
      return
3064 chandransh 7150 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7151 
    if self.success is not None:
3064 chandransh 7152 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7153 
      self.success.write(oprot)
921 rajveer 7154 
      oprot.writeFieldEnd()
3431 rajveer 7155 
    if self.ex is not None:
921 rajveer 7156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7157 
      self.ex.write(oprot)
7158 
      oprot.writeFieldEnd()
7159 
    oprot.writeFieldStop()
7160 
    oprot.writeStructEnd()
7161 
 
3431 rajveer 7162 
  def validate(self):
7163 
    return
7164 
 
7165 
 
921 rajveer 7166 
  def __repr__(self):
7167 
    L = ['%s=%r' % (key, value)
7168 
      for key, value in self.__dict__.iteritems()]
7169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7170 
 
7171 
  def __eq__(self, other):
7172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7173 
 
7174 
  def __ne__(self, other):
7175 
    return not (self == other)
7176 
 
3064 chandransh 7177 
class getLineItemsForOrder_args:
94 ashish 7178 
  """
7179 
  Attributes:
3064 chandransh 7180 
   - orderId
94 ashish 7181 
  """
7182 
 
7183 
  thrift_spec = (
7184 
    None, # 0
3064 chandransh 7185 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7186 
  )
7187 
 
3064 chandransh 7188 
  def __init__(self, orderId=None,):
7189 
    self.orderId = orderId
94 ashish 7190 
 
7191 
  def read(self, iprot):
7192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7194 
      return
7195 
    iprot.readStructBegin()
7196 
    while True:
7197 
      (fname, ftype, fid) = iprot.readFieldBegin()
7198 
      if ftype == TType.STOP:
7199 
        break
7200 
      if fid == 1:
7201 
        if ftype == TType.I64:
3064 chandransh 7202 
          self.orderId = iprot.readI64();
94 ashish 7203 
        else:
7204 
          iprot.skip(ftype)
7205 
      else:
7206 
        iprot.skip(ftype)
7207 
      iprot.readFieldEnd()
7208 
    iprot.readStructEnd()
7209 
 
7210 
  def write(self, oprot):
7211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7213 
      return
3064 chandransh 7214 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7215 
    if self.orderId is not None:
3064 chandransh 7216 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7217 
      oprot.writeI64(self.orderId)
94 ashish 7218 
      oprot.writeFieldEnd()
7219 
    oprot.writeFieldStop()
7220 
    oprot.writeStructEnd()
7221 
 
3431 rajveer 7222 
  def validate(self):
7223 
    return
7224 
 
7225 
 
94 ashish 7226 
  def __repr__(self):
7227 
    L = ['%s=%r' % (key, value)
7228 
      for key, value in self.__dict__.iteritems()]
7229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7230 
 
7231 
  def __eq__(self, other):
7232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7233 
 
7234 
  def __ne__(self, other):
7235 
    return not (self == other)
7236 
 
3064 chandransh 7237 
class getLineItemsForOrder_result:
94 ashish 7238 
  """
7239 
  Attributes:
7240 
   - success
7241 
   - ex
7242 
  """
7243 
 
7244 
  thrift_spec = (
3064 chandransh 7245 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7247 
  )
7248 
 
7249 
  def __init__(self, success=None, ex=None,):
7250 
    self.success = success
7251 
    self.ex = ex
7252 
 
7253 
  def read(self, iprot):
7254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7256 
      return
7257 
    iprot.readStructBegin()
7258 
    while True:
7259 
      (fname, ftype, fid) = iprot.readFieldBegin()
7260 
      if ftype == TType.STOP:
7261 
        break
7262 
      if fid == 0:
483 rajveer 7263 
        if ftype == TType.LIST:
7264 
          self.success = []
4133 chandransh 7265 
          (_etype108, _size105) = iprot.readListBegin()
7266 
          for _i109 in xrange(_size105):
7267 
            _elem110 = LineItem()
7268 
            _elem110.read(iprot)
7269 
            self.success.append(_elem110)
483 rajveer 7270 
          iprot.readListEnd()
94 ashish 7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      elif fid == 1:
7274 
        if ftype == TType.STRUCT:
7275 
          self.ex = TransactionServiceException()
7276 
          self.ex.read(iprot)
7277 
        else:
7278 
          iprot.skip(ftype)
7279 
      else:
7280 
        iprot.skip(ftype)
7281 
      iprot.readFieldEnd()
7282 
    iprot.readStructEnd()
7283 
 
7284 
  def write(self, oprot):
7285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7287 
      return
3064 chandransh 7288 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7289 
    if self.success is not None:
483 rajveer 7290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7291 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7292 
      for iter111 in self.success:
7293 
        iter111.write(oprot)
483 rajveer 7294 
      oprot.writeListEnd()
94 ashish 7295 
      oprot.writeFieldEnd()
3431 rajveer 7296 
    if self.ex is not None:
94 ashish 7297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7298 
      self.ex.write(oprot)
7299 
      oprot.writeFieldEnd()
7300 
    oprot.writeFieldStop()
7301 
    oprot.writeStructEnd()
7302 
 
3431 rajveer 7303 
  def validate(self):
7304 
    return
7305 
 
7306 
 
94 ashish 7307 
  def __repr__(self):
7308 
    L = ['%s=%r' % (key, value)
7309 
      for key, value in self.__dict__.iteritems()]
7310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7311 
 
7312 
  def __eq__(self, other):
7313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7314 
 
7315 
  def __ne__(self, other):
7316 
    return not (self == other)
7317 
 
3064 chandransh 7318 
class getOrderForCustomer_args:
94 ashish 7319 
  """
7320 
  Attributes:
3064 chandransh 7321 
   - orderId
483 rajveer 7322 
   - customerId
94 ashish 7323 
  """
7324 
 
7325 
  thrift_spec = (
7326 
    None, # 0
3064 chandransh 7327 
    (1, TType.I64, 'orderId', None, None, ), # 1
7328 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7329 
  )
7330 
 
3064 chandransh 7331 
  def __init__(self, orderId=None, customerId=None,):
7332 
    self.orderId = orderId
483 rajveer 7333 
    self.customerId = customerId
94 ashish 7334 
 
7335 
  def read(self, iprot):
7336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7338 
      return
7339 
    iprot.readStructBegin()
7340 
    while True:
7341 
      (fname, ftype, fid) = iprot.readFieldBegin()
7342 
      if ftype == TType.STOP:
7343 
        break
7344 
      if fid == 1:
7345 
        if ftype == TType.I64:
3064 chandransh 7346 
          self.orderId = iprot.readI64();
94 ashish 7347 
        else:
7348 
          iprot.skip(ftype)
7349 
      elif fid == 2:
7350 
        if ftype == TType.I64:
3064 chandransh 7351 
          self.customerId = iprot.readI64();
94 ashish 7352 
        else:
7353 
          iprot.skip(ftype)
7354 
      else:
7355 
        iprot.skip(ftype)
7356 
      iprot.readFieldEnd()
7357 
    iprot.readStructEnd()
7358 
 
7359 
  def write(self, oprot):
7360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7362 
      return
3064 chandransh 7363 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7364 
    if self.orderId is not None:
3064 chandransh 7365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7366 
      oprot.writeI64(self.orderId)
7367 
      oprot.writeFieldEnd()
3431 rajveer 7368 
    if self.customerId is not None:
3064 chandransh 7369 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7370 
      oprot.writeI64(self.customerId)
94 ashish 7371 
      oprot.writeFieldEnd()
7372 
    oprot.writeFieldStop()
7373 
    oprot.writeStructEnd()
7374 
 
3431 rajveer 7375 
  def validate(self):
7376 
    return
7377 
 
7378 
 
94 ashish 7379 
  def __repr__(self):
7380 
    L = ['%s=%r' % (key, value)
7381 
      for key, value in self.__dict__.iteritems()]
7382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7383 
 
7384 
  def __eq__(self, other):
7385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7386 
 
7387 
  def __ne__(self, other):
7388 
    return not (self == other)
7389 
 
3064 chandransh 7390 
class getOrderForCustomer_result:
94 ashish 7391 
  """
7392 
  Attributes:
7393 
   - success
7394 
   - ex
7395 
  """
7396 
 
7397 
  thrift_spec = (
3064 chandransh 7398 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7400 
  )
7401 
 
7402 
  def __init__(self, success=None, ex=None,):
7403 
    self.success = success
7404 
    self.ex = ex
7405 
 
7406 
  def read(self, iprot):
7407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7409 
      return
7410 
    iprot.readStructBegin()
7411 
    while True:
7412 
      (fname, ftype, fid) = iprot.readFieldBegin()
7413 
      if ftype == TType.STOP:
7414 
        break
7415 
      if fid == 0:
3064 chandransh 7416 
        if ftype == TType.STRUCT:
7417 
          self.success = Order()
7418 
          self.success.read(iprot)
94 ashish 7419 
        else:
7420 
          iprot.skip(ftype)
7421 
      elif fid == 1:
7422 
        if ftype == TType.STRUCT:
7423 
          self.ex = TransactionServiceException()
7424 
          self.ex.read(iprot)
7425 
        else:
7426 
          iprot.skip(ftype)
7427 
      else:
7428 
        iprot.skip(ftype)
7429 
      iprot.readFieldEnd()
7430 
    iprot.readStructEnd()
7431 
 
7432 
  def write(self, oprot):
7433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7435 
      return
3064 chandransh 7436 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7437 
    if self.success is not None:
3064 chandransh 7438 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7439 
      self.success.write(oprot)
94 ashish 7440 
      oprot.writeFieldEnd()
3431 rajveer 7441 
    if self.ex is not None:
94 ashish 7442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7443 
      self.ex.write(oprot)
7444 
      oprot.writeFieldEnd()
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 getAlerts_args:
94 ashish 7464 
  """
7465 
  Attributes:
3064 chandransh 7466 
   - orderId
7467 
   - valid
94 ashish 7468 
  """
7469 
 
7470 
  thrift_spec = (
7471 
    None, # 0
3064 chandransh 7472 
    (1, TType.I64, 'orderId', None, None, ), # 1
7473 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7474 
  )
7475 
 
3064 chandransh 7476 
  def __init__(self, orderId=None, valid=None,):
7477 
    self.orderId = orderId
7478 
    self.valid = valid
94 ashish 7479 
 
7480 
  def read(self, iprot):
7481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7483 
      return
7484 
    iprot.readStructBegin()
7485 
    while True:
7486 
      (fname, ftype, fid) = iprot.readFieldBegin()
7487 
      if ftype == TType.STOP:
7488 
        break
7489 
      if fid == 1:
3064 chandransh 7490 
        if ftype == TType.I64:
7491 
          self.orderId = iprot.readI64();
94 ashish 7492 
        else:
7493 
          iprot.skip(ftype)
3064 chandransh 7494 
      elif fid == 2:
7495 
        if ftype == TType.BOOL:
7496 
          self.valid = iprot.readBool();
7497 
        else:
7498 
          iprot.skip(ftype)
94 ashish 7499 
      else:
7500 
        iprot.skip(ftype)
7501 
      iprot.readFieldEnd()
7502 
    iprot.readStructEnd()
7503 
 
7504 
  def write(self, oprot):
7505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7507 
      return
3064 chandransh 7508 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7509 
    if self.orderId is not None:
3064 chandransh 7510 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7511 
      oprot.writeI64(self.orderId)
94 ashish 7512 
      oprot.writeFieldEnd()
3431 rajveer 7513 
    if self.valid is not None:
3064 chandransh 7514 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7515 
      oprot.writeBool(self.valid)
7516 
      oprot.writeFieldEnd()
94 ashish 7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
3431 rajveer 7520 
  def validate(self):
7521 
    return
7522 
 
7523 
 
94 ashish 7524 
  def __repr__(self):
7525 
    L = ['%s=%r' % (key, value)
7526 
      for key, value in self.__dict__.iteritems()]
7527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7528 
 
7529 
  def __eq__(self, other):
7530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7531 
 
7532 
  def __ne__(self, other):
7533 
    return not (self == other)
7534 
 
3064 chandransh 7535 
class getAlerts_result:
94 ashish 7536 
  """
7537 
  Attributes:
7538 
   - success
7539 
  """
7540 
 
7541 
  thrift_spec = (
3064 chandransh 7542 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7543 
  )
7544 
 
3064 chandransh 7545 
  def __init__(self, success=None,):
94 ashish 7546 
    self.success = success
7547 
 
7548 
  def read(self, iprot):
7549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7551 
      return
7552 
    iprot.readStructBegin()
7553 
    while True:
7554 
      (fname, ftype, fid) = iprot.readFieldBegin()
7555 
      if ftype == TType.STOP:
7556 
        break
7557 
      if fid == 0:
3064 chandransh 7558 
        if ftype == TType.LIST:
7559 
          self.success = []
4133 chandransh 7560 
          (_etype115, _size112) = iprot.readListBegin()
7561 
          for _i116 in xrange(_size112):
7562 
            _elem117 = Alert()
7563 
            _elem117.read(iprot)
7564 
            self.success.append(_elem117)
3064 chandransh 7565 
          iprot.readListEnd()
94 ashish 7566 
        else:
7567 
          iprot.skip(ftype)
7568 
      else:
7569 
        iprot.skip(ftype)
7570 
      iprot.readFieldEnd()
7571 
    iprot.readStructEnd()
7572 
 
7573 
  def write(self, oprot):
7574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7576 
      return
3064 chandransh 7577 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7578 
    if self.success is not None:
3064 chandransh 7579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7581 
      for iter118 in self.success:
7582 
        iter118.write(oprot)
3064 chandransh 7583 
      oprot.writeListEnd()
94 ashish 7584 
      oprot.writeFieldEnd()
7585 
    oprot.writeFieldStop()
7586 
    oprot.writeStructEnd()
7587 
 
3431 rajveer 7588 
  def validate(self):
7589 
    return
7590 
 
7591 
 
94 ashish 7592 
  def __repr__(self):
7593 
    L = ['%s=%r' % (key, value)
7594 
      for key, value in self.__dict__.iteritems()]
7595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7596 
 
7597 
  def __eq__(self, other):
7598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7599 
 
7600 
  def __ne__(self, other):
7601 
    return not (self == other)
7602 
 
3064 chandransh 7603 
class setAlert_args:
94 ashish 7604 
  """
7605 
  Attributes:
3064 chandransh 7606 
   - orderId
7607 
   - unset
7608 
   - type
7609 
   - comment
94 ashish 7610 
  """
7611 
 
7612 
  thrift_spec = (
7613 
    None, # 0
3064 chandransh 7614 
    (1, TType.I64, 'orderId', None, None, ), # 1
7615 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7616 
    (3, TType.I64, 'type', None, None, ), # 3
7617 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7618 
  )
7619 
 
3064 chandransh 7620 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7621 
    self.orderId = orderId
7622 
    self.unset = unset
7623 
    self.type = type
7624 
    self.comment = comment
94 ashish 7625 
 
7626 
  def read(self, iprot):
7627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7629 
      return
7630 
    iprot.readStructBegin()
7631 
    while True:
7632 
      (fname, ftype, fid) = iprot.readFieldBegin()
7633 
      if ftype == TType.STOP:
7634 
        break
7635 
      if fid == 1:
7636 
        if ftype == TType.I64:
3064 chandransh 7637 
          self.orderId = iprot.readI64();
94 ashish 7638 
        else:
7639 
          iprot.skip(ftype)
3064 chandransh 7640 
      elif fid == 2:
7641 
        if ftype == TType.BOOL:
7642 
          self.unset = iprot.readBool();
7643 
        else:
7644 
          iprot.skip(ftype)
7645 
      elif fid == 3:
7646 
        if ftype == TType.I64:
7647 
          self.type = iprot.readI64();
7648 
        else:
7649 
          iprot.skip(ftype)
7650 
      elif fid == 4:
7651 
        if ftype == TType.STRING:
7652 
          self.comment = iprot.readString();
7653 
        else:
7654 
          iprot.skip(ftype)
94 ashish 7655 
      else:
7656 
        iprot.skip(ftype)
7657 
      iprot.readFieldEnd()
7658 
    iprot.readStructEnd()
7659 
 
7660 
  def write(self, oprot):
7661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7663 
      return
3064 chandransh 7664 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7665 
    if self.orderId is not None:
3064 chandransh 7666 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7667 
      oprot.writeI64(self.orderId)
94 ashish 7668 
      oprot.writeFieldEnd()
3431 rajveer 7669 
    if self.unset is not None:
3064 chandransh 7670 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7671 
      oprot.writeBool(self.unset)
7672 
      oprot.writeFieldEnd()
3431 rajveer 7673 
    if self.type is not None:
3064 chandransh 7674 
      oprot.writeFieldBegin('type', TType.I64, 3)
7675 
      oprot.writeI64(self.type)
7676 
      oprot.writeFieldEnd()
3431 rajveer 7677 
    if self.comment is not None:
3064 chandransh 7678 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7679 
      oprot.writeString(self.comment)
7680 
      oprot.writeFieldEnd()
94 ashish 7681 
    oprot.writeFieldStop()
7682 
    oprot.writeStructEnd()
7683 
 
3431 rajveer 7684 
  def validate(self):
7685 
    return
7686 
 
7687 
 
94 ashish 7688 
  def __repr__(self):
7689 
    L = ['%s=%r' % (key, value)
7690 
      for key, value in self.__dict__.iteritems()]
7691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7692 
 
7693 
  def __eq__(self, other):
7694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7695 
 
7696 
  def __ne__(self, other):
7697 
    return not (self == other)
7698 
 
3064 chandransh 7699 
class setAlert_result:
7700 
 
7701 
  thrift_spec = (
7702 
  )
7703 
 
7704 
  def read(self, iprot):
7705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7707 
      return
7708 
    iprot.readStructBegin()
7709 
    while True:
7710 
      (fname, ftype, fid) = iprot.readFieldBegin()
7711 
      if ftype == TType.STOP:
7712 
        break
7713 
      else:
7714 
        iprot.skip(ftype)
7715 
      iprot.readFieldEnd()
7716 
    iprot.readStructEnd()
7717 
 
7718 
  def write(self, oprot):
7719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7721 
      return
7722 
    oprot.writeStructBegin('setAlert_result')
7723 
    oprot.writeFieldStop()
7724 
    oprot.writeStructEnd()
7725 
 
3431 rajveer 7726 
  def validate(self):
7727 
    return
7728 
 
7729 
 
3064 chandransh 7730 
  def __repr__(self):
7731 
    L = ['%s=%r' % (key, value)
7732 
      for key, value in self.__dict__.iteritems()]
7733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7734 
 
7735 
  def __eq__(self, other):
7736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7737 
 
7738 
  def __ne__(self, other):
7739 
    return not (self == other)
7740 
 
7741 
class getValidOrderCount_args:
7742 
 
7743 
  thrift_spec = (
7744 
  )
7745 
 
7746 
  def read(self, iprot):
7747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7749 
      return
7750 
    iprot.readStructBegin()
7751 
    while True:
7752 
      (fname, ftype, fid) = iprot.readFieldBegin()
7753 
      if ftype == TType.STOP:
7754 
        break
7755 
      else:
7756 
        iprot.skip(ftype)
7757 
      iprot.readFieldEnd()
7758 
    iprot.readStructEnd()
7759 
 
7760 
  def write(self, oprot):
7761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7763 
      return
7764 
    oprot.writeStructBegin('getValidOrderCount_args')
7765 
    oprot.writeFieldStop()
7766 
    oprot.writeStructEnd()
7767 
 
3431 rajveer 7768 
  def validate(self):
7769 
    return
7770 
 
7771 
 
3064 chandransh 7772 
  def __repr__(self):
7773 
    L = ['%s=%r' % (key, value)
7774 
      for key, value in self.__dict__.iteritems()]
7775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7776 
 
7777 
  def __eq__(self, other):
7778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7779 
 
7780 
  def __ne__(self, other):
7781 
    return not (self == other)
7782 
 
7783 
class getValidOrderCount_result:
94 ashish 7784 
  """
7785 
  Attributes:
7786 
   - success
7787 
  """
7788 
 
7789 
  thrift_spec = (
3064 chandransh 7790 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7791 
  )
7792 
 
3064 chandransh 7793 
  def __init__(self, success=None,):
94 ashish 7794 
    self.success = success
7795 
 
7796 
  def read(self, iprot):
7797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7799 
      return
7800 
    iprot.readStructBegin()
7801 
    while True:
7802 
      (fname, ftype, fid) = iprot.readFieldBegin()
7803 
      if ftype == TType.STOP:
7804 
        break
7805 
      if fid == 0:
3064 chandransh 7806 
        if ftype == TType.I64:
7807 
          self.success = iprot.readI64();
94 ashish 7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
3064 chandransh 7819 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7820 
    if self.success is not None:
3064 chandransh 7821 
      oprot.writeFieldBegin('success', TType.I64, 0)
7822 
      oprot.writeI64(self.success)
94 ashish 7823 
      oprot.writeFieldEnd()
7824 
    oprot.writeFieldStop()
7825 
    oprot.writeStructEnd()
7826 
 
3431 rajveer 7827 
  def validate(self):
7828 
    return
7829 
 
7830 
 
94 ashish 7831 
  def __repr__(self):
7832 
    L = ['%s=%r' % (key, value)
7833 
      for key, value in self.__dict__.iteritems()]
7834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7835 
 
7836 
  def __eq__(self, other):
7837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7838 
 
7839 
  def __ne__(self, other):
7840 
    return not (self == other)
7841 
 
3064 chandransh 7842 
class getNoOfCustomersWithSuccessfulTransaction_args:
7843 
 
7844 
  thrift_spec = (
7845 
  )
7846 
 
7847 
  def read(self, iprot):
7848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7850 
      return
7851 
    iprot.readStructBegin()
7852 
    while True:
7853 
      (fname, ftype, fid) = iprot.readFieldBegin()
7854 
      if ftype == TType.STOP:
7855 
        break
7856 
      else:
7857 
        iprot.skip(ftype)
7858 
      iprot.readFieldEnd()
7859 
    iprot.readStructEnd()
7860 
 
7861 
  def write(self, oprot):
7862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7864 
      return
7865 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7866 
    oprot.writeFieldStop()
7867 
    oprot.writeStructEnd()
7868 
 
3431 rajveer 7869 
  def validate(self):
7870 
    return
7871 
 
7872 
 
3064 chandransh 7873 
  def __repr__(self):
7874 
    L = ['%s=%r' % (key, value)
7875 
      for key, value in self.__dict__.iteritems()]
7876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7877 
 
7878 
  def __eq__(self, other):
7879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7880 
 
7881 
  def __ne__(self, other):
7882 
    return not (self == other)
7883 
 
7884 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7885 
  """
7886 
  Attributes:
3064 chandransh 7887 
   - success
94 ashish 7888 
  """
7889 
 
7890 
  thrift_spec = (
3064 chandransh 7891 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7892 
  )
7893 
 
3064 chandransh 7894 
  def __init__(self, success=None,):
7895 
    self.success = success
94 ashish 7896 
 
7897 
  def read(self, iprot):
7898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7900 
      return
7901 
    iprot.readStructBegin()
7902 
    while True:
7903 
      (fname, ftype, fid) = iprot.readFieldBegin()
7904 
      if ftype == TType.STOP:
7905 
        break
3064 chandransh 7906 
      if fid == 0:
94 ashish 7907 
        if ftype == TType.I64:
3064 chandransh 7908 
          self.success = iprot.readI64();
94 ashish 7909 
        else:
7910 
          iprot.skip(ftype)
7911 
      else:
7912 
        iprot.skip(ftype)
7913 
      iprot.readFieldEnd()
7914 
    iprot.readStructEnd()
7915 
 
7916 
  def write(self, oprot):
7917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7919 
      return
3064 chandransh 7920 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7921 
    if self.success is not None:
3064 chandransh 7922 
      oprot.writeFieldBegin('success', TType.I64, 0)
7923 
      oprot.writeI64(self.success)
94 ashish 7924 
      oprot.writeFieldEnd()
7925 
    oprot.writeFieldStop()
7926 
    oprot.writeStructEnd()
7927 
 
3431 rajveer 7928 
  def validate(self):
7929 
    return
7930 
 
7931 
 
94 ashish 7932 
  def __repr__(self):
7933 
    L = ['%s=%r' % (key, value)
7934 
      for key, value in self.__dict__.iteritems()]
7935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7936 
 
7937 
  def __eq__(self, other):
7938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7939 
 
7940 
  def __ne__(self, other):
7941 
    return not (self == other)
7942 
 
3064 chandransh 7943 
class getValidOrdersAmountRange_args:
7944 
 
7945 
  thrift_spec = (
7946 
  )
7947 
 
7948 
  def read(self, iprot):
7949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7951 
      return
7952 
    iprot.readStructBegin()
7953 
    while True:
7954 
      (fname, ftype, fid) = iprot.readFieldBegin()
7955 
      if ftype == TType.STOP:
7956 
        break
7957 
      else:
7958 
        iprot.skip(ftype)
7959 
      iprot.readFieldEnd()
7960 
    iprot.readStructEnd()
7961 
 
7962 
  def write(self, oprot):
7963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7965 
      return
7966 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7967 
    oprot.writeFieldStop()
7968 
    oprot.writeStructEnd()
7969 
 
3431 rajveer 7970 
  def validate(self):
7971 
    return
7972 
 
7973 
 
3064 chandransh 7974 
  def __repr__(self):
7975 
    L = ['%s=%r' % (key, value)
7976 
      for key, value in self.__dict__.iteritems()]
7977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7978 
 
7979 
  def __eq__(self, other):
7980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7981 
 
7982 
  def __ne__(self, other):
7983 
    return not (self == other)
7984 
 
7985 
class getValidOrdersAmountRange_result:
94 ashish 7986 
  """
7987 
  Attributes:
7988 
   - success
7989 
  """
7990 
 
7991 
  thrift_spec = (
3064 chandransh 7992 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7993 
  )
7994 
 
3064 chandransh 7995 
  def __init__(self, success=None,):
94 ashish 7996 
    self.success = success
7997 
 
7998 
  def read(self, iprot):
7999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8001 
      return
8002 
    iprot.readStructBegin()
8003 
    while True:
8004 
      (fname, ftype, fid) = iprot.readFieldBegin()
8005 
      if ftype == TType.STOP:
8006 
        break
8007 
      if fid == 0:
483 rajveer 8008 
        if ftype == TType.LIST:
8009 
          self.success = []
4133 chandransh 8010 
          (_etype122, _size119) = iprot.readListBegin()
8011 
          for _i123 in xrange(_size119):
8012 
            _elem124 = iprot.readDouble();
8013 
            self.success.append(_elem124)
483 rajveer 8014 
          iprot.readListEnd()
94 ashish 8015 
        else:
8016 
          iprot.skip(ftype)
8017 
      else:
8018 
        iprot.skip(ftype)
8019 
      iprot.readFieldEnd()
8020 
    iprot.readStructEnd()
8021 
 
8022 
  def write(self, oprot):
8023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8025 
      return
3064 chandransh 8026 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8027 
    if self.success is not None:
483 rajveer 8028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8029 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8030 
      for iter125 in self.success:
8031 
        oprot.writeDouble(iter125)
483 rajveer 8032 
      oprot.writeListEnd()
94 ashish 8033 
      oprot.writeFieldEnd()
8034 
    oprot.writeFieldStop()
8035 
    oprot.writeStructEnd()
8036 
 
3431 rajveer 8037 
  def validate(self):
8038 
    return
8039 
 
8040 
 
94 ashish 8041 
  def __repr__(self):
8042 
    L = ['%s=%r' % (key, value)
8043 
      for key, value in self.__dict__.iteritems()]
8044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8045 
 
8046 
  def __eq__(self, other):
8047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8048 
 
8049 
  def __ne__(self, other):
8050 
    return not (self == other)
8051 
 
3064 chandransh 8052 
class getValidOrders_args:
1528 ankur.sing 8053 
  """
8054 
  Attributes:
3064 chandransh 8055 
   - limit
1528 ankur.sing 8056 
  """
8057 
 
8058 
  thrift_spec = (
8059 
    None, # 0
3064 chandransh 8060 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8061 
  )
8062 
 
3064 chandransh 8063 
  def __init__(self, limit=None,):
8064 
    self.limit = limit
1528 ankur.sing 8065 
 
8066 
  def read(self, iprot):
8067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8069 
      return
8070 
    iprot.readStructBegin()
8071 
    while True:
8072 
      (fname, ftype, fid) = iprot.readFieldBegin()
8073 
      if ftype == TType.STOP:
8074 
        break
8075 
      if fid == 1:
8076 
        if ftype == TType.I64:
3064 chandransh 8077 
          self.limit = iprot.readI64();
1528 ankur.sing 8078 
        else:
8079 
          iprot.skip(ftype)
8080 
      else:
8081 
        iprot.skip(ftype)
8082 
      iprot.readFieldEnd()
8083 
    iprot.readStructEnd()
8084 
 
8085 
  def write(self, oprot):
8086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8088 
      return
3064 chandransh 8089 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8090 
    if self.limit is not None:
3064 chandransh 8091 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8092 
      oprot.writeI64(self.limit)
1528 ankur.sing 8093 
      oprot.writeFieldEnd()
8094 
    oprot.writeFieldStop()
8095 
    oprot.writeStructEnd()
8096 
 
3431 rajveer 8097 
  def validate(self):
8098 
    return
8099 
 
8100 
 
1528 ankur.sing 8101 
  def __repr__(self):
8102 
    L = ['%s=%r' % (key, value)
8103 
      for key, value in self.__dict__.iteritems()]
8104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8105 
 
8106 
  def __eq__(self, other):
8107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8108 
 
8109 
  def __ne__(self, other):
8110 
    return not (self == other)
8111 
 
3064 chandransh 8112 
class getValidOrders_result:
1528 ankur.sing 8113 
  """
8114 
  Attributes:
8115 
   - success
8116 
  """
8117 
 
8118 
  thrift_spec = (
3064 chandransh 8119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8120 
  )
8121 
 
3064 chandransh 8122 
  def __init__(self, success=None,):
1528 ankur.sing 8123 
    self.success = success
8124 
 
8125 
  def read(self, iprot):
8126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8128 
      return
8129 
    iprot.readStructBegin()
8130 
    while True:
8131 
      (fname, ftype, fid) = iprot.readFieldBegin()
8132 
      if ftype == TType.STOP:
8133 
        break
8134 
      if fid == 0:
3064 chandransh 8135 
        if ftype == TType.LIST:
8136 
          self.success = []
4133 chandransh 8137 
          (_etype129, _size126) = iprot.readListBegin()
8138 
          for _i130 in xrange(_size126):
8139 
            _elem131 = Order()
8140 
            _elem131.read(iprot)
8141 
            self.success.append(_elem131)
3064 chandransh 8142 
          iprot.readListEnd()
1528 ankur.sing 8143 
        else:
8144 
          iprot.skip(ftype)
8145 
      else:
8146 
        iprot.skip(ftype)
8147 
      iprot.readFieldEnd()
8148 
    iprot.readStructEnd()
8149 
 
8150 
  def write(self, oprot):
8151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8153 
      return
3064 chandransh 8154 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8155 
    if self.success is not None:
3064 chandransh 8156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8158 
      for iter132 in self.success:
8159 
        iter132.write(oprot)
3064 chandransh 8160 
      oprot.writeListEnd()
1528 ankur.sing 8161 
      oprot.writeFieldEnd()
8162 
    oprot.writeFieldStop()
8163 
    oprot.writeStructEnd()
8164 
 
3431 rajveer 8165 
  def validate(self):
8166 
    return
8167 
 
8168 
 
1528 ankur.sing 8169 
  def __repr__(self):
8170 
    L = ['%s=%r' % (key, value)
8171 
      for key, value in self.__dict__.iteritems()]
8172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8173 
 
8174 
  def __eq__(self, other):
8175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8176 
 
8177 
  def __ne__(self, other):
8178 
    return not (self == other)
8179 
 
1220 chandransh 8180 
class batchOrders_args:
8181 
  """
8182 
  Attributes:
8183 
   - warehouseId
8184 
  """
8185 
 
8186 
  thrift_spec = (
8187 
    None, # 0
8188 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8189 
  )
8190 
 
8191 
  def __init__(self, warehouseId=None,):
8192 
    self.warehouseId = warehouseId
8193 
 
8194 
  def read(self, iprot):
8195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8197 
      return
8198 
    iprot.readStructBegin()
8199 
    while True:
8200 
      (fname, ftype, fid) = iprot.readFieldBegin()
8201 
      if ftype == TType.STOP:
8202 
        break
8203 
      if fid == 1:
8204 
        if ftype == TType.I64:
8205 
          self.warehouseId = iprot.readI64();
8206 
        else:
8207 
          iprot.skip(ftype)
8208 
      else:
8209 
        iprot.skip(ftype)
8210 
      iprot.readFieldEnd()
8211 
    iprot.readStructEnd()
8212 
 
8213 
  def write(self, oprot):
8214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8216 
      return
8217 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8218 
    if self.warehouseId is not None:
1220 chandransh 8219 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8220 
      oprot.writeI64(self.warehouseId)
8221 
      oprot.writeFieldEnd()
8222 
    oprot.writeFieldStop()
8223 
    oprot.writeStructEnd()
8224 
 
3431 rajveer 8225 
  def validate(self):
8226 
    return
8227 
 
8228 
 
1220 chandransh 8229 
  def __repr__(self):
8230 
    L = ['%s=%r' % (key, value)
8231 
      for key, value in self.__dict__.iteritems()]
8232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8233 
 
8234 
  def __eq__(self, other):
8235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8236 
 
8237 
  def __ne__(self, other):
8238 
    return not (self == other)
8239 
 
8240 
class batchOrders_result:
8241 
  """
8242 
  Attributes:
8243 
   - success
8244 
   - ex
8245 
  """
8246 
 
8247 
  thrift_spec = (
8248 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8250 
  )
8251 
 
8252 
  def __init__(self, success=None, ex=None,):
8253 
    self.success = success
8254 
    self.ex = ex
8255 
 
8256 
  def read(self, iprot):
8257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8259 
      return
8260 
    iprot.readStructBegin()
8261 
    while True:
8262 
      (fname, ftype, fid) = iprot.readFieldBegin()
8263 
      if ftype == TType.STOP:
8264 
        break
8265 
      if fid == 0:
8266 
        if ftype == TType.LIST:
8267 
          self.success = []
4133 chandransh 8268 
          (_etype136, _size133) = iprot.readListBegin()
8269 
          for _i137 in xrange(_size133):
8270 
            _elem138 = Order()
8271 
            _elem138.read(iprot)
8272 
            self.success.append(_elem138)
1220 chandransh 8273 
          iprot.readListEnd()
8274 
        else:
8275 
          iprot.skip(ftype)
8276 
      elif fid == 1:
8277 
        if ftype == TType.STRUCT:
8278 
          self.ex = TransactionServiceException()
8279 
          self.ex.read(iprot)
8280 
        else:
8281 
          iprot.skip(ftype)
8282 
      else:
8283 
        iprot.skip(ftype)
8284 
      iprot.readFieldEnd()
8285 
    iprot.readStructEnd()
8286 
 
8287 
  def write(self, oprot):
8288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8290 
      return
8291 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8292 
    if self.success is not None:
1220 chandransh 8293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8295 
      for iter139 in self.success:
8296 
        iter139.write(oprot)
1220 chandransh 8297 
      oprot.writeListEnd()
8298 
      oprot.writeFieldEnd()
3431 rajveer 8299 
    if self.ex is not None:
1220 chandransh 8300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8301 
      self.ex.write(oprot)
8302 
      oprot.writeFieldEnd()
8303 
    oprot.writeFieldStop()
8304 
    oprot.writeStructEnd()
8305 
 
3431 rajveer 8306 
  def validate(self):
8307 
    return
8308 
 
8309 
 
1220 chandransh 8310 
  def __repr__(self):
8311 
    L = ['%s=%r' % (key, value)
8312 
      for key, value in self.__dict__.iteritems()]
8313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8314 
 
8315 
  def __eq__(self, other):
8316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8317 
 
8318 
  def __ne__(self, other):
8319 
    return not (self == other)
8320 
 
1208 chandransh 8321 
class markOrderAsOutOfStock_args:
8322 
  """
8323 
  Attributes:
8324 
   - orderId
8325 
  """
8326 
 
8327 
  thrift_spec = (
8328 
    None, # 0
8329 
    (1, TType.I64, 'orderId', None, None, ), # 1
8330 
  )
8331 
 
8332 
  def __init__(self, orderId=None,):
8333 
    self.orderId = orderId
8334 
 
8335 
  def read(self, iprot):
8336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8338 
      return
8339 
    iprot.readStructBegin()
8340 
    while True:
8341 
      (fname, ftype, fid) = iprot.readFieldBegin()
8342 
      if ftype == TType.STOP:
8343 
        break
8344 
      if fid == 1:
8345 
        if ftype == TType.I64:
8346 
          self.orderId = iprot.readI64();
8347 
        else:
8348 
          iprot.skip(ftype)
8349 
      else:
8350 
        iprot.skip(ftype)
8351 
      iprot.readFieldEnd()
8352 
    iprot.readStructEnd()
8353 
 
8354 
  def write(self, oprot):
8355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8357 
      return
8358 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8359 
    if self.orderId is not None:
1208 chandransh 8360 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8361 
      oprot.writeI64(self.orderId)
8362 
      oprot.writeFieldEnd()
8363 
    oprot.writeFieldStop()
8364 
    oprot.writeStructEnd()
8365 
 
3431 rajveer 8366 
  def validate(self):
8367 
    return
8368 
 
8369 
 
1208 chandransh 8370 
  def __repr__(self):
8371 
    L = ['%s=%r' % (key, value)
8372 
      for key, value in self.__dict__.iteritems()]
8373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8374 
 
8375 
  def __eq__(self, other):
8376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8377 
 
8378 
  def __ne__(self, other):
8379 
    return not (self == other)
8380 
 
8381 
class markOrderAsOutOfStock_result:
8382 
  """
8383 
  Attributes:
8384 
   - success
8385 
   - ex
8386 
  """
8387 
 
8388 
  thrift_spec = (
8389 
    (0, TType.BOOL, 'success', None, None, ), # 0
8390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8391 
  )
8392 
 
8393 
  def __init__(self, success=None, ex=None,):
8394 
    self.success = success
8395 
    self.ex = ex
8396 
 
8397 
  def read(self, iprot):
8398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8400 
      return
8401 
    iprot.readStructBegin()
8402 
    while True:
8403 
      (fname, ftype, fid) = iprot.readFieldBegin()
8404 
      if ftype == TType.STOP:
8405 
        break
8406 
      if fid == 0:
8407 
        if ftype == TType.BOOL:
8408 
          self.success = iprot.readBool();
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      elif fid == 1:
8412 
        if ftype == TType.STRUCT:
8413 
          self.ex = TransactionServiceException()
8414 
          self.ex.read(iprot)
8415 
        else:
8416 
          iprot.skip(ftype)
8417 
      else:
8418 
        iprot.skip(ftype)
8419 
      iprot.readFieldEnd()
8420 
    iprot.readStructEnd()
8421 
 
8422 
  def write(self, oprot):
8423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8425 
      return
8426 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8427 
    if self.success is not None:
1208 chandransh 8428 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8429 
      oprot.writeBool(self.success)
8430 
      oprot.writeFieldEnd()
3431 rajveer 8431 
    if self.ex is not None:
1208 chandransh 8432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8433 
      self.ex.write(oprot)
8434 
      oprot.writeFieldEnd()
8435 
    oprot.writeFieldStop()
8436 
    oprot.writeStructEnd()
8437 
 
3431 rajveer 8438 
  def validate(self):
8439 
    return
8440 
 
8441 
 
1208 chandransh 8442 
  def __repr__(self):
8443 
    L = ['%s=%r' % (key, value)
8444 
      for key, value in self.__dict__.iteritems()]
8445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8446 
 
8447 
  def __eq__(self, other):
8448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8449 
 
8450 
  def __ne__(self, other):
8451 
    return not (self == other)
8452 
 
3064 chandransh 8453 
class verifyOrder_args:
759 chandransh 8454 
  """
8455 
  Attributes:
3064 chandransh 8456 
   - orderId
759 chandransh 8457 
  """
8458 
 
8459 
  thrift_spec = (
8460 
    None, # 0
3064 chandransh 8461 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8462 
  )
8463 
 
3064 chandransh 8464 
  def __init__(self, orderId=None,):
8465 
    self.orderId = orderId
759 chandransh 8466 
 
8467 
  def read(self, iprot):
8468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8470 
      return
8471 
    iprot.readStructBegin()
8472 
    while True:
8473 
      (fname, ftype, fid) = iprot.readFieldBegin()
8474 
      if ftype == TType.STOP:
8475 
        break
8476 
      if fid == 1:
8477 
        if ftype == TType.I64:
3064 chandransh 8478 
          self.orderId = iprot.readI64();
759 chandransh 8479 
        else:
8480 
          iprot.skip(ftype)
8481 
      else:
8482 
        iprot.skip(ftype)
8483 
      iprot.readFieldEnd()
8484 
    iprot.readStructEnd()
8485 
 
8486 
  def write(self, oprot):
8487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8489 
      return
3064 chandransh 8490 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8491 
    if self.orderId is not None:
3064 chandransh 8492 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8493 
      oprot.writeI64(self.orderId)
759 chandransh 8494 
      oprot.writeFieldEnd()
8495 
    oprot.writeFieldStop()
8496 
    oprot.writeStructEnd()
8497 
 
3431 rajveer 8498 
  def validate(self):
8499 
    return
8500 
 
8501 
 
759 chandransh 8502 
  def __repr__(self):
8503 
    L = ['%s=%r' % (key, value)
8504 
      for key, value in self.__dict__.iteritems()]
8505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8506 
 
8507 
  def __eq__(self, other):
8508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8509 
 
8510 
  def __ne__(self, other):
8511 
    return not (self == other)
8512 
 
3064 chandransh 8513 
class verifyOrder_result:
759 chandransh 8514 
  """
8515 
  Attributes:
8516 
   - success
8517 
   - ex
8518 
  """
8519 
 
8520 
  thrift_spec = (
8521 
    (0, TType.BOOL, 'success', None, None, ), # 0
8522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8523 
  )
8524 
 
8525 
  def __init__(self, success=None, ex=None,):
8526 
    self.success = success
8527 
    self.ex = ex
8528 
 
8529 
  def read(self, iprot):
8530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8532 
      return
8533 
    iprot.readStructBegin()
8534 
    while True:
8535 
      (fname, ftype, fid) = iprot.readFieldBegin()
8536 
      if ftype == TType.STOP:
8537 
        break
8538 
      if fid == 0:
8539 
        if ftype == TType.BOOL:
8540 
          self.success = iprot.readBool();
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 1:
8544 
        if ftype == TType.STRUCT:
8545 
          self.ex = TransactionServiceException()
8546 
          self.ex.read(iprot)
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      else:
8550 
        iprot.skip(ftype)
8551 
      iprot.readFieldEnd()
8552 
    iprot.readStructEnd()
8553 
 
8554 
  def write(self, oprot):
8555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8557 
      return
3064 chandransh 8558 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8559 
    if self.success is not None:
759 chandransh 8560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8561 
      oprot.writeBool(self.success)
8562 
      oprot.writeFieldEnd()
3431 rajveer 8563 
    if self.ex is not None:
759 chandransh 8564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8565 
      self.ex.write(oprot)
8566 
      oprot.writeFieldEnd()
8567 
    oprot.writeFieldStop()
8568 
    oprot.writeStructEnd()
8569 
 
3431 rajveer 8570 
  def validate(self):
8571 
    return
8572 
 
8573 
 
759 chandransh 8574 
  def __repr__(self):
8575 
    L = ['%s=%r' % (key, value)
8576 
      for key, value in self.__dict__.iteritems()]
8577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8578 
 
8579 
  def __eq__(self, other):
8580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8581 
 
8582 
  def __ne__(self, other):
8583 
    return not (self == other)
8584 
 
3064 chandransh 8585 
class acceptOrder_args:
1113 chandransh 8586 
  """
8587 
  Attributes:
3064 chandransh 8588 
   - orderId
1113 chandransh 8589 
  """
8590 
 
8591 
  thrift_spec = (
8592 
    None, # 0
3064 chandransh 8593 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8594 
  )
8595 
 
3064 chandransh 8596 
  def __init__(self, orderId=None,):
8597 
    self.orderId = orderId
1113 chandransh 8598 
 
8599 
  def read(self, iprot):
8600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8602 
      return
8603 
    iprot.readStructBegin()
8604 
    while True:
8605 
      (fname, ftype, fid) = iprot.readFieldBegin()
8606 
      if ftype == TType.STOP:
8607 
        break
8608 
      if fid == 1:
8609 
        if ftype == TType.I64:
3064 chandransh 8610 
          self.orderId = iprot.readI64();
1113 chandransh 8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      else:
8614 
        iprot.skip(ftype)
8615 
      iprot.readFieldEnd()
8616 
    iprot.readStructEnd()
8617 
 
8618 
  def write(self, oprot):
8619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8621 
      return
3064 chandransh 8622 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8623 
    if self.orderId is not None:
3064 chandransh 8624 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8625 
      oprot.writeI64(self.orderId)
1113 chandransh 8626 
      oprot.writeFieldEnd()
8627 
    oprot.writeFieldStop()
8628 
    oprot.writeStructEnd()
8629 
 
3431 rajveer 8630 
  def validate(self):
8631 
    return
8632 
 
8633 
 
1113 chandransh 8634 
  def __repr__(self):
8635 
    L = ['%s=%r' % (key, value)
8636 
      for key, value in self.__dict__.iteritems()]
8637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8638 
 
8639 
  def __eq__(self, other):
8640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8641 
 
8642 
  def __ne__(self, other):
8643 
    return not (self == other)
8644 
 
3064 chandransh 8645 
class acceptOrder_result:
1113 chandransh 8646 
  """
8647 
  Attributes:
8648 
   - success
8649 
   - ex
8650 
  """
8651 
 
8652 
  thrift_spec = (
3064 chandransh 8653 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8655 
  )
8656 
 
8657 
  def __init__(self, success=None, ex=None,):
8658 
    self.success = success
8659 
    self.ex = ex
8660 
 
8661 
  def read(self, iprot):
8662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8664 
      return
8665 
    iprot.readStructBegin()
8666 
    while True:
8667 
      (fname, ftype, fid) = iprot.readFieldBegin()
8668 
      if ftype == TType.STOP:
8669 
        break
8670 
      if fid == 0:
3064 chandransh 8671 
        if ftype == TType.BOOL:
8672 
          self.success = iprot.readBool();
1113 chandransh 8673 
        else:
8674 
          iprot.skip(ftype)
8675 
      elif fid == 1:
8676 
        if ftype == TType.STRUCT:
8677 
          self.ex = TransactionServiceException()
8678 
          self.ex.read(iprot)
8679 
        else:
8680 
          iprot.skip(ftype)
8681 
      else:
8682 
        iprot.skip(ftype)
8683 
      iprot.readFieldEnd()
8684 
    iprot.readStructEnd()
8685 
 
8686 
  def write(self, oprot):
8687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8689 
      return
3064 chandransh 8690 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8691 
    if self.success is not None:
3064 chandransh 8692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8693 
      oprot.writeBool(self.success)
1113 chandransh 8694 
      oprot.writeFieldEnd()
3431 rajveer 8695 
    if self.ex is not None:
1113 chandransh 8696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8697 
      self.ex.write(oprot)
8698 
      oprot.writeFieldEnd()
8699 
    oprot.writeFieldStop()
8700 
    oprot.writeStructEnd()
8701 
 
3431 rajveer 8702 
  def validate(self):
8703 
    return
8704 
 
8705 
 
1113 chandransh 8706 
  def __repr__(self):
8707 
    L = ['%s=%r' % (key, value)
8708 
      for key, value in self.__dict__.iteritems()]
8709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8710 
 
8711 
  def __eq__(self, other):
8712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8713 
 
8714 
  def __ne__(self, other):
8715 
    return not (self == other)
8716 
 
3064 chandransh 8717 
class addBillingDetails_args:
1135 chandransh 8718 
  """
8719 
  Attributes:
3064 chandransh 8720 
   - orderId
8721 
   - invoice_number
4283 anupam.sin 8722 
   - imeiNumber
8723 
   - itemNumber
3064 chandransh 8724 
   - billed_by
4264 rajveer 8725 
   - jacketNumber
4283 anupam.sin 8726 
   - billingType
8727 
   - vendorId
1135 chandransh 8728 
  """
8729 
 
8730 
  thrift_spec = (
8731 
    None, # 0
3064 chandransh 8732 
    (1, TType.I64, 'orderId', None, None, ), # 1
8733 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8734 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8735 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8736 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8737 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8738 
    (7, TType.I64, 'billingType', None, None, ), # 7
8739 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8740 
  )
8741 
 
4283 anupam.sin 8742 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8743 
    self.orderId = orderId
8744 
    self.invoice_number = invoice_number
4283 anupam.sin 8745 
    self.imeiNumber = imeiNumber
8746 
    self.itemNumber = itemNumber
3064 chandransh 8747 
    self.billed_by = billed_by
4264 rajveer 8748 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8749 
    self.billingType = billingType
8750 
    self.vendorId = vendorId
1135 chandransh 8751 
 
8752 
  def read(self, iprot):
8753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8755 
      return
8756 
    iprot.readStructBegin()
8757 
    while True:
8758 
      (fname, ftype, fid) = iprot.readFieldBegin()
8759 
      if ftype == TType.STOP:
8760 
        break
8761 
      if fid == 1:
8762 
        if ftype == TType.I64:
3064 chandransh 8763 
          self.orderId = iprot.readI64();
1135 chandransh 8764 
        else:
8765 
          iprot.skip(ftype)
8766 
      elif fid == 2:
3064 chandransh 8767 
        if ftype == TType.STRING:
8768 
          self.invoice_number = iprot.readString();
1135 chandransh 8769 
        else:
8770 
          iprot.skip(ftype)
3064 chandransh 8771 
      elif fid == 3:
4264 rajveer 8772 
        if ftype == TType.I64:
3064 chandransh 8773 
          self.imeiNumber = iprot.readI64();
8774 
        else:
8775 
          iprot.skip(ftype)
8776 
      elif fid == 4:
8777 
        if ftype == TType.STRING:
8778 
          self.itemNumber = iprot.readString();
8779 
        else:
8780 
          iprot.skip(ftype)
8781 
      elif fid == 5:
8782 
        if ftype == TType.STRING:
4283 anupam.sin 8783 
          self.billed_by = iprot.readString();
3064 chandransh 8784 
        else:
8785 
          iprot.skip(ftype)
8786 
      elif fid == 6:
8787 
        if ftype == TType.I64:
4283 anupam.sin 8788 
          self.jacketNumber = iprot.readI64();
8789 
        else:
8790 
          iprot.skip(ftype)
8791 
      elif fid == 7:
8792 
        if ftype == TType.I64:
3064 chandransh 8793 
          self.billingType = iprot.readI64();
8794 
        else:
8795 
          iprot.skip(ftype)
4283 anupam.sin 8796 
      elif fid == 8:
8797 
        if ftype == TType.I64:
8798 
          self.vendorId = iprot.readI64();
8799 
        else:
8800 
          iprot.skip(ftype)
1246 chandransh 8801 
      else:
8802 
        iprot.skip(ftype)
8803 
      iprot.readFieldEnd()
8804 
    iprot.readStructEnd()
8805 
 
8806 
  def write(self, oprot):
8807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8809 
      return
4283 anupam.sin 8810 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8811 
    if self.orderId is not None:
3064 chandransh 8812 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8813 
      oprot.writeI64(self.orderId)
1246 chandransh 8814 
      oprot.writeFieldEnd()
4283 anupam.sin 8815 
    if self.invoice_number is not None:
8816 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8817 
      oprot.writeString(self.invoice_number)
1246 chandransh 8818 
      oprot.writeFieldEnd()
3431 rajveer 8819 
    if self.imeiNumber is not None:
3064 chandransh 8820 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8821 
      oprot.writeI64(self.imeiNumber)
8822 
      oprot.writeFieldEnd()
3431 rajveer 8823 
    if self.itemNumber is not None:
3064 chandransh 8824 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8825 
      oprot.writeString(self.itemNumber)
8826 
      oprot.writeFieldEnd()
4283 anupam.sin 8827 
    if self.billed_by is not None:
8828 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8829 
      oprot.writeString(self.billed_by)
3064 chandransh 8830 
      oprot.writeFieldEnd()
4283 anupam.sin 8831 
    if self.jacketNumber is not None:
8832 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8833 
      oprot.writeI64(self.jacketNumber)
8834 
      oprot.writeFieldEnd()
3431 rajveer 8835 
    if self.billingType is not None:
4283 anupam.sin 8836 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8837 
      oprot.writeI64(self.billingType)
8838 
      oprot.writeFieldEnd()
4283 anupam.sin 8839 
    if self.vendorId is not None:
8840 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8841 
      oprot.writeI64(self.vendorId)
8842 
      oprot.writeFieldEnd()
1246 chandransh 8843 
    oprot.writeFieldStop()
8844 
    oprot.writeStructEnd()
8845 
 
3431 rajveer 8846 
  def validate(self):
8847 
    return
8848 
 
8849 
 
1246 chandransh 8850 
  def __repr__(self):
8851 
    L = ['%s=%r' % (key, value)
8852 
      for key, value in self.__dict__.iteritems()]
8853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8854 
 
8855 
  def __eq__(self, other):
8856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8857 
 
8858 
  def __ne__(self, other):
8859 
    return not (self == other)
8860 
 
4283 anupam.sin 8861 
class addBillingDetails_result:
1246 chandransh 8862 
  """
8863 
  Attributes:
3064 chandransh 8864 
   - success
1246 chandransh 8865 
   - ex
8866 
  """
8867 
 
8868 
  thrift_spec = (
3064 chandransh 8869 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8871 
  )
8872 
 
3064 chandransh 8873 
  def __init__(self, success=None, ex=None,):
8874 
    self.success = success
1246 chandransh 8875 
    self.ex = ex
8876 
 
8877 
  def read(self, iprot):
8878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8880 
      return
8881 
    iprot.readStructBegin()
8882 
    while True:
8883 
      (fname, ftype, fid) = iprot.readFieldBegin()
8884 
      if ftype == TType.STOP:
8885 
        break
3064 chandransh 8886 
      if fid == 0:
8887 
        if ftype == TType.BOOL:
8888 
          self.success = iprot.readBool();
8889 
        else:
8890 
          iprot.skip(ftype)
8891 
      elif fid == 1:
1246 chandransh 8892 
        if ftype == TType.STRUCT:
8893 
          self.ex = TransactionServiceException()
8894 
          self.ex.read(iprot)
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      else:
8898 
        iprot.skip(ftype)
8899 
      iprot.readFieldEnd()
8900 
    iprot.readStructEnd()
8901 
 
8902 
  def write(self, oprot):
8903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8905 
      return
4283 anupam.sin 8906 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8907 
    if self.success is not None:
3064 chandransh 8908 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8909 
      oprot.writeBool(self.success)
8910 
      oprot.writeFieldEnd()
3431 rajveer 8911 
    if self.ex is not None:
1246 chandransh 8912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8913 
      self.ex.write(oprot)
8914 
      oprot.writeFieldEnd()
8915 
    oprot.writeFieldStop()
8916 
    oprot.writeStructEnd()
8917 
 
3431 rajveer 8918 
  def validate(self):
8919 
    return
8920 
 
8921 
 
1246 chandransh 8922 
  def __repr__(self):
8923 
    L = ['%s=%r' % (key, value)
8924 
      for key, value in self.__dict__.iteritems()]
8925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8926 
 
8927 
  def __eq__(self, other):
8928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8929 
 
8930 
  def __ne__(self, other):
8931 
    return not (self == other)
8932 
 
3064 chandransh 8933 
class markOrdersAsManifested_args:
1408 ankur.sing 8934 
  """
8935 
  Attributes:
3064 chandransh 8936 
   - warehouseId
1408 ankur.sing 8937 
   - providerId
3064 chandransh 8938 
   - cod
1408 ankur.sing 8939 
  """
8940 
 
8941 
  thrift_spec = (
8942 
    None, # 0
3064 chandransh 8943 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8944 
    (2, TType.I64, 'providerId', None, None, ), # 2
8945 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8946 
  )
8947 
 
3064 chandransh 8948 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8949 
    self.warehouseId = warehouseId
1408 ankur.sing 8950 
    self.providerId = providerId
3064 chandransh 8951 
    self.cod = cod
1408 ankur.sing 8952 
 
8953 
  def read(self, iprot):
8954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8956 
      return
8957 
    iprot.readStructBegin()
8958 
    while True:
8959 
      (fname, ftype, fid) = iprot.readFieldBegin()
8960 
      if ftype == TType.STOP:
8961 
        break
8962 
      if fid == 1:
8963 
        if ftype == TType.I64:
3064 chandransh 8964 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8965 
        else:
8966 
          iprot.skip(ftype)
8967 
      elif fid == 2:
8968 
        if ftype == TType.I64:
3064 chandransh 8969 
          self.providerId = iprot.readI64();
1408 ankur.sing 8970 
        else:
8971 
          iprot.skip(ftype)
3064 chandransh 8972 
      elif fid == 3:
8973 
        if ftype == TType.BOOL:
8974 
          self.cod = iprot.readBool();
8975 
        else:
8976 
          iprot.skip(ftype)
1408 ankur.sing 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('markOrdersAsManifested_args')
3431 rajveer 8987 
    if self.warehouseId is not None:
3064 chandransh 8988 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8989 
      oprot.writeI64(self.warehouseId)
8990 
      oprot.writeFieldEnd()
3431 rajveer 8991 
    if self.providerId is not None:
3064 chandransh 8992 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 8993 
      oprot.writeI64(self.providerId)
8994 
      oprot.writeFieldEnd()
3431 rajveer 8995 
    if self.cod is not None:
3064 chandransh 8996 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
8997 
      oprot.writeBool(self.cod)
1408 ankur.sing 8998 
      oprot.writeFieldEnd()
8999 
    oprot.writeFieldStop()
9000 
    oprot.writeStructEnd()
9001 
 
3431 rajveer 9002 
  def validate(self):
9003 
    return
9004 
 
9005 
 
1408 ankur.sing 9006 
  def __repr__(self):
9007 
    L = ['%s=%r' % (key, value)
9008 
      for key, value in self.__dict__.iteritems()]
9009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9010 
 
9011 
  def __eq__(self, other):
9012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9013 
 
9014 
  def __ne__(self, other):
9015 
    return not (self == other)
9016 
 
3064 chandransh 9017 
class markOrdersAsManifested_result:
1408 ankur.sing 9018 
  """
9019 
  Attributes:
9020 
   - success
3064 chandransh 9021 
   - ex
1408 ankur.sing 9022 
  """
9023 
 
9024 
  thrift_spec = (
3064 chandransh 9025 
    (0, TType.BOOL, 'success', None, None, ), # 0
9026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9027 
  )
9028 
 
3064 chandransh 9029 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9030 
    self.success = success
3064 chandransh 9031 
    self.ex = ex
1408 ankur.sing 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 == 0:
3064 chandransh 9043 
        if ftype == TType.BOOL:
9044 
          self.success = iprot.readBool();
1408 ankur.sing 9045 
        else:
9046 
          iprot.skip(ftype)
3064 chandransh 9047 
      elif fid == 1:
9048 
        if ftype == TType.STRUCT:
9049 
          self.ex = TransactionServiceException()
9050 
          self.ex.read(iprot)
9051 
        else:
9052 
          iprot.skip(ftype)
1408 ankur.sing 9053 
      else:
9054 
        iprot.skip(ftype)
9055 
      iprot.readFieldEnd()
9056 
    iprot.readStructEnd()
9057 
 
9058 
  def write(self, oprot):
9059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9061 
      return
3064 chandransh 9062 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9063 
    if self.success is not None:
3064 chandransh 9064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9065 
      oprot.writeBool(self.success)
1408 ankur.sing 9066 
      oprot.writeFieldEnd()
3431 rajveer 9067 
    if self.ex is not None:
3064 chandransh 9068 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9069 
      self.ex.write(oprot)
9070 
      oprot.writeFieldEnd()
1408 ankur.sing 9071 
    oprot.writeFieldStop()
9072 
    oprot.writeStructEnd()
9073 
 
3431 rajveer 9074 
  def validate(self):
9075 
    return
9076 
 
9077 
 
1408 ankur.sing 9078 
  def __repr__(self):
9079 
    L = ['%s=%r' % (key, value)
9080 
      for key, value in self.__dict__.iteritems()]
9081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9082 
 
9083 
  def __eq__(self, other):
9084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9085 
 
9086 
  def __ne__(self, other):
9087 
    return not (self == other)
9088 
 
3064 chandransh 9089 
class markOrdersAsPickedUp_args:
304 ashish 9090 
  """
9091 
  Attributes:
3064 chandransh 9092 
   - providerId
9093 
   - pickupDetails
304 ashish 9094 
  """
94 ashish 9095 
 
304 ashish 9096 
  thrift_spec = (
9097 
    None, # 0
3064 chandransh 9098 
    (1, TType.I64, 'providerId', None, None, ), # 1
9099 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9100 
  )
9101 
 
3064 chandransh 9102 
  def __init__(self, providerId=None, pickupDetails=None,):
9103 
    self.providerId = providerId
9104 
    self.pickupDetails = pickupDetails
304 ashish 9105 
 
9106 
  def read(self, iprot):
9107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9109 
      return
9110 
    iprot.readStructBegin()
9111 
    while True:
9112 
      (fname, ftype, fid) = iprot.readFieldBegin()
9113 
      if ftype == TType.STOP:
9114 
        break
9115 
      if fid == 1:
9116 
        if ftype == TType.I64:
3064 chandransh 9117 
          self.providerId = iprot.readI64();
304 ashish 9118 
        else:
9119 
          iprot.skip(ftype)
9120 
      elif fid == 2:
3064 chandransh 9121 
        if ftype == TType.MAP:
9122 
          self.pickupDetails = {}
4133 chandransh 9123 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9124 
          for _i144 in xrange(_size140):
9125 
            _key145 = iprot.readString();
9126 
            _val146 = iprot.readString();
9127 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9128 
          iprot.readMapEnd()
304 ashish 9129 
        else:
9130 
          iprot.skip(ftype)
9131 
      else:
9132 
        iprot.skip(ftype)
9133 
      iprot.readFieldEnd()
9134 
    iprot.readStructEnd()
9135 
 
9136 
  def write(self, oprot):
9137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9139 
      return
3064 chandransh 9140 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9141 
    if self.providerId is not None:
3064 chandransh 9142 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9143 
      oprot.writeI64(self.providerId)
304 ashish 9144 
      oprot.writeFieldEnd()
3431 rajveer 9145 
    if self.pickupDetails is not None:
3064 chandransh 9146 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9147 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9148 
      for kiter147,viter148 in self.pickupDetails.items():
9149 
        oprot.writeString(kiter147)
9150 
        oprot.writeString(viter148)
3064 chandransh 9151 
      oprot.writeMapEnd()
304 ashish 9152 
      oprot.writeFieldEnd()
9153 
    oprot.writeFieldStop()
9154 
    oprot.writeStructEnd()
9155 
 
3431 rajveer 9156 
  def validate(self):
9157 
    return
9158 
 
9159 
 
304 ashish 9160 
  def __repr__(self):
9161 
    L = ['%s=%r' % (key, value)
9162 
      for key, value in self.__dict__.iteritems()]
9163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9164 
 
9165 
  def __eq__(self, other):
9166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9167 
 
9168 
  def __ne__(self, other):
9169 
    return not (self == other)
9170 
 
3064 chandransh 9171 
class markOrdersAsPickedUp_result:
304 ashish 9172 
  """
9173 
  Attributes:
9174 
   - success
3064 chandransh 9175 
   - ex
304 ashish 9176 
  """
9177 
 
9178 
  thrift_spec = (
3064 chandransh 9179 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9181 
  )
9182 
 
3064 chandransh 9183 
  def __init__(self, success=None, ex=None,):
304 ashish 9184 
    self.success = success
3064 chandransh 9185 
    self.ex = ex
304 ashish 9186 
 
9187 
  def read(self, iprot):
9188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9190 
      return
9191 
    iprot.readStructBegin()
9192 
    while True:
9193 
      (fname, ftype, fid) = iprot.readFieldBegin()
9194 
      if ftype == TType.STOP:
9195 
        break
9196 
      if fid == 0:
9197 
        if ftype == TType.LIST:
9198 
          self.success = []
4133 chandransh 9199 
          (_etype152, _size149) = iprot.readListBegin()
9200 
          for _i153 in xrange(_size149):
9201 
            _elem154 = Order()
9202 
            _elem154.read(iprot)
9203 
            self.success.append(_elem154)
304 ashish 9204 
          iprot.readListEnd()
9205 
        else:
9206 
          iprot.skip(ftype)
3064 chandransh 9207 
      elif fid == 1:
9208 
        if ftype == TType.STRUCT:
9209 
          self.ex = TransactionServiceException()
9210 
          self.ex.read(iprot)
9211 
        else:
9212 
          iprot.skip(ftype)
304 ashish 9213 
      else:
9214 
        iprot.skip(ftype)
9215 
      iprot.readFieldEnd()
9216 
    iprot.readStructEnd()
9217 
 
9218 
  def write(self, oprot):
9219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9221 
      return
3064 chandransh 9222 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9223 
    if self.success is not None:
304 ashish 9224 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9225 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9226 
      for iter155 in self.success:
9227 
        iter155.write(oprot)
304 ashish 9228 
      oprot.writeListEnd()
9229 
      oprot.writeFieldEnd()
3431 rajveer 9230 
    if self.ex is not None:
3064 chandransh 9231 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9232 
      self.ex.write(oprot)
9233 
      oprot.writeFieldEnd()
304 ashish 9234 
    oprot.writeFieldStop()
9235 
    oprot.writeStructEnd()
9236 
 
3431 rajveer 9237 
  def validate(self):
9238 
    return
9239 
 
9240 
 
304 ashish 9241 
  def __repr__(self):
9242 
    L = ['%s=%r' % (key, value)
9243 
      for key, value in self.__dict__.iteritems()]
9244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9245 
 
9246 
  def __eq__(self, other):
9247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9248 
 
9249 
  def __ne__(self, other):
9250 
    return not (self == other)
9251 
 
3064 chandransh 9252 
class markOrdersAsDelivered_args:
304 ashish 9253 
  """
9254 
  Attributes:
3064 chandransh 9255 
   - providerId
9256 
   - deliveredOrders
304 ashish 9257 
  """
9258 
 
9259 
  thrift_spec = (
9260 
    None, # 0
3064 chandransh 9261 
    (1, TType.I64, 'providerId', None, None, ), # 1
9262 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9263 
  )
9264 
 
3064 chandransh 9265 
  def __init__(self, providerId=None, deliveredOrders=None,):
9266 
    self.providerId = providerId
9267 
    self.deliveredOrders = deliveredOrders
304 ashish 9268 
 
9269 
  def read(self, iprot):
9270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9272 
      return
9273 
    iprot.readStructBegin()
9274 
    while True:
9275 
      (fname, ftype, fid) = iprot.readFieldBegin()
9276 
      if ftype == TType.STOP:
9277 
        break
9278 
      if fid == 1:
9279 
        if ftype == TType.I64:
3064 chandransh 9280 
          self.providerId = iprot.readI64();
304 ashish 9281 
        else:
9282 
          iprot.skip(ftype)
9283 
      elif fid == 2:
3064 chandransh 9284 
        if ftype == TType.MAP:
9285 
          self.deliveredOrders = {}
4133 chandransh 9286 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9287 
          for _i160 in xrange(_size156):
9288 
            _key161 = iprot.readString();
9289 
            _val162 = iprot.readString();
9290 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9291 
          iprot.readMapEnd()
304 ashish 9292 
        else:
9293 
          iprot.skip(ftype)
9294 
      else:
9295 
        iprot.skip(ftype)
9296 
      iprot.readFieldEnd()
9297 
    iprot.readStructEnd()
9298 
 
9299 
  def write(self, oprot):
9300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9302 
      return
3064 chandransh 9303 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9304 
    if self.providerId is not None:
3064 chandransh 9305 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9306 
      oprot.writeI64(self.providerId)
304 ashish 9307 
      oprot.writeFieldEnd()
3431 rajveer 9308 
    if self.deliveredOrders is not None:
3064 chandransh 9309 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9310 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9311 
      for kiter163,viter164 in self.deliveredOrders.items():
9312 
        oprot.writeString(kiter163)
9313 
        oprot.writeString(viter164)
3064 chandransh 9314 
      oprot.writeMapEnd()
304 ashish 9315 
      oprot.writeFieldEnd()
9316 
    oprot.writeFieldStop()
9317 
    oprot.writeStructEnd()
9318 
 
3431 rajveer 9319 
  def validate(self):
9320 
    return
9321 
 
9322 
 
304 ashish 9323 
  def __repr__(self):
9324 
    L = ['%s=%r' % (key, value)
9325 
      for key, value in self.__dict__.iteritems()]
9326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9327 
 
9328 
  def __eq__(self, other):
9329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9330 
 
9331 
  def __ne__(self, other):
9332 
    return not (self == other)
9333 
 
3064 chandransh 9334 
class markOrdersAsDelivered_result:
9335 
  """
9336 
  Attributes:
9337 
   - ex
9338 
  """
304 ashish 9339 
 
9340 
  thrift_spec = (
3064 chandransh 9341 
    None, # 0
9342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9343 
  )
9344 
 
3064 chandransh 9345 
  def __init__(self, ex=None,):
9346 
    self.ex = ex
304 ashish 9347 
 
1596 ankur.sing 9348 
  def read(self, iprot):
9349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9351 
      return
9352 
    iprot.readStructBegin()
9353 
    while True:
9354 
      (fname, ftype, fid) = iprot.readFieldBegin()
9355 
      if ftype == TType.STOP:
9356 
        break
3064 chandransh 9357 
      if fid == 1:
9358 
        if ftype == TType.STRUCT:
9359 
          self.ex = TransactionServiceException()
9360 
          self.ex.read(iprot)
9361 
        else:
9362 
          iprot.skip(ftype)
1596 ankur.sing 9363 
      else:
9364 
        iprot.skip(ftype)
9365 
      iprot.readFieldEnd()
9366 
    iprot.readStructEnd()
9367 
 
9368 
  def write(self, oprot):
9369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9371 
      return
3064 chandransh 9372 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9373 
    if self.ex is not None:
3064 chandransh 9374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9375 
      self.ex.write(oprot)
9376 
      oprot.writeFieldEnd()
1596 ankur.sing 9377 
    oprot.writeFieldStop()
9378 
    oprot.writeStructEnd()
9379 
 
3431 rajveer 9380 
  def validate(self):
9381 
    return
9382 
 
9383 
 
1596 ankur.sing 9384 
  def __repr__(self):
9385 
    L = ['%s=%r' % (key, value)
9386 
      for key, value in self.__dict__.iteritems()]
9387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9388 
 
9389 
  def __eq__(self, other):
9390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9391 
 
9392 
  def __ne__(self, other):
9393 
    return not (self == other)
9394 
 
3064 chandransh 9395 
class markOrdersAsFailed_args:
1596 ankur.sing 9396 
  """
9397 
  Attributes:
3064 chandransh 9398 
   - providerId
9399 
   - returnedOrders
1596 ankur.sing 9400 
  """
9401 
 
9402 
  thrift_spec = (
3064 chandransh 9403 
    None, # 0
9404 
    (1, TType.I64, 'providerId', None, None, ), # 1
9405 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9406 
  )
9407 
 
3064 chandransh 9408 
  def __init__(self, providerId=None, returnedOrders=None,):
9409 
    self.providerId = providerId
9410 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9411 
 
9412 
  def read(self, iprot):
9413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9415 
      return
9416 
    iprot.readStructBegin()
9417 
    while True:
9418 
      (fname, ftype, fid) = iprot.readFieldBegin()
9419 
      if ftype == TType.STOP:
9420 
        break
3064 chandransh 9421 
      if fid == 1:
1596 ankur.sing 9422 
        if ftype == TType.I64:
3064 chandransh 9423 
          self.providerId = iprot.readI64();
1596 ankur.sing 9424 
        else:
9425 
          iprot.skip(ftype)
3064 chandransh 9426 
      elif fid == 2:
9427 
        if ftype == TType.MAP:
9428 
          self.returnedOrders = {}
4133 chandransh 9429 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9430 
          for _i169 in xrange(_size165):
9431 
            _key170 = iprot.readString();
9432 
            _val171 = iprot.readString();
9433 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9434 
          iprot.readMapEnd()
9435 
        else:
9436 
          iprot.skip(ftype)
1596 ankur.sing 9437 
      else:
9438 
        iprot.skip(ftype)
9439 
      iprot.readFieldEnd()
9440 
    iprot.readStructEnd()
9441 
 
9442 
  def write(self, oprot):
9443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9445 
      return
3064 chandransh 9446 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9447 
    if self.providerId is not None:
3064 chandransh 9448 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9449 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9450 
      oprot.writeFieldEnd()
3431 rajveer 9451 
    if self.returnedOrders is not None:
3064 chandransh 9452 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9453 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9454 
      for kiter172,viter173 in self.returnedOrders.items():
9455 
        oprot.writeString(kiter172)
9456 
        oprot.writeString(viter173)
3064 chandransh 9457 
      oprot.writeMapEnd()
9458 
      oprot.writeFieldEnd()
1596 ankur.sing 9459 
    oprot.writeFieldStop()
9460 
    oprot.writeStructEnd()
9461 
 
3431 rajveer 9462 
  def validate(self):
9463 
    return
9464 
 
9465 
 
1596 ankur.sing 9466 
  def __repr__(self):
9467 
    L = ['%s=%r' % (key, value)
9468 
      for key, value in self.__dict__.iteritems()]
9469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9470 
 
9471 
  def __eq__(self, other):
9472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9473 
 
9474 
  def __ne__(self, other):
9475 
    return not (self == other)
9476 
 
3064 chandransh 9477 
class markOrdersAsFailed_result:
9478 
  """
9479 
  Attributes:
9480 
   - ex
9481 
  """
1596 ankur.sing 9482 
 
1627 ankur.sing 9483 
  thrift_spec = (
3064 chandransh 9484 
    None, # 0
9485 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9486 
  )
9487 
 
3064 chandransh 9488 
  def __init__(self, ex=None,):
9489 
    self.ex = ex
9490 
 
1627 ankur.sing 9491 
  def read(self, iprot):
9492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9494 
      return
9495 
    iprot.readStructBegin()
9496 
    while True:
9497 
      (fname, ftype, fid) = iprot.readFieldBegin()
9498 
      if ftype == TType.STOP:
9499 
        break
3064 chandransh 9500 
      if fid == 1:
9501 
        if ftype == TType.STRUCT:
9502 
          self.ex = TransactionServiceException()
9503 
          self.ex.read(iprot)
9504 
        else:
9505 
          iprot.skip(ftype)
1627 ankur.sing 9506 
      else:
9507 
        iprot.skip(ftype)
9508 
      iprot.readFieldEnd()
9509 
    iprot.readStructEnd()
9510 
 
9511 
  def write(self, oprot):
9512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9514 
      return
3064 chandransh 9515 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9516 
    if self.ex is not None:
3064 chandransh 9517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9518 
      self.ex.write(oprot)
9519 
      oprot.writeFieldEnd()
1627 ankur.sing 9520 
    oprot.writeFieldStop()
9521 
    oprot.writeStructEnd()
9522 
 
3431 rajveer 9523 
  def validate(self):
9524 
    return
9525 
 
9526 
 
1627 ankur.sing 9527 
  def __repr__(self):
9528 
    L = ['%s=%r' % (key, value)
9529 
      for key, value in self.__dict__.iteritems()]
9530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9531 
 
9532 
  def __eq__(self, other):
9533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9534 
 
9535 
  def __ne__(self, other):
9536 
    return not (self == other)
9537 
 
3064 chandransh 9538 
class updateNonDeliveryReason_args:
1627 ankur.sing 9539 
  """
9540 
  Attributes:
3064 chandransh 9541 
   - providerId
9542 
   - undeliveredOrders
1627 ankur.sing 9543 
  """
9544 
 
9545 
  thrift_spec = (
3064 chandransh 9546 
    None, # 0
9547 
    (1, TType.I64, 'providerId', None, None, ), # 1
9548 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9549 
  )
9550 
 
3064 chandransh 9551 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9552 
    self.providerId = providerId
9553 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9554 
 
9555 
  def read(self, iprot):
9556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9558 
      return
9559 
    iprot.readStructBegin()
9560 
    while True:
9561 
      (fname, ftype, fid) = iprot.readFieldBegin()
9562 
      if ftype == TType.STOP:
9563 
        break
3064 chandransh 9564 
      if fid == 1:
1627 ankur.sing 9565 
        if ftype == TType.I64:
3064 chandransh 9566 
          self.providerId = iprot.readI64();
1627 ankur.sing 9567 
        else:
9568 
          iprot.skip(ftype)
3064 chandransh 9569 
      elif fid == 2:
9570 
        if ftype == TType.MAP:
9571 
          self.undeliveredOrders = {}
4133 chandransh 9572 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9573 
          for _i178 in xrange(_size174):
9574 
            _key179 = iprot.readString();
9575 
            _val180 = iprot.readString();
9576 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9577 
          iprot.readMapEnd()
9578 
        else:
9579 
          iprot.skip(ftype)
1627 ankur.sing 9580 
      else:
9581 
        iprot.skip(ftype)
9582 
      iprot.readFieldEnd()
9583 
    iprot.readStructEnd()
9584 
 
9585 
  def write(self, oprot):
9586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9588 
      return
3064 chandransh 9589 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9590 
    if self.providerId is not None:
3064 chandransh 9591 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9592 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9593 
      oprot.writeFieldEnd()
3431 rajveer 9594 
    if self.undeliveredOrders is not None:
3064 chandransh 9595 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9596 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9597 
      for kiter181,viter182 in self.undeliveredOrders.items():
9598 
        oprot.writeString(kiter181)
9599 
        oprot.writeString(viter182)
3064 chandransh 9600 
      oprot.writeMapEnd()
9601 
      oprot.writeFieldEnd()
1627 ankur.sing 9602 
    oprot.writeFieldStop()
9603 
    oprot.writeStructEnd()
9604 
 
3431 rajveer 9605 
  def validate(self):
9606 
    return
9607 
 
9608 
 
1627 ankur.sing 9609 
  def __repr__(self):
9610 
    L = ['%s=%r' % (key, value)
9611 
      for key, value in self.__dict__.iteritems()]
9612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9613 
 
9614 
  def __eq__(self, other):
9615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9616 
 
9617 
  def __ne__(self, other):
9618 
    return not (self == other)
9619 
 
3064 chandransh 9620 
class updateNonDeliveryReason_result:
1627 ankur.sing 9621 
  """
9622 
  Attributes:
3064 chandransh 9623 
   - ex
1627 ankur.sing 9624 
  """
9625 
 
9626 
  thrift_spec = (
3064 chandransh 9627 
    None, # 0
9628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9629 
  )
9630 
 
3064 chandransh 9631 
  def __init__(self, ex=None,):
9632 
    self.ex = ex
1627 ankur.sing 9633 
 
9634 
  def read(self, iprot):
9635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9637 
      return
9638 
    iprot.readStructBegin()
9639 
    while True:
9640 
      (fname, ftype, fid) = iprot.readFieldBegin()
9641 
      if ftype == TType.STOP:
9642 
        break
3064 chandransh 9643 
      if fid == 1:
9644 
        if ftype == TType.STRUCT:
9645 
          self.ex = TransactionServiceException()
9646 
          self.ex.read(iprot)
1627 ankur.sing 9647 
        else:
9648 
          iprot.skip(ftype)
9649 
      else:
9650 
        iprot.skip(ftype)
9651 
      iprot.readFieldEnd()
9652 
    iprot.readStructEnd()
9653 
 
9654 
  def write(self, oprot):
9655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9657 
      return
3064 chandransh 9658 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9659 
    if self.ex is not None:
3064 chandransh 9660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9661 
      self.ex.write(oprot)
1627 ankur.sing 9662 
      oprot.writeFieldEnd()
9663 
    oprot.writeFieldStop()
9664 
    oprot.writeStructEnd()
9665 
 
3431 rajveer 9666 
  def validate(self):
9667 
    return
9668 
 
9669 
 
1627 ankur.sing 9670 
  def __repr__(self):
9671 
    L = ['%s=%r' % (key, value)
9672 
      for key, value in self.__dict__.iteritems()]
9673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9674 
 
9675 
  def __eq__(self, other):
9676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9677 
 
9678 
  def __ne__(self, other):
9679 
    return not (self == other)
9680 
 
3064 chandransh 9681 
class getUndeliveredOrders_args:
1886 ankur.sing 9682 
  """
9683 
  Attributes:
3064 chandransh 9684 
   - providerId
9685 
   - warehouseId
1886 ankur.sing 9686 
  """
1627 ankur.sing 9687 
 
1886 ankur.sing 9688 
  thrift_spec = (
9689 
    None, # 0
3064 chandransh 9690 
    (1, TType.I64, 'providerId', None, None, ), # 1
9691 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9692 
  )
9693 
 
3064 chandransh 9694 
  def __init__(self, providerId=None, warehouseId=None,):
9695 
    self.providerId = providerId
9696 
    self.warehouseId = warehouseId
1886 ankur.sing 9697 
 
9698 
  def read(self, iprot):
9699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9701 
      return
9702 
    iprot.readStructBegin()
9703 
    while True:
9704 
      (fname, ftype, fid) = iprot.readFieldBegin()
9705 
      if ftype == TType.STOP:
9706 
        break
9707 
      if fid == 1:
9708 
        if ftype == TType.I64:
3064 chandransh 9709 
          self.providerId = iprot.readI64();
1886 ankur.sing 9710 
        else:
9711 
          iprot.skip(ftype)
3064 chandransh 9712 
      elif fid == 2:
9713 
        if ftype == TType.I64:
9714 
          self.warehouseId = iprot.readI64();
9715 
        else:
9716 
          iprot.skip(ftype)
1886 ankur.sing 9717 
      else:
9718 
        iprot.skip(ftype)
9719 
      iprot.readFieldEnd()
9720 
    iprot.readStructEnd()
9721 
 
9722 
  def write(self, oprot):
9723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9725 
      return
3064 chandransh 9726 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9727 
    if self.providerId is not None:
3064 chandransh 9728 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9729 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9730 
      oprot.writeFieldEnd()
3431 rajveer 9731 
    if self.warehouseId is not None:
3064 chandransh 9732 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9733 
      oprot.writeI64(self.warehouseId)
9734 
      oprot.writeFieldEnd()
1886 ankur.sing 9735 
    oprot.writeFieldStop()
9736 
    oprot.writeStructEnd()
9737 
 
3431 rajveer 9738 
  def validate(self):
9739 
    return
9740 
 
9741 
 
1886 ankur.sing 9742 
  def __repr__(self):
9743 
    L = ['%s=%r' % (key, value)
9744 
      for key, value in self.__dict__.iteritems()]
9745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9746 
 
9747 
  def __eq__(self, other):
9748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9749 
 
9750 
  def __ne__(self, other):
9751 
    return not (self == other)
9752 
 
3064 chandransh 9753 
class getUndeliveredOrders_result:
1886 ankur.sing 9754 
  """
9755 
  Attributes:
9756 
   - success
9757 
  """
9758 
 
9759 
  thrift_spec = (
9760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9761 
  )
9762 
 
9763 
  def __init__(self, success=None,):
9764 
    self.success = success
9765 
 
9766 
  def read(self, iprot):
9767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9769 
      return
9770 
    iprot.readStructBegin()
9771 
    while True:
9772 
      (fname, ftype, fid) = iprot.readFieldBegin()
9773 
      if ftype == TType.STOP:
9774 
        break
9775 
      if fid == 0:
9776 
        if ftype == TType.LIST:
9777 
          self.success = []
4133 chandransh 9778 
          (_etype186, _size183) = iprot.readListBegin()
9779 
          for _i187 in xrange(_size183):
9780 
            _elem188 = Order()
9781 
            _elem188.read(iprot)
9782 
            self.success.append(_elem188)
1886 ankur.sing 9783 
          iprot.readListEnd()
9784 
        else:
9785 
          iprot.skip(ftype)
9786 
      else:
9787 
        iprot.skip(ftype)
9788 
      iprot.readFieldEnd()
9789 
    iprot.readStructEnd()
9790 
 
9791 
  def write(self, oprot):
9792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9794 
      return
3064 chandransh 9795 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9796 
    if self.success is not None:
1886 ankur.sing 9797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9799 
      for iter189 in self.success:
9800 
        iter189.write(oprot)
1886 ankur.sing 9801 
      oprot.writeListEnd()
9802 
      oprot.writeFieldEnd()
9803 
    oprot.writeFieldStop()
9804 
    oprot.writeStructEnd()
9805 
 
3431 rajveer 9806 
  def validate(self):
9807 
    return
9808 
 
9809 
 
1886 ankur.sing 9810 
  def __repr__(self):
9811 
    L = ['%s=%r' % (key, value)
9812 
      for key, value in self.__dict__.iteritems()]
9813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9814 
 
9815 
  def __eq__(self, other):
9816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9817 
 
9818 
  def __ne__(self, other):
9819 
    return not (self == other)
9820 
 
2536 chandransh 9821 
class toggleDOAFlag_args:
9822 
  """
9823 
  Attributes:
9824 
   - orderId
9825 
  """
1886 ankur.sing 9826 
 
2536 chandransh 9827 
  thrift_spec = (
9828 
    None, # 0
9829 
    (1, TType.I64, 'orderId', None, None, ), # 1
9830 
  )
9831 
 
9832 
  def __init__(self, orderId=None,):
9833 
    self.orderId = orderId
9834 
 
9835 
  def read(self, iprot):
9836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9838 
      return
9839 
    iprot.readStructBegin()
9840 
    while True:
9841 
      (fname, ftype, fid) = iprot.readFieldBegin()
9842 
      if ftype == TType.STOP:
9843 
        break
9844 
      if fid == 1:
9845 
        if ftype == TType.I64:
9846 
          self.orderId = iprot.readI64();
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
9858 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9859 
    if self.orderId is not None:
2536 chandransh 9860 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9861 
      oprot.writeI64(self.orderId)
9862 
      oprot.writeFieldEnd()
9863 
    oprot.writeFieldStop()
9864 
    oprot.writeStructEnd()
9865 
 
3431 rajveer 9866 
  def validate(self):
9867 
    return
9868 
 
9869 
 
2536 chandransh 9870 
  def __repr__(self):
9871 
    L = ['%s=%r' % (key, value)
9872 
      for key, value in self.__dict__.iteritems()]
9873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9874 
 
9875 
  def __eq__(self, other):
9876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9877 
 
9878 
  def __ne__(self, other):
9879 
    return not (self == other)
9880 
 
9881 
class toggleDOAFlag_result:
9882 
  """
9883 
  Attributes:
9884 
   - success
9885 
   - ex
9886 
  """
9887 
 
9888 
  thrift_spec = (
9889 
    (0, TType.BOOL, 'success', None, None, ), # 0
9890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9891 
  )
9892 
 
9893 
  def __init__(self, success=None, ex=None,):
9894 
    self.success = success
9895 
    self.ex = ex
9896 
 
9897 
  def read(self, iprot):
9898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9900 
      return
9901 
    iprot.readStructBegin()
9902 
    while True:
9903 
      (fname, ftype, fid) = iprot.readFieldBegin()
9904 
      if ftype == TType.STOP:
9905 
        break
9906 
      if fid == 0:
9907 
        if ftype == TType.BOOL:
9908 
          self.success = iprot.readBool();
9909 
        else:
9910 
          iprot.skip(ftype)
9911 
      elif fid == 1:
9912 
        if ftype == TType.STRUCT:
9913 
          self.ex = TransactionServiceException()
9914 
          self.ex.read(iprot)
9915 
        else:
9916 
          iprot.skip(ftype)
9917 
      else:
9918 
        iprot.skip(ftype)
9919 
      iprot.readFieldEnd()
9920 
    iprot.readStructEnd()
9921 
 
9922 
  def write(self, oprot):
9923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9925 
      return
9926 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9927 
    if self.success is not None:
2536 chandransh 9928 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9929 
      oprot.writeBool(self.success)
9930 
      oprot.writeFieldEnd()
3431 rajveer 9931 
    if self.ex is not None:
2536 chandransh 9932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9933 
      self.ex.write(oprot)
9934 
      oprot.writeFieldEnd()
9935 
    oprot.writeFieldStop()
9936 
    oprot.writeStructEnd()
9937 
 
3431 rajveer 9938 
  def validate(self):
9939 
    return
9940 
 
9941 
 
2536 chandransh 9942 
  def __repr__(self):
9943 
    L = ['%s=%r' % (key, value)
9944 
      for key, value in self.__dict__.iteritems()]
9945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9946 
 
9947 
  def __eq__(self, other):
9948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9949 
 
9950 
  def __ne__(self, other):
9951 
    return not (self == other)
9952 
 
9953 
class requestPickupNumber_args:
9954 
  """
9955 
  Attributes:
9956 
   - orderId
9957 
  """
9958 
 
9959 
  thrift_spec = (
9960 
    None, # 0
9961 
    (1, TType.I64, 'orderId', None, None, ), # 1
9962 
  )
9963 
 
9964 
  def __init__(self, orderId=None,):
9965 
    self.orderId = orderId
9966 
 
9967 
  def read(self, iprot):
9968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9970 
      return
9971 
    iprot.readStructBegin()
9972 
    while True:
9973 
      (fname, ftype, fid) = iprot.readFieldBegin()
9974 
      if ftype == TType.STOP:
9975 
        break
9976 
      if fid == 1:
9977 
        if ftype == TType.I64:
9978 
          self.orderId = iprot.readI64();
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      else:
9982 
        iprot.skip(ftype)
9983 
      iprot.readFieldEnd()
9984 
    iprot.readStructEnd()
9985 
 
9986 
  def write(self, oprot):
9987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9989 
      return
9990 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 9991 
    if self.orderId is not None:
2536 chandransh 9992 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9993 
      oprot.writeI64(self.orderId)
9994 
      oprot.writeFieldEnd()
9995 
    oprot.writeFieldStop()
9996 
    oprot.writeStructEnd()
9997 
 
3431 rajveer 9998 
  def validate(self):
9999 
    return
10000 
 
10001 
 
2536 chandransh 10002 
  def __repr__(self):
10003 
    L = ['%s=%r' % (key, value)
10004 
      for key, value in self.__dict__.iteritems()]
10005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10006 
 
10007 
  def __eq__(self, other):
10008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10009 
 
10010 
  def __ne__(self, other):
10011 
    return not (self == other)
10012 
 
10013 
class requestPickupNumber_result:
10014 
  """
10015 
  Attributes:
10016 
   - success
10017 
   - ex
10018 
  """
10019 
 
10020 
  thrift_spec = (
10021 
    (0, TType.BOOL, 'success', None, None, ), # 0
10022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10023 
  )
10024 
 
10025 
  def __init__(self, success=None, ex=None,):
10026 
    self.success = success
10027 
    self.ex = ex
10028 
 
10029 
  def read(self, iprot):
10030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10032 
      return
10033 
    iprot.readStructBegin()
10034 
    while True:
10035 
      (fname, ftype, fid) = iprot.readFieldBegin()
10036 
      if ftype == TType.STOP:
10037 
        break
10038 
      if fid == 0:
10039 
        if ftype == TType.BOOL:
10040 
          self.success = iprot.readBool();
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      elif fid == 1:
10044 
        if ftype == TType.STRUCT:
10045 
          self.ex = TransactionServiceException()
10046 
          self.ex.read(iprot)
10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      else:
10050 
        iprot.skip(ftype)
10051 
      iprot.readFieldEnd()
10052 
    iprot.readStructEnd()
10053 
 
10054 
  def write(self, oprot):
10055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10057 
      return
10058 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10059 
    if self.success is not None:
2536 chandransh 10060 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10061 
      oprot.writeBool(self.success)
10062 
      oprot.writeFieldEnd()
3431 rajveer 10063 
    if self.ex is not None:
2536 chandransh 10064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10065 
      self.ex.write(oprot)
10066 
      oprot.writeFieldEnd()
10067 
    oprot.writeFieldStop()
10068 
    oprot.writeStructEnd()
10069 
 
3431 rajveer 10070 
  def validate(self):
10071 
    return
10072 
 
10073 
 
2536 chandransh 10074 
  def __repr__(self):
10075 
    L = ['%s=%r' % (key, value)
10076 
      for key, value in self.__dict__.iteritems()]
10077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10078 
 
10079 
  def __eq__(self, other):
10080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10081 
 
10082 
  def __ne__(self, other):
10083 
    return not (self == other)
10084 
 
10085 
class authorizePickup_args:
10086 
  """
10087 
  Attributes:
10088 
   - orderId
10089 
   - pickupNumber
10090 
  """
10091 
 
10092 
  thrift_spec = (
10093 
    None, # 0
10094 
    (1, TType.I64, 'orderId', None, None, ), # 1
10095 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10096 
  )
10097 
 
10098 
  def __init__(self, orderId=None, pickupNumber=None,):
10099 
    self.orderId = orderId
10100 
    self.pickupNumber = pickupNumber
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 1:
10112 
        if ftype == TType.I64:
10113 
          self.orderId = iprot.readI64();
10114 
        else:
10115 
          iprot.skip(ftype)
10116 
      elif fid == 2:
10117 
        if ftype == TType.STRING:
10118 
          self.pickupNumber = iprot.readString();
10119 
        else:
10120 
          iprot.skip(ftype)
10121 
      else:
10122 
        iprot.skip(ftype)
10123 
      iprot.readFieldEnd()
10124 
    iprot.readStructEnd()
10125 
 
10126 
  def write(self, oprot):
10127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10129 
      return
10130 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10131 
    if self.orderId is not None:
2536 chandransh 10132 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10133 
      oprot.writeI64(self.orderId)
10134 
      oprot.writeFieldEnd()
3431 rajveer 10135 
    if self.pickupNumber is not None:
2536 chandransh 10136 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10137 
      oprot.writeString(self.pickupNumber)
10138 
      oprot.writeFieldEnd()
10139 
    oprot.writeFieldStop()
10140 
    oprot.writeStructEnd()
10141 
 
3431 rajveer 10142 
  def validate(self):
10143 
    return
10144 
 
10145 
 
2536 chandransh 10146 
  def __repr__(self):
10147 
    L = ['%s=%r' % (key, value)
10148 
      for key, value in self.__dict__.iteritems()]
10149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10150 
 
10151 
  def __eq__(self, other):
10152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10153 
 
10154 
  def __ne__(self, other):
10155 
    return not (self == other)
10156 
 
10157 
class authorizePickup_result:
10158 
  """
10159 
  Attributes:
10160 
   - success
10161 
   - ex
10162 
  """
10163 
 
10164 
  thrift_spec = (
10165 
    (0, TType.BOOL, 'success', None, None, ), # 0
10166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10167 
  )
10168 
 
10169 
  def __init__(self, success=None, ex=None,):
10170 
    self.success = success
10171 
    self.ex = ex
10172 
 
10173 
  def read(self, iprot):
10174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10176 
      return
10177 
    iprot.readStructBegin()
10178 
    while True:
10179 
      (fname, ftype, fid) = iprot.readFieldBegin()
10180 
      if ftype == TType.STOP:
10181 
        break
10182 
      if fid == 0:
10183 
        if ftype == TType.BOOL:
10184 
          self.success = iprot.readBool();
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      elif fid == 1:
10188 
        if ftype == TType.STRUCT:
10189 
          self.ex = TransactionServiceException()
10190 
          self.ex.read(iprot)
10191 
        else:
10192 
          iprot.skip(ftype)
10193 
      else:
10194 
        iprot.skip(ftype)
10195 
      iprot.readFieldEnd()
10196 
    iprot.readStructEnd()
10197 
 
10198 
  def write(self, oprot):
10199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10201 
      return
10202 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10203 
    if self.success is not None:
2536 chandransh 10204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10205 
      oprot.writeBool(self.success)
10206 
      oprot.writeFieldEnd()
3431 rajveer 10207 
    if self.ex is not None:
2536 chandransh 10208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10209 
      self.ex.write(oprot)
10210 
      oprot.writeFieldEnd()
10211 
    oprot.writeFieldStop()
10212 
    oprot.writeStructEnd()
10213 
 
3431 rajveer 10214 
  def validate(self):
10215 
    return
10216 
 
10217 
 
2536 chandransh 10218 
  def __repr__(self):
10219 
    L = ['%s=%r' % (key, value)
10220 
      for key, value in self.__dict__.iteritems()]
10221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10222 
 
10223 
  def __eq__(self, other):
10224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10225 
 
10226 
  def __ne__(self, other):
10227 
    return not (self == other)
10228 
 
2764 chandransh 10229 
class markDoasAsPickedUp_args:
10230 
  """
10231 
  Attributes:
10232 
   - providerId
10233 
   - pickupDetails
10234 
  """
10235 
 
10236 
  thrift_spec = (
10237 
    None, # 0
10238 
    (1, TType.I64, 'providerId', None, None, ), # 1
10239 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10240 
  )
10241 
 
10242 
  def __init__(self, providerId=None, pickupDetails=None,):
10243 
    self.providerId = providerId
10244 
    self.pickupDetails = pickupDetails
10245 
 
10246 
  def read(self, iprot):
10247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10249 
      return
10250 
    iprot.readStructBegin()
10251 
    while True:
10252 
      (fname, ftype, fid) = iprot.readFieldBegin()
10253 
      if ftype == TType.STOP:
10254 
        break
10255 
      if fid == 1:
10256 
        if ftype == TType.I64:
10257 
          self.providerId = iprot.readI64();
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      elif fid == 2:
10261 
        if ftype == TType.MAP:
10262 
          self.pickupDetails = {}
4133 chandransh 10263 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10264 
          for _i194 in xrange(_size190):
10265 
            _key195 = iprot.readString();
10266 
            _val196 = iprot.readString();
10267 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10268 
          iprot.readMapEnd()
10269 
        else:
10270 
          iprot.skip(ftype)
10271 
      else:
10272 
        iprot.skip(ftype)
10273 
      iprot.readFieldEnd()
10274 
    iprot.readStructEnd()
10275 
 
10276 
  def write(self, oprot):
10277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10279 
      return
10280 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10281 
    if self.providerId is not None:
2764 chandransh 10282 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10283 
      oprot.writeI64(self.providerId)
10284 
      oprot.writeFieldEnd()
3431 rajveer 10285 
    if self.pickupDetails is not None:
2764 chandransh 10286 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10287 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10288 
      for kiter197,viter198 in self.pickupDetails.items():
10289 
        oprot.writeString(kiter197)
10290 
        oprot.writeString(viter198)
2764 chandransh 10291 
      oprot.writeMapEnd()
10292 
      oprot.writeFieldEnd()
10293 
    oprot.writeFieldStop()
10294 
    oprot.writeStructEnd()
10295 
 
3431 rajveer 10296 
  def validate(self):
10297 
    return
10298 
 
10299 
 
2764 chandransh 10300 
  def __repr__(self):
10301 
    L = ['%s=%r' % (key, value)
10302 
      for key, value in self.__dict__.iteritems()]
10303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10304 
 
10305 
  def __eq__(self, other):
10306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10307 
 
10308 
  def __ne__(self, other):
10309 
    return not (self == other)
10310 
 
10311 
class markDoasAsPickedUp_result:
10312 
  """
10313 
  Attributes:
10314 
   - success
10315 
  """
10316 
 
10317 
  thrift_spec = (
10318 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10319 
  )
10320 
 
10321 
  def __init__(self, success=None,):
10322 
    self.success = success
10323 
 
10324 
  def read(self, iprot):
10325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10327 
      return
10328 
    iprot.readStructBegin()
10329 
    while True:
10330 
      (fname, ftype, fid) = iprot.readFieldBegin()
10331 
      if ftype == TType.STOP:
10332 
        break
10333 
      if fid == 0:
10334 
        if ftype == TType.LIST:
10335 
          self.success = []
4133 chandransh 10336 
          (_etype202, _size199) = iprot.readListBegin()
10337 
          for _i203 in xrange(_size199):
10338 
            _elem204 = Order()
10339 
            _elem204.read(iprot)
10340 
            self.success.append(_elem204)
2764 chandransh 10341 
          iprot.readListEnd()
10342 
        else:
10343 
          iprot.skip(ftype)
10344 
      else:
10345 
        iprot.skip(ftype)
10346 
      iprot.readFieldEnd()
10347 
    iprot.readStructEnd()
10348 
 
10349 
  def write(self, oprot):
10350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10352 
      return
10353 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10354 
    if self.success is not None:
2764 chandransh 10355 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10356 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10357 
      for iter205 in self.success:
10358 
        iter205.write(oprot)
2764 chandransh 10359 
      oprot.writeListEnd()
10360 
      oprot.writeFieldEnd()
10361 
    oprot.writeFieldStop()
10362 
    oprot.writeStructEnd()
10363 
 
3431 rajveer 10364 
  def validate(self):
10365 
    return
10366 
 
10367 
 
2764 chandransh 10368 
  def __repr__(self):
10369 
    L = ['%s=%r' % (key, value)
10370 
      for key, value in self.__dict__.iteritems()]
10371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10372 
 
10373 
  def __eq__(self, other):
10374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10375 
 
10376 
  def __ne__(self, other):
10377 
    return not (self == other)
10378 
 
2616 chandransh 10379 
class receiveReturn_args:
2591 chandransh 10380 
  """
10381 
  Attributes:
10382 
   - orderId
10383 
  """
2536 chandransh 10384 
 
2591 chandransh 10385 
  thrift_spec = (
10386 
    None, # 0
10387 
    (1, TType.I64, 'orderId', None, None, ), # 1
10388 
  )
10389 
 
10390 
  def __init__(self, orderId=None,):
10391 
    self.orderId = orderId
10392 
 
10393 
  def read(self, iprot):
10394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10396 
      return
10397 
    iprot.readStructBegin()
10398 
    while True:
10399 
      (fname, ftype, fid) = iprot.readFieldBegin()
10400 
      if ftype == TType.STOP:
10401 
        break
10402 
      if fid == 1:
10403 
        if ftype == TType.I64:
10404 
          self.orderId = iprot.readI64();
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      else:
10408 
        iprot.skip(ftype)
10409 
      iprot.readFieldEnd()
10410 
    iprot.readStructEnd()
10411 
 
10412 
  def write(self, oprot):
10413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10415 
      return
2616 chandransh 10416 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10417 
    if self.orderId is not None:
2591 chandransh 10418 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10419 
      oprot.writeI64(self.orderId)
10420 
      oprot.writeFieldEnd()
10421 
    oprot.writeFieldStop()
10422 
    oprot.writeStructEnd()
10423 
 
3431 rajveer 10424 
  def validate(self):
10425 
    return
10426 
 
10427 
 
2591 chandransh 10428 
  def __repr__(self):
10429 
    L = ['%s=%r' % (key, value)
10430 
      for key, value in self.__dict__.iteritems()]
10431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10432 
 
10433 
  def __eq__(self, other):
10434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10435 
 
10436 
  def __ne__(self, other):
10437 
    return not (self == other)
10438 
 
2616 chandransh 10439 
class receiveReturn_result:
2591 chandransh 10440 
  """
10441 
  Attributes:
10442 
   - success
10443 
   - ex
10444 
  """
10445 
 
10446 
  thrift_spec = (
10447 
    (0, TType.BOOL, 'success', None, None, ), # 0
10448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10449 
  )
10450 
 
10451 
  def __init__(self, success=None, ex=None,):
10452 
    self.success = success
10453 
    self.ex = ex
10454 
 
10455 
  def read(self, iprot):
10456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10458 
      return
10459 
    iprot.readStructBegin()
10460 
    while True:
10461 
      (fname, ftype, fid) = iprot.readFieldBegin()
10462 
      if ftype == TType.STOP:
10463 
        break
10464 
      if fid == 0:
10465 
        if ftype == TType.BOOL:
10466 
          self.success = iprot.readBool();
10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      elif fid == 1:
10470 
        if ftype == TType.STRUCT:
10471 
          self.ex = TransactionServiceException()
10472 
          self.ex.read(iprot)
10473 
        else:
10474 
          iprot.skip(ftype)
10475 
      else:
10476 
        iprot.skip(ftype)
10477 
      iprot.readFieldEnd()
10478 
    iprot.readStructEnd()
10479 
 
10480 
  def write(self, oprot):
10481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10483 
      return
2616 chandransh 10484 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10485 
    if self.success is not None:
2591 chandransh 10486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10487 
      oprot.writeBool(self.success)
10488 
      oprot.writeFieldEnd()
3431 rajveer 10489 
    if self.ex is not None:
2591 chandransh 10490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10491 
      self.ex.write(oprot)
10492 
      oprot.writeFieldEnd()
10493 
    oprot.writeFieldStop()
10494 
    oprot.writeStructEnd()
10495 
 
3431 rajveer 10496 
  def validate(self):
10497 
    return
10498 
 
10499 
 
2591 chandransh 10500 
  def __repr__(self):
10501 
    L = ['%s=%r' % (key, value)
10502 
      for key, value in self.__dict__.iteritems()]
10503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10504 
 
10505 
  def __eq__(self, other):
10506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10507 
 
10508 
  def __ne__(self, other):
10509 
    return not (self == other)
10510 
 
10511 
class validateDoa_args:
10512 
  """
10513 
  Attributes:
10514 
   - orderId
10515 
   - isValid
10516 
  """
10517 
 
10518 
  thrift_spec = (
10519 
    None, # 0
10520 
    (1, TType.I64, 'orderId', None, None, ), # 1
10521 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10522 
  )
10523 
 
10524 
  def __init__(self, orderId=None, isValid=None,):
10525 
    self.orderId = orderId
10526 
    self.isValid = isValid
10527 
 
10528 
  def read(self, iprot):
10529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10531 
      return
10532 
    iprot.readStructBegin()
10533 
    while True:
10534 
      (fname, ftype, fid) = iprot.readFieldBegin()
10535 
      if ftype == TType.STOP:
10536 
        break
10537 
      if fid == 1:
10538 
        if ftype == TType.I64:
10539 
          self.orderId = iprot.readI64();
10540 
        else:
10541 
          iprot.skip(ftype)
10542 
      elif fid == 2:
10543 
        if ftype == TType.BOOL:
10544 
          self.isValid = iprot.readBool();
10545 
        else:
10546 
          iprot.skip(ftype)
10547 
      else:
10548 
        iprot.skip(ftype)
10549 
      iprot.readFieldEnd()
10550 
    iprot.readStructEnd()
10551 
 
10552 
  def write(self, oprot):
10553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10555 
      return
10556 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10557 
    if self.orderId is not None:
2591 chandransh 10558 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10559 
      oprot.writeI64(self.orderId)
10560 
      oprot.writeFieldEnd()
3431 rajveer 10561 
    if self.isValid is not None:
2591 chandransh 10562 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10563 
      oprot.writeBool(self.isValid)
10564 
      oprot.writeFieldEnd()
10565 
    oprot.writeFieldStop()
10566 
    oprot.writeStructEnd()
10567 
 
3431 rajveer 10568 
  def validate(self):
10569 
    return
10570 
 
10571 
 
2591 chandransh 10572 
  def __repr__(self):
10573 
    L = ['%s=%r' % (key, value)
10574 
      for key, value in self.__dict__.iteritems()]
10575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10576 
 
10577 
  def __eq__(self, other):
10578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10579 
 
10580 
  def __ne__(self, other):
10581 
    return not (self == other)
10582 
 
10583 
class validateDoa_result:
10584 
  """
10585 
  Attributes:
10586 
   - success
10587 
   - ex
10588 
  """
10589 
 
10590 
  thrift_spec = (
10591 
    (0, TType.BOOL, 'success', None, None, ), # 0
10592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10593 
  )
10594 
 
10595 
  def __init__(self, success=None, ex=None,):
10596 
    self.success = success
10597 
    self.ex = ex
10598 
 
10599 
  def read(self, iprot):
10600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10602 
      return
10603 
    iprot.readStructBegin()
10604 
    while True:
10605 
      (fname, ftype, fid) = iprot.readFieldBegin()
10606 
      if ftype == TType.STOP:
10607 
        break
10608 
      if fid == 0:
10609 
        if ftype == TType.BOOL:
10610 
          self.success = iprot.readBool();
10611 
        else:
10612 
          iprot.skip(ftype)
10613 
      elif fid == 1:
10614 
        if ftype == TType.STRUCT:
10615 
          self.ex = TransactionServiceException()
10616 
          self.ex.read(iprot)
10617 
        else:
10618 
          iprot.skip(ftype)
10619 
      else:
10620 
        iprot.skip(ftype)
10621 
      iprot.readFieldEnd()
10622 
    iprot.readStructEnd()
10623 
 
10624 
  def write(self, oprot):
10625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10627 
      return
10628 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10629 
    if self.success is not None:
2591 chandransh 10630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10631 
      oprot.writeBool(self.success)
10632 
      oprot.writeFieldEnd()
3431 rajveer 10633 
    if self.ex is not None:
2591 chandransh 10634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10635 
      self.ex.write(oprot)
10636 
      oprot.writeFieldEnd()
10637 
    oprot.writeFieldStop()
10638 
    oprot.writeStructEnd()
10639 
 
3431 rajveer 10640 
  def validate(self):
10641 
    return
10642 
 
10643 
 
2591 chandransh 10644 
  def __repr__(self):
10645 
    L = ['%s=%r' % (key, value)
10646 
      for key, value in self.__dict__.iteritems()]
10647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10648 
 
10649 
  def __eq__(self, other):
10650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10651 
 
10652 
  def __ne__(self, other):
10653 
    return not (self == other)
10654 
 
2616 chandransh 10655 
class reshipOrder_args:
10656 
  """
10657 
  Attributes:
10658 
   - orderId
10659 
  """
2591 chandransh 10660 
 
2616 chandransh 10661 
  thrift_spec = (
10662 
    None, # 0
10663 
    (1, TType.I64, 'orderId', None, None, ), # 1
10664 
  )
10665 
 
10666 
  def __init__(self, orderId=None,):
10667 
    self.orderId = orderId
10668 
 
10669 
  def read(self, iprot):
10670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10672 
      return
10673 
    iprot.readStructBegin()
10674 
    while True:
10675 
      (fname, ftype, fid) = iprot.readFieldBegin()
10676 
      if ftype == TType.STOP:
10677 
        break
10678 
      if fid == 1:
10679 
        if ftype == TType.I64:
10680 
          self.orderId = iprot.readI64();
10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      else:
10684 
        iprot.skip(ftype)
10685 
      iprot.readFieldEnd()
10686 
    iprot.readStructEnd()
10687 
 
10688 
  def write(self, oprot):
10689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10691 
      return
10692 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10693 
    if self.orderId is not None:
2616 chandransh 10694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10695 
      oprot.writeI64(self.orderId)
10696 
      oprot.writeFieldEnd()
10697 
    oprot.writeFieldStop()
10698 
    oprot.writeStructEnd()
10699 
 
3431 rajveer 10700 
  def validate(self):
10701 
    return
10702 
 
10703 
 
2616 chandransh 10704 
  def __repr__(self):
10705 
    L = ['%s=%r' % (key, value)
10706 
      for key, value in self.__dict__.iteritems()]
10707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10708 
 
10709 
  def __eq__(self, other):
10710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10711 
 
10712 
  def __ne__(self, other):
10713 
    return not (self == other)
10714 
 
10715 
class reshipOrder_result:
10716 
  """
10717 
  Attributes:
10718 
   - success
10719 
   - ex
10720 
  """
10721 
 
10722 
  thrift_spec = (
10723 
    (0, TType.I64, 'success', None, None, ), # 0
10724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10725 
  )
10726 
 
10727 
  def __init__(self, success=None, ex=None,):
10728 
    self.success = success
10729 
    self.ex = ex
10730 
 
10731 
  def read(self, iprot):
10732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10734 
      return
10735 
    iprot.readStructBegin()
10736 
    while True:
10737 
      (fname, ftype, fid) = iprot.readFieldBegin()
10738 
      if ftype == TType.STOP:
10739 
        break
10740 
      if fid == 0:
10741 
        if ftype == TType.I64:
10742 
          self.success = iprot.readI64();
10743 
        else:
10744 
          iprot.skip(ftype)
10745 
      elif fid == 1:
10746 
        if ftype == TType.STRUCT:
10747 
          self.ex = TransactionServiceException()
10748 
          self.ex.read(iprot)
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('reshipOrder_result')
3431 rajveer 10761 
    if self.success is not None:
2616 chandransh 10762 
      oprot.writeFieldBegin('success', TType.I64, 0)
10763 
      oprot.writeI64(self.success)
10764 
      oprot.writeFieldEnd()
3431 rajveer 10765 
    if self.ex is not None:
2616 chandransh 10766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10767 
      self.ex.write(oprot)
10768 
      oprot.writeFieldEnd()
10769 
    oprot.writeFieldStop()
10770 
    oprot.writeStructEnd()
10771 
 
3431 rajveer 10772 
  def validate(self):
10773 
    return
10774 
 
10775 
 
2616 chandransh 10776 
  def __repr__(self):
10777 
    L = ['%s=%r' % (key, value)
10778 
      for key, value in self.__dict__.iteritems()]
10779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10780 
 
10781 
  def __eq__(self, other):
10782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10783 
 
10784 
  def __ne__(self, other):
10785 
    return not (self == other)
10786 
 
10787 
class refundOrder_args:
10788 
  """
10789 
  Attributes:
10790 
   - orderId
3226 chandransh 10791 
   - refundedBy
10792 
   - reason
2616 chandransh 10793 
  """
10794 
 
10795 
  thrift_spec = (
10796 
    None, # 0
10797 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10798 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10799 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10800 
  )
10801 
 
3226 chandransh 10802 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10803 
    self.orderId = orderId
3226 chandransh 10804 
    self.refundedBy = refundedBy
10805 
    self.reason = reason
2616 chandransh 10806 
 
10807 
  def read(self, iprot):
10808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10810 
      return
10811 
    iprot.readStructBegin()
10812 
    while True:
10813 
      (fname, ftype, fid) = iprot.readFieldBegin()
10814 
      if ftype == TType.STOP:
10815 
        break
10816 
      if fid == 1:
10817 
        if ftype == TType.I64:
10818 
          self.orderId = iprot.readI64();
10819 
        else:
10820 
          iprot.skip(ftype)
3226 chandransh 10821 
      elif fid == 2:
10822 
        if ftype == TType.STRING:
10823 
          self.refundedBy = iprot.readString();
10824 
        else:
10825 
          iprot.skip(ftype)
10826 
      elif fid == 3:
10827 
        if ftype == TType.STRING:
10828 
          self.reason = iprot.readString();
10829 
        else:
10830 
          iprot.skip(ftype)
2616 chandransh 10831 
      else:
10832 
        iprot.skip(ftype)
10833 
      iprot.readFieldEnd()
10834 
    iprot.readStructEnd()
10835 
 
10836 
  def write(self, oprot):
10837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10839 
      return
10840 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10841 
    if self.orderId is not None:
2616 chandransh 10842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10843 
      oprot.writeI64(self.orderId)
10844 
      oprot.writeFieldEnd()
3431 rajveer 10845 
    if self.refundedBy is not None:
3226 chandransh 10846 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10847 
      oprot.writeString(self.refundedBy)
10848 
      oprot.writeFieldEnd()
3431 rajveer 10849 
    if self.reason is not None:
3226 chandransh 10850 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10851 
      oprot.writeString(self.reason)
10852 
      oprot.writeFieldEnd()
2616 chandransh 10853 
    oprot.writeFieldStop()
10854 
    oprot.writeStructEnd()
10855 
 
3431 rajveer 10856 
  def validate(self):
10857 
    return
10858 
 
10859 
 
2616 chandransh 10860 
  def __repr__(self):
10861 
    L = ['%s=%r' % (key, value)
10862 
      for key, value in self.__dict__.iteritems()]
10863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10864 
 
10865 
  def __eq__(self, other):
10866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10867 
 
10868 
  def __ne__(self, other):
10869 
    return not (self == other)
10870 
 
10871 
class refundOrder_result:
10872 
  """
10873 
  Attributes:
10874 
   - success
10875 
   - ex
10876 
  """
10877 
 
10878 
  thrift_spec = (
10879 
    (0, TType.BOOL, 'success', None, None, ), # 0
10880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10881 
  )
10882 
 
10883 
  def __init__(self, success=None, ex=None,):
10884 
    self.success = success
10885 
    self.ex = ex
10886 
 
10887 
  def read(self, iprot):
10888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10890 
      return
10891 
    iprot.readStructBegin()
10892 
    while True:
10893 
      (fname, ftype, fid) = iprot.readFieldBegin()
10894 
      if ftype == TType.STOP:
10895 
        break
10896 
      if fid == 0:
10897 
        if ftype == TType.BOOL:
10898 
          self.success = iprot.readBool();
10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      elif fid == 1:
10902 
        if ftype == TType.STRUCT:
10903 
          self.ex = TransactionServiceException()
10904 
          self.ex.read(iprot)
10905 
        else:
10906 
          iprot.skip(ftype)
10907 
      else:
10908 
        iprot.skip(ftype)
10909 
      iprot.readFieldEnd()
10910 
    iprot.readStructEnd()
10911 
 
10912 
  def write(self, oprot):
10913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10915 
      return
10916 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10917 
    if self.success is not None:
2616 chandransh 10918 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10919 
      oprot.writeBool(self.success)
10920 
      oprot.writeFieldEnd()
3431 rajveer 10921 
    if self.ex is not None:
2616 chandransh 10922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10923 
      self.ex.write(oprot)
10924 
      oprot.writeFieldEnd()
10925 
    oprot.writeFieldStop()
10926 
    oprot.writeStructEnd()
10927 
 
3431 rajveer 10928 
  def validate(self):
10929 
    return
10930 
 
10931 
 
2616 chandransh 10932 
  def __repr__(self):
10933 
    L = ['%s=%r' % (key, value)
10934 
      for key, value in self.__dict__.iteritems()]
10935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10936 
 
10937 
  def __eq__(self, other):
10938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10939 
 
10940 
  def __ne__(self, other):
10941 
    return not (self == other)
10942 
 
2690 chandransh 10943 
class getReturnOrders_args:
10944 
  """
10945 
  Attributes:
10946 
   - warehouseId
10947 
   - fromDate
10948 
   - toDate
10949 
  """
2616 chandransh 10950 
 
2690 chandransh 10951 
  thrift_spec = (
10952 
    None, # 0
10953 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10954 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10955 
    (3, TType.I64, 'toDate', None, None, ), # 3
10956 
  )
10957 
 
10958 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10959 
    self.warehouseId = warehouseId
10960 
    self.fromDate = fromDate
10961 
    self.toDate = toDate
10962 
 
10963 
  def read(self, iprot):
10964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10966 
      return
10967 
    iprot.readStructBegin()
10968 
    while True:
10969 
      (fname, ftype, fid) = iprot.readFieldBegin()
10970 
      if ftype == TType.STOP:
10971 
        break
10972 
      if fid == 1:
10973 
        if ftype == TType.I64:
10974 
          self.warehouseId = iprot.readI64();
10975 
        else:
10976 
          iprot.skip(ftype)
10977 
      elif fid == 2:
10978 
        if ftype == TType.I64:
10979 
          self.fromDate = iprot.readI64();
10980 
        else:
10981 
          iprot.skip(ftype)
10982 
      elif fid == 3:
10983 
        if ftype == TType.I64:
10984 
          self.toDate = iprot.readI64();
10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      else:
10988 
        iprot.skip(ftype)
10989 
      iprot.readFieldEnd()
10990 
    iprot.readStructEnd()
10991 
 
10992 
  def write(self, oprot):
10993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10995 
      return
10996 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 10997 
    if self.warehouseId is not None:
2690 chandransh 10998 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10999 
      oprot.writeI64(self.warehouseId)
11000 
      oprot.writeFieldEnd()
3431 rajveer 11001 
    if self.fromDate is not None:
2690 chandransh 11002 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11003 
      oprot.writeI64(self.fromDate)
11004 
      oprot.writeFieldEnd()
3431 rajveer 11005 
    if self.toDate is not None:
2690 chandransh 11006 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11007 
      oprot.writeI64(self.toDate)
11008 
      oprot.writeFieldEnd()
11009 
    oprot.writeFieldStop()
11010 
    oprot.writeStructEnd()
11011 
 
3431 rajveer 11012 
  def validate(self):
11013 
    return
11014 
 
11015 
 
2690 chandransh 11016 
  def __repr__(self):
11017 
    L = ['%s=%r' % (key, value)
11018 
      for key, value in self.__dict__.iteritems()]
11019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11020 
 
11021 
  def __eq__(self, other):
11022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11023 
 
11024 
  def __ne__(self, other):
11025 
    return not (self == other)
11026 
 
11027 
class getReturnOrders_result:
11028 
  """
11029 
  Attributes:
11030 
   - success
11031 
  """
11032 
 
11033 
  thrift_spec = (
11034 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11035 
  )
11036 
 
11037 
  def __init__(self, success=None,):
11038 
    self.success = success
11039 
 
11040 
  def read(self, iprot):
11041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11043 
      return
11044 
    iprot.readStructBegin()
11045 
    while True:
11046 
      (fname, ftype, fid) = iprot.readFieldBegin()
11047 
      if ftype == TType.STOP:
11048 
        break
11049 
      if fid == 0:
11050 
        if ftype == TType.LIST:
11051 
          self.success = []
4133 chandransh 11052 
          (_etype209, _size206) = iprot.readListBegin()
11053 
          for _i210 in xrange(_size206):
11054 
            _elem211 = ReturnOrder()
11055 
            _elem211.read(iprot)
11056 
            self.success.append(_elem211)
2690 chandransh 11057 
          iprot.readListEnd()
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      else:
11061 
        iprot.skip(ftype)
11062 
      iprot.readFieldEnd()
11063 
    iprot.readStructEnd()
11064 
 
11065 
  def write(self, oprot):
11066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11068 
      return
11069 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11070 
    if self.success is not None:
2690 chandransh 11071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11073 
      for iter212 in self.success:
11074 
        iter212.write(oprot)
2690 chandransh 11075 
      oprot.writeListEnd()
11076 
      oprot.writeFieldEnd()
11077 
    oprot.writeFieldStop()
11078 
    oprot.writeStructEnd()
11079 
 
3431 rajveer 11080 
  def validate(self):
11081 
    return
11082 
 
11083 
 
2690 chandransh 11084 
  def __repr__(self):
11085 
    L = ['%s=%r' % (key, value)
11086 
      for key, value in self.__dict__.iteritems()]
11087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11088 
 
11089 
  def __eq__(self, other):
11090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11091 
 
11092 
  def __ne__(self, other):
11093 
    return not (self == other)
11094 
 
2700 chandransh 11095 
class getReturnOrder_args:
11096 
  """
11097 
  Attributes:
11098 
   - id
11099 
  """
11100 
 
11101 
  thrift_spec = (
11102 
    None, # 0
11103 
    (1, TType.I64, 'id', None, None, ), # 1
11104 
  )
11105 
 
11106 
  def __init__(self, id=None,):
11107 
    self.id = id
11108 
 
11109 
  def read(self, iprot):
11110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11112 
      return
11113 
    iprot.readStructBegin()
11114 
    while True:
11115 
      (fname, ftype, fid) = iprot.readFieldBegin()
11116 
      if ftype == TType.STOP:
11117 
        break
11118 
      if fid == 1:
11119 
        if ftype == TType.I64:
11120 
          self.id = iprot.readI64();
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
11132 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11133 
    if self.id is not None:
2700 chandransh 11134 
      oprot.writeFieldBegin('id', TType.I64, 1)
11135 
      oprot.writeI64(self.id)
11136 
      oprot.writeFieldEnd()
11137 
    oprot.writeFieldStop()
11138 
    oprot.writeStructEnd()
11139 
 
3431 rajveer 11140 
  def validate(self):
11141 
    return
11142 
 
11143 
 
2700 chandransh 11144 
  def __repr__(self):
11145 
    L = ['%s=%r' % (key, value)
11146 
      for key, value in self.__dict__.iteritems()]
11147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11148 
 
11149 
  def __eq__(self, other):
11150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11151 
 
11152 
  def __ne__(self, other):
11153 
    return not (self == other)
11154 
 
11155 
class getReturnOrder_result:
11156 
  """
11157 
  Attributes:
11158 
   - success
11159 
   - ex
11160 
  """
11161 
 
11162 
  thrift_spec = (
11163 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11165 
  )
11166 
 
11167 
  def __init__(self, success=None, ex=None,):
11168 
    self.success = success
11169 
    self.ex = ex
11170 
 
11171 
  def read(self, iprot):
11172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11174 
      return
11175 
    iprot.readStructBegin()
11176 
    while True:
11177 
      (fname, ftype, fid) = iprot.readFieldBegin()
11178 
      if ftype == TType.STOP:
11179 
        break
11180 
      if fid == 0:
11181 
        if ftype == TType.STRUCT:
11182 
          self.success = ReturnOrder()
11183 
          self.success.read(iprot)
11184 
        else:
11185 
          iprot.skip(ftype)
11186 
      elif fid == 1:
11187 
        if ftype == TType.STRUCT:
11188 
          self.ex = TransactionServiceException()
11189 
          self.ex.read(iprot)
11190 
        else:
11191 
          iprot.skip(ftype)
11192 
      else:
11193 
        iprot.skip(ftype)
11194 
      iprot.readFieldEnd()
11195 
    iprot.readStructEnd()
11196 
 
11197 
  def write(self, oprot):
11198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11200 
      return
11201 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11202 
    if self.success is not None:
2700 chandransh 11203 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11204 
      self.success.write(oprot)
11205 
      oprot.writeFieldEnd()
3431 rajveer 11206 
    if self.ex is not None:
2700 chandransh 11207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11208 
      self.ex.write(oprot)
11209 
      oprot.writeFieldEnd()
11210 
    oprot.writeFieldStop()
11211 
    oprot.writeStructEnd()
11212 
 
3431 rajveer 11213 
  def validate(self):
11214 
    return
11215 
 
11216 
 
2700 chandransh 11217 
  def __repr__(self):
11218 
    L = ['%s=%r' % (key, value)
11219 
      for key, value in self.__dict__.iteritems()]
11220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11221 
 
11222 
  def __eq__(self, other):
11223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11224 
 
11225 
  def __ne__(self, other):
11226 
    return not (self == other)
11227 
 
2690 chandransh 11228 
class processReturn_args:
11229 
  """
11230 
  Attributes:
11231 
   - returnOrderId
11232 
  """
11233 
 
11234 
  thrift_spec = (
11235 
    None, # 0
11236 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11237 
  )
11238 
 
11239 
  def __init__(self, returnOrderId=None,):
11240 
    self.returnOrderId = returnOrderId
11241 
 
11242 
  def read(self, iprot):
11243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11245 
      return
11246 
    iprot.readStructBegin()
11247 
    while True:
11248 
      (fname, ftype, fid) = iprot.readFieldBegin()
11249 
      if ftype == TType.STOP:
11250 
        break
11251 
      if fid == 1:
11252 
        if ftype == TType.I64:
11253 
          self.returnOrderId = iprot.readI64();
11254 
        else:
11255 
          iprot.skip(ftype)
11256 
      else:
11257 
        iprot.skip(ftype)
11258 
      iprot.readFieldEnd()
11259 
    iprot.readStructEnd()
11260 
 
11261 
  def write(self, oprot):
11262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11264 
      return
11265 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11266 
    if self.returnOrderId is not None:
2690 chandransh 11267 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11268 
      oprot.writeI64(self.returnOrderId)
11269 
      oprot.writeFieldEnd()
11270 
    oprot.writeFieldStop()
11271 
    oprot.writeStructEnd()
11272 
 
3431 rajveer 11273 
  def validate(self):
11274 
    return
11275 
 
11276 
 
2690 chandransh 11277 
  def __repr__(self):
11278 
    L = ['%s=%r' % (key, value)
11279 
      for key, value in self.__dict__.iteritems()]
11280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11281 
 
11282 
  def __eq__(self, other):
11283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11284 
 
11285 
  def __ne__(self, other):
11286 
    return not (self == other)
11287 
 
11288 
class processReturn_result:
11289 
  """
11290 
  Attributes:
11291 
   - ex
11292 
  """
11293 
 
11294 
  thrift_spec = (
11295 
    None, # 0
11296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11297 
  )
11298 
 
11299 
  def __init__(self, ex=None,):
11300 
    self.ex = ex
11301 
 
11302 
  def read(self, iprot):
11303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11305 
      return
11306 
    iprot.readStructBegin()
11307 
    while True:
11308 
      (fname, ftype, fid) = iprot.readFieldBegin()
11309 
      if ftype == TType.STOP:
11310 
        break
11311 
      if fid == 1:
11312 
        if ftype == TType.STRUCT:
11313 
          self.ex = TransactionServiceException()
11314 
          self.ex.read(iprot)
11315 
        else:
11316 
          iprot.skip(ftype)
11317 
      else:
11318 
        iprot.skip(ftype)
11319 
      iprot.readFieldEnd()
11320 
    iprot.readStructEnd()
11321 
 
11322 
  def write(self, oprot):
11323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11325 
      return
11326 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11327 
    if self.ex is not None:
2690 chandransh 11328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11329 
      self.ex.write(oprot)
11330 
      oprot.writeFieldEnd()
11331 
    oprot.writeFieldStop()
11332 
    oprot.writeStructEnd()
11333 
 
3431 rajveer 11334 
  def validate(self):
11335 
    return
11336 
 
11337 
 
2690 chandransh 11338 
  def __repr__(self):
11339 
    L = ['%s=%r' % (key, value)
11340 
      for key, value in self.__dict__.iteritems()]
11341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11342 
 
11343 
  def __eq__(self, other):
11344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11345 
 
11346 
  def __ne__(self, other):
11347 
    return not (self == other)
11348 
 
2819 chandransh 11349 
class createPurchaseOrder_args:
11350 
  """
11351 
  Attributes:
11352 
   - warehouseId
11353 
  """
2690 chandransh 11354 
 
2819 chandransh 11355 
  thrift_spec = (
11356 
    None, # 0
11357 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11358 
  )
11359 
 
11360 
  def __init__(self, warehouseId=None,):
11361 
    self.warehouseId = warehouseId
11362 
 
11363 
  def read(self, iprot):
11364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11366 
      return
11367 
    iprot.readStructBegin()
11368 
    while True:
11369 
      (fname, ftype, fid) = iprot.readFieldBegin()
11370 
      if ftype == TType.STOP:
11371 
        break
11372 
      if fid == 1:
11373 
        if ftype == TType.I64:
11374 
          self.warehouseId = iprot.readI64();
11375 
        else:
11376 
          iprot.skip(ftype)
11377 
      else:
11378 
        iprot.skip(ftype)
11379 
      iprot.readFieldEnd()
11380 
    iprot.readStructEnd()
11381 
 
11382 
  def write(self, oprot):
11383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11385 
      return
11386 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11387 
    if self.warehouseId is not None:
2819 chandransh 11388 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11389 
      oprot.writeI64(self.warehouseId)
11390 
      oprot.writeFieldEnd()
11391 
    oprot.writeFieldStop()
11392 
    oprot.writeStructEnd()
11393 
 
3431 rajveer 11394 
  def validate(self):
11395 
    return
11396 
 
11397 
 
2819 chandransh 11398 
  def __repr__(self):
11399 
    L = ['%s=%r' % (key, value)
11400 
      for key, value in self.__dict__.iteritems()]
11401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11402 
 
11403 
  def __eq__(self, other):
11404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11405 
 
11406 
  def __ne__(self, other):
11407 
    return not (self == other)
11408 
 
11409 
class createPurchaseOrder_result:
11410 
  """
11411 
  Attributes:
11412 
   - success
11413 
   - ex
11414 
  """
11415 
 
11416 
  thrift_spec = (
11417 
    (0, TType.I64, 'success', None, None, ), # 0
11418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11419 
  )
11420 
 
11421 
  def __init__(self, success=None, ex=None,):
11422 
    self.success = success
11423 
    self.ex = ex
11424 
 
11425 
  def read(self, iprot):
11426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11428 
      return
11429 
    iprot.readStructBegin()
11430 
    while True:
11431 
      (fname, ftype, fid) = iprot.readFieldBegin()
11432 
      if ftype == TType.STOP:
11433 
        break
11434 
      if fid == 0:
11435 
        if ftype == TType.I64:
11436 
          self.success = iprot.readI64();
11437 
        else:
11438 
          iprot.skip(ftype)
11439 
      elif fid == 1:
11440 
        if ftype == TType.STRUCT:
11441 
          self.ex = TransactionServiceException()
11442 
          self.ex.read(iprot)
11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
11454 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11455 
    if self.success is not None:
2819 chandransh 11456 
      oprot.writeFieldBegin('success', TType.I64, 0)
11457 
      oprot.writeI64(self.success)
11458 
      oprot.writeFieldEnd()
3431 rajveer 11459 
    if self.ex is not None:
2819 chandransh 11460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11461 
      self.ex.write(oprot)
11462 
      oprot.writeFieldEnd()
11463 
    oprot.writeFieldStop()
11464 
    oprot.writeStructEnd()
11465 
 
3431 rajveer 11466 
  def validate(self):
11467 
    return
11468 
 
11469 
 
2819 chandransh 11470 
  def __repr__(self):
11471 
    L = ['%s=%r' % (key, value)
11472 
      for key, value in self.__dict__.iteritems()]
11473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11474 
 
11475 
  def __eq__(self, other):
11476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11477 
 
11478 
  def __ne__(self, other):
11479 
    return not (self == other)
3451 chandransh 11480 
 
11481 
class updateWeight_args:
11482 
  """
11483 
  Attributes:
11484 
   - orderId
11485 
   - weight
11486 
  """
11487 
 
11488 
  thrift_spec = (
11489 
    None, # 0
11490 
    (1, TType.I64, 'orderId', None, None, ), # 1
11491 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11492 
  )
11493 
 
11494 
  def __init__(self, orderId=None, weight=None,):
11495 
    self.orderId = orderId
11496 
    self.weight = weight
11497 
 
11498 
  def read(self, iprot):
11499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11501 
      return
11502 
    iprot.readStructBegin()
11503 
    while True:
11504 
      (fname, ftype, fid) = iprot.readFieldBegin()
11505 
      if ftype == TType.STOP:
11506 
        break
11507 
      if fid == 1:
11508 
        if ftype == TType.I64:
11509 
          self.orderId = iprot.readI64();
11510 
        else:
11511 
          iprot.skip(ftype)
11512 
      elif fid == 2:
11513 
        if ftype == TType.DOUBLE:
11514 
          self.weight = iprot.readDouble();
11515 
        else:
11516 
          iprot.skip(ftype)
11517 
      else:
11518 
        iprot.skip(ftype)
11519 
      iprot.readFieldEnd()
11520 
    iprot.readStructEnd()
11521 
 
11522 
  def write(self, oprot):
11523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11525 
      return
11526 
    oprot.writeStructBegin('updateWeight_args')
11527 
    if self.orderId is not None:
11528 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11529 
      oprot.writeI64(self.orderId)
11530 
      oprot.writeFieldEnd()
11531 
    if self.weight is not None:
11532 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11533 
      oprot.writeDouble(self.weight)
11534 
      oprot.writeFieldEnd()
11535 
    oprot.writeFieldStop()
11536 
    oprot.writeStructEnd()
11537 
 
11538 
  def validate(self):
11539 
    return
11540 
 
11541 
 
11542 
  def __repr__(self):
11543 
    L = ['%s=%r' % (key, value)
11544 
      for key, value in self.__dict__.iteritems()]
11545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11546 
 
11547 
  def __eq__(self, other):
11548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11549 
 
11550 
  def __ne__(self, other):
11551 
    return not (self == other)
11552 
 
11553 
class updateWeight_result:
11554 
  """
11555 
  Attributes:
11556 
   - success
11557 
   - ex
11558 
  """
11559 
 
11560 
  thrift_spec = (
11561 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11562 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11563 
  )
11564 
 
11565 
  def __init__(self, success=None, ex=None,):
11566 
    self.success = success
11567 
    self.ex = ex
11568 
 
11569 
  def read(self, iprot):
11570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11572 
      return
11573 
    iprot.readStructBegin()
11574 
    while True:
11575 
      (fname, ftype, fid) = iprot.readFieldBegin()
11576 
      if ftype == TType.STOP:
11577 
        break
11578 
      if fid == 0:
11579 
        if ftype == TType.STRUCT:
11580 
          self.success = Order()
11581 
          self.success.read(iprot)
11582 
        else:
11583 
          iprot.skip(ftype)
11584 
      elif fid == 1:
11585 
        if ftype == TType.STRUCT:
11586 
          self.ex = TransactionServiceException()
11587 
          self.ex.read(iprot)
11588 
        else:
11589 
          iprot.skip(ftype)
11590 
      else:
11591 
        iprot.skip(ftype)
11592 
      iprot.readFieldEnd()
11593 
    iprot.readStructEnd()
11594 
 
11595 
  def write(self, oprot):
11596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11598 
      return
11599 
    oprot.writeStructBegin('updateWeight_result')
11600 
    if self.success is not None:
11601 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11602 
      self.success.write(oprot)
11603 
      oprot.writeFieldEnd()
11604 
    if self.ex is not None:
11605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11606 
      self.ex.write(oprot)
11607 
      oprot.writeFieldEnd()
11608 
    oprot.writeFieldStop()
11609 
    oprot.writeStructEnd()
11610 
 
11611 
  def validate(self):
11612 
    return
11613 
 
11614 
 
11615 
  def __repr__(self):
11616 
    L = ['%s=%r' % (key, value)
11617 
      for key, value in self.__dict__.iteritems()]
11618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11619 
 
11620 
  def __eq__(self, other):
11621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11622 
 
11623 
  def __ne__(self, other):
11624 
    return not (self == other)
3469 chandransh 11625 
 
11626 
class changeItem_args:
11627 
  """
11628 
  Attributes:
11629 
   - orderId
11630 
   - itemId
11631 
  """
11632 
 
11633 
  thrift_spec = (
11634 
    None, # 0
11635 
    (1, TType.I64, 'orderId', None, None, ), # 1
11636 
    (2, TType.I64, 'itemId', None, None, ), # 2
11637 
  )
11638 
 
11639 
  def __init__(self, orderId=None, itemId=None,):
11640 
    self.orderId = orderId
11641 
    self.itemId = itemId
11642 
 
11643 
  def read(self, iprot):
11644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11646 
      return
11647 
    iprot.readStructBegin()
11648 
    while True:
11649 
      (fname, ftype, fid) = iprot.readFieldBegin()
11650 
      if ftype == TType.STOP:
11651 
        break
11652 
      if fid == 1:
11653 
        if ftype == TType.I64:
11654 
          self.orderId = iprot.readI64();
11655 
        else:
11656 
          iprot.skip(ftype)
11657 
      elif fid == 2:
11658 
        if ftype == TType.I64:
11659 
          self.itemId = iprot.readI64();
11660 
        else:
11661 
          iprot.skip(ftype)
11662 
      else:
11663 
        iprot.skip(ftype)
11664 
      iprot.readFieldEnd()
11665 
    iprot.readStructEnd()
11666 
 
11667 
  def write(self, oprot):
11668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11670 
      return
11671 
    oprot.writeStructBegin('changeItem_args')
11672 
    if self.orderId is not None:
11673 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11674 
      oprot.writeI64(self.orderId)
11675 
      oprot.writeFieldEnd()
11676 
    if self.itemId is not None:
11677 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11678 
      oprot.writeI64(self.itemId)
11679 
      oprot.writeFieldEnd()
11680 
    oprot.writeFieldStop()
11681 
    oprot.writeStructEnd()
11682 
 
11683 
  def validate(self):
11684 
    return
11685 
 
11686 
 
11687 
  def __repr__(self):
11688 
    L = ['%s=%r' % (key, value)
11689 
      for key, value in self.__dict__.iteritems()]
11690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11691 
 
11692 
  def __eq__(self, other):
11693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11694 
 
11695 
  def __ne__(self, other):
11696 
    return not (self == other)
11697 
 
11698 
class changeItem_result:
11699 
  """
11700 
  Attributes:
11701 
   - success
11702 
   - ex
11703 
  """
11704 
 
11705 
  thrift_spec = (
11706 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11708 
  )
11709 
 
11710 
  def __init__(self, success=None, ex=None,):
11711 
    self.success = success
11712 
    self.ex = ex
11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 0:
11724 
        if ftype == TType.STRUCT:
11725 
          self.success = Order()
11726 
          self.success.read(iprot)
11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      elif fid == 1:
11730 
        if ftype == TType.STRUCT:
11731 
          self.ex = TransactionServiceException()
11732 
          self.ex.read(iprot)
11733 
        else:
11734 
          iprot.skip(ftype)
11735 
      else:
11736 
        iprot.skip(ftype)
11737 
      iprot.readFieldEnd()
11738 
    iprot.readStructEnd()
11739 
 
11740 
  def write(self, oprot):
11741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11743 
      return
11744 
    oprot.writeStructBegin('changeItem_result')
11745 
    if self.success is not None:
11746 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11747 
      self.success.write(oprot)
11748 
      oprot.writeFieldEnd()
11749 
    if self.ex is not None:
11750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11751 
      self.ex.write(oprot)
11752 
      oprot.writeFieldEnd()
11753 
    oprot.writeFieldStop()
11754 
    oprot.writeStructEnd()
11755 
 
11756 
  def validate(self):
11757 
    return
11758 
 
11759 
 
11760 
  def __repr__(self):
11761 
    L = ['%s=%r' % (key, value)
11762 
      for key, value in self.__dict__.iteritems()]
11763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11764 
 
11765 
  def __eq__(self, other):
11766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11767 
 
11768 
  def __ne__(self, other):
11769 
    return not (self == other)
11770 
 
11771 
class shiftToWarehouse_args:
11772 
  """
11773 
  Attributes:
11774 
   - orderId
11775 
   - warehouseId
11776 
  """
11777 
 
11778 
  thrift_spec = (
11779 
    None, # 0
11780 
    (1, TType.I64, 'orderId', None, None, ), # 1
11781 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11782 
  )
11783 
 
11784 
  def __init__(self, orderId=None, warehouseId=None,):
11785 
    self.orderId = orderId
11786 
    self.warehouseId = warehouseId
11787 
 
11788 
  def read(self, iprot):
11789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11791 
      return
11792 
    iprot.readStructBegin()
11793 
    while True:
11794 
      (fname, ftype, fid) = iprot.readFieldBegin()
11795 
      if ftype == TType.STOP:
11796 
        break
11797 
      if fid == 1:
11798 
        if ftype == TType.I64:
11799 
          self.orderId = iprot.readI64();
11800 
        else:
11801 
          iprot.skip(ftype)
11802 
      elif fid == 2:
11803 
        if ftype == TType.I64:
11804 
          self.warehouseId = iprot.readI64();
11805 
        else:
11806 
          iprot.skip(ftype)
11807 
      else:
11808 
        iprot.skip(ftype)
11809 
      iprot.readFieldEnd()
11810 
    iprot.readStructEnd()
11811 
 
11812 
  def write(self, oprot):
11813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11815 
      return
11816 
    oprot.writeStructBegin('shiftToWarehouse_args')
11817 
    if self.orderId is not None:
11818 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11819 
      oprot.writeI64(self.orderId)
11820 
      oprot.writeFieldEnd()
11821 
    if self.warehouseId is not None:
11822 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11823 
      oprot.writeI64(self.warehouseId)
11824 
      oprot.writeFieldEnd()
11825 
    oprot.writeFieldStop()
11826 
    oprot.writeStructEnd()
11827 
 
11828 
  def validate(self):
11829 
    return
11830 
 
11831 
 
11832 
  def __repr__(self):
11833 
    L = ['%s=%r' % (key, value)
11834 
      for key, value in self.__dict__.iteritems()]
11835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11836 
 
11837 
  def __eq__(self, other):
11838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11839 
 
11840 
  def __ne__(self, other):
11841 
    return not (self == other)
11842 
 
11843 
class shiftToWarehouse_result:
11844 
  """
11845 
  Attributes:
11846 
   - success
11847 
   - ex
11848 
  """
11849 
 
11850 
  thrift_spec = (
11851 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11853 
  )
11854 
 
11855 
  def __init__(self, success=None, ex=None,):
11856 
    self.success = success
11857 
    self.ex = ex
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 == 0:
11869 
        if ftype == TType.STRUCT:
11870 
          self.success = Order()
11871 
          self.success.read(iprot)
11872 
        else:
11873 
          iprot.skip(ftype)
11874 
      elif fid == 1:
11875 
        if ftype == TType.STRUCT:
11876 
          self.ex = TransactionServiceException()
11877 
          self.ex.read(iprot)
11878 
        else:
11879 
          iprot.skip(ftype)
11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
11889 
    oprot.writeStructBegin('shiftToWarehouse_result')
11890 
    if self.success is not None:
11891 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11892 
      self.success.write(oprot)
11893 
      oprot.writeFieldEnd()
11894 
    if self.ex is not None:
11895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11896 
      self.ex.write(oprot)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
3553 chandransh 11915 
 
11916 
class addDelayReason_args:
11917 
  """
11918 
  Attributes:
11919 
   - orderId
11920 
   - delayReason
3986 chandransh 11921 
   - furtherDelay
3553 chandransh 11922 
  """
11923 
 
11924 
  thrift_spec = (
11925 
    None, # 0
11926 
    (1, TType.I64, 'orderId', None, None, ), # 1
11927 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11928 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11929 
  )
11930 
 
3986 chandransh 11931 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 11932 
    self.orderId = orderId
11933 
    self.delayReason = delayReason
3986 chandransh 11934 
    self.furtherDelay = furtherDelay
3553 chandransh 11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
11945 
      if fid == 1:
11946 
        if ftype == TType.I64:
11947 
          self.orderId = iprot.readI64();
11948 
        else:
11949 
          iprot.skip(ftype)
11950 
      elif fid == 2:
11951 
        if ftype == TType.I32:
11952 
          self.delayReason = iprot.readI32();
11953 
        else:
11954 
          iprot.skip(ftype)
3986 chandransh 11955 
      elif fid == 3:
11956 
        if ftype == TType.I64:
11957 
          self.furtherDelay = iprot.readI64();
11958 
        else:
11959 
          iprot.skip(ftype)
3553 chandransh 11960 
      else:
11961 
        iprot.skip(ftype)
11962 
      iprot.readFieldEnd()
11963 
    iprot.readStructEnd()
11964 
 
11965 
  def write(self, oprot):
11966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11968 
      return
11969 
    oprot.writeStructBegin('addDelayReason_args')
11970 
    if self.orderId is not None:
11971 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11972 
      oprot.writeI64(self.orderId)
11973 
      oprot.writeFieldEnd()
11974 
    if self.delayReason is not None:
11975 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11976 
      oprot.writeI32(self.delayReason)
11977 
      oprot.writeFieldEnd()
3986 chandransh 11978 
    if self.furtherDelay is not None:
11979 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
11980 
      oprot.writeI64(self.furtherDelay)
11981 
      oprot.writeFieldEnd()
3553 chandransh 11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
12000 
class addDelayReason_result:
12001 
  """
12002 
  Attributes:
12003 
   - success
12004 
   - ex
12005 
  """
12006 
 
12007 
  thrift_spec = (
12008 
    (0, TType.BOOL, 'success', None, None, ), # 0
12009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12010 
  )
12011 
 
12012 
  def __init__(self, success=None, ex=None,):
12013 
    self.success = success
12014 
    self.ex = ex
12015 
 
12016 
  def read(self, iprot):
12017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12019 
      return
12020 
    iprot.readStructBegin()
12021 
    while True:
12022 
      (fname, ftype, fid) = iprot.readFieldBegin()
12023 
      if ftype == TType.STOP:
12024 
        break
12025 
      if fid == 0:
12026 
        if ftype == TType.BOOL:
12027 
          self.success = iprot.readBool();
12028 
        else:
12029 
          iprot.skip(ftype)
12030 
      elif fid == 1:
12031 
        if ftype == TType.STRUCT:
12032 
          self.ex = TransactionServiceException()
12033 
          self.ex.read(iprot)
12034 
        else:
12035 
          iprot.skip(ftype)
12036 
      else:
12037 
        iprot.skip(ftype)
12038 
      iprot.readFieldEnd()
12039 
    iprot.readStructEnd()
12040 
 
12041 
  def write(self, oprot):
12042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12044 
      return
12045 
    oprot.writeStructBegin('addDelayReason_result')
12046 
    if self.success is not None:
12047 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12048 
      oprot.writeBool(self.success)
12049 
      oprot.writeFieldEnd()
12050 
    if self.ex is not None:
12051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12052 
      self.ex.write(oprot)
12053 
      oprot.writeFieldEnd()
12054 
    oprot.writeFieldStop()
12055 
    oprot.writeStructEnd()
12056 
 
12057 
  def validate(self):
12058 
    return
12059 
 
12060 
 
12061 
  def __repr__(self):
12062 
    L = ['%s=%r' % (key, value)
12063 
      for key, value in self.__dict__.iteritems()]
12064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12065 
 
12066 
  def __eq__(self, other):
12067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12068 
 
12069 
  def __ne__(self, other):
12070 
    return not (self == other)
3956 chandransh 12071 
 
12072 
class reconcileCodCollection_args:
12073 
  """
12074 
  Attributes:
12075 
   - collectedAmountMap
12076 
   - xferBy
12077 
   - xferTxnId
12078 
   - xferDate
12079 
  """
12080 
 
12081 
  thrift_spec = (
12082 
    None, # 0
12083 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12084 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12085 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12086 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12087 
  )
12088 
 
12089 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12090 
    self.collectedAmountMap = collectedAmountMap
12091 
    self.xferBy = xferBy
12092 
    self.xferTxnId = xferTxnId
12093 
    self.xferDate = xferDate
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 1:
12105 
        if ftype == TType.MAP:
12106 
          self.collectedAmountMap = {}
4133 chandransh 12107 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12108 
          for _i217 in xrange(_size213):
12109 
            _key218 = iprot.readString();
12110 
            _val219 = iprot.readDouble();
12111 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12112 
          iprot.readMapEnd()
12113 
        else:
12114 
          iprot.skip(ftype)
12115 
      elif fid == 2:
12116 
        if ftype == TType.STRING:
12117 
          self.xferBy = iprot.readString();
12118 
        else:
12119 
          iprot.skip(ftype)
12120 
      elif fid == 3:
12121 
        if ftype == TType.STRING:
12122 
          self.xferTxnId = iprot.readString();
12123 
        else:
12124 
          iprot.skip(ftype)
12125 
      elif fid == 4:
12126 
        if ftype == TType.I64:
12127 
          self.xferDate = iprot.readI64();
12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      else:
12131 
        iprot.skip(ftype)
12132 
      iprot.readFieldEnd()
12133 
    iprot.readStructEnd()
12134 
 
12135 
  def write(self, oprot):
12136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12138 
      return
12139 
    oprot.writeStructBegin('reconcileCodCollection_args')
12140 
    if self.collectedAmountMap is not None:
12141 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12142 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12143 
      for kiter220,viter221 in self.collectedAmountMap.items():
12144 
        oprot.writeString(kiter220)
12145 
        oprot.writeDouble(viter221)
3956 chandransh 12146 
      oprot.writeMapEnd()
12147 
      oprot.writeFieldEnd()
12148 
    if self.xferBy is not None:
12149 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12150 
      oprot.writeString(self.xferBy)
12151 
      oprot.writeFieldEnd()
12152 
    if self.xferTxnId is not None:
12153 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12154 
      oprot.writeString(self.xferTxnId)
12155 
      oprot.writeFieldEnd()
12156 
    if self.xferDate is not None:
12157 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12158 
      oprot.writeI64(self.xferDate)
12159 
      oprot.writeFieldEnd()
12160 
    oprot.writeFieldStop()
12161 
    oprot.writeStructEnd()
12162 
 
12163 
  def validate(self):
12164 
    return
12165 
 
12166 
 
12167 
  def __repr__(self):
12168 
    L = ['%s=%r' % (key, value)
12169 
      for key, value in self.__dict__.iteritems()]
12170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12171 
 
12172 
  def __eq__(self, other):
12173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12174 
 
12175 
  def __ne__(self, other):
12176 
    return not (self == other)
12177 
 
12178 
class reconcileCodCollection_result:
12179 
  """
12180 
  Attributes:
12181 
   - success
12182 
   - ex
12183 
  """
12184 
 
12185 
  thrift_spec = (
12186 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12188 
  )
12189 
 
12190 
  def __init__(self, success=None, ex=None,):
12191 
    self.success = success
12192 
    self.ex = ex
12193 
 
12194 
  def read(self, iprot):
12195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12197 
      return
12198 
    iprot.readStructBegin()
12199 
    while True:
12200 
      (fname, ftype, fid) = iprot.readFieldBegin()
12201 
      if ftype == TType.STOP:
12202 
        break
12203 
      if fid == 0:
12204 
        if ftype == TType.MAP:
12205 
          self.success = {}
4133 chandransh 12206 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12207 
          for _i226 in xrange(_size222):
12208 
            _key227 = iprot.readString();
12209 
            _val228 = iprot.readString();
12210 
            self.success[_key227] = _val228
3956 chandransh 12211 
          iprot.readMapEnd()
12212 
        else:
12213 
          iprot.skip(ftype)
12214 
      elif fid == 1:
12215 
        if ftype == TType.STRUCT:
12216 
          self.ex = TransactionServiceException()
12217 
          self.ex.read(iprot)
12218 
        else:
12219 
          iprot.skip(ftype)
12220 
      else:
12221 
        iprot.skip(ftype)
12222 
      iprot.readFieldEnd()
12223 
    iprot.readStructEnd()
12224 
 
12225 
  def write(self, oprot):
12226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12228 
      return
12229 
    oprot.writeStructBegin('reconcileCodCollection_result')
12230 
    if self.success is not None:
12231 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12232 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12233 
      for kiter229,viter230 in self.success.items():
12234 
        oprot.writeString(kiter229)
12235 
        oprot.writeString(viter230)
3956 chandransh 12236 
      oprot.writeMapEnd()
12237 
      oprot.writeFieldEnd()
12238 
    if self.ex is not None:
12239 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12240 
      self.ex.write(oprot)
12241 
      oprot.writeFieldEnd()
12242 
    oprot.writeFieldStop()
12243 
    oprot.writeStructEnd()
12244 
 
12245 
  def validate(self):
12246 
    return
12247 
 
12248 
 
12249 
  def __repr__(self):
12250 
    L = ['%s=%r' % (key, value)
12251 
      for key, value in self.__dict__.iteritems()]
12252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12253 
 
12254 
  def __eq__(self, other):
12255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12256 
 
12257 
  def __ne__(self, other):
12258 
    return not (self == other)
4008 mandeep.dh 12259 
 
12260 
class getTransactionsRequiringExtraProcessing_args:
12261 
  """
12262 
  Attributes:
12263 
   - category
12264 
  """
12265 
 
12266 
  thrift_spec = (
12267 
    None, # 0
12268 
    (1, TType.I32, 'category', None, None, ), # 1
12269 
  )
12270 
 
12271 
  def __init__(self, category=None,):
12272 
    self.category = category
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      if fid == 1:
12284 
        if ftype == TType.I32:
12285 
          self.category = iprot.readI32();
12286 
        else:
12287 
          iprot.skip(ftype)
12288 
      else:
12289 
        iprot.skip(ftype)
12290 
      iprot.readFieldEnd()
12291 
    iprot.readStructEnd()
12292 
 
12293 
  def write(self, oprot):
12294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12296 
      return
12297 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12298 
    if self.category is not None:
12299 
      oprot.writeFieldBegin('category', TType.I32, 1)
12300 
      oprot.writeI32(self.category)
12301 
      oprot.writeFieldEnd()
12302 
    oprot.writeFieldStop()
12303 
    oprot.writeStructEnd()
12304 
 
12305 
  def validate(self):
12306 
    return
12307 
 
12308 
 
12309 
  def __repr__(self):
12310 
    L = ['%s=%r' % (key, value)
12311 
      for key, value in self.__dict__.iteritems()]
12312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12313 
 
12314 
  def __eq__(self, other):
12315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12316 
 
12317 
  def __ne__(self, other):
12318 
    return not (self == other)
12319 
 
12320 
class getTransactionsRequiringExtraProcessing_result:
12321 
  """
12322 
  Attributes:
12323 
   - success
12324 
  """
12325 
 
12326 
  thrift_spec = (
12327 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12328 
  )
12329 
 
12330 
  def __init__(self, success=None,):
12331 
    self.success = success
12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 0:
12343 
        if ftype == TType.LIST:
12344 
          self.success = []
4133 chandransh 12345 
          (_etype234, _size231) = iprot.readListBegin()
12346 
          for _i235 in xrange(_size231):
12347 
            _elem236 = iprot.readI64();
12348 
            self.success.append(_elem236)
4008 mandeep.dh 12349 
          iprot.readListEnd()
12350 
        else:
12351 
          iprot.skip(ftype)
12352 
      else:
12353 
        iprot.skip(ftype)
12354 
      iprot.readFieldEnd()
12355 
    iprot.readStructEnd()
12356 
 
12357 
  def write(self, oprot):
12358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12360 
      return
12361 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12362 
    if self.success is not None:
12363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12364 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12365 
      for iter237 in self.success:
12366 
        oprot.writeI64(iter237)
4008 mandeep.dh 12367 
      oprot.writeListEnd()
12368 
      oprot.writeFieldEnd()
12369 
    oprot.writeFieldStop()
12370 
    oprot.writeStructEnd()
12371 
 
12372 
  def validate(self):
12373 
    return
12374 
 
12375 
 
12376 
  def __repr__(self):
12377 
    L = ['%s=%r' % (key, value)
12378 
      for key, value in self.__dict__.iteritems()]
12379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12380 
 
12381 
  def __eq__(self, other):
12382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12383 
 
12384 
  def __ne__(self, other):
12385 
    return not (self == other)
12386 
 
12387 
class markTransactionAsProcessed_args:
12388 
  """
12389 
  Attributes:
12390 
   - transactionId
12391 
   - category
12392 
  """
12393 
 
12394 
  thrift_spec = (
12395 
    None, # 0
12396 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12397 
    (2, TType.I32, 'category', None, None, ), # 2
12398 
  )
12399 
 
12400 
  def __init__(self, transactionId=None, category=None,):
12401 
    self.transactionId = transactionId
12402 
    self.category = category
12403 
 
12404 
  def read(self, iprot):
12405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12407 
      return
12408 
    iprot.readStructBegin()
12409 
    while True:
12410 
      (fname, ftype, fid) = iprot.readFieldBegin()
12411 
      if ftype == TType.STOP:
12412 
        break
12413 
      if fid == 1:
12414 
        if ftype == TType.I64:
12415 
          self.transactionId = iprot.readI64();
12416 
        else:
12417 
          iprot.skip(ftype)
12418 
      elif fid == 2:
12419 
        if ftype == TType.I32:
12420 
          self.category = iprot.readI32();
12421 
        else:
12422 
          iprot.skip(ftype)
12423 
      else:
12424 
        iprot.skip(ftype)
12425 
      iprot.readFieldEnd()
12426 
    iprot.readStructEnd()
12427 
 
12428 
  def write(self, oprot):
12429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12431 
      return
12432 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12433 
    if self.transactionId is not None:
12434 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12435 
      oprot.writeI64(self.transactionId)
12436 
      oprot.writeFieldEnd()
12437 
    if self.category is not None:
12438 
      oprot.writeFieldBegin('category', TType.I32, 2)
12439 
      oprot.writeI32(self.category)
12440 
      oprot.writeFieldEnd()
12441 
    oprot.writeFieldStop()
12442 
    oprot.writeStructEnd()
12443 
 
12444 
  def validate(self):
12445 
    return
12446 
 
12447 
 
12448 
  def __repr__(self):
12449 
    L = ['%s=%r' % (key, value)
12450 
      for key, value in self.__dict__.iteritems()]
12451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12452 
 
12453 
  def __eq__(self, other):
12454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12455 
 
12456 
  def __ne__(self, other):
12457 
    return not (self == other)
12458 
 
12459 
class markTransactionAsProcessed_result:
12460 
 
12461 
  thrift_spec = (
12462 
  )
12463 
 
12464 
  def read(self, iprot):
12465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12467 
      return
12468 
    iprot.readStructBegin()
12469 
    while True:
12470 
      (fname, ftype, fid) = iprot.readFieldBegin()
12471 
      if ftype == TType.STOP:
12472 
        break
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12483 
    oprot.writeFieldStop()
12484 
    oprot.writeStructEnd()
12485 
 
12486 
  def validate(self):
12487 
    return
12488 
 
12489 
 
12490 
  def __repr__(self):
12491 
    L = ['%s=%r' % (key, value)
12492 
      for key, value in self.__dict__.iteritems()]
12493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12494 
 
12495 
  def __eq__(self, other):
12496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12497 
 
12498 
  def __ne__(self, other):
12499 
    return not (self == other)
4018 chandransh 12500 
 
12501 
class getItemWiseRiskyOrdersCount_args:
12502 
 
12503 
  thrift_spec = (
12504 
  )
12505 
 
12506 
  def read(self, iprot):
12507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12509 
      return
12510 
    iprot.readStructBegin()
12511 
    while True:
12512 
      (fname, ftype, fid) = iprot.readFieldBegin()
12513 
      if ftype == TType.STOP:
12514 
        break
12515 
      else:
12516 
        iprot.skip(ftype)
12517 
      iprot.readFieldEnd()
12518 
    iprot.readStructEnd()
12519 
 
12520 
  def write(self, oprot):
12521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12523 
      return
12524 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12525 
    oprot.writeFieldStop()
12526 
    oprot.writeStructEnd()
12527 
 
12528 
  def validate(self):
12529 
    return
12530 
 
12531 
 
12532 
  def __repr__(self):
12533 
    L = ['%s=%r' % (key, value)
12534 
      for key, value in self.__dict__.iteritems()]
12535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12536 
 
12537 
  def __eq__(self, other):
12538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12539 
 
12540 
  def __ne__(self, other):
12541 
    return not (self == other)
12542 
 
12543 
class getItemWiseRiskyOrdersCount_result:
12544 
  """
12545 
  Attributes:
12546 
   - success
12547 
  """
12548 
 
12549 
  thrift_spec = (
12550 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12551 
  )
12552 
 
12553 
  def __init__(self, success=None,):
12554 
    self.success = success
12555 
 
12556 
  def read(self, iprot):
12557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12559 
      return
12560 
    iprot.readStructBegin()
12561 
    while True:
12562 
      (fname, ftype, fid) = iprot.readFieldBegin()
12563 
      if ftype == TType.STOP:
12564 
        break
12565 
      if fid == 0:
12566 
        if ftype == TType.MAP:
12567 
          self.success = {}
4133 chandransh 12568 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12569 
          for _i242 in xrange(_size238):
12570 
            _key243 = iprot.readI64();
12571 
            _val244 = iprot.readI64();
12572 
            self.success[_key243] = _val244
4018 chandransh 12573 
          iprot.readMapEnd()
12574 
        else:
12575 
          iprot.skip(ftype)
12576 
      else:
12577 
        iprot.skip(ftype)
12578 
      iprot.readFieldEnd()
12579 
    iprot.readStructEnd()
12580 
 
12581 
  def write(self, oprot):
12582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12584 
      return
12585 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12586 
    if self.success is not None:
12587 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12588 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12589 
      for kiter245,viter246 in self.success.items():
12590 
        oprot.writeI64(kiter245)
12591 
        oprot.writeI64(viter246)
4018 chandransh 12592 
      oprot.writeMapEnd()
12593 
      oprot.writeFieldEnd()
12594 
    oprot.writeFieldStop()
12595 
    oprot.writeStructEnd()
12596 
 
12597 
  def validate(self):
12598 
    return
12599 
 
12600 
 
12601 
  def __repr__(self):
12602 
    L = ['%s=%r' % (key, value)
12603 
      for key, value in self.__dict__.iteritems()]
12604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12605 
 
12606 
  def __eq__(self, other):
12607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12608 
 
12609 
  def __ne__(self, other):
12610 
    return not (self == other)
4247 rajveer 12611 
 
4295 varun.gupt 12612 
class getOrdersForItemIds_args:
12613 
  """
12614 
  Attributes:
12615 
   - itemIds
12616 
  """
12617 
 
12618 
  thrift_spec = (
12619 
    None, # 0
12620 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12621 
  )
12622 
 
12623 
  def __init__(self, itemIds=None,):
12624 
    self.itemIds = itemIds
12625 
 
12626 
  def read(self, iprot):
12627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12629 
      return
12630 
    iprot.readStructBegin()
12631 
    while True:
12632 
      (fname, ftype, fid) = iprot.readFieldBegin()
12633 
      if ftype == TType.STOP:
12634 
        break
12635 
      if fid == 1:
12636 
        if ftype == TType.LIST:
12637 
          self.itemIds = []
12638 
          (_etype250, _size247) = iprot.readListBegin()
12639 
          for _i251 in xrange(_size247):
12640 
            _elem252 = iprot.readI64();
12641 
            self.itemIds.append(_elem252)
12642 
          iprot.readListEnd()
12643 
        else:
12644 
          iprot.skip(ftype)
12645 
      else:
12646 
        iprot.skip(ftype)
12647 
      iprot.readFieldEnd()
12648 
    iprot.readStructEnd()
12649 
 
12650 
  def write(self, oprot):
12651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12653 
      return
12654 
    oprot.writeStructBegin('getOrdersForItemIds_args')
12655 
    if self.itemIds is not None:
12656 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12657 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12658 
      for iter253 in self.itemIds:
12659 
        oprot.writeI64(iter253)
12660 
      oprot.writeListEnd()
12661 
      oprot.writeFieldEnd()
12662 
    oprot.writeFieldStop()
12663 
    oprot.writeStructEnd()
12664 
 
12665 
  def validate(self):
12666 
    return
12667 
 
12668 
 
12669 
  def __repr__(self):
12670 
    L = ['%s=%r' % (key, value)
12671 
      for key, value in self.__dict__.iteritems()]
12672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12673 
 
12674 
  def __eq__(self, other):
12675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12676 
 
12677 
  def __ne__(self, other):
12678 
    return not (self == other)
12679 
 
12680 
class getOrdersForItemIds_result:
12681 
  """
12682 
  Attributes:
12683 
   - success
12684 
  """
12685 
 
12686 
  thrift_spec = (
12687 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12688 
  )
12689 
 
12690 
  def __init__(self, success=None,):
12691 
    self.success = success
12692 
 
12693 
  def read(self, iprot):
12694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12696 
      return
12697 
    iprot.readStructBegin()
12698 
    while True:
12699 
      (fname, ftype, fid) = iprot.readFieldBegin()
12700 
      if ftype == TType.STOP:
12701 
        break
12702 
      if fid == 0:
12703 
        if ftype == TType.LIST:
12704 
          self.success = []
12705 
          (_etype257, _size254) = iprot.readListBegin()
12706 
          for _i258 in xrange(_size254):
12707 
            _elem259 = Order()
12708 
            _elem259.read(iprot)
12709 
            self.success.append(_elem259)
12710 
          iprot.readListEnd()
12711 
        else:
12712 
          iprot.skip(ftype)
12713 
      else:
12714 
        iprot.skip(ftype)
12715 
      iprot.readFieldEnd()
12716 
    iprot.readStructEnd()
12717 
 
12718 
  def write(self, oprot):
12719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12721 
      return
12722 
    oprot.writeStructBegin('getOrdersForItemIds_result')
12723 
    if self.success is not None:
12724 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12725 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12726 
      for iter260 in self.success:
12727 
        iter260.write(oprot)
12728 
      oprot.writeListEnd()
12729 
      oprot.writeFieldEnd()
12730 
    oprot.writeFieldStop()
12731 
    oprot.writeStructEnd()
12732 
 
12733 
  def validate(self):
12734 
    return
12735 
 
12736 
 
12737 
  def __repr__(self):
12738 
    L = ['%s=%r' % (key, value)
12739 
      for key, value in self.__dict__.iteritems()]
12740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12741 
 
12742 
  def __eq__(self, other):
12743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12744 
 
12745 
  def __ne__(self, other):
12746 
    return not (self == other)
12747 
 
4247 rajveer 12748 
class markOrderCancellationRequestReceived_args:
12749 
  """
12750 
  Attributes:
12751 
   - orderId
12752 
  """
12753 
 
12754 
  thrift_spec = (
12755 
    None, # 0
12756 
    (1, TType.I64, 'orderId', None, None, ), # 1
12757 
  )
12758 
 
12759 
  def __init__(self, orderId=None,):
12760 
    self.orderId = orderId
12761 
 
12762 
  def read(self, iprot):
12763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12765 
      return
12766 
    iprot.readStructBegin()
12767 
    while True:
12768 
      (fname, ftype, fid) = iprot.readFieldBegin()
12769 
      if ftype == TType.STOP:
12770 
        break
12771 
      if fid == 1:
12772 
        if ftype == TType.I64:
12773 
          self.orderId = iprot.readI64();
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      else:
12777 
        iprot.skip(ftype)
12778 
      iprot.readFieldEnd()
12779 
    iprot.readStructEnd()
12780 
 
12781 
  def write(self, oprot):
12782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12784 
      return
12785 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12786 
    if self.orderId is not None:
12787 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12788 
      oprot.writeI64(self.orderId)
12789 
      oprot.writeFieldEnd()
12790 
    oprot.writeFieldStop()
12791 
    oprot.writeStructEnd()
12792 
 
12793 
  def validate(self):
12794 
    return
12795 
 
12796 
 
12797 
  def __repr__(self):
12798 
    L = ['%s=%r' % (key, value)
12799 
      for key, value in self.__dict__.iteritems()]
12800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12801 
 
12802 
  def __eq__(self, other):
12803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12804 
 
12805 
  def __ne__(self, other):
12806 
    return not (self == other)
12807 
 
12808 
class markOrderCancellationRequestReceived_result:
12809 
  """
12810 
  Attributes:
12811 
   - ex
12812 
  """
12813 
 
12814 
  thrift_spec = (
12815 
    None, # 0
12816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12817 
  )
12818 
 
12819 
  def __init__(self, ex=None,):
12820 
    self.ex = ex
12821 
 
12822 
  def read(self, iprot):
12823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12825 
      return
12826 
    iprot.readStructBegin()
12827 
    while True:
12828 
      (fname, ftype, fid) = iprot.readFieldBegin()
12829 
      if ftype == TType.STOP:
12830 
        break
12831 
      if fid == 1:
12832 
        if ftype == TType.STRUCT:
12833 
          self.ex = TransactionServiceException()
12834 
          self.ex.read(iprot)
12835 
        else:
12836 
          iprot.skip(ftype)
12837 
      else:
12838 
        iprot.skip(ftype)
12839 
      iprot.readFieldEnd()
12840 
    iprot.readStructEnd()
12841 
 
12842 
  def write(self, oprot):
12843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12845 
      return
12846 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12847 
    if self.ex is not None:
12848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12849 
      self.ex.write(oprot)
12850 
      oprot.writeFieldEnd()
12851 
    oprot.writeFieldStop()
12852 
    oprot.writeStructEnd()
12853 
 
12854 
  def validate(self):
12855 
    return
12856 
 
12857 
 
12858 
  def __repr__(self):
12859 
    L = ['%s=%r' % (key, value)
12860 
      for key, value in self.__dict__.iteritems()]
12861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12862 
 
12863 
  def __eq__(self, other):
12864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12865 
 
12866 
  def __ne__(self, other):
12867 
    return not (self == other)
12868 
 
12869 
class markOrderCancellationRequestConfirmed_args:
12870 
  """
12871 
  Attributes:
12872 
   - orderId
12873 
  """
12874 
 
12875 
  thrift_spec = (
12876 
    None, # 0
12877 
    (1, TType.I64, 'orderId', None, None, ), # 1
12878 
  )
12879 
 
12880 
  def __init__(self, orderId=None,):
12881 
    self.orderId = orderId
12882 
 
12883 
  def read(self, iprot):
12884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12886 
      return
12887 
    iprot.readStructBegin()
12888 
    while True:
12889 
      (fname, ftype, fid) = iprot.readFieldBegin()
12890 
      if ftype == TType.STOP:
12891 
        break
12892 
      if fid == 1:
12893 
        if ftype == TType.I64:
12894 
          self.orderId = iprot.readI64();
12895 
        else:
12896 
          iprot.skip(ftype)
12897 
      else:
12898 
        iprot.skip(ftype)
12899 
      iprot.readFieldEnd()
12900 
    iprot.readStructEnd()
12901 
 
12902 
  def write(self, oprot):
12903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12905 
      return
12906 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12907 
    if self.orderId is not None:
12908 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12909 
      oprot.writeI64(self.orderId)
12910 
      oprot.writeFieldEnd()
12911 
    oprot.writeFieldStop()
12912 
    oprot.writeStructEnd()
12913 
 
12914 
  def validate(self):
12915 
    return
12916 
 
12917 
 
12918 
  def __repr__(self):
12919 
    L = ['%s=%r' % (key, value)
12920 
      for key, value in self.__dict__.iteritems()]
12921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12922 
 
12923 
  def __eq__(self, other):
12924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12925 
 
12926 
  def __ne__(self, other):
12927 
    return not (self == other)
12928 
 
12929 
class markOrderCancellationRequestConfirmed_result:
12930 
  """
12931 
  Attributes:
12932 
   - ex
12933 
  """
12934 
 
12935 
  thrift_spec = (
12936 
    None, # 0
12937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12938 
  )
12939 
 
12940 
  def __init__(self, ex=None,):
12941 
    self.ex = ex
12942 
 
12943 
  def read(self, iprot):
12944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12946 
      return
12947 
    iprot.readStructBegin()
12948 
    while True:
12949 
      (fname, ftype, fid) = iprot.readFieldBegin()
12950 
      if ftype == TType.STOP:
12951 
        break
12952 
      if fid == 1:
12953 
        if ftype == TType.STRUCT:
12954 
          self.ex = TransactionServiceException()
12955 
          self.ex.read(iprot)
12956 
        else:
12957 
          iprot.skip(ftype)
12958 
      else:
12959 
        iprot.skip(ftype)
12960 
      iprot.readFieldEnd()
12961 
    iprot.readStructEnd()
12962 
 
12963 
  def write(self, oprot):
12964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12966 
      return
12967 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12968 
    if self.ex is not None:
12969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12970 
      self.ex.write(oprot)
12971 
      oprot.writeFieldEnd()
12972 
    oprot.writeFieldStop()
12973 
    oprot.writeStructEnd()
12974 
 
12975 
  def validate(self):
12976 
    return
12977 
 
12978 
 
12979 
  def __repr__(self):
12980 
    L = ['%s=%r' % (key, value)
12981 
      for key, value in self.__dict__.iteritems()]
12982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12983 
 
12984 
  def __eq__(self, other):
12985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12986 
 
12987 
  def __ne__(self, other):
12988 
    return not (self == other)
12989 
 
12990 
class markOrderCancellationRequestDenied_args:
12991 
  """
12992 
  Attributes:
12993 
   - orderId
12994 
  """
12995 
 
12996 
  thrift_spec = (
12997 
    None, # 0
12998 
    (1, TType.I64, 'orderId', None, None, ), # 1
12999 
  )
13000 
 
13001 
  def __init__(self, orderId=None,):
13002 
    self.orderId = orderId
13003 
 
13004 
  def read(self, iprot):
13005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13007 
      return
13008 
    iprot.readStructBegin()
13009 
    while True:
13010 
      (fname, ftype, fid) = iprot.readFieldBegin()
13011 
      if ftype == TType.STOP:
13012 
        break
13013 
      if fid == 1:
13014 
        if ftype == TType.I64:
13015 
          self.orderId = iprot.readI64();
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
13027 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13028 
    if self.orderId is not None:
13029 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13030 
      oprot.writeI64(self.orderId)
13031 
      oprot.writeFieldEnd()
13032 
    oprot.writeFieldStop()
13033 
    oprot.writeStructEnd()
13034 
 
13035 
  def validate(self):
13036 
    return
13037 
 
13038 
 
13039 
  def __repr__(self):
13040 
    L = ['%s=%r' % (key, value)
13041 
      for key, value in self.__dict__.iteritems()]
13042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13043 
 
13044 
  def __eq__(self, other):
13045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13046 
 
13047 
  def __ne__(self, other):
13048 
    return not (self == other)
13049 
 
13050 
class markOrderCancellationRequestDenied_result:
13051 
  """
13052 
  Attributes:
13053 
   - ex
13054 
  """
13055 
 
13056 
  thrift_spec = (
13057 
    None, # 0
13058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13059 
  )
13060 
 
13061 
  def __init__(self, ex=None,):
13062 
    self.ex = ex
13063 
 
13064 
  def read(self, iprot):
13065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13067 
      return
13068 
    iprot.readStructBegin()
13069 
    while True:
13070 
      (fname, ftype, fid) = iprot.readFieldBegin()
13071 
      if ftype == TType.STOP:
13072 
        break
13073 
      if fid == 1:
13074 
        if ftype == TType.STRUCT:
13075 
          self.ex = TransactionServiceException()
13076 
          self.ex.read(iprot)
13077 
        else:
13078 
          iprot.skip(ftype)
13079 
      else:
13080 
        iprot.skip(ftype)
13081 
      iprot.readFieldEnd()
13082 
    iprot.readStructEnd()
13083 
 
13084 
  def write(self, oprot):
13085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13087 
      return
13088 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13089 
    if self.ex is not None:
13090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13091 
      self.ex.write(oprot)
13092 
      oprot.writeFieldEnd()
13093 
    oprot.writeFieldStop()
13094 
    oprot.writeStructEnd()
13095 
 
13096 
  def validate(self):
13097 
    return
13098 
 
13099 
 
13100 
  def __repr__(self):
13101 
    L = ['%s=%r' % (key, value)
13102 
      for key, value in self.__dict__.iteritems()]
13103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13104 
 
13105 
  def __eq__(self, other):
13106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13107 
 
13108 
  def __ne__(self, other):
13109 
    return not (self == other)
13110 
 
4258 rajveer 13111 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13112 
  """
13113 
  Attributes:
4258 rajveer 13114 
   - transactionId
4247 rajveer 13115 
  """
13116 
 
13117 
  thrift_spec = (
13118 
    None, # 0
4258 rajveer 13119 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13120 
  )
13121 
 
4258 rajveer 13122 
  def __init__(self, transactionId=None,):
13123 
    self.transactionId = transactionId
4247 rajveer 13124 
 
13125 
  def read(self, iprot):
13126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13128 
      return
13129 
    iprot.readStructBegin()
13130 
    while True:
13131 
      (fname, ftype, fid) = iprot.readFieldBegin()
13132 
      if ftype == TType.STOP:
13133 
        break
13134 
      if fid == 1:
13135 
        if ftype == TType.I64:
4258 rajveer 13136 
          self.transactionId = iprot.readI64();
4247 rajveer 13137 
        else:
13138 
          iprot.skip(ftype)
13139 
      else:
13140 
        iprot.skip(ftype)
13141 
      iprot.readFieldEnd()
13142 
    iprot.readStructEnd()
13143 
 
13144 
  def write(self, oprot):
13145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13147 
      return
4258 rajveer 13148 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13149 
    if self.transactionId is not None:
13150 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13151 
      oprot.writeI64(self.transactionId)
4247 rajveer 13152 
      oprot.writeFieldEnd()
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
4258 rajveer 13171 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13172 
  """
13173 
  Attributes:
13174 
   - ex
13175 
  """
13176 
 
13177 
  thrift_spec = (
13178 
    None, # 0
13179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13180 
  )
13181 
 
13182 
  def __init__(self, ex=None,):
13183 
    self.ex = ex
13184 
 
13185 
  def read(self, iprot):
13186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13188 
      return
13189 
    iprot.readStructBegin()
13190 
    while True:
13191 
      (fname, ftype, fid) = iprot.readFieldBegin()
13192 
      if ftype == TType.STOP:
13193 
        break
13194 
      if fid == 1:
13195 
        if ftype == TType.STRUCT:
13196 
          self.ex = TransactionServiceException()
13197 
          self.ex.read(iprot)
13198 
        else:
13199 
          iprot.skip(ftype)
13200 
      else:
13201 
        iprot.skip(ftype)
13202 
      iprot.readFieldEnd()
13203 
    iprot.readStructEnd()
13204 
 
13205 
  def write(self, oprot):
13206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13208 
      return
4258 rajveer 13209 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13210 
    if self.ex is not None:
13211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13212 
      self.ex.write(oprot)
13213 
      oprot.writeFieldEnd()
13214 
    oprot.writeFieldStop()
13215 
    oprot.writeStructEnd()
13216 
 
13217 
  def validate(self):
13218 
    return
13219 
 
13220 
 
13221 
  def __repr__(self):
13222 
    L = ['%s=%r' % (key, value)
13223 
      for key, value in self.__dict__.iteritems()]
13224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13225 
 
13226 
  def __eq__(self, other):
13227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13228 
 
13229 
  def __ne__(self, other):
13230 
    return not (self == other)
4259 anupam.sin 13231 
 
13232 
class refundTransaction_args:
13233 
  """
13234 
  Attributes:
13235 
   - transactionId
13236 
   - refundedBy
13237 
   - reason
13238 
  """
13239 
 
13240 
  thrift_spec = (
13241 
    None, # 0
13242 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13243 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13244 
    (3, TType.STRING, 'reason', None, None, ), # 3
13245 
  )
13246 
 
13247 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13248 
    self.transactionId = transactionId
13249 
    self.refundedBy = refundedBy
13250 
    self.reason = reason
13251 
 
13252 
  def read(self, iprot):
13253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13255 
      return
13256 
    iprot.readStructBegin()
13257 
    while True:
13258 
      (fname, ftype, fid) = iprot.readFieldBegin()
13259 
      if ftype == TType.STOP:
13260 
        break
13261 
      if fid == 1:
13262 
        if ftype == TType.I64:
13263 
          self.transactionId = iprot.readI64();
13264 
        else:
13265 
          iprot.skip(ftype)
13266 
      elif fid == 2:
13267 
        if ftype == TType.STRING:
13268 
          self.refundedBy = iprot.readString();
13269 
        else:
13270 
          iprot.skip(ftype)
13271 
      elif fid == 3:
13272 
        if ftype == TType.STRING:
13273 
          self.reason = iprot.readString();
13274 
        else:
13275 
          iprot.skip(ftype)
13276 
      else:
13277 
        iprot.skip(ftype)
13278 
      iprot.readFieldEnd()
13279 
    iprot.readStructEnd()
13280 
 
13281 
  def write(self, oprot):
13282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13284 
      return
13285 
    oprot.writeStructBegin('refundTransaction_args')
13286 
    if self.transactionId is not None:
13287 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13288 
      oprot.writeI64(self.transactionId)
13289 
      oprot.writeFieldEnd()
13290 
    if self.refundedBy is not None:
13291 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13292 
      oprot.writeString(self.refundedBy)
13293 
      oprot.writeFieldEnd()
13294 
    if self.reason is not None:
13295 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13296 
      oprot.writeString(self.reason)
13297 
      oprot.writeFieldEnd()
13298 
    oprot.writeFieldStop()
13299 
    oprot.writeStructEnd()
13300 
 
13301 
  def validate(self):
13302 
    return
13303 
 
13304 
 
13305 
  def __repr__(self):
13306 
    L = ['%s=%r' % (key, value)
13307 
      for key, value in self.__dict__.iteritems()]
13308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13309 
 
13310 
  def __eq__(self, other):
13311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13312 
 
13313 
  def __ne__(self, other):
13314 
    return not (self == other)
13315 
 
13316 
class refundTransaction_result:
13317 
  """
13318 
  Attributes:
13319 
   - ex
13320 
  """
13321 
 
13322 
  thrift_spec = (
13323 
    None, # 0
13324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13325 
  )
13326 
 
13327 
  def __init__(self, ex=None,):
13328 
    self.ex = ex
13329 
 
13330 
  def read(self, iprot):
13331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13333 
      return
13334 
    iprot.readStructBegin()
13335 
    while True:
13336 
      (fname, ftype, fid) = iprot.readFieldBegin()
13337 
      if ftype == TType.STOP:
13338 
        break
13339 
      if fid == 1:
13340 
        if ftype == TType.STRUCT:
13341 
          self.ex = TransactionServiceException()
13342 
          self.ex.read(iprot)
13343 
        else:
13344 
          iprot.skip(ftype)
13345 
      else:
13346 
        iprot.skip(ftype)
13347 
      iprot.readFieldEnd()
13348 
    iprot.readStructEnd()
13349 
 
13350 
  def write(self, oprot):
13351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13353 
      return
13354 
    oprot.writeStructBegin('refundTransaction_result')
13355 
    if self.ex is not None:
13356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13357 
      self.ex.write(oprot)
13358 
      oprot.writeFieldEnd()
13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
4285 rajveer 13376 
 
13377 
class acceptOrdersForItemId_args:
13378 
  """
13379 
  Attributes:
13380 
   - itemId
13381 
   - inventory
13382 
  """
13383 
 
13384 
  thrift_spec = (
13385 
    None, # 0
13386 
    (1, TType.I64, 'itemId', None, None, ), # 1
13387 
    (2, TType.I64, 'inventory', None, None, ), # 2
13388 
  )
13389 
 
13390 
  def __init__(self, itemId=None, inventory=None,):
13391 
    self.itemId = itemId
13392 
    self.inventory = inventory
13393 
 
13394 
  def read(self, iprot):
13395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13397 
      return
13398 
    iprot.readStructBegin()
13399 
    while True:
13400 
      (fname, ftype, fid) = iprot.readFieldBegin()
13401 
      if ftype == TType.STOP:
13402 
        break
13403 
      if fid == 1:
13404 
        if ftype == TType.I64:
13405 
          self.itemId = iprot.readI64();
13406 
        else:
13407 
          iprot.skip(ftype)
13408 
      elif fid == 2:
13409 
        if ftype == TType.I64:
13410 
          self.inventory = iprot.readI64();
13411 
        else:
13412 
          iprot.skip(ftype)
13413 
      else:
13414 
        iprot.skip(ftype)
13415 
      iprot.readFieldEnd()
13416 
    iprot.readStructEnd()
13417 
 
13418 
  def write(self, oprot):
13419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13421 
      return
13422 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13423 
    if self.itemId is not None:
13424 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13425 
      oprot.writeI64(self.itemId)
13426 
      oprot.writeFieldEnd()
13427 
    if self.inventory is not None:
13428 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13429 
      oprot.writeI64(self.inventory)
13430 
      oprot.writeFieldEnd()
13431 
    oprot.writeFieldStop()
13432 
    oprot.writeStructEnd()
13433 
 
13434 
  def validate(self):
13435 
    return
13436 
 
13437 
 
13438 
  def __repr__(self):
13439 
    L = ['%s=%r' % (key, value)
13440 
      for key, value in self.__dict__.iteritems()]
13441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13442 
 
13443 
  def __eq__(self, other):
13444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13445 
 
13446 
  def __ne__(self, other):
13447 
    return not (self == other)
13448 
 
13449 
class acceptOrdersForItemId_result:
13450 
  """
13451 
  Attributes:
13452 
   - success
13453 
   - ex
13454 
  """
13455 
 
13456 
  thrift_spec = (
13457 
    (0, TType.BOOL, 'success', None, None, ), # 0
13458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13459 
  )
13460 
 
13461 
  def __init__(self, success=None, ex=None,):
13462 
    self.success = success
13463 
    self.ex = ex
13464 
 
13465 
  def read(self, iprot):
13466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13468 
      return
13469 
    iprot.readStructBegin()
13470 
    while True:
13471 
      (fname, ftype, fid) = iprot.readFieldBegin()
13472 
      if ftype == TType.STOP:
13473 
        break
13474 
      if fid == 0:
13475 
        if ftype == TType.BOOL:
13476 
          self.success = iprot.readBool();
13477 
        else:
13478 
          iprot.skip(ftype)
13479 
      elif fid == 1:
13480 
        if ftype == TType.STRUCT:
13481 
          self.ex = TransactionServiceException()
13482 
          self.ex.read(iprot)
13483 
        else:
13484 
          iprot.skip(ftype)
13485 
      else:
13486 
        iprot.skip(ftype)
13487 
      iprot.readFieldEnd()
13488 
    iprot.readStructEnd()
13489 
 
13490 
  def write(self, oprot):
13491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13493 
      return
13494 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13495 
    if self.success is not None:
13496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13497 
      oprot.writeBool(self.success)
13498 
      oprot.writeFieldEnd()
13499 
    if self.ex is not None:
13500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13501 
      self.ex.write(oprot)
13502 
      oprot.writeFieldEnd()
13503 
    oprot.writeFieldStop()
13504 
    oprot.writeStructEnd()
13505 
 
13506 
  def validate(self):
13507 
    return
13508 
 
13509 
 
13510 
  def __repr__(self):
13511 
    L = ['%s=%r' % (key, value)
13512 
      for key, value in self.__dict__.iteritems()]
13513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13514 
 
13515 
  def __eq__(self, other):
13516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13517 
 
13518 
  def __ne__(self, other):
13519 
    return not (self == other)
4303 rajveer 13520 
 
13521 
class markOrdersAsPORaised_args:
13522 
  """
13523 
  Attributes:
13524 
   - vendorId
13525 
   - itemId
13526 
   - quantity
13527 
   - estimate
13528 
  """
13529 
 
13530 
  thrift_spec = (
13531 
    None, # 0
13532 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13533 
    (2, TType.I64, 'itemId', None, None, ), # 2
13534 
    (3, TType.I64, 'quantity', None, None, ), # 3
13535 
    (4, TType.I64, 'estimate', None, None, ), # 4
13536 
  )
13537 
 
13538 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
13539 
    self.vendorId = vendorId
13540 
    self.itemId = itemId
13541 
    self.quantity = quantity
13542 
    self.estimate = estimate
13543 
 
13544 
  def read(self, iprot):
13545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13547 
      return
13548 
    iprot.readStructBegin()
13549 
    while True:
13550 
      (fname, ftype, fid) = iprot.readFieldBegin()
13551 
      if ftype == TType.STOP:
13552 
        break
13553 
      if fid == 1:
13554 
        if ftype == TType.I64:
13555 
          self.vendorId = iprot.readI64();
13556 
        else:
13557 
          iprot.skip(ftype)
13558 
      elif fid == 2:
13559 
        if ftype == TType.I64:
13560 
          self.itemId = iprot.readI64();
13561 
        else:
13562 
          iprot.skip(ftype)
13563 
      elif fid == 3:
13564 
        if ftype == TType.I64:
13565 
          self.quantity = iprot.readI64();
13566 
        else:
13567 
          iprot.skip(ftype)
13568 
      elif fid == 4:
13569 
        if ftype == TType.I64:
13570 
          self.estimate = iprot.readI64();
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      else:
13574 
        iprot.skip(ftype)
13575 
      iprot.readFieldEnd()
13576 
    iprot.readStructEnd()
13577 
 
13578 
  def write(self, oprot):
13579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13581 
      return
13582 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
13583 
    if self.vendorId is not None:
13584 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13585 
      oprot.writeI64(self.vendorId)
13586 
      oprot.writeFieldEnd()
13587 
    if self.itemId is not None:
13588 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13589 
      oprot.writeI64(self.itemId)
13590 
      oprot.writeFieldEnd()
13591 
    if self.quantity is not None:
13592 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13593 
      oprot.writeI64(self.quantity)
13594 
      oprot.writeFieldEnd()
13595 
    if self.estimate is not None:
13596 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13597 
      oprot.writeI64(self.estimate)
13598 
      oprot.writeFieldEnd()
13599 
    oprot.writeFieldStop()
13600 
    oprot.writeStructEnd()
13601 
 
13602 
  def validate(self):
13603 
    return
13604 
 
13605 
 
13606 
  def __repr__(self):
13607 
    L = ['%s=%r' % (key, value)
13608 
      for key, value in self.__dict__.iteritems()]
13609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13610 
 
13611 
  def __eq__(self, other):
13612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13613 
 
13614 
  def __ne__(self, other):
13615 
    return not (self == other)
13616 
 
13617 
class markOrdersAsPORaised_result:
13618 
  """
13619 
  Attributes:
13620 
   - ex
13621 
  """
13622 
 
13623 
  thrift_spec = (
13624 
    None, # 0
13625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13626 
  )
13627 
 
13628 
  def __init__(self, ex=None,):
13629 
    self.ex = ex
13630 
 
13631 
  def read(self, iprot):
13632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13634 
      return
13635 
    iprot.readStructBegin()
13636 
    while True:
13637 
      (fname, ftype, fid) = iprot.readFieldBegin()
13638 
      if ftype == TType.STOP:
13639 
        break
13640 
      if fid == 1:
13641 
        if ftype == TType.STRUCT:
13642 
          self.ex = TransactionServiceException()
13643 
          self.ex.read(iprot)
13644 
        else:
13645 
          iprot.skip(ftype)
13646 
      else:
13647 
        iprot.skip(ftype)
13648 
      iprot.readFieldEnd()
13649 
    iprot.readStructEnd()
13650 
 
13651 
  def write(self, oprot):
13652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13654 
      return
13655 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
13656 
    if self.ex is not None:
13657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13658 
      self.ex.write(oprot)
13659 
      oprot.writeFieldEnd()
13660 
    oprot.writeFieldStop()
13661 
    oprot.writeStructEnd()
13662 
 
13663 
  def validate(self):
13664 
    return
13665 
 
13666 
 
13667 
  def __repr__(self):
13668 
    L = ['%s=%r' % (key, value)
13669 
      for key, value in self.__dict__.iteritems()]
13670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13671 
 
13672 
  def __eq__(self, other):
13673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13674 
 
13675 
  def __ne__(self, other):
13676 
    return not (self == other)
13677 
 
13678 
class markOrdersAsReversalInitiated_args:
13679 
  """
13680 
  Attributes:
13681 
   - vendorId
13682 
   - itemId
13683 
   - quantity
13684 
   - estimate
13685 
  """
13686 
 
13687 
  thrift_spec = (
13688 
    None, # 0
13689 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13690 
    (2, TType.I64, 'itemId', None, None, ), # 2
13691 
    (3, TType.I64, 'quantity', None, None, ), # 3
13692 
    (4, TType.I64, 'estimate', None, None, ), # 4
13693 
  )
13694 
 
13695 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
13696 
    self.vendorId = vendorId
13697 
    self.itemId = itemId
13698 
    self.quantity = quantity
13699 
    self.estimate = estimate
13700 
 
13701 
  def read(self, iprot):
13702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13704 
      return
13705 
    iprot.readStructBegin()
13706 
    while True:
13707 
      (fname, ftype, fid) = iprot.readFieldBegin()
13708 
      if ftype == TType.STOP:
13709 
        break
13710 
      if fid == 1:
13711 
        if ftype == TType.I64:
13712 
          self.vendorId = iprot.readI64();
13713 
        else:
13714 
          iprot.skip(ftype)
13715 
      elif fid == 2:
13716 
        if ftype == TType.I64:
13717 
          self.itemId = iprot.readI64();
13718 
        else:
13719 
          iprot.skip(ftype)
13720 
      elif fid == 3:
13721 
        if ftype == TType.I64:
13722 
          self.quantity = iprot.readI64();
13723 
        else:
13724 
          iprot.skip(ftype)
13725 
      elif fid == 4:
13726 
        if ftype == TType.I64:
13727 
          self.estimate = iprot.readI64();
13728 
        else:
13729 
          iprot.skip(ftype)
13730 
      else:
13731 
        iprot.skip(ftype)
13732 
      iprot.readFieldEnd()
13733 
    iprot.readStructEnd()
13734 
 
13735 
  def write(self, oprot):
13736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13738 
      return
13739 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
13740 
    if self.vendorId is not None:
13741 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13742 
      oprot.writeI64(self.vendorId)
13743 
      oprot.writeFieldEnd()
13744 
    if self.itemId is not None:
13745 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13746 
      oprot.writeI64(self.itemId)
13747 
      oprot.writeFieldEnd()
13748 
    if self.quantity is not None:
13749 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13750 
      oprot.writeI64(self.quantity)
13751 
      oprot.writeFieldEnd()
13752 
    if self.estimate is not None:
13753 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13754 
      oprot.writeI64(self.estimate)
13755 
      oprot.writeFieldEnd()
13756 
    oprot.writeFieldStop()
13757 
    oprot.writeStructEnd()
13758 
 
13759 
  def validate(self):
13760 
    return
13761 
 
13762 
 
13763 
  def __repr__(self):
13764 
    L = ['%s=%r' % (key, value)
13765 
      for key, value in self.__dict__.iteritems()]
13766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13767 
 
13768 
  def __eq__(self, other):
13769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13770 
 
13771 
  def __ne__(self, other):
13772 
    return not (self == other)
13773 
 
13774 
class markOrdersAsReversalInitiated_result:
13775 
  """
13776 
  Attributes:
13777 
   - ex
13778 
  """
13779 
 
13780 
  thrift_spec = (
13781 
    None, # 0
13782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13783 
  )
13784 
 
13785 
  def __init__(self, ex=None,):
13786 
    self.ex = ex
13787 
 
13788 
  def read(self, iprot):
13789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13791 
      return
13792 
    iprot.readStructBegin()
13793 
    while True:
13794 
      (fname, ftype, fid) = iprot.readFieldBegin()
13795 
      if ftype == TType.STOP:
13796 
        break
13797 
      if fid == 1:
13798 
        if ftype == TType.STRUCT:
13799 
          self.ex = TransactionServiceException()
13800 
          self.ex.read(iprot)
13801 
        else:
13802 
          iprot.skip(ftype)
13803 
      else:
13804 
        iprot.skip(ftype)
13805 
      iprot.readFieldEnd()
13806 
    iprot.readStructEnd()
13807 
 
13808 
  def write(self, oprot):
13809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13811 
      return
13812 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
13813 
    if self.ex is not None:
13814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13815 
      self.ex.write(oprot)
13816 
      oprot.writeFieldEnd()
13817 
    oprot.writeFieldStop()
13818 
    oprot.writeStructEnd()
13819 
 
13820 
  def validate(self):
13821 
    return
13822 
 
13823 
 
13824 
  def __repr__(self):
13825 
    L = ['%s=%r' % (key, value)
13826 
      for key, value in self.__dict__.iteritems()]
13827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13828 
 
13829 
  def __eq__(self, other):
13830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13831 
 
13832 
  def __ne__(self, other):
13833 
    return not (self == other)
13834 
 
13835 
class markOrdersAsNotAvailabke_args:
13836 
  """
13837 
  Attributes:
13838 
   - vendorId
13839 
   - itemId
13840 
   - quantity
13841 
   - estimate
13842 
  """
13843 
 
13844 
  thrift_spec = (
13845 
    None, # 0
13846 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13847 
    (2, TType.I64, 'itemId', None, None, ), # 2
13848 
    (3, TType.I64, 'quantity', None, None, ), # 3
13849 
    (4, TType.I64, 'estimate', None, None, ), # 4
13850 
  )
13851 
 
13852 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
13853 
    self.vendorId = vendorId
13854 
    self.itemId = itemId
13855 
    self.quantity = quantity
13856 
    self.estimate = estimate
13857 
 
13858 
  def read(self, iprot):
13859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13861 
      return
13862 
    iprot.readStructBegin()
13863 
    while True:
13864 
      (fname, ftype, fid) = iprot.readFieldBegin()
13865 
      if ftype == TType.STOP:
13866 
        break
13867 
      if fid == 1:
13868 
        if ftype == TType.I64:
13869 
          self.vendorId = iprot.readI64();
13870 
        else:
13871 
          iprot.skip(ftype)
13872 
      elif fid == 2:
13873 
        if ftype == TType.I64:
13874 
          self.itemId = iprot.readI64();
13875 
        else:
13876 
          iprot.skip(ftype)
13877 
      elif fid == 3:
13878 
        if ftype == TType.I64:
13879 
          self.quantity = iprot.readI64();
13880 
        else:
13881 
          iprot.skip(ftype)
13882 
      elif fid == 4:
13883 
        if ftype == TType.I64:
13884 
          self.estimate = iprot.readI64();
13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      else:
13888 
        iprot.skip(ftype)
13889 
      iprot.readFieldEnd()
13890 
    iprot.readStructEnd()
13891 
 
13892 
  def write(self, oprot):
13893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13895 
      return
13896 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
13897 
    if self.vendorId is not None:
13898 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13899 
      oprot.writeI64(self.vendorId)
13900 
      oprot.writeFieldEnd()
13901 
    if self.itemId is not None:
13902 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13903 
      oprot.writeI64(self.itemId)
13904 
      oprot.writeFieldEnd()
13905 
    if self.quantity is not None:
13906 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13907 
      oprot.writeI64(self.quantity)
13908 
      oprot.writeFieldEnd()
13909 
    if self.estimate is not None:
13910 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13911 
      oprot.writeI64(self.estimate)
13912 
      oprot.writeFieldEnd()
13913 
    oprot.writeFieldStop()
13914 
    oprot.writeStructEnd()
13915 
 
13916 
  def validate(self):
13917 
    return
13918 
 
13919 
 
13920 
  def __repr__(self):
13921 
    L = ['%s=%r' % (key, value)
13922 
      for key, value in self.__dict__.iteritems()]
13923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13924 
 
13925 
  def __eq__(self, other):
13926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13927 
 
13928 
  def __ne__(self, other):
13929 
    return not (self == other)
13930 
 
13931 
class markOrdersAsNotAvailabke_result:
13932 
  """
13933 
  Attributes:
13934 
   - ex
13935 
  """
13936 
 
13937 
  thrift_spec = (
13938 
    None, # 0
13939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13940 
  )
13941 
 
13942 
  def __init__(self, ex=None,):
13943 
    self.ex = ex
13944 
 
13945 
  def read(self, iprot):
13946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13948 
      return
13949 
    iprot.readStructBegin()
13950 
    while True:
13951 
      (fname, ftype, fid) = iprot.readFieldBegin()
13952 
      if ftype == TType.STOP:
13953 
        break
13954 
      if fid == 1:
13955 
        if ftype == TType.STRUCT:
13956 
          self.ex = TransactionServiceException()
13957 
          self.ex.read(iprot)
13958 
        else:
13959 
          iprot.skip(ftype)
13960 
      else:
13961 
        iprot.skip(ftype)
13962 
      iprot.readFieldEnd()
13963 
    iprot.readStructEnd()
13964 
 
13965 
  def write(self, oprot):
13966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13968 
      return
13969 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
13970 
    if self.ex is not None:
13971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13972 
      self.ex.write(oprot)
13973 
      oprot.writeFieldEnd()
13974 
    oprot.writeFieldStop()
13975 
    oprot.writeStructEnd()
13976 
 
13977 
  def validate(self):
13978 
    return
13979 
 
13980 
 
13981 
  def __repr__(self):
13982 
    L = ['%s=%r' % (key, value)
13983 
      for key, value in self.__dict__.iteritems()]
13984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13985 
 
13986 
  def __eq__(self, other):
13987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13988 
 
13989 
  def __ne__(self, other):
13990 
    return not (self == other)