Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
404 
    Returns the final flag status.
405 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4295 varun.gupt 659 
  def getOrdersForItemIds(self, itemIds):
660 
    """
661 
    Returns a list of all orders which have items with given id
662 
 
663 
    Parameters:
664 
     - itemIds
665 
    """
666 
    pass
667 
 
4247 rajveer 668 
  def markOrderCancellationRequestReceived(self, orderId):
669 
    """
670 
    Mark order as cancellation request received. If customer sends request of cancellation of
671 
    a particular order, this method will be called. It will just change status of the order
672 
    depending on its current status. It also records the previous status, so that we can move
673 
    back to that status if cancellation request is denied.
4018 chandransh 674 
 
4247 rajveer 675 
    Parameters:
676 
     - orderId
677 
    """
678 
    pass
679 
 
680 
  def markOrderCancellationRequestConfirmed(self, orderId):
681 
    """
682 
    If we decide to to cancel order, CRM will call this method to move the status of order to
683 
    cancellation request confirmed. After this OM will be able to cancel the order.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
690 
  def markOrderCancellationRequestDenied(self, orderId):
691 
    """
692 
    If we decide to not to cancel order, we will move the order ro previous status.
693 
 
694 
    Parameters:
695 
     - orderId
696 
    """
697 
    pass
698 
 
4258 rajveer 699 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 700 
    """
4258 rajveer 701 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
702 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 703 
 
704 
    Parameters:
4258 rajveer 705 
     - transactionId
4247 rajveer 706 
    """
707 
    pass
708 
 
4259 anupam.sin 709 
  def refundTransaction(self, transactionId, refundedBy, reason):
710 
    """
711 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
712 
    need to be cancelled
4247 rajveer 713 
 
4259 anupam.sin 714 
    Parameters:
715 
     - transactionId
716 
     - refundedBy
717 
     - reason
718 
    """
719 
    pass
720 
 
4324 mandeep.dh 721 
  def updateShipmentAddress(self, orderId, addressId):
722 
    """
723 
    Updates shipment address of an order. Delivery and shipping date estimates
724 
    etc. are also updated here.
725 
 
726 
    Throws TransactionServiceException in case address change is not
727 
    possible due to certain reasons such as new pincode in address is
728 
    not serviceable etc.
729 
 
730 
    Parameters:
731 
     - orderId
732 
     - addressId
733 
    """
734 
    pass
735 
 
4285 rajveer 736 
  def acceptOrdersForItemId(self, itemId, inventory):
737 
    """
738 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
739 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 740 
 
4285 rajveer 741 
    Parameters:
742 
     - itemId
743 
     - inventory
744 
    """
745 
    pass
746 
 
4303 rajveer 747 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
748 
    """
749 
    Parameters:
750 
     - vendorId
751 
     - itemId
752 
     - quantity
753 
     - estimate
754 
    """
755 
    pass
4285 rajveer 756 
 
4303 rajveer 757 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
758 
    """
759 
    Parameters:
760 
     - vendorId
761 
     - itemId
762 
     - quantity
763 
     - estimate
764 
    """
765 
    pass
766 
 
767 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
768 
    """
769 
    Parameters:
770 
     - vendorId
771 
     - itemId
772 
     - quantity
773 
     - estimate
774 
    """
775 
    pass
776 
 
777 
 
3376 rajveer 778 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 779 
  def __init__(self, iprot, oprot=None):
3376 rajveer 780 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 781 
 
782 
  def createTransaction(self, transaction):
783 
    """
784 
    Parameters:
785 
     - transaction
786 
    """
787 
    self.send_createTransaction(transaction)
132 ashish 788 
    return self.recv_createTransaction()
94 ashish 789 
 
790 
  def send_createTransaction(self, transaction):
791 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
792 
    args = createTransaction_args()
793 
    args.transaction = transaction
794 
    args.write(self._oprot)
795 
    self._oprot.writeMessageEnd()
796 
    self._oprot.trans.flush()
797 
 
798 
  def recv_createTransaction(self, ):
799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
800 
    if mtype == TMessageType.EXCEPTION:
801 
      x = TApplicationException()
802 
      x.read(self._iprot)
803 
      self._iprot.readMessageEnd()
804 
      raise x
805 
    result = createTransaction_result()
806 
    result.read(self._iprot)
807 
    self._iprot.readMessageEnd()
3431 rajveer 808 
    if result.success is not None:
132 ashish 809 
      return result.success
3431 rajveer 810 
    if result.ex is not None:
94 ashish 811 
      raise result.ex
132 ashish 812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 813 
 
814 
  def getTransaction(self, id):
815 
    """
816 
    Parameters:
817 
     - id
818 
    """
819 
    self.send_getTransaction(id)
820 
    return self.recv_getTransaction()
821 
 
822 
  def send_getTransaction(self, id):
823 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
824 
    args = getTransaction_args()
825 
    args.id = id
826 
    args.write(self._oprot)
827 
    self._oprot.writeMessageEnd()
828 
    self._oprot.trans.flush()
829 
 
830 
  def recv_getTransaction(self, ):
831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
832 
    if mtype == TMessageType.EXCEPTION:
833 
      x = TApplicationException()
834 
      x.read(self._iprot)
835 
      self._iprot.readMessageEnd()
836 
      raise x
837 
    result = getTransaction_result()
838 
    result.read(self._iprot)
839 
    self._iprot.readMessageEnd()
3431 rajveer 840 
    if result.success is not None:
94 ashish 841 
      return result.success
3431 rajveer 842 
    if result.ex is not None:
94 ashish 843 
      raise result.ex
844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
845 
 
846 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
847 
    """
848 
    Parameters:
849 
     - customerId
850 
     - from_date
851 
     - to_date
852 
     - status
853 
    """
854 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
855 
    return self.recv_getTransactionsForCustomer()
856 
 
857 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
858 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
859 
    args = getTransactionsForCustomer_args()
860 
    args.customerId = customerId
861 
    args.from_date = from_date
862 
    args.to_date = to_date
863 
    args.status = status
864 
    args.write(self._oprot)
865 
    self._oprot.writeMessageEnd()
866 
    self._oprot.trans.flush()
867 
 
868 
  def recv_getTransactionsForCustomer(self, ):
869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
870 
    if mtype == TMessageType.EXCEPTION:
871 
      x = TApplicationException()
872 
      x.read(self._iprot)
873 
      self._iprot.readMessageEnd()
874 
      raise x
875 
    result = getTransactionsForCustomer_result()
876 
    result.read(self._iprot)
877 
    self._iprot.readMessageEnd()
3431 rajveer 878 
    if result.success is not None:
94 ashish 879 
      return result.success
3431 rajveer 880 
    if result.ex is not None:
94 ashish 881 
      raise result.ex
882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
883 
 
132 ashish 884 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
885 
    """
886 
    Parameters:
887 
     - shoppingCartId
888 
    """
889 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
890 
    return self.recv_getTransactionsForShoppingCartId()
891 
 
892 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
893 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
894 
    args = getTransactionsForShoppingCartId_args()
895 
    args.shoppingCartId = shoppingCartId
896 
    args.write(self._oprot)
897 
    self._oprot.writeMessageEnd()
898 
    self._oprot.trans.flush()
899 
 
900 
  def recv_getTransactionsForShoppingCartId(self, ):
901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
902 
    if mtype == TMessageType.EXCEPTION:
903 
      x = TApplicationException()
904 
      x.read(self._iprot)
905 
      self._iprot.readMessageEnd()
906 
      raise x
907 
    result = getTransactionsForShoppingCartId_result()
908 
    result.read(self._iprot)
909 
    self._iprot.readMessageEnd()
3431 rajveer 910 
    if result.success is not None:
132 ashish 911 
      return result.success
3431 rajveer 912 
    if result.ex is not None:
132 ashish 913 
      raise result.ex
914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
915 
 
94 ashish 916 
  def getTransactionStatus(self, transactionId):
917 
    """
918 
    Parameters:
919 
     - transactionId
920 
    """
921 
    self.send_getTransactionStatus(transactionId)
922 
    return self.recv_getTransactionStatus()
923 
 
924 
  def send_getTransactionStatus(self, transactionId):
925 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
926 
    args = getTransactionStatus_args()
927 
    args.transactionId = transactionId
928 
    args.write(self._oprot)
929 
    self._oprot.writeMessageEnd()
930 
    self._oprot.trans.flush()
931 
 
932 
  def recv_getTransactionStatus(self, ):
933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
934 
    if mtype == TMessageType.EXCEPTION:
935 
      x = TApplicationException()
936 
      x.read(self._iprot)
937 
      self._iprot.readMessageEnd()
938 
      raise x
939 
    result = getTransactionStatus_result()
940 
    result.read(self._iprot)
941 
    self._iprot.readMessageEnd()
3431 rajveer 942 
    if result.success is not None:
94 ashish 943 
      return result.success
3431 rajveer 944 
    if result.ex is not None:
94 ashish 945 
      raise result.ex
946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
947 
 
948 
  def changeTransactionStatus(self, transactionId, status, description):
949 
    """
950 
    Parameters:
951 
     - transactionId
952 
     - status
953 
     - description
954 
    """
955 
    self.send_changeTransactionStatus(transactionId, status, description)
956 
    return self.recv_changeTransactionStatus()
957 
 
958 
  def send_changeTransactionStatus(self, transactionId, status, description):
959 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
960 
    args = changeTransactionStatus_args()
961 
    args.transactionId = transactionId
962 
    args.status = status
963 
    args.description = description
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_changeTransactionStatus(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = changeTransactionStatus_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
3431 rajveer 978 
    if result.success is not None:
94 ashish 979 
      return result.success
3431 rajveer 980 
    if result.ex is not None:
94 ashish 981 
      raise result.ex
982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
983 
 
1398 varun.gupt 984 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 985 
    """
986 
    Parameters:
987 
     - transactionId
988 
    """
1398 varun.gupt 989 
    self.send_enqueueTransactionInfoEmail(transactionId)
990 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 991 
 
1398 varun.gupt 992 
  def send_enqueueTransactionInfoEmail(self, transactionId):
993 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
994 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 995 
    args.transactionId = transactionId
996 
    args.write(self._oprot)
997 
    self._oprot.writeMessageEnd()
998 
    self._oprot.trans.flush()
999 
 
1398 varun.gupt 1000 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1002 
    if mtype == TMessageType.EXCEPTION:
1003 
      x = TApplicationException()
1004 
      x.read(self._iprot)
1005 
      self._iprot.readMessageEnd()
1006 
      raise x
1398 varun.gupt 1007 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1008 
    result.read(self._iprot)
1009 
    self._iprot.readMessageEnd()
3431 rajveer 1010 
    if result.success is not None:
1382 varun.gupt 1011 
      return result.success
3431 rajveer 1012 
    if result.ex is not None:
1382 varun.gupt 1013 
      raise result.ex
1398 varun.gupt 1014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1015 
 
483 rajveer 1016 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1017 
    """
1018 
    Parameters:
483 rajveer 1019 
     - status
1020 
     - from_date
1021 
     - to_date
1022 
     - warehouse_id
94 ashish 1023 
    """
483 rajveer 1024 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1025 
    return self.recv_getAllOrders()
94 ashish 1026 
 
483 rajveer 1027 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1028 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1029 
    args = getAllOrders_args()
1030 
    args.status = status
1031 
    args.from_date = from_date
1032 
    args.to_date = to_date
1033 
    args.warehouse_id = warehouse_id
94 ashish 1034 
    args.write(self._oprot)
1035 
    self._oprot.writeMessageEnd()
1036 
    self._oprot.trans.flush()
1037 
 
483 rajveer 1038 
  def recv_getAllOrders(self, ):
94 ashish 1039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1040 
    if mtype == TMessageType.EXCEPTION:
1041 
      x = TApplicationException()
1042 
      x.read(self._iprot)
1043 
      self._iprot.readMessageEnd()
1044 
      raise x
483 rajveer 1045 
    result = getAllOrders_result()
94 ashish 1046 
    result.read(self._iprot)
1047 
    self._iprot.readMessageEnd()
3431 rajveer 1048 
    if result.success is not None:
94 ashish 1049 
      return result.success
3431 rajveer 1050 
    if result.ex is not None:
94 ashish 1051 
      raise result.ex
483 rajveer 1052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1053 
 
4133 chandransh 1054 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1055 
    """
1056 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1057 
    Pass the status as null and the limit as 0 to ignore them.
1058 
 
1059 
    Parameters:
1060 
     - statuses
1061 
     - offset
1062 
     - limit
1063 
     - warehouse_id
1064 
    """
1065 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1066 
    return self.recv_getOrdersInBatch()
1067 
 
1068 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1069 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1070 
    args = getOrdersInBatch_args()
1071 
    args.statuses = statuses
1072 
    args.offset = offset
1073 
    args.limit = limit
1074 
    args.warehouse_id = warehouse_id
1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
1079 
  def recv_getOrdersInBatch(self, ):
1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
1086 
    result = getOrdersInBatch_result()
1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
1089 
    if result.success is not None:
1090 
      return result.success
1091 
    if result.ex is not None:
1092 
      raise result.ex
1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1094 
 
1095 
  def getOrderCount(self, statuses, warehouseId):
1096 
    """
1097 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1098 
 
1099 
    Parameters:
1100 
     - statuses
1101 
     - warehouseId
1102 
    """
1103 
    self.send_getOrderCount(statuses, warehouseId)
1104 
    return self.recv_getOrderCount()
1105 
 
1106 
  def send_getOrderCount(self, statuses, warehouseId):
1107 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1108 
    args = getOrderCount_args()
1109 
    args.statuses = statuses
1110 
    args.warehouseId = warehouseId
1111 
    args.write(self._oprot)
1112 
    self._oprot.writeMessageEnd()
1113 
    self._oprot.trans.flush()
1114 
 
1115 
  def recv_getOrderCount(self, ):
1116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1117 
    if mtype == TMessageType.EXCEPTION:
1118 
      x = TApplicationException()
1119 
      x.read(self._iprot)
1120 
      self._iprot.readMessageEnd()
1121 
      raise x
1122 
    result = getOrderCount_result()
1123 
    result.read(self._iprot)
1124 
    self._iprot.readMessageEnd()
1125 
    if result.success is not None:
1126 
      return result.success
1127 
    if result.ex is not None:
1128 
      raise result.ex
1129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1130 
 
999 varun.gupt 1131 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1132 
    """
1132 chandransh 1133 
    Returns orders within a range of their billing dates
3431 rajveer 1134 
 
999 varun.gupt 1135 
    Parameters:
1136 
     - status
1137 
     - start_billing_date
1138 
     - end_billing_date
1139 
     - warehouse_id
1140 
    """
1141 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1142 
    return self.recv_getOrdersByBillingDate()
1143 
 
1144 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1145 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1146 
    args = getOrdersByBillingDate_args()
1147 
    args.status = status
1148 
    args.start_billing_date = start_billing_date
1149 
    args.end_billing_date = end_billing_date
1150 
    args.warehouse_id = warehouse_id
1151 
    args.write(self._oprot)
1152 
    self._oprot.writeMessageEnd()
1153 
    self._oprot.trans.flush()
1154 
 
1155 
  def recv_getOrdersByBillingDate(self, ):
1156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1157 
    if mtype == TMessageType.EXCEPTION:
1158 
      x = TApplicationException()
1159 
      x.read(self._iprot)
1160 
      self._iprot.readMessageEnd()
1161 
      raise x
1162 
    result = getOrdersByBillingDate_result()
1163 
    result.read(self._iprot)
1164 
    self._iprot.readMessageEnd()
3431 rajveer 1165 
    if result.success is not None:
999 varun.gupt 1166 
      return result.success
3431 rajveer 1167 
    if result.ex is not None:
999 varun.gupt 1168 
      raise result.ex
1169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1170 
 
3451 chandransh 1171 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1172 
    """
1173 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1174 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1175 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1176 
 
3427 chandransh 1177 
    Parameters:
1178 
     - fromShippingDate
1179 
     - toShippingDate
1180 
     - providerId
1181 
     - warehouseId
3451 chandransh 1182 
     - cod
3427 chandransh 1183 
    """
3451 chandransh 1184 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1185 
    return self.recv_getOrdersByShippingDate()
1186 
 
3451 chandransh 1187 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1188 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1189 
    args = getOrdersByShippingDate_args()
1190 
    args.fromShippingDate = fromShippingDate
1191 
    args.toShippingDate = toShippingDate
1192 
    args.providerId = providerId
1193 
    args.warehouseId = warehouseId
3451 chandransh 1194 
    args.cod = cod
3427 chandransh 1195 
    args.write(self._oprot)
1196 
    self._oprot.writeMessageEnd()
1197 
    self._oprot.trans.flush()
1198 
 
1199 
  def recv_getOrdersByShippingDate(self, ):
1200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1201 
    if mtype == TMessageType.EXCEPTION:
1202 
      x = TApplicationException()
1203 
      x.read(self._iprot)
1204 
      self._iprot.readMessageEnd()
1205 
      raise x
1206 
    result = getOrdersByShippingDate_result()
1207 
    result.read(self._iprot)
1208 
    self._iprot.readMessageEnd()
3431 rajveer 1209 
    if result.success is not None:
3427 chandransh 1210 
      return result.success
3431 rajveer 1211 
    if result.ex is not None:
3427 chandransh 1212 
      raise result.ex
1213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1214 
 
1382 varun.gupt 1215 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1216 
    """
1217 
    Returns order ids for orders which can be returned
3431 rajveer 1218 
 
1382 varun.gupt 1219 
    Parameters:
1220 
     - customer_id
1221 
     - limit
1222 
    """
1223 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1224 
    return self.recv_getReturnableOrdersForCustomer()
1225 
 
1226 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1227 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1228 
    args = getReturnableOrdersForCustomer_args()
1229 
    args.customer_id = customer_id
1230 
    args.limit = limit
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_getReturnableOrdersForCustomer(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = getReturnableOrdersForCustomer_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
3431 rajveer 1245 
    if result.success is not None:
1382 varun.gupt 1246 
      return result.success
3431 rajveer 1247 
    if result.ex is not None:
1382 varun.gupt 1248 
      raise result.ex
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1250 
 
1251 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1252 
    """
1253 
    Returns order ids for orders which can be cancelled
3431 rajveer 1254 
 
1382 varun.gupt 1255 
    Parameters:
1256 
     - customer_id
1257 
     - limit
1258 
    """
1259 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1260 
    return self.recv_getCancellableOrdersForCustomer()
1261 
 
1262 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1263 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1264 
    args = getCancellableOrdersForCustomer_args()
1265 
    args.customer_id = customer_id
1266 
    args.limit = limit
1267 
    args.write(self._oprot)
1268 
    self._oprot.writeMessageEnd()
1269 
    self._oprot.trans.flush()
1270 
 
1271 
  def recv_getCancellableOrdersForCustomer(self, ):
1272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1273 
    if mtype == TMessageType.EXCEPTION:
1274 
      x = TApplicationException()
1275 
      x.read(self._iprot)
1276 
      self._iprot.readMessageEnd()
1277 
      raise x
1278 
    result = getCancellableOrdersForCustomer_result()
1279 
    result.read(self._iprot)
1280 
    self._iprot.readMessageEnd()
3431 rajveer 1281 
    if result.success is not None:
1382 varun.gupt 1282 
      return result.success
3431 rajveer 1283 
    if result.ex is not None:
1382 varun.gupt 1284 
      raise result.ex
1285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1286 
 
483 rajveer 1287 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1288 
    """
1289 
    Parameters:
483 rajveer 1290 
     - orderId
1291 
     - status
1292 
     - description
94 ashish 1293 
    """
483 rajveer 1294 
    self.send_changeOrderStatus(orderId, status, description)
1295 
    return self.recv_changeOrderStatus()
94 ashish 1296 
 
483 rajveer 1297 
  def send_changeOrderStatus(self, orderId, status, description):
1298 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1299 
    args = changeOrderStatus_args()
1300 
    args.orderId = orderId
1301 
    args.status = status
1302 
    args.description = description
94 ashish 1303 
    args.write(self._oprot)
1304 
    self._oprot.writeMessageEnd()
1305 
    self._oprot.trans.flush()
1306 
 
483 rajveer 1307 
  def recv_changeOrderStatus(self, ):
94 ashish 1308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1309 
    if mtype == TMessageType.EXCEPTION:
1310 
      x = TApplicationException()
1311 
      x.read(self._iprot)
1312 
      self._iprot.readMessageEnd()
1313 
      raise x
483 rajveer 1314 
    result = changeOrderStatus_result()
94 ashish 1315 
    result.read(self._iprot)
1316 
    self._iprot.readMessageEnd()
3431 rajveer 1317 
    if result.success is not None:
94 ashish 1318 
      return result.success
3431 rajveer 1319 
    if result.ex is not None:
94 ashish 1320 
      raise result.ex
483 rajveer 1321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1322 
 
1528 ankur.sing 1323 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1324 
    """
1528 ankur.sing 1325 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1326 
    only user who owns the transaction can view its order details.
3431 rajveer 1327 
 
94 ashish 1328 
    Parameters:
1329 
     - transactionId
1528 ankur.sing 1330 
     - customerId
94 ashish 1331 
    """
1528 ankur.sing 1332 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1333 
    return self.recv_getOrdersForTransaction()
94 ashish 1334 
 
1528 ankur.sing 1335 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1336 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1337 
    args = getOrdersForTransaction_args()
94 ashish 1338 
    args.transactionId = transactionId
1528 ankur.sing 1339 
    args.customerId = customerId
94 ashish 1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
483 rajveer 1344 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
483 rajveer 1351 
    result = getOrdersForTransaction_result()
94 ashish 1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
3431 rajveer 1354 
    if result.success is not None:
94 ashish 1355 
      return result.success
3431 rajveer 1356 
    if result.ex is not None:
94 ashish 1357 
      raise result.ex
483 rajveer 1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1359 
 
3014 chandransh 1360 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1361 
    """
3014 chandransh 1362 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1363 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1364 
 
94 ashish 1365 
    Parameters:
483 rajveer 1366 
     - customerId
1367 
     - from_date
1368 
     - to_date
3014 chandransh 1369 
     - statuses
94 ashish 1370 
    """
3014 chandransh 1371 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1372 
    return self.recv_getOrdersForCustomer()
94 ashish 1373 
 
3014 chandransh 1374 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1375 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1376 
    args = getOrdersForCustomer_args()
1377 
    args.customerId = customerId
1378 
    args.from_date = from_date
1379 
    args.to_date = to_date
3014 chandransh 1380 
    args.statuses = statuses
94 ashish 1381 
    args.write(self._oprot)
1382 
    self._oprot.writeMessageEnd()
1383 
    self._oprot.trans.flush()
1384 
 
483 rajveer 1385 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1387 
    if mtype == TMessageType.EXCEPTION:
1388 
      x = TApplicationException()
1389 
      x.read(self._iprot)
1390 
      self._iprot.readMessageEnd()
1391 
      raise x
483 rajveer 1392 
    result = getOrdersForCustomer_result()
94 ashish 1393 
    result.read(self._iprot)
1394 
    self._iprot.readMessageEnd()
3431 rajveer 1395 
    if result.success is not None:
94 ashish 1396 
      return result.success
3431 rajveer 1397 
    if result.ex is not None:
94 ashish 1398 
      raise result.ex
483 rajveer 1399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1400 
 
483 rajveer 1401 
  def createOrder(self, order):
94 ashish 1402 
    """
1403 
    Parameters:
483 rajveer 1404 
     - order
94 ashish 1405 
    """
483 rajveer 1406 
    self.send_createOrder(order)
1407 
    return self.recv_createOrder()
94 ashish 1408 
 
483 rajveer 1409 
  def send_createOrder(self, order):
1410 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1411 
    args = createOrder_args()
1412 
    args.order = order
94 ashish 1413 
    args.write(self._oprot)
1414 
    self._oprot.writeMessageEnd()
1415 
    self._oprot.trans.flush()
1416 
 
483 rajveer 1417 
  def recv_createOrder(self, ):
94 ashish 1418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1419 
    if mtype == TMessageType.EXCEPTION:
1420 
      x = TApplicationException()
1421 
      x.read(self._iprot)
1422 
      self._iprot.readMessageEnd()
1423 
      raise x
483 rajveer 1424 
    result = createOrder_result()
94 ashish 1425 
    result.read(self._iprot)
1426 
    self._iprot.readMessageEnd()
3431 rajveer 1427 
    if result.success is not None:
94 ashish 1428 
      return result.success
3431 rajveer 1429 
    if result.ex is not None:
94 ashish 1430 
      raise result.ex
483 rajveer 1431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1432 
 
483 rajveer 1433 
  def getOrder(self, id):
94 ashish 1434 
    """
1435 
    Parameters:
483 rajveer 1436 
     - id
94 ashish 1437 
    """
483 rajveer 1438 
    self.send_getOrder(id)
1439 
    return self.recv_getOrder()
94 ashish 1440 
 
483 rajveer 1441 
  def send_getOrder(self, id):
1442 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1443 
    args = getOrder_args()
1444 
    args.id = id
94 ashish 1445 
    args.write(self._oprot)
1446 
    self._oprot.writeMessageEnd()
1447 
    self._oprot.trans.flush()
1448 
 
483 rajveer 1449 
  def recv_getOrder(self, ):
94 ashish 1450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1451 
    if mtype == TMessageType.EXCEPTION:
1452 
      x = TApplicationException()
1453 
      x.read(self._iprot)
1454 
      self._iprot.readMessageEnd()
1455 
      raise x
483 rajveer 1456 
    result = getOrder_result()
94 ashish 1457 
    result.read(self._iprot)
1458 
    self._iprot.readMessageEnd()
3431 rajveer 1459 
    if result.success is not None:
94 ashish 1460 
      return result.success
3431 rajveer 1461 
    if result.ex is not None:
94 ashish 1462 
      raise result.ex
483 rajveer 1463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1464 
 
483 rajveer 1465 
  def getLineItemsForOrder(self, orderId):
94 ashish 1466 
    """
1467 
    Parameters:
483 rajveer 1468 
     - orderId
94 ashish 1469 
    """
483 rajveer 1470 
    self.send_getLineItemsForOrder(orderId)
1471 
    return self.recv_getLineItemsForOrder()
94 ashish 1472 
 
483 rajveer 1473 
  def send_getLineItemsForOrder(self, orderId):
1474 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1475 
    args = getLineItemsForOrder_args()
1476 
    args.orderId = orderId
94 ashish 1477 
    args.write(self._oprot)
1478 
    self._oprot.writeMessageEnd()
1479 
    self._oprot.trans.flush()
1480 
 
483 rajveer 1481 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1483 
    if mtype == TMessageType.EXCEPTION:
1484 
      x = TApplicationException()
1485 
      x.read(self._iprot)
1486 
      self._iprot.readMessageEnd()
1487 
      raise x
483 rajveer 1488 
    result = getLineItemsForOrder_result()
94 ashish 1489 
    result.read(self._iprot)
1490 
    self._iprot.readMessageEnd()
3431 rajveer 1491 
    if result.success is not None:
94 ashish 1492 
      return result.success
3431 rajveer 1493 
    if result.ex is not None:
94 ashish 1494 
      raise result.ex
483 rajveer 1495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1496 
 
1528 ankur.sing 1497 
  def getOrderForCustomer(self, orderId, customerId):
1498 
    """
1499 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1500 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1501 
 
1528 ankur.sing 1502 
    Parameters:
1503 
     - orderId
1504 
     - customerId
1505 
    """
1506 
    self.send_getOrderForCustomer(orderId, customerId)
1507 
    return self.recv_getOrderForCustomer()
1508 
 
1509 
  def send_getOrderForCustomer(self, orderId, customerId):
1510 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1511 
    args = getOrderForCustomer_args()
1512 
    args.orderId = orderId
1513 
    args.customerId = customerId
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getOrderForCustomer(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getOrderForCustomer_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
3431 rajveer 1528 
    if result.success is not None:
1528 ankur.sing 1529 
      return result.success
3431 rajveer 1530 
    if result.ex is not None:
1528 ankur.sing 1531 
      raise result.ex
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1533 
 
3064 chandransh 1534 
  def getAlerts(self, orderId, valid):
1535 
    """
1536 
    Parameters:
1537 
     - orderId
1538 
     - valid
1539 
    """
1540 
    self.send_getAlerts(orderId, valid)
1541 
    return self.recv_getAlerts()
1542 
 
1543 
  def send_getAlerts(self, orderId, valid):
1544 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1545 
    args = getAlerts_args()
1546 
    args.orderId = orderId
1547 
    args.valid = valid
1548 
    args.write(self._oprot)
1549 
    self._oprot.writeMessageEnd()
1550 
    self._oprot.trans.flush()
1551 
 
1552 
  def recv_getAlerts(self, ):
1553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1554 
    if mtype == TMessageType.EXCEPTION:
1555 
      x = TApplicationException()
1556 
      x.read(self._iprot)
1557 
      self._iprot.readMessageEnd()
1558 
      raise x
1559 
    result = getAlerts_result()
1560 
    result.read(self._iprot)
1561 
    self._iprot.readMessageEnd()
3431 rajveer 1562 
    if result.success is not None:
3064 chandransh 1563 
      return result.success
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1565 
 
1566 
  def setAlert(self, orderId, unset, type, comment):
1567 
    """
1568 
    Parameters:
1569 
     - orderId
1570 
     - unset
1571 
     - type
1572 
     - comment
1573 
    """
1574 
    self.send_setAlert(orderId, unset, type, comment)
1575 
    self.recv_setAlert()
1576 
 
1577 
  def send_setAlert(self, orderId, unset, type, comment):
1578 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1579 
    args = setAlert_args()
1580 
    args.orderId = orderId
1581 
    args.unset = unset
1582 
    args.type = type
1583 
    args.comment = comment
1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_setAlert(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = setAlert_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
1598 
    return
1599 
 
1600 
  def getValidOrderCount(self, ):
1601 
    """
1602 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1603 
    """
1604 
    self.send_getValidOrderCount()
1605 
    return self.recv_getValidOrderCount()
1606 
 
1607 
  def send_getValidOrderCount(self, ):
1608 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1609 
    args = getValidOrderCount_args()
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getValidOrderCount(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getValidOrderCount_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
3431 rajveer 1624 
    if result.success is not None:
3064 chandransh 1625 
      return result.success
1626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1627 
 
1628 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1629 
    """
1630 
    Returns the number of distinct customers who have done successful transactions
1631 
    """
1632 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1633 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1634 
 
1635 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1636 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1637 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
3064 chandransh 1653 
      return result.success
1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1655 
 
1656 
  def getValidOrdersAmountRange(self, ):
1657 
    """
1658 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1659 
    List contains two values, first minimum amount and second maximum amount.
1660 
    """
1661 
    self.send_getValidOrdersAmountRange()
1662 
    return self.recv_getValidOrdersAmountRange()
1663 
 
1664 
  def send_getValidOrdersAmountRange(self, ):
1665 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1666 
    args = getValidOrdersAmountRange_args()
1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1671 
  def recv_getValidOrdersAmountRange(self, ):
1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1678 
    result = getValidOrdersAmountRange_result()
1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
3431 rajveer 1681 
    if result.success is not None:
3064 chandransh 1682 
      return result.success
1683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1684 
 
1685 
  def getValidOrders(self, limit):
1686 
    """
1687 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1688 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1689 
 
3064 chandransh 1690 
    Parameters:
1691 
     - limit
1692 
    """
1693 
    self.send_getValidOrders(limit)
1694 
    return self.recv_getValidOrders()
1695 
 
1696 
  def send_getValidOrders(self, limit):
1697 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1698 
    args = getValidOrders_args()
1699 
    args.limit = limit
1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_getValidOrders(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = getValidOrders_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
3431 rajveer 1714 
    if result.success is not None:
3064 chandransh 1715 
      return result.success
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1717 
 
1220 chandransh 1718 
  def batchOrders(self, warehouseId):
1719 
    """
1720 
    Create a batch of all the pending orders for the given warehouse.
1721 
    The returned list is orderd by created_timestamp.
1722 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1723 
 
1220 chandransh 1724 
    Parameters:
1725 
     - warehouseId
1726 
    """
1727 
    self.send_batchOrders(warehouseId)
1728 
    return self.recv_batchOrders()
1729 
 
1730 
  def send_batchOrders(self, warehouseId):
1731 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1732 
    args = batchOrders_args()
1733 
    args.warehouseId = warehouseId
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_batchOrders(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = batchOrders_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
3431 rajveer 1748 
    if result.success is not None:
1220 chandransh 1749 
      return result.success
3431 rajveer 1750 
    if result.ex is not None:
1220 chandransh 1751 
      raise result.ex
1752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1753 
 
1208 chandransh 1754 
  def markOrderAsOutOfStock(self, orderId):
1755 
    """
1756 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1757 
 
1208 chandransh 1758 
    Parameters:
1759 
     - orderId
1760 
    """
1761 
    self.send_markOrderAsOutOfStock(orderId)
1762 
    return self.recv_markOrderAsOutOfStock()
1763 
 
1764 
  def send_markOrderAsOutOfStock(self, orderId):
1765 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1766 
    args = markOrderAsOutOfStock_args()
1767 
    args.orderId = orderId
1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
1772 
  def recv_markOrderAsOutOfStock(self, ):
1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
1779 
    result = markOrderAsOutOfStock_result()
1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
3431 rajveer 1782 
    if result.success is not None:
1208 chandransh 1783 
      return result.success
3431 rajveer 1784 
    if result.ex is not None:
1208 chandransh 1785 
      raise result.ex
1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1787 
 
3064 chandransh 1788 
  def verifyOrder(self, orderId):
759 chandransh 1789 
    """
3064 chandransh 1790 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1791 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1792 
    used for all other orders as well.
1793 
    Throws an exception if no such order exists.
3431 rajveer 1794 
 
759 chandransh 1795 
    Parameters:
3064 chandransh 1796 
     - orderId
759 chandransh 1797 
    """
3064 chandransh 1798 
    self.send_verifyOrder(orderId)
1799 
    return self.recv_verifyOrder()
759 chandransh 1800 
 
3064 chandransh 1801 
  def send_verifyOrder(self, orderId):
1802 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1803 
    args = verifyOrder_args()
1804 
    args.orderId = orderId
759 chandransh 1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
3064 chandransh 1809 
  def recv_verifyOrder(self, ):
759 chandransh 1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
3064 chandransh 1816 
    result = verifyOrder_result()
759 chandransh 1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
3431 rajveer 1819 
    if result.success is not None:
759 chandransh 1820 
      return result.success
3431 rajveer 1821 
    if result.ex is not None:
759 chandransh 1822 
      raise result.ex
3064 chandransh 1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1824 
 
3064 chandransh 1825 
  def acceptOrder(self, orderId):
1113 chandransh 1826 
    """
3064 chandransh 1827 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1828 
    given order is not a COD order, it also captures the payment if the same has
1829 
    not been captured.
1830 
    Throws an exception if no such order exists.
3431 rajveer 1831 
 
1113 chandransh 1832 
    Parameters:
3064 chandransh 1833 
     - orderId
1113 chandransh 1834 
    """
3064 chandransh 1835 
    self.send_acceptOrder(orderId)
1836 
    return self.recv_acceptOrder()
1113 chandransh 1837 
 
3064 chandransh 1838 
  def send_acceptOrder(self, orderId):
1839 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1840 
    args = acceptOrder_args()
1841 
    args.orderId = orderId
1113 chandransh 1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
3064 chandransh 1846 
  def recv_acceptOrder(self, ):
1113 chandransh 1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
3064 chandransh 1853 
    result = acceptOrder_result()
1113 chandransh 1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
3431 rajveer 1856 
    if result.success is not None:
1113 chandransh 1857 
      return result.success
3431 rajveer 1858 
    if result.ex is not None:
1113 chandransh 1859 
      raise result.ex
3064 chandransh 1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1861 
 
4283 anupam.sin 1862 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1863 
    """
3064 chandransh 1864 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1865 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1866 
    the IMEI no. if a -1 is supplied.
1867 
    Also, it generates an invoice number for the order, marks the order as
1868 
    BILLED and sets the billing timestamp.
1869 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1870 
 
1135 chandransh 1871 
    Parameters:
3064 chandransh 1872 
     - orderId
1873 
     - invoice_number
4283 anupam.sin 1874 
     - imeiNumber
1875 
     - itemNumber
3064 chandransh 1876 
     - billed_by
4264 rajveer 1877 
     - jacketNumber
4283 anupam.sin 1878 
     - billingType
1879 
     - vendorId
1135 chandransh 1880 
    """
4283 anupam.sin 1881 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1882 
    return self.recv_addBillingDetails()
1135 chandransh 1883 
 
4283 anupam.sin 1884 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1885 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1886 
    args = addBillingDetails_args()
1887 
    args.orderId = orderId
1888 
    args.invoice_number = invoice_number
4283 anupam.sin 1889 
    args.imeiNumber = imeiNumber
1890 
    args.itemNumber = itemNumber
3064 chandransh 1891 
    args.billed_by = billed_by
4264 rajveer 1892 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1893 
    args.billingType = billingType
1894 
    args.vendorId = vendorId
1135 chandransh 1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
3064 chandransh 1899 
  def recv_addBillingDetails(self, ):
1135 chandransh 1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
3064 chandransh 1906 
    result = addBillingDetails_result()
1135 chandransh 1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
3064 chandransh 1910 
      return result.success
3431 rajveer 1911 
    if result.ex is not None:
1135 chandransh 1912 
      raise result.ex
3064 chandransh 1913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1914 
 
3064 chandransh 1915 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1916 
    """
3064 chandransh 1917 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1918 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1919 
 
1408 ankur.sing 1920 
    Parameters:
3064 chandransh 1921 
     - warehouseId
1408 ankur.sing 1922 
     - providerId
3064 chandransh 1923 
     - cod
1408 ankur.sing 1924 
    """
3064 chandransh 1925 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1926 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1927 
 
3064 chandransh 1928 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1929 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1930 
    args = markOrdersAsManifested_args()
1931 
    args.warehouseId = warehouseId
1408 ankur.sing 1932 
    args.providerId = providerId
3064 chandransh 1933 
    args.cod = cod
1408 ankur.sing 1934 
    args.write(self._oprot)
1935 
    self._oprot.writeMessageEnd()
1936 
    self._oprot.trans.flush()
1937 
 
3064 chandransh 1938 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1940 
    if mtype == TMessageType.EXCEPTION:
1941 
      x = TApplicationException()
1942 
      x.read(self._iprot)
1943 
      self._iprot.readMessageEnd()
1944 
      raise x
3064 chandransh 1945 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1946 
    result.read(self._iprot)
1947 
    self._iprot.readMessageEnd()
3431 rajveer 1948 
    if result.success is not None:
1408 ankur.sing 1949 
      return result.success
3431 rajveer 1950 
    if result.ex is not None:
3064 chandransh 1951 
      raise result.ex
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1953 
 
3064 chandransh 1954 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1955 
    """
3064 chandransh 1956 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1957 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1958 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1959 
 
94 ashish 1960 
    Parameters:
3064 chandransh 1961 
     - providerId
1962 
     - pickupDetails
304 ashish 1963 
    """
3064 chandransh 1964 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1965 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1966 
 
3064 chandransh 1967 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1968 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1969 
    args = markOrdersAsPickedUp_args()
1970 
    args.providerId = providerId
1971 
    args.pickupDetails = pickupDetails
304 ashish 1972 
    args.write(self._oprot)
1973 
    self._oprot.writeMessageEnd()
1974 
    self._oprot.trans.flush()
1975 
 
3064 chandransh 1976 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1978 
    if mtype == TMessageType.EXCEPTION:
1979 
      x = TApplicationException()
1980 
      x.read(self._iprot)
1981 
      self._iprot.readMessageEnd()
1982 
      raise x
3064 chandransh 1983 
    result = markOrdersAsPickedUp_result()
304 ashish 1984 
    result.read(self._iprot)
1985 
    self._iprot.readMessageEnd()
3431 rajveer 1986 
    if result.success is not None:
304 ashish 1987 
      return result.success
3431 rajveer 1988 
    if result.ex is not None:
3064 chandransh 1989 
      raise result.ex
1990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1991 
 
3064 chandransh 1992 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1993 
    """
3064 chandransh 1994 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1995 
    the name of the receiver.
1996 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1997 
 
304 ashish 1998 
    Parameters:
3064 chandransh 1999 
     - providerId
2000 
     - deliveredOrders
304 ashish 2001 
    """
3064 chandransh 2002 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2003 
    self.recv_markOrdersAsDelivered()
304 ashish 2004 
 
3064 chandransh 2005 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2006 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2007 
    args = markOrdersAsDelivered_args()
2008 
    args.providerId = providerId
2009 
    args.deliveredOrders = deliveredOrders
304 ashish 2010 
    args.write(self._oprot)
2011 
    self._oprot.writeMessageEnd()
2012 
    self._oprot.trans.flush()
2013 
 
3064 chandransh 2014 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2016 
    if mtype == TMessageType.EXCEPTION:
2017 
      x = TApplicationException()
2018 
      x.read(self._iprot)
2019 
      self._iprot.readMessageEnd()
2020 
      raise x
3064 chandransh 2021 
    result = markOrdersAsDelivered_result()
304 ashish 2022 
    result.read(self._iprot)
2023 
    self._iprot.readMessageEnd()
3431 rajveer 2024 
    if result.ex is not None:
3064 chandransh 2025 
      raise result.ex
304 ashish 2026 
    return
2027 
 
3064 chandransh 2028 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2029 
    """
3064 chandransh 2030 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2031 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2032 
 
3064 chandransh 2033 
    Parameters:
2034 
     - providerId
2035 
     - returnedOrders
1596 ankur.sing 2036 
    """
3064 chandransh 2037 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2038 
    self.recv_markOrdersAsFailed()
304 ashish 2039 
 
3064 chandransh 2040 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2041 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2042 
    args = markOrdersAsFailed_args()
2043 
    args.providerId = providerId
2044 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
3064 chandransh 2049 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
3064 chandransh 2056 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.ex is not None:
3064 chandransh 2060 
      raise result.ex
2061 
    return
1596 ankur.sing 2062 
 
3064 chandransh 2063 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2064 
    """
3064 chandransh 2065 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2066 
 
3064 chandransh 2067 
    Parameters:
2068 
     - providerId
2069 
     - undeliveredOrders
1627 ankur.sing 2070 
    """
3064 chandransh 2071 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2072 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2073 
 
3064 chandransh 2074 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2075 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2076 
    args = updateNonDeliveryReason_args()
2077 
    args.providerId = providerId
2078 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
3064 chandransh 2083 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
3064 chandransh 2090 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
3431 rajveer 2093 
    if result.ex is not None:
3064 chandransh 2094 
      raise result.ex
2095 
    return
1627 ankur.sing 2096 
 
3064 chandransh 2097 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2098 
    """
3064 chandransh 2099 
    Returns the list of orders whose delivery time has passed but have not been
2100 
    delivered yet for the given provider and warehouse. To get a complete list of
2101 
    undelivered orders, pass them as -1.
2102 
    Returns an empty list if no such orders exist.
3431 rajveer 2103 
 
1886 ankur.sing 2104 
    Parameters:
3064 chandransh 2105 
     - providerId
2106 
     - warehouseId
1886 ankur.sing 2107 
    """
3064 chandransh 2108 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2109 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2110 
 
3064 chandransh 2111 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2112 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2113 
    args = getUndeliveredOrders_args()
2114 
    args.providerId = providerId
2115 
    args.warehouseId = warehouseId
1886 ankur.sing 2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
3064 chandransh 2120 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
3064 chandransh 2127 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
3431 rajveer 2130 
    if result.success is not None:
1886 ankur.sing 2131 
      return result.success
3064 chandransh 2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2133 
 
2536 chandransh 2134 
  def toggleDOAFlag(self, orderId):
2135 
    """
2136 
    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.
2137 
    Returns the final flag status.
2138 
    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 2139 
 
2536 chandransh 2140 
    Parameters:
2141 
     - orderId
2142 
    """
2143 
    self.send_toggleDOAFlag(orderId)
2144 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2145 
 
2536 chandransh 2146 
  def send_toggleDOAFlag(self, orderId):
2147 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2148 
    args = toggleDOAFlag_args()
2149 
    args.orderId = orderId
2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
2154 
  def recv_toggleDOAFlag(self, ):
2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
2161 
    result = toggleDOAFlag_result()
2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
3431 rajveer 2164 
    if result.success is not None:
2536 chandransh 2165 
      return result.success
3431 rajveer 2166 
    if result.ex is not None:
2536 chandransh 2167 
      raise result.ex
2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2169 
 
2170 
  def requestPickupNumber(self, orderId):
2171 
    """
2172 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2173 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2174 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2175 
    For any other status, it returns false.
2176 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2177 
 
2536 chandransh 2178 
    Parameters:
2179 
     - orderId
2180 
    """
2181 
    self.send_requestPickupNumber(orderId)
2182 
    return self.recv_requestPickupNumber()
2183 
 
2184 
  def send_requestPickupNumber(self, orderId):
2185 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2186 
    args = requestPickupNumber_args()
2187 
    args.orderId = orderId
2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
2192 
  def recv_requestPickupNumber(self, ):
2193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2194 
    if mtype == TMessageType.EXCEPTION:
2195 
      x = TApplicationException()
2196 
      x.read(self._iprot)
2197 
      self._iprot.readMessageEnd()
2198 
      raise x
2199 
    result = requestPickupNumber_result()
2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
3431 rajveer 2202 
    if result.success is not None:
2536 chandransh 2203 
      return result.success
3431 rajveer 2204 
    if result.ex is not None:
2536 chandransh 2205 
      raise result.ex
2206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2207 
 
2208 
  def authorizePickup(self, orderId, pickupNumber):
2209 
    """
2210 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2211 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2212 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2213 
    	3. Returns true
2591 chandransh 2214 
    If the order is in any other status, it returns false.
2536 chandransh 2215 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2216 
 
2536 chandransh 2217 
    Parameters:
2218 
     - orderId
2219 
     - pickupNumber
2220 
    """
2221 
    self.send_authorizePickup(orderId, pickupNumber)
2222 
    return self.recv_authorizePickup()
2223 
 
2224 
  def send_authorizePickup(self, orderId, pickupNumber):
2225 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2226 
    args = authorizePickup_args()
2227 
    args.orderId = orderId
2228 
    args.pickupNumber = pickupNumber
2229 
    args.write(self._oprot)
2230 
    self._oprot.writeMessageEnd()
2231 
    self._oprot.trans.flush()
2232 
 
2233 
  def recv_authorizePickup(self, ):
2234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2235 
    if mtype == TMessageType.EXCEPTION:
2236 
      x = TApplicationException()
2237 
      x.read(self._iprot)
2238 
      self._iprot.readMessageEnd()
2239 
      raise x
2240 
    result = authorizePickup_result()
2241 
    result.read(self._iprot)
2242 
    self._iprot.readMessageEnd()
3431 rajveer 2243 
    if result.success is not None:
2536 chandransh 2244 
      return result.success
3431 rajveer 2245 
    if result.ex is not None:
2536 chandransh 2246 
      raise result.ex
2247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2248 
 
2764 chandransh 2249 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2250 
    """
2251 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2252 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2253 
 
2764 chandransh 2254 
    Parameters:
2255 
     - providerId
2256 
     - pickupDetails
2257 
    """
2258 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2259 
    return self.recv_markDoasAsPickedUp()
2260 
 
2261 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2262 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2263 
    args = markDoasAsPickedUp_args()
2264 
    args.providerId = providerId
2265 
    args.pickupDetails = pickupDetails
2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
2270 
  def recv_markDoasAsPickedUp(self, ):
2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
2277 
    result = markDoasAsPickedUp_result()
2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
3431 rajveer 2280 
    if result.success is not None:
2764 chandransh 2281 
      return result.success
2282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2283 
 
2616 chandransh 2284 
  def receiveReturn(self, orderId):
2591 chandransh 2285 
    """
2599 chandransh 2286 
    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 2287 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2288 
    If the order is in any other state, it returns false.
2289 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2290 
 
2591 chandransh 2291 
    Parameters:
2292 
     - orderId
2293 
    """
2616 chandransh 2294 
    self.send_receiveReturn(orderId)
2295 
    return self.recv_receiveReturn()
2536 chandransh 2296 
 
2616 chandransh 2297 
  def send_receiveReturn(self, orderId):
2298 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2299 
    args = receiveReturn_args()
2591 chandransh 2300 
    args.orderId = orderId
2301 
    args.write(self._oprot)
2302 
    self._oprot.writeMessageEnd()
2303 
    self._oprot.trans.flush()
2304 
 
2616 chandransh 2305 
  def recv_receiveReturn(self, ):
2591 chandransh 2306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2307 
    if mtype == TMessageType.EXCEPTION:
2308 
      x = TApplicationException()
2309 
      x.read(self._iprot)
2310 
      self._iprot.readMessageEnd()
2311 
      raise x
2616 chandransh 2312 
    result = receiveReturn_result()
2591 chandransh 2313 
    result.read(self._iprot)
2314 
    self._iprot.readMessageEnd()
3431 rajveer 2315 
    if result.success is not None:
2591 chandransh 2316 
      return result.success
3431 rajveer 2317 
    if result.ex is not None:
2591 chandransh 2318 
      raise result.ex
2616 chandransh 2319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2320 
 
2321 
  def validateDoa(self, orderId, isValid):
2322 
    """
2599 chandransh 2323 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2324 
    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 2325 
    If the order is in any other state, it returns false.
2326 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2327 
 
2591 chandransh 2328 
    Parameters:
2329 
     - orderId
2330 
     - isValid
2331 
    """
2332 
    self.send_validateDoa(orderId, isValid)
2333 
    return self.recv_validateDoa()
2334 
 
2335 
  def send_validateDoa(self, orderId, isValid):
2336 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2337 
    args = validateDoa_args()
2338 
    args.orderId = orderId
2339 
    args.isValid = isValid
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_validateDoa(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = validateDoa_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
3431 rajveer 2354 
    if result.success is not None:
2591 chandransh 2355 
      return result.success
3431 rajveer 2356 
    if result.ex is not None:
2591 chandransh 2357 
      raise result.ex
2358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2359 
 
2616 chandransh 2360 
  def reshipOrder(self, orderId):
2361 
    """
2362 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2363 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2364 
    	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.
2365 
 
2366 
    If the order is in DOA_CERT_VALID state, it does the following:
2367 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2368 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2369 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2370 
 
2616 chandransh 2371 
    Returns the id of the newly created order.
3431 rajveer 2372 
 
2616 chandransh 2373 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2374 
 
2616 chandransh 2375 
    Parameters:
2376 
     - orderId
2377 
    """
2378 
    self.send_reshipOrder(orderId)
2379 
    return self.recv_reshipOrder()
2591 chandransh 2380 
 
2616 chandransh 2381 
  def send_reshipOrder(self, orderId):
2382 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2383 
    args = reshipOrder_args()
2384 
    args.orderId = orderId
2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
2389 
  def recv_reshipOrder(self, ):
2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
2396 
    result = reshipOrder_result()
2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
3431 rajveer 2399 
    if result.success is not None:
2616 chandransh 2400 
      return result.success
3431 rajveer 2401 
    if result.ex is not None:
2616 chandransh 2402 
      raise result.ex
2403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2404 
 
3226 chandransh 2405 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2406 
    """
2407 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2408 
    	1. Creates a refund request for batch processing.
2409 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2410 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2411 
 
2616 chandransh 2412 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2413 
    	1. Creates a refund request for batch processing.
3226 chandransh 2414 
    	2. Cancels the reservation of the item in the warehouse.
2415 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2416 
 
3226 chandransh 2417 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2418 
    	1. Cancels the reservation of the item in the warehouse.
2419 
    	2. Marks the current order as CANCELED.
2420 
 
2421 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2422 
 
2616 chandransh 2423 
    Returns True if it is successful, False otherwise.
3431 rajveer 2424 
 
2616 chandransh 2425 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2426 
 
2616 chandransh 2427 
    Parameters:
2428 
     - orderId
3226 chandransh 2429 
     - refundedBy
2430 
     - reason
2616 chandransh 2431 
    """
3226 chandransh 2432 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2433 
    return self.recv_refundOrder()
2434 
 
3226 chandransh 2435 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2436 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2437 
    args = refundOrder_args()
2438 
    args.orderId = orderId
3226 chandransh 2439 
    args.refundedBy = refundedBy
2440 
    args.reason = reason
2616 chandransh 2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_refundOrder(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = refundOrder_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
3431 rajveer 2455 
    if result.success is not None:
2616 chandransh 2456 
      return result.success
3431 rajveer 2457 
    if result.ex is not None:
2616 chandransh 2458 
      raise result.ex
2459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2460 
 
2690 chandransh 2461 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2462 
    """
2463 
    Get all return orders created between the from and to dates for the given warehouse.
2464 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2465 
 
2690 chandransh 2466 
    Parameters:
2467 
     - warehouseId
2468 
     - fromDate
2469 
     - toDate
2470 
    """
2471 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2472 
    return self.recv_getReturnOrders()
2616 chandransh 2473 
 
2690 chandransh 2474 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2475 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2476 
    args = getReturnOrders_args()
2477 
    args.warehouseId = warehouseId
2478 
    args.fromDate = fromDate
2479 
    args.toDate = toDate
2480 
    args.write(self._oprot)
2481 
    self._oprot.writeMessageEnd()
2482 
    self._oprot.trans.flush()
2483 
 
2484 
  def recv_getReturnOrders(self, ):
2485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2486 
    if mtype == TMessageType.EXCEPTION:
2487 
      x = TApplicationException()
2488 
      x.read(self._iprot)
2489 
      self._iprot.readMessageEnd()
2490 
      raise x
2491 
    result = getReturnOrders_result()
2492 
    result.read(self._iprot)
2493 
    self._iprot.readMessageEnd()
3431 rajveer 2494 
    if result.success is not None:
2690 chandransh 2495 
      return result.success
2496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2497 
 
2700 chandransh 2498 
  def getReturnOrder(self, id):
2499 
    """
2500 
    Returns the ReturnOrder corresponding to the given id.
2501 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2502 
 
2700 chandransh 2503 
    Parameters:
2504 
     - id
2505 
    """
2506 
    self.send_getReturnOrder(id)
2507 
    return self.recv_getReturnOrder()
2508 
 
2509 
  def send_getReturnOrder(self, id):
2510 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2511 
    args = getReturnOrder_args()
2512 
    args.id = id
2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
2517 
  def recv_getReturnOrder(self, ):
2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
2524 
    result = getReturnOrder_result()
2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
3431 rajveer 2527 
    if result.success is not None:
2700 chandransh 2528 
      return result.success
3431 rajveer 2529 
    if result.ex is not None:
2700 chandransh 2530 
      raise result.ex
2531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2532 
 
2690 chandransh 2533 
  def processReturn(self, returnOrderId):
2534 
    """
2535 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2536 
 
2690 chandransh 2537 
    Parameters:
2538 
     - returnOrderId
2539 
    """
2540 
    self.send_processReturn(returnOrderId)
2541 
    self.recv_processReturn()
2542 
 
2543 
  def send_processReturn(self, returnOrderId):
2544 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2545 
    args = processReturn_args()
2546 
    args.returnOrderId = returnOrderId
2547 
    args.write(self._oprot)
2548 
    self._oprot.writeMessageEnd()
2549 
    self._oprot.trans.flush()
2550 
 
2551 
  def recv_processReturn(self, ):
2552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2553 
    if mtype == TMessageType.EXCEPTION:
2554 
      x = TApplicationException()
2555 
      x.read(self._iprot)
2556 
      self._iprot.readMessageEnd()
2557 
      raise x
2558 
    result = processReturn_result()
2559 
    result.read(self._iprot)
2560 
    self._iprot.readMessageEnd()
3431 rajveer 2561 
    if result.ex is not None:
2690 chandransh 2562 
      raise result.ex
2563 
    return
2564 
 
2819 chandransh 2565 
  def createPurchaseOrder(self, warehouseId):
2566 
    """
2567 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2568 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2569 
 
2819 chandransh 2570 
    Parameters:
2571 
     - warehouseId
2572 
    """
2573 
    self.send_createPurchaseOrder(warehouseId)
2574 
    return self.recv_createPurchaseOrder()
2690 chandransh 2575 
 
2819 chandransh 2576 
  def send_createPurchaseOrder(self, warehouseId):
2577 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2578 
    args = createPurchaseOrder_args()
2579 
    args.warehouseId = warehouseId
2580 
    args.write(self._oprot)
2581 
    self._oprot.writeMessageEnd()
2582 
    self._oprot.trans.flush()
2583 
 
2584 
  def recv_createPurchaseOrder(self, ):
2585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2586 
    if mtype == TMessageType.EXCEPTION:
2587 
      x = TApplicationException()
2588 
      x.read(self._iprot)
2589 
      self._iprot.readMessageEnd()
2590 
      raise x
2591 
    result = createPurchaseOrder_result()
2592 
    result.read(self._iprot)
2593 
    self._iprot.readMessageEnd()
3431 rajveer 2594 
    if result.success is not None:
2819 chandransh 2595 
      return result.success
3431 rajveer 2596 
    if result.ex is not None:
2819 chandransh 2597 
      raise result.ex
2598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2599 
 
3451 chandransh 2600 
  def updateWeight(self, orderId, weight):
2601 
    """
2602 
    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 2603 
 
3451 chandransh 2604 
    Parameters:
2605 
     - orderId
2606 
     - weight
2607 
    """
2608 
    self.send_updateWeight(orderId, weight)
2609 
    return self.recv_updateWeight()
2610 
 
2611 
  def send_updateWeight(self, orderId, weight):
2612 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2613 
    args = updateWeight_args()
2614 
    args.orderId = orderId
2615 
    args.weight = weight
2616 
    args.write(self._oprot)
2617 
    self._oprot.writeMessageEnd()
2618 
    self._oprot.trans.flush()
2619 
 
2620 
  def recv_updateWeight(self, ):
2621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2622 
    if mtype == TMessageType.EXCEPTION:
2623 
      x = TApplicationException()
2624 
      x.read(self._iprot)
2625 
      self._iprot.readMessageEnd()
2626 
      raise x
2627 
    result = updateWeight_result()
2628 
    result.read(self._iprot)
2629 
    self._iprot.readMessageEnd()
2630 
    if result.success is not None:
2631 
      return result.success
2632 
    if result.ex is not None:
2633 
      raise result.ex
2634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2635 
 
3469 chandransh 2636 
  def changeItem(self, orderId, itemId):
2637 
    """
2638 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2639 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2640 
 
3469 chandransh 2641 
    Parameters:
2642 
     - orderId
2643 
     - itemId
2644 
    """
2645 
    self.send_changeItem(orderId, itemId)
2646 
    return self.recv_changeItem()
2647 
 
2648 
  def send_changeItem(self, orderId, itemId):
2649 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2650 
    args = changeItem_args()
2651 
    args.orderId = orderId
2652 
    args.itemId = itemId
2653 
    args.write(self._oprot)
2654 
    self._oprot.writeMessageEnd()
2655 
    self._oprot.trans.flush()
2656 
 
2657 
  def recv_changeItem(self, ):
2658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2659 
    if mtype == TMessageType.EXCEPTION:
2660 
      x = TApplicationException()
2661 
      x.read(self._iprot)
2662 
      self._iprot.readMessageEnd()
2663 
      raise x
2664 
    result = changeItem_result()
2665 
    result.read(self._iprot)
2666 
    self._iprot.readMessageEnd()
2667 
    if result.success is not None:
2668 
      return result.success
2669 
    if result.ex is not None:
2670 
      raise result.ex
2671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2672 
 
2673 
  def shiftToWarehouse(self, orderId, warehouseId):
2674 
    """
2675 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2676 
 
2677 
    Parameters:
2678 
     - orderId
2679 
     - warehouseId
2680 
    """
2681 
    self.send_shiftToWarehouse(orderId, warehouseId)
2682 
    return self.recv_shiftToWarehouse()
2683 
 
2684 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2685 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2686 
    args = shiftToWarehouse_args()
2687 
    args.orderId = orderId
2688 
    args.warehouseId = warehouseId
2689 
    args.write(self._oprot)
2690 
    self._oprot.writeMessageEnd()
2691 
    self._oprot.trans.flush()
2692 
 
2693 
  def recv_shiftToWarehouse(self, ):
2694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2695 
    if mtype == TMessageType.EXCEPTION:
2696 
      x = TApplicationException()
2697 
      x.read(self._iprot)
2698 
      self._iprot.readMessageEnd()
2699 
      raise x
2700 
    result = shiftToWarehouse_result()
2701 
    result.read(self._iprot)
2702 
    self._iprot.readMessageEnd()
2703 
    if result.success is not None:
2704 
      return result.success
2705 
    if result.ex is not None:
2706 
      raise result.ex
2707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2708 
 
3986 chandransh 2709 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2710 
    """
2711 
    Adds the given delay reason to the given order.
3986 chandransh 2712 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2713 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2714 
 
3553 chandransh 2715 
    Parameters:
2716 
     - orderId
2717 
     - delayReason
3986 chandransh 2718 
     - furtherDelay
3553 chandransh 2719 
    """
3986 chandransh 2720 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2721 
    return self.recv_addDelayReason()
2722 
 
3986 chandransh 2723 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2724 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2725 
    args = addDelayReason_args()
2726 
    args.orderId = orderId
2727 
    args.delayReason = delayReason
3986 chandransh 2728 
    args.furtherDelay = furtherDelay
3553 chandransh 2729 
    args.write(self._oprot)
2730 
    self._oprot.writeMessageEnd()
2731 
    self._oprot.trans.flush()
2732 
 
2733 
  def recv_addDelayReason(self, ):
2734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2735 
    if mtype == TMessageType.EXCEPTION:
2736 
      x = TApplicationException()
2737 
      x.read(self._iprot)
2738 
      self._iprot.readMessageEnd()
2739 
      raise x
2740 
    result = addDelayReason_result()
2741 
    result.read(self._iprot)
2742 
    self._iprot.readMessageEnd()
2743 
    if result.success is not None:
2744 
      return result.success
2745 
    if result.ex is not None:
2746 
      raise result.ex
2747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2748 
 
3956 chandransh 2749 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2750 
    """
2751 
    Marks the COD orders with given AWB nos. as having been processed.
2752 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2753 
 
3956 chandransh 2754 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2755 
    1. There is no order corresponding to an AWB number.
2756 
    2. The captured amount for a payment exceeds the total payment.
2757 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2758 
 
2759 
    Parameters:
2760 
     - collectedAmountMap
2761 
     - xferBy
2762 
     - xferTxnId
2763 
     - xferDate
2764 
    """
2765 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2766 
    return self.recv_reconcileCodCollection()
2767 
 
2768 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2769 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2770 
    args = reconcileCodCollection_args()
2771 
    args.collectedAmountMap = collectedAmountMap
2772 
    args.xferBy = xferBy
2773 
    args.xferTxnId = xferTxnId
2774 
    args.xferDate = xferDate
2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
2779 
  def recv_reconcileCodCollection(self, ):
2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
2786 
    result = reconcileCodCollection_result()
2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
2789 
    if result.success is not None:
2790 
      return result.success
2791 
    if result.ex is not None:
2792 
      raise result.ex
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2794 
 
4008 mandeep.dh 2795 
  def getTransactionsRequiringExtraProcessing(self, category):
2796 
    """
4065 mandeep.dh 2797 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2798 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2799 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2800 
 
4008 mandeep.dh 2801 
    Parameters:
2802 
     - category
2803 
    """
2804 
    self.send_getTransactionsRequiringExtraProcessing(category)
2805 
    return self.recv_getTransactionsRequiringExtraProcessing()
2806 
 
2807 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2808 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2809 
    args = getTransactionsRequiringExtraProcessing_args()
2810 
    args.category = category
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
2822 
    result = getTransactionsRequiringExtraProcessing_result()
2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
2825 
    if result.success is not None:
2826 
      return result.success
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2828 
 
2829 
  def markTransactionAsProcessed(self, transactionId, category):
2830 
    """
2831 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2832 
    It essentially deletes the transaction id record for a particular
2833 
    processing type category (if present) from DB.
2834 
    This is currently used by CRM application.
4008 mandeep.dh 2835 
 
2836 
    Parameters:
2837 
     - transactionId
2838 
     - category
2839 
    """
2840 
    self.send_markTransactionAsProcessed(transactionId, category)
2841 
    self.recv_markTransactionAsProcessed()
2842 
 
2843 
  def send_markTransactionAsProcessed(self, transactionId, category):
2844 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2845 
    args = markTransactionAsProcessed_args()
2846 
    args.transactionId = transactionId
2847 
    args.category = category
2848 
    args.write(self._oprot)
2849 
    self._oprot.writeMessageEnd()
2850 
    self._oprot.trans.flush()
2851 
 
2852 
  def recv_markTransactionAsProcessed(self, ):
2853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2854 
    if mtype == TMessageType.EXCEPTION:
2855 
      x = TApplicationException()
2856 
      x.read(self._iprot)
2857 
      self._iprot.readMessageEnd()
2858 
      raise x
2859 
    result = markTransactionAsProcessed_result()
2860 
    result.read(self._iprot)
2861 
    self._iprot.readMessageEnd()
2862 
    return
2863 
 
4018 chandransh 2864 
  def getItemWiseRiskyOrdersCount(self, ):
2865 
    """
2866 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2867 
    is defined as one whose shipping date is about to expire.
2868 
    """
2869 
    self.send_getItemWiseRiskyOrdersCount()
2870 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2871 
 
4018 chandransh 2872 
  def send_getItemWiseRiskyOrdersCount(self, ):
2873 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2874 
    args = getItemWiseRiskyOrdersCount_args()
2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = getItemWiseRiskyOrdersCount_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
2889 
    if result.success is not None:
2890 
      return result.success
2891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2892 
 
4295 varun.gupt 2893 
  def getOrdersForItemIds(self, itemIds):
2894 
    """
2895 
    Returns a list of all orders which have items with given id
2896 
 
2897 
    Parameters:
2898 
     - itemIds
2899 
    """
2900 
    self.send_getOrdersForItemIds(itemIds)
2901 
    return self.recv_getOrdersForItemIds()
2902 
 
2903 
  def send_getOrdersForItemIds(self, itemIds):
2904 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2905 
    args = getOrdersForItemIds_args()
2906 
    args.itemIds = itemIds
2907 
    args.write(self._oprot)
2908 
    self._oprot.writeMessageEnd()
2909 
    self._oprot.trans.flush()
2910 
 
2911 
  def recv_getOrdersForItemIds(self, ):
2912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2913 
    if mtype == TMessageType.EXCEPTION:
2914 
      x = TApplicationException()
2915 
      x.read(self._iprot)
2916 
      self._iprot.readMessageEnd()
2917 
      raise x
2918 
    result = getOrdersForItemIds_result()
2919 
    result.read(self._iprot)
2920 
    self._iprot.readMessageEnd()
2921 
    if result.success is not None:
2922 
      return result.success
2923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2924 
 
4247 rajveer 2925 
  def markOrderCancellationRequestReceived(self, orderId):
2926 
    """
2927 
    Mark order as cancellation request received. If customer sends request of cancellation of
2928 
    a particular order, this method will be called. It will just change status of the order
2929 
    depending on its current status. It also records the previous status, so that we can move
2930 
    back to that status if cancellation request is denied.
4018 chandransh 2931 
 
4247 rajveer 2932 
    Parameters:
2933 
     - orderId
2934 
    """
2935 
    self.send_markOrderCancellationRequestReceived(orderId)
2936 
    self.recv_markOrderCancellationRequestReceived()
2937 
 
2938 
  def send_markOrderCancellationRequestReceived(self, orderId):
2939 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2940 
    args = markOrderCancellationRequestReceived_args()
2941 
    args.orderId = orderId
2942 
    args.write(self._oprot)
2943 
    self._oprot.writeMessageEnd()
2944 
    self._oprot.trans.flush()
2945 
 
2946 
  def recv_markOrderCancellationRequestReceived(self, ):
2947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2948 
    if mtype == TMessageType.EXCEPTION:
2949 
      x = TApplicationException()
2950 
      x.read(self._iprot)
2951 
      self._iprot.readMessageEnd()
2952 
      raise x
2953 
    result = markOrderCancellationRequestReceived_result()
2954 
    result.read(self._iprot)
2955 
    self._iprot.readMessageEnd()
2956 
    if result.ex is not None:
2957 
      raise result.ex
2958 
    return
2959 
 
2960 
  def markOrderCancellationRequestConfirmed(self, orderId):
2961 
    """
2962 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2963 
    cancellation request confirmed. After this OM will be able to cancel the order.
2964 
 
2965 
    Parameters:
2966 
     - orderId
2967 
    """
2968 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2969 
    self.recv_markOrderCancellationRequestConfirmed()
2970 
 
2971 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2972 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2973 
    args = markOrderCancellationRequestConfirmed_args()
2974 
    args.orderId = orderId
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = markOrderCancellationRequestConfirmed_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
2989 
    if result.ex is not None:
2990 
      raise result.ex
2991 
    return
2992 
 
2993 
  def markOrderCancellationRequestDenied(self, orderId):
2994 
    """
2995 
    If we decide to not to cancel order, we will move the order ro previous status.
2996 
 
2997 
    Parameters:
2998 
     - orderId
2999 
    """
3000 
    self.send_markOrderCancellationRequestDenied(orderId)
3001 
    self.recv_markOrderCancellationRequestDenied()
3002 
 
3003 
  def send_markOrderCancellationRequestDenied(self, orderId):
3004 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3005 
    args = markOrderCancellationRequestDenied_args()
3006 
    args.orderId = orderId
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_markOrderCancellationRequestDenied(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = markOrderCancellationRequestDenied_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.ex is not None:
3022 
      raise result.ex
3023 
    return
3024 
 
4258 rajveer 3025 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3026 
    """
4258 rajveer 3027 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3028 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3029 
 
3030 
    Parameters:
4258 rajveer 3031 
     - transactionId
4247 rajveer 3032 
    """
4258 rajveer 3033 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3034 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3035 
 
4258 rajveer 3036 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3037 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3038 
    args = markTransactionAsPaymentFlagRemoved_args()
3039 
    args.transactionId = transactionId
4247 rajveer 3040 
    args.write(self._oprot)
3041 
    self._oprot.writeMessageEnd()
3042 
    self._oprot.trans.flush()
3043 
 
4258 rajveer 3044 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3046 
    if mtype == TMessageType.EXCEPTION:
3047 
      x = TApplicationException()
3048 
      x.read(self._iprot)
3049 
      self._iprot.readMessageEnd()
3050 
      raise x
4258 rajveer 3051 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3052 
    result.read(self._iprot)
3053 
    self._iprot.readMessageEnd()
3054 
    if result.ex is not None:
3055 
      raise result.ex
3056 
    return
3057 
 
4259 anupam.sin 3058 
  def refundTransaction(self, transactionId, refundedBy, reason):
3059 
    """
3060 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3061 
    need to be cancelled
4247 rajveer 3062 
 
4259 anupam.sin 3063 
    Parameters:
3064 
     - transactionId
3065 
     - refundedBy
3066 
     - reason
3067 
    """
3068 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3069 
    self.recv_refundTransaction()
3070 
 
3071 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3072 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3073 
    args = refundTransaction_args()
3074 
    args.transactionId = transactionId
3075 
    args.refundedBy = refundedBy
3076 
    args.reason = reason
3077 
    args.write(self._oprot)
3078 
    self._oprot.writeMessageEnd()
3079 
    self._oprot.trans.flush()
3080 
 
3081 
  def recv_refundTransaction(self, ):
3082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3083 
    if mtype == TMessageType.EXCEPTION:
3084 
      x = TApplicationException()
3085 
      x.read(self._iprot)
3086 
      self._iprot.readMessageEnd()
3087 
      raise x
3088 
    result = refundTransaction_result()
3089 
    result.read(self._iprot)
3090 
    self._iprot.readMessageEnd()
3091 
    if result.ex is not None:
3092 
      raise result.ex
3093 
    return
3094 
 
4324 mandeep.dh 3095 
  def updateShipmentAddress(self, orderId, addressId):
3096 
    """
3097 
    Updates shipment address of an order. Delivery and shipping date estimates
3098 
    etc. are also updated here.
3099 
 
3100 
    Throws TransactionServiceException in case address change is not
3101 
    possible due to certain reasons such as new pincode in address is
3102 
    not serviceable etc.
3103 
 
3104 
    Parameters:
3105 
     - orderId
3106 
     - addressId
3107 
    """
3108 
    self.send_updateShipmentAddress(orderId, addressId)
3109 
    self.recv_updateShipmentAddress()
3110 
 
3111 
  def send_updateShipmentAddress(self, orderId, addressId):
3112 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3113 
    args = updateShipmentAddress_args()
3114 
    args.orderId = orderId
3115 
    args.addressId = addressId
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_updateShipmentAddress(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = updateShipmentAddress_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3130 
    if result.ex is not None:
3131 
      raise result.ex
3132 
    return
3133 
 
4285 rajveer 3134 
  def acceptOrdersForItemId(self, itemId, inventory):
3135 
    """
3136 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3137 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3138 
 
4285 rajveer 3139 
    Parameters:
3140 
     - itemId
3141 
     - inventory
3142 
    """
3143 
    self.send_acceptOrdersForItemId(itemId, inventory)
3144 
    return self.recv_acceptOrdersForItemId()
3145 
 
3146 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3147 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3148 
    args = acceptOrdersForItemId_args()
3149 
    args.itemId = itemId
3150 
    args.inventory = inventory
3151 
    args.write(self._oprot)
3152 
    self._oprot.writeMessageEnd()
3153 
    self._oprot.trans.flush()
3154 
 
3155 
  def recv_acceptOrdersForItemId(self, ):
3156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3157 
    if mtype == TMessageType.EXCEPTION:
3158 
      x = TApplicationException()
3159 
      x.read(self._iprot)
3160 
      self._iprot.readMessageEnd()
3161 
      raise x
3162 
    result = acceptOrdersForItemId_result()
3163 
    result.read(self._iprot)
3164 
    self._iprot.readMessageEnd()
3165 
    if result.success is not None:
3166 
      return result.success
3167 
    if result.ex is not None:
3168 
      raise result.ex
3169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3170 
 
4303 rajveer 3171 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
3172 
    """
3173 
    Parameters:
3174 
     - vendorId
3175 
     - itemId
3176 
     - quantity
3177 
     - estimate
3178 
    """
3179 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate)
3180 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3181 
 
4303 rajveer 3182 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate):
3183 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3184 
    args = markOrdersAsPORaised_args()
3185 
    args.vendorId = vendorId
3186 
    args.itemId = itemId
3187 
    args.quantity = quantity
3188 
    args.estimate = estimate
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_markOrdersAsPORaised(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = markOrdersAsPORaised_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.ex is not None:
3204 
      raise result.ex
3205 
    return
3206 
 
3207 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
3208 
    """
3209 
    Parameters:
3210 
     - vendorId
3211 
     - itemId
3212 
     - quantity
3213 
     - estimate
3214 
    """
3215 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate)
3216 
    self.recv_markOrdersAsReversalInitiated()
3217 
 
3218 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate):
3219 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3220 
    args = markOrdersAsReversalInitiated_args()
3221 
    args.vendorId = vendorId
3222 
    args.itemId = itemId
3223 
    args.quantity = quantity
3224 
    args.estimate = estimate
3225 
    args.write(self._oprot)
3226 
    self._oprot.writeMessageEnd()
3227 
    self._oprot.trans.flush()
3228 
 
3229 
  def recv_markOrdersAsReversalInitiated(self, ):
3230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3231 
    if mtype == TMessageType.EXCEPTION:
3232 
      x = TApplicationException()
3233 
      x.read(self._iprot)
3234 
      self._iprot.readMessageEnd()
3235 
      raise x
3236 
    result = markOrdersAsReversalInitiated_result()
3237 
    result.read(self._iprot)
3238 
    self._iprot.readMessageEnd()
3239 
    if result.ex is not None:
3240 
      raise result.ex
3241 
    return
3242 
 
3243 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
3244 
    """
3245 
    Parameters:
3246 
     - vendorId
3247 
     - itemId
3248 
     - quantity
3249 
     - estimate
3250 
    """
3251 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate)
3252 
    self.recv_markOrdersAsNotAvailabke()
3253 
 
3254 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate):
3255 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3256 
    args = markOrdersAsNotAvailabke_args()
3257 
    args.vendorId = vendorId
3258 
    args.itemId = itemId
3259 
    args.quantity = quantity
3260 
    args.estimate = estimate
3261 
    args.write(self._oprot)
3262 
    self._oprot.writeMessageEnd()
3263 
    self._oprot.trans.flush()
3264 
 
3265 
  def recv_markOrdersAsNotAvailabke(self, ):
3266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3267 
    if mtype == TMessageType.EXCEPTION:
3268 
      x = TApplicationException()
3269 
      x.read(self._iprot)
3270 
      self._iprot.readMessageEnd()
3271 
      raise x
3272 
    result = markOrdersAsNotAvailabke_result()
3273 
    result.read(self._iprot)
3274 
    self._iprot.readMessageEnd()
3275 
    if result.ex is not None:
3276 
      raise result.ex
3277 
    return
3278 
 
3279 
 
3376 rajveer 3280 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3281 
  def __init__(self, handler):
3376 rajveer 3282 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3283 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3284 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3285 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3286 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3287 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3288 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3289 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3290 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3291 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3292 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3293 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3294 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3295 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3296 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3297 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3298 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3299 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3300 
    self._processMap["createOrder"] = Processor.process_createOrder
3301 
    self._processMap["getOrder"] = Processor.process_getOrder
3302 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3303 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3304 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3305 
    self._processMap["setAlert"] = Processor.process_setAlert
3306 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3307 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3308 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3309 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3310 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3311 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3312 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3313 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3314 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3315 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3316 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3317 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3318 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3319 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3320 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3321 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3322 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3323 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3324 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3325 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3326 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3327 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3328 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3329 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3330 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3331 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3332 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3333 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3334 
    self._processMap["changeItem"] = Processor.process_changeItem
3335 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3336 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3337 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3338 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3339 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3340 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3341 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3342 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3343 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3344 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3345 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3346 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3347 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3348 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3349 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3350 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3351 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
94 ashish 3352 
 
3353 
  def process(self, iprot, oprot):
3354 
    (name, type, seqid) = iprot.readMessageBegin()
3355 
    if name not in self._processMap:
3356 
      iprot.skip(TType.STRUCT)
3357 
      iprot.readMessageEnd()
3358 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3359 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3360 
      x.write(oprot)
3361 
      oprot.writeMessageEnd()
3362 
      oprot.trans.flush()
3363 
      return
3364 
    else:
3365 
      self._processMap[name](self, seqid, iprot, oprot)
3366 
    return True
3367 
 
3368 
  def process_createTransaction(self, seqid, iprot, oprot):
3369 
    args = createTransaction_args()
3370 
    args.read(iprot)
3371 
    iprot.readMessageEnd()
3372 
    result = createTransaction_result()
3373 
    try:
132 ashish 3374 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3375 
    except TransactionServiceException, ex:
3376 
      result.ex = ex
3377 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3378 
    result.write(oprot)
3379 
    oprot.writeMessageEnd()
3380 
    oprot.trans.flush()
3381 
 
3382 
  def process_getTransaction(self, seqid, iprot, oprot):
3383 
    args = getTransaction_args()
3384 
    args.read(iprot)
3385 
    iprot.readMessageEnd()
3386 
    result = getTransaction_result()
3387 
    try:
3388 
      result.success = self._handler.getTransaction(args.id)
3389 
    except TransactionServiceException, ex:
3390 
      result.ex = ex
3391 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3392 
    result.write(oprot)
3393 
    oprot.writeMessageEnd()
3394 
    oprot.trans.flush()
3395 
 
3396 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3397 
    args = getTransactionsForCustomer_args()
3398 
    args.read(iprot)
3399 
    iprot.readMessageEnd()
3400 
    result = getTransactionsForCustomer_result()
3401 
    try:
3402 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3403 
    except TransactionServiceException, ex:
3404 
      result.ex = ex
3405 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3406 
    result.write(oprot)
3407 
    oprot.writeMessageEnd()
3408 
    oprot.trans.flush()
3409 
 
132 ashish 3410 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3411 
    args = getTransactionsForShoppingCartId_args()
3412 
    args.read(iprot)
3413 
    iprot.readMessageEnd()
3414 
    result = getTransactionsForShoppingCartId_result()
3415 
    try:
3416 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3417 
    except TransactionServiceException, ex:
3418 
      result.ex = ex
3419 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3420 
    result.write(oprot)
3421 
    oprot.writeMessageEnd()
3422 
    oprot.trans.flush()
3423 
 
94 ashish 3424 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3425 
    args = getTransactionStatus_args()
3426 
    args.read(iprot)
3427 
    iprot.readMessageEnd()
3428 
    result = getTransactionStatus_result()
3429 
    try:
3430 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3431 
    except TransactionServiceException, ex:
3432 
      result.ex = ex
3433 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3434 
    result.write(oprot)
3435 
    oprot.writeMessageEnd()
3436 
    oprot.trans.flush()
3437 
 
3438 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3439 
    args = changeTransactionStatus_args()
3440 
    args.read(iprot)
3441 
    iprot.readMessageEnd()
3442 
    result = changeTransactionStatus_result()
3443 
    try:
3444 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3445 
    except TransactionServiceException, ex:
3446 
      result.ex = ex
3447 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3448 
    result.write(oprot)
3449 
    oprot.writeMessageEnd()
3450 
    oprot.trans.flush()
3451 
 
1398 varun.gupt 3452 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3453 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3454 
    args.read(iprot)
3455 
    iprot.readMessageEnd()
1398 varun.gupt 3456 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3457 
    try:
1398 varun.gupt 3458 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3459 
    except TransactionServiceException, ex:
3460 
      result.ex = ex
1398 varun.gupt 3461 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3462 
    result.write(oprot)
3463 
    oprot.writeMessageEnd()
3464 
    oprot.trans.flush()
3465 
 
483 rajveer 3466 
  def process_getAllOrders(self, seqid, iprot, oprot):
3467 
    args = getAllOrders_args()
94 ashish 3468 
    args.read(iprot)
3469 
    iprot.readMessageEnd()
483 rajveer 3470 
    result = getAllOrders_result()
94 ashish 3471 
    try:
483 rajveer 3472 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3473 
    except TransactionServiceException, ex:
3474 
      result.ex = ex
483 rajveer 3475 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3476 
    result.write(oprot)
3477 
    oprot.writeMessageEnd()
3478 
    oprot.trans.flush()
3479 
 
4133 chandransh 3480 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3481 
    args = getOrdersInBatch_args()
3482 
    args.read(iprot)
3483 
    iprot.readMessageEnd()
3484 
    result = getOrdersInBatch_result()
3485 
    try:
3486 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3487 
    except TransactionServiceException, ex:
3488 
      result.ex = ex
3489 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3490 
    result.write(oprot)
3491 
    oprot.writeMessageEnd()
3492 
    oprot.trans.flush()
3493 
 
3494 
  def process_getOrderCount(self, seqid, iprot, oprot):
3495 
    args = getOrderCount_args()
3496 
    args.read(iprot)
3497 
    iprot.readMessageEnd()
3498 
    result = getOrderCount_result()
3499 
    try:
3500 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3501 
    except TransactionServiceException, ex:
3502 
      result.ex = ex
3503 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3504 
    result.write(oprot)
3505 
    oprot.writeMessageEnd()
3506 
    oprot.trans.flush()
3507 
 
999 varun.gupt 3508 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3509 
    args = getOrdersByBillingDate_args()
3510 
    args.read(iprot)
3511 
    iprot.readMessageEnd()
3512 
    result = getOrdersByBillingDate_result()
3513 
    try:
3514 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3515 
    except TransactionServiceException, ex:
3516 
      result.ex = ex
3517 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3518 
    result.write(oprot)
3519 
    oprot.writeMessageEnd()
3520 
    oprot.trans.flush()
3521 
 
3427 chandransh 3522 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3523 
    args = getOrdersByShippingDate_args()
3524 
    args.read(iprot)
3525 
    iprot.readMessageEnd()
3526 
    result = getOrdersByShippingDate_result()
3527 
    try:
3451 chandransh 3528 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3529 
    except TransactionServiceException, ex:
3530 
      result.ex = ex
3531 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3532 
    result.write(oprot)
3533 
    oprot.writeMessageEnd()
3534 
    oprot.trans.flush()
3535 
 
1382 varun.gupt 3536 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3537 
    args = getReturnableOrdersForCustomer_args()
3538 
    args.read(iprot)
3539 
    iprot.readMessageEnd()
3540 
    result = getReturnableOrdersForCustomer_result()
3541 
    try:
3542 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3543 
    except TransactionServiceException, ex:
3544 
      result.ex = ex
3545 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3546 
    result.write(oprot)
3547 
    oprot.writeMessageEnd()
3548 
    oprot.trans.flush()
3549 
 
3550 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3551 
    args = getCancellableOrdersForCustomer_args()
3552 
    args.read(iprot)
3553 
    iprot.readMessageEnd()
3554 
    result = getCancellableOrdersForCustomer_result()
3555 
    try:
3556 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3557 
    except TransactionServiceException, ex:
3558 
      result.ex = ex
3559 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3560 
    result.write(oprot)
3561 
    oprot.writeMessageEnd()
3562 
    oprot.trans.flush()
3563 
 
483 rajveer 3564 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3565 
    args = changeOrderStatus_args()
94 ashish 3566 
    args.read(iprot)
3567 
    iprot.readMessageEnd()
483 rajveer 3568 
    result = changeOrderStatus_result()
94 ashish 3569 
    try:
483 rajveer 3570 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3571 
    except TransactionServiceException, ex:
3572 
      result.ex = ex
483 rajveer 3573 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3574 
    result.write(oprot)
3575 
    oprot.writeMessageEnd()
3576 
    oprot.trans.flush()
3577 
 
483 rajveer 3578 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3579 
    args = getOrdersForTransaction_args()
94 ashish 3580 
    args.read(iprot)
3581 
    iprot.readMessageEnd()
483 rajveer 3582 
    result = getOrdersForTransaction_result()
94 ashish 3583 
    try:
1528 ankur.sing 3584 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3585 
    except TransactionServiceException, ex:
3586 
      result.ex = ex
483 rajveer 3587 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3588 
    result.write(oprot)
3589 
    oprot.writeMessageEnd()
3590 
    oprot.trans.flush()
3591 
 
483 rajveer 3592 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3593 
    args = getOrdersForCustomer_args()
94 ashish 3594 
    args.read(iprot)
3595 
    iprot.readMessageEnd()
483 rajveer 3596 
    result = getOrdersForCustomer_result()
94 ashish 3597 
    try:
3014 chandransh 3598 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3599 
    except TransactionServiceException, ex:
3600 
      result.ex = ex
483 rajveer 3601 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3602 
    result.write(oprot)
3603 
    oprot.writeMessageEnd()
3604 
    oprot.trans.flush()
3605 
 
483 rajveer 3606 
  def process_createOrder(self, seqid, iprot, oprot):
3607 
    args = createOrder_args()
94 ashish 3608 
    args.read(iprot)
3609 
    iprot.readMessageEnd()
483 rajveer 3610 
    result = createOrder_result()
94 ashish 3611 
    try:
483 rajveer 3612 
      result.success = self._handler.createOrder(args.order)
94 ashish 3613 
    except TransactionServiceException, ex:
3614 
      result.ex = ex
483 rajveer 3615 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3616 
    result.write(oprot)
3617 
    oprot.writeMessageEnd()
3618 
    oprot.trans.flush()
3619 
 
483 rajveer 3620 
  def process_getOrder(self, seqid, iprot, oprot):
3621 
    args = getOrder_args()
94 ashish 3622 
    args.read(iprot)
3623 
    iprot.readMessageEnd()
483 rajveer 3624 
    result = getOrder_result()
94 ashish 3625 
    try:
483 rajveer 3626 
      result.success = self._handler.getOrder(args.id)
94 ashish 3627 
    except TransactionServiceException, ex:
3628 
      result.ex = ex
483 rajveer 3629 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3630 
    result.write(oprot)
3631 
    oprot.writeMessageEnd()
3632 
    oprot.trans.flush()
3633 
 
483 rajveer 3634 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3635 
    args = getLineItemsForOrder_args()
94 ashish 3636 
    args.read(iprot)
3637 
    iprot.readMessageEnd()
483 rajveer 3638 
    result = getLineItemsForOrder_result()
94 ashish 3639 
    try:
483 rajveer 3640 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3641 
    except TransactionServiceException, ex:
3642 
      result.ex = ex
483 rajveer 3643 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3644 
    result.write(oprot)
3645 
    oprot.writeMessageEnd()
3646 
    oprot.trans.flush()
3647 
 
1528 ankur.sing 3648 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3649 
    args = getOrderForCustomer_args()
3650 
    args.read(iprot)
3651 
    iprot.readMessageEnd()
3652 
    result = getOrderForCustomer_result()
3653 
    try:
3654 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3655 
    except TransactionServiceException, ex:
3656 
      result.ex = ex
3657 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3658 
    result.write(oprot)
3659 
    oprot.writeMessageEnd()
3660 
    oprot.trans.flush()
3661 
 
3064 chandransh 3662 
  def process_getAlerts(self, seqid, iprot, oprot):
3663 
    args = getAlerts_args()
3664 
    args.read(iprot)
3665 
    iprot.readMessageEnd()
3666 
    result = getAlerts_result()
3667 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3668 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3669 
    result.write(oprot)
3670 
    oprot.writeMessageEnd()
3671 
    oprot.trans.flush()
3672 
 
3673 
  def process_setAlert(self, seqid, iprot, oprot):
3674 
    args = setAlert_args()
3675 
    args.read(iprot)
3676 
    iprot.readMessageEnd()
3677 
    result = setAlert_result()
3678 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3679 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3680 
    result.write(oprot)
3681 
    oprot.writeMessageEnd()
3682 
    oprot.trans.flush()
3683 
 
3684 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3685 
    args = getValidOrderCount_args()
3686 
    args.read(iprot)
3687 
    iprot.readMessageEnd()
3688 
    result = getValidOrderCount_result()
3689 
    result.success = self._handler.getValidOrderCount()
3690 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3691 
    result.write(oprot)
3692 
    oprot.writeMessageEnd()
3693 
    oprot.trans.flush()
3694 
 
3695 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3696 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3697 
    args.read(iprot)
3698 
    iprot.readMessageEnd()
3699 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3700 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3701 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3702 
    result.write(oprot)
3703 
    oprot.writeMessageEnd()
3704 
    oprot.trans.flush()
3705 
 
3706 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3707 
    args = getValidOrdersAmountRange_args()
3708 
    args.read(iprot)
3709 
    iprot.readMessageEnd()
3710 
    result = getValidOrdersAmountRange_result()
3711 
    result.success = self._handler.getValidOrdersAmountRange()
3712 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3713 
    result.write(oprot)
3714 
    oprot.writeMessageEnd()
3715 
    oprot.trans.flush()
3716 
 
3717 
  def process_getValidOrders(self, seqid, iprot, oprot):
3718 
    args = getValidOrders_args()
3719 
    args.read(iprot)
3720 
    iprot.readMessageEnd()
3721 
    result = getValidOrders_result()
3722 
    result.success = self._handler.getValidOrders(args.limit)
3723 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3724 
    result.write(oprot)
3725 
    oprot.writeMessageEnd()
3726 
    oprot.trans.flush()
3727 
 
1220 chandransh 3728 
  def process_batchOrders(self, seqid, iprot, oprot):
3729 
    args = batchOrders_args()
3730 
    args.read(iprot)
3731 
    iprot.readMessageEnd()
3732 
    result = batchOrders_result()
3733 
    try:
3734 
      result.success = self._handler.batchOrders(args.warehouseId)
3735 
    except TransactionServiceException, ex:
3736 
      result.ex = ex
3737 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3738 
    result.write(oprot)
3739 
    oprot.writeMessageEnd()
3740 
    oprot.trans.flush()
3741 
 
1208 chandransh 3742 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3743 
    args = markOrderAsOutOfStock_args()
3744 
    args.read(iprot)
3745 
    iprot.readMessageEnd()
3746 
    result = markOrderAsOutOfStock_result()
3747 
    try:
3748 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3749 
    except TransactionServiceException, ex:
3750 
      result.ex = ex
3751 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3752 
    result.write(oprot)
3753 
    oprot.writeMessageEnd()
3754 
    oprot.trans.flush()
3755 
 
3064 chandransh 3756 
  def process_verifyOrder(self, seqid, iprot, oprot):
3757 
    args = verifyOrder_args()
759 chandransh 3758 
    args.read(iprot)
3759 
    iprot.readMessageEnd()
3064 chandransh 3760 
    result = verifyOrder_result()
759 chandransh 3761 
    try:
3064 chandransh 3762 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3763 
    except TransactionServiceException, ex:
3764 
      result.ex = ex
3064 chandransh 3765 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3766 
    result.write(oprot)
3767 
    oprot.writeMessageEnd()
3768 
    oprot.trans.flush()
3769 
 
3064 chandransh 3770 
  def process_acceptOrder(self, seqid, iprot, oprot):
3771 
    args = acceptOrder_args()
1113 chandransh 3772 
    args.read(iprot)
3773 
    iprot.readMessageEnd()
3064 chandransh 3774 
    result = acceptOrder_result()
1113 chandransh 3775 
    try:
3064 chandransh 3776 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3777 
    except TransactionServiceException, ex:
3778 
      result.ex = ex
3064 chandransh 3779 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3780 
    result.write(oprot)
3781 
    oprot.writeMessageEnd()
3782 
    oprot.trans.flush()
3783 
 
3064 chandransh 3784 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3785 
    args = addBillingDetails_args()
1135 chandransh 3786 
    args.read(iprot)
3787 
    iprot.readMessageEnd()
3064 chandransh 3788 
    result = addBillingDetails_result()
1135 chandransh 3789 
    try:
4283 anupam.sin 3790 
      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 3791 
    except TransactionServiceException, ex:
3792 
      result.ex = ex
3064 chandransh 3793 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3794 
    result.write(oprot)
3795 
    oprot.writeMessageEnd()
3796 
    oprot.trans.flush()
3797 
 
3064 chandransh 3798 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3799 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3800 
    args.read(iprot)
3801 
    iprot.readMessageEnd()
3064 chandransh 3802 
    result = markOrdersAsManifested_result()
3803 
    try:
3804 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3805 
    except TransactionServiceException, ex:
3806 
      result.ex = ex
3807 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3808 
    result.write(oprot)
3809 
    oprot.writeMessageEnd()
3810 
    oprot.trans.flush()
3811 
 
3064 chandransh 3812 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3813 
    args = markOrdersAsPickedUp_args()
304 ashish 3814 
    args.read(iprot)
3815 
    iprot.readMessageEnd()
3064 chandransh 3816 
    result = markOrdersAsPickedUp_result()
3817 
    try:
3818 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3819 
    except TransactionServiceException, ex:
3820 
      result.ex = ex
3821 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3822 
    result.write(oprot)
3823 
    oprot.writeMessageEnd()
3824 
    oprot.trans.flush()
94 ashish 3825 
 
3064 chandransh 3826 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3827 
    args = markOrdersAsDelivered_args()
304 ashish 3828 
    args.read(iprot)
3829 
    iprot.readMessageEnd()
3064 chandransh 3830 
    result = markOrdersAsDelivered_result()
3831 
    try:
3832 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3833 
    except TransactionServiceException, ex:
3834 
      result.ex = ex
3835 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3836 
    result.write(oprot)
3837 
    oprot.writeMessageEnd()
3838 
    oprot.trans.flush()
3839 
 
3064 chandransh 3840 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3841 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3842 
    args.read(iprot)
3843 
    iprot.readMessageEnd()
3064 chandransh 3844 
    result = markOrdersAsFailed_result()
3845 
    try:
3846 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3847 
    except TransactionServiceException, ex:
3848 
      result.ex = ex
3849 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3850 
    result.write(oprot)
3851 
    oprot.writeMessageEnd()
3852 
    oprot.trans.flush()
304 ashish 3853 
 
3064 chandransh 3854 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3855 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3856 
    args.read(iprot)
3857 
    iprot.readMessageEnd()
3064 chandransh 3858 
    result = updateNonDeliveryReason_result()
3859 
    try:
3860 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3861 
    except TransactionServiceException, ex:
3862 
      result.ex = ex
3863 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3864 
    result.write(oprot)
3865 
    oprot.writeMessageEnd()
3866 
    oprot.trans.flush()
1596 ankur.sing 3867 
 
3064 chandransh 3868 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3869 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3870 
    args.read(iprot)
3871 
    iprot.readMessageEnd()
3064 chandransh 3872 
    result = getUndeliveredOrders_result()
3873 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3874 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3875 
    result.write(oprot)
3876 
    oprot.writeMessageEnd()
3877 
    oprot.trans.flush()
3878 
 
2536 chandransh 3879 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3880 
    args = toggleDOAFlag_args()
3881 
    args.read(iprot)
3882 
    iprot.readMessageEnd()
3883 
    result = toggleDOAFlag_result()
3884 
    try:
3885 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3886 
    except TransactionServiceException, ex:
3887 
      result.ex = ex
3888 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3889 
    result.write(oprot)
3890 
    oprot.writeMessageEnd()
3891 
    oprot.trans.flush()
1886 ankur.sing 3892 
 
2536 chandransh 3893 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3894 
    args = requestPickupNumber_args()
3895 
    args.read(iprot)
3896 
    iprot.readMessageEnd()
3897 
    result = requestPickupNumber_result()
3898 
    try:
3899 
      result.success = self._handler.requestPickupNumber(args.orderId)
3900 
    except TransactionServiceException, ex:
3901 
      result.ex = ex
3902 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3903 
    result.write(oprot)
3904 
    oprot.writeMessageEnd()
3905 
    oprot.trans.flush()
3906 
 
3907 
  def process_authorizePickup(self, seqid, iprot, oprot):
3908 
    args = authorizePickup_args()
3909 
    args.read(iprot)
3910 
    iprot.readMessageEnd()
3911 
    result = authorizePickup_result()
3912 
    try:
3913 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3914 
    except TransactionServiceException, ex:
3915 
      result.ex = ex
3916 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3917 
    result.write(oprot)
3918 
    oprot.writeMessageEnd()
3919 
    oprot.trans.flush()
3920 
 
2764 chandransh 3921 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3922 
    args = markDoasAsPickedUp_args()
3923 
    args.read(iprot)
3924 
    iprot.readMessageEnd()
3925 
    result = markDoasAsPickedUp_result()
3926 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3927 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3928 
    result.write(oprot)
3929 
    oprot.writeMessageEnd()
3930 
    oprot.trans.flush()
3931 
 
2616 chandransh 3932 
  def process_receiveReturn(self, seqid, iprot, oprot):
3933 
    args = receiveReturn_args()
2591 chandransh 3934 
    args.read(iprot)
3935 
    iprot.readMessageEnd()
2616 chandransh 3936 
    result = receiveReturn_result()
2591 chandransh 3937 
    try:
2616 chandransh 3938 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3939 
    except TransactionServiceException, ex:
3940 
      result.ex = ex
2616 chandransh 3941 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3942 
    result.write(oprot)
3943 
    oprot.writeMessageEnd()
3944 
    oprot.trans.flush()
2536 chandransh 3945 
 
2591 chandransh 3946 
  def process_validateDoa(self, seqid, iprot, oprot):
3947 
    args = validateDoa_args()
3948 
    args.read(iprot)
3949 
    iprot.readMessageEnd()
3950 
    result = validateDoa_result()
3951 
    try:
3952 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3953 
    except TransactionServiceException, ex:
3954 
      result.ex = ex
3955 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3956 
    result.write(oprot)
3957 
    oprot.writeMessageEnd()
3958 
    oprot.trans.flush()
3959 
 
2616 chandransh 3960 
  def process_reshipOrder(self, seqid, iprot, oprot):
3961 
    args = reshipOrder_args()
3962 
    args.read(iprot)
3963 
    iprot.readMessageEnd()
3964 
    result = reshipOrder_result()
3965 
    try:
3966 
      result.success = self._handler.reshipOrder(args.orderId)
3967 
    except TransactionServiceException, ex:
3968 
      result.ex = ex
3969 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3970 
    result.write(oprot)
3971 
    oprot.writeMessageEnd()
3972 
    oprot.trans.flush()
2591 chandransh 3973 
 
2616 chandransh 3974 
  def process_refundOrder(self, seqid, iprot, oprot):
3975 
    args = refundOrder_args()
3976 
    args.read(iprot)
3977 
    iprot.readMessageEnd()
3978 
    result = refundOrder_result()
3979 
    try:
3226 chandransh 3980 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3981 
    except TransactionServiceException, ex:
3982 
      result.ex = ex
3983 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3984 
    result.write(oprot)
3985 
    oprot.writeMessageEnd()
3986 
    oprot.trans.flush()
3987 
 
2690 chandransh 3988 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3989 
    args = getReturnOrders_args()
3990 
    args.read(iprot)
3991 
    iprot.readMessageEnd()
3992 
    result = getReturnOrders_result()
3993 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3994 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
2616 chandransh 3998 
 
2700 chandransh 3999 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4000 
    args = getReturnOrder_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = getReturnOrder_result()
4004 
    try:
4005 
      result.success = self._handler.getReturnOrder(args.id)
4006 
    except TransactionServiceException, ex:
4007 
      result.ex = ex
4008 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
2690 chandransh 4013 
  def process_processReturn(self, seqid, iprot, oprot):
4014 
    args = processReturn_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = processReturn_result()
4018 
    try:
4019 
      self._handler.processReturn(args.returnOrderId)
4020 
    except TransactionServiceException, ex:
4021 
      result.ex = ex
4022 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
2819 chandransh 4027 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4028 
    args = createPurchaseOrder_args()
4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
4031 
    result = createPurchaseOrder_result()
4032 
    try:
4033 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4034 
    except TransactionServiceException, ex:
4035 
      result.ex = ex
4036 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
2690 chandransh 4040 
 
3451 chandransh 4041 
  def process_updateWeight(self, seqid, iprot, oprot):
4042 
    args = updateWeight_args()
4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
4045 
    result = updateWeight_result()
4046 
    try:
4047 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4048 
    except TransactionServiceException, ex:
4049 
      result.ex = ex
4050 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
2819 chandransh 4054 
 
3469 chandransh 4055 
  def process_changeItem(self, seqid, iprot, oprot):
4056 
    args = changeItem_args()
4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
4059 
    result = changeItem_result()
4060 
    try:
4061 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4062 
    except TransactionServiceException, ex:
4063 
      result.ex = ex
4064 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
3451 chandransh 4068 
 
3469 chandransh 4069 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4070 
    args = shiftToWarehouse_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = shiftToWarehouse_result()
4074 
    try:
4075 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4076 
    except TransactionServiceException, ex:
4077 
      result.ex = ex
4078 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
3553 chandransh 4083 
  def process_addDelayReason(self, seqid, iprot, oprot):
4084 
    args = addDelayReason_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = addDelayReason_result()
4088 
    try:
3986 chandransh 4089 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4090 
    except TransactionServiceException, ex:
4091 
      result.ex = ex
4092 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
3469 chandransh 4096 
 
3956 chandransh 4097 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4098 
    args = reconcileCodCollection_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = reconcileCodCollection_result()
4102 
    try:
4103 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4104 
    except TransactionServiceException, ex:
4105 
      result.ex = ex
4106 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
3553 chandransh 4110 
 
4008 mandeep.dh 4111 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4112 
    args = getTransactionsRequiringExtraProcessing_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getTransactionsRequiringExtraProcessing_result()
4116 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4117 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
3956 chandransh 4121 
 
4008 mandeep.dh 4122 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4123 
    args = markTransactionAsProcessed_args()
4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
4126 
    result = markTransactionAsProcessed_result()
4127 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4128 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
4018 chandransh 4133 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4134 
    args = getItemWiseRiskyOrdersCount_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = getItemWiseRiskyOrdersCount_result()
4138 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4139 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4140 
    result.write(oprot)
4141 
    oprot.writeMessageEnd()
4142 
    oprot.trans.flush()
4008 mandeep.dh 4143 
 
4295 varun.gupt 4144 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4145 
    args = getOrdersForItemIds_args()
4146 
    args.read(iprot)
4147 
    iprot.readMessageEnd()
4148 
    result = getOrdersForItemIds_result()
4149 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4150 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
4247 rajveer 4155 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4156 
    args = markOrderCancellationRequestReceived_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = markOrderCancellationRequestReceived_result()
4160 
    try:
4161 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4162 
    except TransactionServiceException, ex:
4163 
      result.ex = ex
4164 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4018 chandransh 4168 
 
4247 rajveer 4169 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4170 
    args = markOrderCancellationRequestConfirmed_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = markOrderCancellationRequestConfirmed_result()
4174 
    try:
4175 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4176 
    except TransactionServiceException, ex:
4177 
      result.ex = ex
4178 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
4183 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4184 
    args = markOrderCancellationRequestDenied_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = markOrderCancellationRequestDenied_result()
4188 
    try:
4189 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4190 
    except TransactionServiceException, ex:
4191 
      result.ex = ex
4192 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
4258 rajveer 4197 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4198 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4258 rajveer 4201 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4202 
    try:
4258 rajveer 4203 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4204 
    except TransactionServiceException, ex:
4205 
      result.ex = ex
4258 rajveer 4206 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
4259 anupam.sin 4211 
  def process_refundTransaction(self, seqid, iprot, oprot):
4212 
    args = refundTransaction_args()
4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
4215 
    result = refundTransaction_result()
4216 
    try:
4217 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4218 
    except TransactionServiceException, ex:
4219 
      result.ex = ex
4220 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4247 rajveer 4224 
 
4324 mandeep.dh 4225 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4226 
    args = updateShipmentAddress_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = updateShipmentAddress_result()
4230 
    try:
4231 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4232 
    except TransactionServiceException, ex:
4233 
      result.ex = ex
4234 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4285 rajveer 4239 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4240 
    args = acceptOrdersForItemId_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = acceptOrdersForItemId_result()
4244 
    try:
4245 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4246 
    except TransactionServiceException, ex:
4247 
      result.ex = ex
4248 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4259 anupam.sin 4252 
 
4303 rajveer 4253 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4254 
    args = markOrdersAsPORaised_args()
4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
4257 
    result = markOrdersAsPORaised_result()
4258 
    try:
4259 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate)
4260 
    except TransactionServiceException, ex:
4261 
      result.ex = ex
4262 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
4285 rajveer 4266 
 
4303 rajveer 4267 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4268 
    args = markOrdersAsReversalInitiated_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = markOrdersAsReversalInitiated_result()
4272 
    try:
4273 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate)
4274 
    except TransactionServiceException, ex:
4275 
      result.ex = ex
4276 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
4281 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4282 
    args = markOrdersAsNotAvailabke_args()
4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
4285 
    result = markOrdersAsNotAvailabke_result()
4286 
    try:
4287 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate)
4288 
    except TransactionServiceException, ex:
4289 
      result.ex = ex
4290 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
4295 
 
94 ashish 4296 
# HELPER FUNCTIONS AND STRUCTURES
4297 
 
4298 
class createTransaction_args:
4299 
  """
4300 
  Attributes:
4301 
   - transaction
4302 
  """
4303 
 
4304 
  thrift_spec = (
4305 
    None, # 0
4306 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4307 
  )
4308 
 
4309 
  def __init__(self, transaction=None,):
4310 
    self.transaction = transaction
4311 
 
4312 
  def read(self, iprot):
4313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4315 
      return
4316 
    iprot.readStructBegin()
4317 
    while True:
4318 
      (fname, ftype, fid) = iprot.readFieldBegin()
4319 
      if ftype == TType.STOP:
4320 
        break
4321 
      if fid == 1:
4322 
        if ftype == TType.STRUCT:
4323 
          self.transaction = Transaction()
4324 
          self.transaction.read(iprot)
4325 
        else:
4326 
          iprot.skip(ftype)
4327 
      else:
4328 
        iprot.skip(ftype)
4329 
      iprot.readFieldEnd()
4330 
    iprot.readStructEnd()
4331 
 
4332 
  def write(self, oprot):
4333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4335 
      return
4336 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4337 
    if self.transaction is not None:
94 ashish 4338 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4339 
      self.transaction.write(oprot)
4340 
      oprot.writeFieldEnd()
4341 
    oprot.writeFieldStop()
4342 
    oprot.writeStructEnd()
4343 
 
3431 rajveer 4344 
  def validate(self):
4345 
    return
4346 
 
4347 
 
94 ashish 4348 
  def __repr__(self):
4349 
    L = ['%s=%r' % (key, value)
4350 
      for key, value in self.__dict__.iteritems()]
4351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4352 
 
4353 
  def __eq__(self, other):
4354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4355 
 
4356 
  def __ne__(self, other):
4357 
    return not (self == other)
4358 
 
4359 
class createTransaction_result:
4360 
  """
4361 
  Attributes:
132 ashish 4362 
   - success
94 ashish 4363 
   - ex
4364 
  """
4365 
 
4366 
  thrift_spec = (
132 ashish 4367 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4369 
  )
4370 
 
132 ashish 4371 
  def __init__(self, success=None, ex=None,):
4372 
    self.success = success
94 ashish 4373 
    self.ex = ex
4374 
 
4375 
  def read(self, iprot):
4376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4378 
      return
4379 
    iprot.readStructBegin()
4380 
    while True:
4381 
      (fname, ftype, fid) = iprot.readFieldBegin()
4382 
      if ftype == TType.STOP:
4383 
        break
132 ashish 4384 
      if fid == 0:
4385 
        if ftype == TType.I64:
4386 
          self.success = iprot.readI64();
4387 
        else:
4388 
          iprot.skip(ftype)
4389 
      elif fid == 1:
94 ashish 4390 
        if ftype == TType.STRUCT:
4391 
          self.ex = TransactionServiceException()
4392 
          self.ex.read(iprot)
4393 
        else:
4394 
          iprot.skip(ftype)
4395 
      else:
4396 
        iprot.skip(ftype)
4397 
      iprot.readFieldEnd()
4398 
    iprot.readStructEnd()
4399 
 
4400 
  def write(self, oprot):
4401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4403 
      return
4404 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4405 
    if self.success is not None:
132 ashish 4406 
      oprot.writeFieldBegin('success', TType.I64, 0)
4407 
      oprot.writeI64(self.success)
4408 
      oprot.writeFieldEnd()
3431 rajveer 4409 
    if self.ex is not None:
94 ashish 4410 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4411 
      self.ex.write(oprot)
4412 
      oprot.writeFieldEnd()
4413 
    oprot.writeFieldStop()
4414 
    oprot.writeStructEnd()
4415 
 
3431 rajveer 4416 
  def validate(self):
4417 
    return
4418 
 
4419 
 
94 ashish 4420 
  def __repr__(self):
4421 
    L = ['%s=%r' % (key, value)
4422 
      for key, value in self.__dict__.iteritems()]
4423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4424 
 
4425 
  def __eq__(self, other):
4426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4427 
 
4428 
  def __ne__(self, other):
4429 
    return not (self == other)
4430 
 
4431 
class getTransaction_args:
4432 
  """
4433 
  Attributes:
4434 
   - id
4435 
  """
4436 
 
4437 
  thrift_spec = (
4438 
    None, # 0
4439 
    (1, TType.I64, 'id', None, None, ), # 1
4440 
  )
4441 
 
4442 
  def __init__(self, id=None,):
4443 
    self.id = id
4444 
 
4445 
  def read(self, iprot):
4446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4448 
      return
4449 
    iprot.readStructBegin()
4450 
    while True:
4451 
      (fname, ftype, fid) = iprot.readFieldBegin()
4452 
      if ftype == TType.STOP:
4453 
        break
4454 
      if fid == 1:
4455 
        if ftype == TType.I64:
4456 
          self.id = iprot.readI64();
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_args')
3431 rajveer 4469 
    if self.id is not None:
94 ashish 4470 
      oprot.writeFieldBegin('id', TType.I64, 1)
4471 
      oprot.writeI64(self.id)
4472 
      oprot.writeFieldEnd()
4473 
    oprot.writeFieldStop()
4474 
    oprot.writeStructEnd()
4475 
 
3431 rajveer 4476 
  def validate(self):
4477 
    return
4478 
 
4479 
 
94 ashish 4480 
  def __repr__(self):
4481 
    L = ['%s=%r' % (key, value)
4482 
      for key, value in self.__dict__.iteritems()]
4483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4484 
 
4485 
  def __eq__(self, other):
4486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4487 
 
4488 
  def __ne__(self, other):
4489 
    return not (self == other)
4490 
 
4491 
class getTransaction_result:
4492 
  """
4493 
  Attributes:
4494 
   - success
4495 
   - ex
4496 
  """
4497 
 
4498 
  thrift_spec = (
4499 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4501 
  )
4502 
 
4503 
  def __init__(self, success=None, ex=None,):
4504 
    self.success = success
4505 
    self.ex = ex
4506 
 
4507 
  def read(self, iprot):
4508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4510 
      return
4511 
    iprot.readStructBegin()
4512 
    while True:
4513 
      (fname, ftype, fid) = iprot.readFieldBegin()
4514 
      if ftype == TType.STOP:
4515 
        break
4516 
      if fid == 0:
4517 
        if ftype == TType.STRUCT:
4518 
          self.success = Transaction()
4519 
          self.success.read(iprot)
4520 
        else:
4521 
          iprot.skip(ftype)
4522 
      elif fid == 1:
4523 
        if ftype == TType.STRUCT:
4524 
          self.ex = TransactionServiceException()
4525 
          self.ex.read(iprot)
4526 
        else:
4527 
          iprot.skip(ftype)
4528 
      else:
4529 
        iprot.skip(ftype)
4530 
      iprot.readFieldEnd()
4531 
    iprot.readStructEnd()
4532 
 
4533 
  def write(self, oprot):
4534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4536 
      return
4537 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4538 
    if self.success is not None:
94 ashish 4539 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4540 
      self.success.write(oprot)
4541 
      oprot.writeFieldEnd()
3431 rajveer 4542 
    if self.ex is not None:
94 ashish 4543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4544 
      self.ex.write(oprot)
4545 
      oprot.writeFieldEnd()
4546 
    oprot.writeFieldStop()
4547 
    oprot.writeStructEnd()
4548 
 
3431 rajveer 4549 
  def validate(self):
4550 
    return
4551 
 
4552 
 
94 ashish 4553 
  def __repr__(self):
4554 
    L = ['%s=%r' % (key, value)
4555 
      for key, value in self.__dict__.iteritems()]
4556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4557 
 
4558 
  def __eq__(self, other):
4559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4560 
 
4561 
  def __ne__(self, other):
4562 
    return not (self == other)
4563 
 
4564 
class getTransactionsForCustomer_args:
4565 
  """
4566 
  Attributes:
4567 
   - customerId
4568 
   - from_date
4569 
   - to_date
4570 
   - status
4571 
  """
4572 
 
4573 
  thrift_spec = (
4574 
    None, # 0
4575 
    (1, TType.I64, 'customerId', None, None, ), # 1
4576 
    (2, TType.I64, 'from_date', None, None, ), # 2
4577 
    (3, TType.I64, 'to_date', None, None, ), # 3
4578 
    (4, TType.I32, 'status', None, None, ), # 4
4579 
  )
4580 
 
4581 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4582 
    self.customerId = customerId
4583 
    self.from_date = from_date
4584 
    self.to_date = to_date
4585 
    self.status = status
4586 
 
4587 
  def read(self, iprot):
4588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4590 
      return
4591 
    iprot.readStructBegin()
4592 
    while True:
4593 
      (fname, ftype, fid) = iprot.readFieldBegin()
4594 
      if ftype == TType.STOP:
4595 
        break
4596 
      if fid == 1:
4597 
        if ftype == TType.I64:
4598 
          self.customerId = iprot.readI64();
4599 
        else:
4600 
          iprot.skip(ftype)
4601 
      elif fid == 2:
4602 
        if ftype == TType.I64:
4603 
          self.from_date = iprot.readI64();
4604 
        else:
4605 
          iprot.skip(ftype)
4606 
      elif fid == 3:
4607 
        if ftype == TType.I64:
4608 
          self.to_date = iprot.readI64();
4609 
        else:
4610 
          iprot.skip(ftype)
4611 
      elif fid == 4:
4612 
        if ftype == TType.I32:
4613 
          self.status = iprot.readI32();
4614 
        else:
4615 
          iprot.skip(ftype)
4616 
      else:
4617 
        iprot.skip(ftype)
4618 
      iprot.readFieldEnd()
4619 
    iprot.readStructEnd()
4620 
 
4621 
  def write(self, oprot):
4622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4624 
      return
4625 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4626 
    if self.customerId is not None:
94 ashish 4627 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4628 
      oprot.writeI64(self.customerId)
4629 
      oprot.writeFieldEnd()
3431 rajveer 4630 
    if self.from_date is not None:
94 ashish 4631 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4632 
      oprot.writeI64(self.from_date)
4633 
      oprot.writeFieldEnd()
3431 rajveer 4634 
    if self.to_date is not None:
94 ashish 4635 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4636 
      oprot.writeI64(self.to_date)
4637 
      oprot.writeFieldEnd()
3431 rajveer 4638 
    if self.status is not None:
94 ashish 4639 
      oprot.writeFieldBegin('status', TType.I32, 4)
4640 
      oprot.writeI32(self.status)
4641 
      oprot.writeFieldEnd()
4642 
    oprot.writeFieldStop()
4643 
    oprot.writeStructEnd()
4644 
 
3431 rajveer 4645 
  def validate(self):
4646 
    return
4647 
 
4648 
 
94 ashish 4649 
  def __repr__(self):
4650 
    L = ['%s=%r' % (key, value)
4651 
      for key, value in self.__dict__.iteritems()]
4652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4653 
 
4654 
  def __eq__(self, other):
4655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4656 
 
4657 
  def __ne__(self, other):
4658 
    return not (self == other)
4659 
 
4660 
class getTransactionsForCustomer_result:
4661 
  """
4662 
  Attributes:
4663 
   - success
4664 
   - ex
4665 
  """
4666 
 
4667 
  thrift_spec = (
4668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4670 
  )
4671 
 
4672 
  def __init__(self, success=None, ex=None,):
4673 
    self.success = success
4674 
    self.ex = ex
4675 
 
4676 
  def read(self, iprot):
4677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4679 
      return
4680 
    iprot.readStructBegin()
4681 
    while True:
4682 
      (fname, ftype, fid) = iprot.readFieldBegin()
4683 
      if ftype == TType.STOP:
4684 
        break
4685 
      if fid == 0:
4686 
        if ftype == TType.LIST:
4687 
          self.success = []
685 chandransh 4688 
          (_etype17, _size14) = iprot.readListBegin()
4689 
          for _i18 in xrange(_size14):
4690 
            _elem19 = Transaction()
4691 
            _elem19.read(iprot)
4692 
            self.success.append(_elem19)
94 ashish 4693 
          iprot.readListEnd()
4694 
        else:
4695 
          iprot.skip(ftype)
4696 
      elif fid == 1:
4697 
        if ftype == TType.STRUCT:
4698 
          self.ex = TransactionServiceException()
4699 
          self.ex.read(iprot)
4700 
        else:
4701 
          iprot.skip(ftype)
4702 
      else:
4703 
        iprot.skip(ftype)
4704 
      iprot.readFieldEnd()
4705 
    iprot.readStructEnd()
4706 
 
4707 
  def write(self, oprot):
4708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4710 
      return
4711 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4712 
    if self.success is not None:
94 ashish 4713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4715 
      for iter20 in self.success:
4716 
        iter20.write(oprot)
94 ashish 4717 
      oprot.writeListEnd()
4718 
      oprot.writeFieldEnd()
3431 rajveer 4719 
    if self.ex is not None:
94 ashish 4720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4721 
      self.ex.write(oprot)
4722 
      oprot.writeFieldEnd()
4723 
    oprot.writeFieldStop()
4724 
    oprot.writeStructEnd()
4725 
 
3431 rajveer 4726 
  def validate(self):
4727 
    return
4728 
 
4729 
 
94 ashish 4730 
  def __repr__(self):
4731 
    L = ['%s=%r' % (key, value)
4732 
      for key, value in self.__dict__.iteritems()]
4733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4734 
 
4735 
  def __eq__(self, other):
4736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4737 
 
4738 
  def __ne__(self, other):
4739 
    return not (self == other)
4740 
 
132 ashish 4741 
class getTransactionsForShoppingCartId_args:
4742 
  """
4743 
  Attributes:
4744 
   - shoppingCartId
4745 
  """
4746 
 
4747 
  thrift_spec = (
4748 
    None, # 0
4749 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4750 
  )
4751 
 
4752 
  def __init__(self, shoppingCartId=None,):
4753 
    self.shoppingCartId = shoppingCartId
4754 
 
4755 
  def read(self, iprot):
4756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4758 
      return
4759 
    iprot.readStructBegin()
4760 
    while True:
4761 
      (fname, ftype, fid) = iprot.readFieldBegin()
4762 
      if ftype == TType.STOP:
4763 
        break
4764 
      if fid == 1:
4765 
        if ftype == TType.I64:
4766 
          self.shoppingCartId = iprot.readI64();
4767 
        else:
4768 
          iprot.skip(ftype)
4769 
      else:
4770 
        iprot.skip(ftype)
4771 
      iprot.readFieldEnd()
4772 
    iprot.readStructEnd()
4773 
 
4774 
  def write(self, oprot):
4775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4777 
      return
4778 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4779 
    if self.shoppingCartId is not None:
132 ashish 4780 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4781 
      oprot.writeI64(self.shoppingCartId)
4782 
      oprot.writeFieldEnd()
4783 
    oprot.writeFieldStop()
4784 
    oprot.writeStructEnd()
4785 
 
3431 rajveer 4786 
  def validate(self):
4787 
    return
4788 
 
4789 
 
132 ashish 4790 
  def __repr__(self):
4791 
    L = ['%s=%r' % (key, value)
4792 
      for key, value in self.__dict__.iteritems()]
4793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4794 
 
4795 
  def __eq__(self, other):
4796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4797 
 
4798 
  def __ne__(self, other):
4799 
    return not (self == other)
4800 
 
4801 
class getTransactionsForShoppingCartId_result:
4802 
  """
4803 
  Attributes:
4804 
   - success
4805 
   - ex
4806 
  """
4807 
 
4808 
  thrift_spec = (
4809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4810 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4811 
  )
4812 
 
4813 
  def __init__(self, success=None, ex=None,):
4814 
    self.success = success
4815 
    self.ex = ex
4816 
 
4817 
  def read(self, iprot):
4818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4820 
      return
4821 
    iprot.readStructBegin()
4822 
    while True:
4823 
      (fname, ftype, fid) = iprot.readFieldBegin()
4824 
      if ftype == TType.STOP:
4825 
        break
4826 
      if fid == 0:
4827 
        if ftype == TType.LIST:
4828 
          self.success = []
685 chandransh 4829 
          (_etype24, _size21) = iprot.readListBegin()
4830 
          for _i25 in xrange(_size21):
4831 
            _elem26 = Transaction()
4832 
            _elem26.read(iprot)
4833 
            self.success.append(_elem26)
132 ashish 4834 
          iprot.readListEnd()
4835 
        else:
4836 
          iprot.skip(ftype)
4837 
      elif fid == 1:
4838 
        if ftype == TType.STRUCT:
4839 
          self.ex = TransactionServiceException()
4840 
          self.ex.read(iprot)
4841 
        else:
4842 
          iprot.skip(ftype)
4843 
      else:
4844 
        iprot.skip(ftype)
4845 
      iprot.readFieldEnd()
4846 
    iprot.readStructEnd()
4847 
 
4848 
  def write(self, oprot):
4849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4851 
      return
4852 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4853 
    if self.success is not None:
132 ashish 4854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4855 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4856 
      for iter27 in self.success:
4857 
        iter27.write(oprot)
132 ashish 4858 
      oprot.writeListEnd()
4859 
      oprot.writeFieldEnd()
3431 rajveer 4860 
    if self.ex is not None:
132 ashish 4861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4862 
      self.ex.write(oprot)
4863 
      oprot.writeFieldEnd()
4864 
    oprot.writeFieldStop()
4865 
    oprot.writeStructEnd()
4866 
 
3431 rajveer 4867 
  def validate(self):
4868 
    return
4869 
 
4870 
 
132 ashish 4871 
  def __repr__(self):
4872 
    L = ['%s=%r' % (key, value)
4873 
      for key, value in self.__dict__.iteritems()]
4874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4875 
 
4876 
  def __eq__(self, other):
4877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4878 
 
4879 
  def __ne__(self, other):
4880 
    return not (self == other)
4881 
 
94 ashish 4882 
class getTransactionStatus_args:
4883 
  """
4884 
  Attributes:
4885 
   - transactionId
4886 
  """
4887 
 
4888 
  thrift_spec = (
4889 
    None, # 0
4890 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4891 
  )
4892 
 
4893 
  def __init__(self, transactionId=None,):
4894 
    self.transactionId = transactionId
4895 
 
4896 
  def read(self, iprot):
4897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4899 
      return
4900 
    iprot.readStructBegin()
4901 
    while True:
4902 
      (fname, ftype, fid) = iprot.readFieldBegin()
4903 
      if ftype == TType.STOP:
4904 
        break
4905 
      if fid == 1:
4906 
        if ftype == TType.I64:
4907 
          self.transactionId = iprot.readI64();
4908 
        else:
4909 
          iprot.skip(ftype)
4910 
      else:
4911 
        iprot.skip(ftype)
4912 
      iprot.readFieldEnd()
4913 
    iprot.readStructEnd()
4914 
 
4915 
  def write(self, oprot):
4916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4918 
      return
4919 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4920 
    if self.transactionId is not None:
94 ashish 4921 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4922 
      oprot.writeI64(self.transactionId)
4923 
      oprot.writeFieldEnd()
4924 
    oprot.writeFieldStop()
4925 
    oprot.writeStructEnd()
4926 
 
3431 rajveer 4927 
  def validate(self):
4928 
    return
4929 
 
4930 
 
94 ashish 4931 
  def __repr__(self):
4932 
    L = ['%s=%r' % (key, value)
4933 
      for key, value in self.__dict__.iteritems()]
4934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4935 
 
4936 
  def __eq__(self, other):
4937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4938 
 
4939 
  def __ne__(self, other):
4940 
    return not (self == other)
4941 
 
4942 
class getTransactionStatus_result:
4943 
  """
4944 
  Attributes:
4945 
   - success
4946 
   - ex
4947 
  """
4948 
 
4949 
  thrift_spec = (
4950 
    (0, TType.I32, 'success', None, None, ), # 0
4951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4952 
  )
4953 
 
4954 
  def __init__(self, success=None, ex=None,):
4955 
    self.success = success
4956 
    self.ex = ex
4957 
 
4958 
  def read(self, iprot):
4959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4961 
      return
4962 
    iprot.readStructBegin()
4963 
    while True:
4964 
      (fname, ftype, fid) = iprot.readFieldBegin()
4965 
      if ftype == TType.STOP:
4966 
        break
4967 
      if fid == 0:
4968 
        if ftype == TType.I32:
4969 
          self.success = iprot.readI32();
4970 
        else:
4971 
          iprot.skip(ftype)
4972 
      elif fid == 1:
4973 
        if ftype == TType.STRUCT:
4974 
          self.ex = TransactionServiceException()
4975 
          self.ex.read(iprot)
4976 
        else:
4977 
          iprot.skip(ftype)
4978 
      else:
4979 
        iprot.skip(ftype)
4980 
      iprot.readFieldEnd()
4981 
    iprot.readStructEnd()
4982 
 
4983 
  def write(self, oprot):
4984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4986 
      return
4987 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4988 
    if self.success is not None:
94 ashish 4989 
      oprot.writeFieldBegin('success', TType.I32, 0)
4990 
      oprot.writeI32(self.success)
4991 
      oprot.writeFieldEnd()
3431 rajveer 4992 
    if self.ex is not None:
94 ashish 4993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4994 
      self.ex.write(oprot)
4995 
      oprot.writeFieldEnd()
4996 
    oprot.writeFieldStop()
4997 
    oprot.writeStructEnd()
4998 
 
3431 rajveer 4999 
  def validate(self):
5000 
    return
5001 
 
5002 
 
94 ashish 5003 
  def __repr__(self):
5004 
    L = ['%s=%r' % (key, value)
5005 
      for key, value in self.__dict__.iteritems()]
5006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5007 
 
5008 
  def __eq__(self, other):
5009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5010 
 
5011 
  def __ne__(self, other):
5012 
    return not (self == other)
5013 
 
5014 
class changeTransactionStatus_args:
5015 
  """
5016 
  Attributes:
5017 
   - transactionId
5018 
   - status
5019 
   - description
5020 
  """
5021 
 
5022 
  thrift_spec = (
5023 
    None, # 0
5024 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5025 
    (2, TType.I32, 'status', None, None, ), # 2
5026 
    (3, TType.STRING, 'description', None, None, ), # 3
5027 
  )
5028 
 
5029 
  def __init__(self, transactionId=None, status=None, description=None,):
5030 
    self.transactionId = transactionId
5031 
    self.status = status
5032 
    self.description = description
5033 
 
5034 
  def read(self, iprot):
5035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5037 
      return
5038 
    iprot.readStructBegin()
5039 
    while True:
5040 
      (fname, ftype, fid) = iprot.readFieldBegin()
5041 
      if ftype == TType.STOP:
5042 
        break
5043 
      if fid == 1:
5044 
        if ftype == TType.I64:
5045 
          self.transactionId = iprot.readI64();
5046 
        else:
5047 
          iprot.skip(ftype)
5048 
      elif fid == 2:
5049 
        if ftype == TType.I32:
5050 
          self.status = iprot.readI32();
5051 
        else:
5052 
          iprot.skip(ftype)
5053 
      elif fid == 3:
5054 
        if ftype == TType.STRING:
5055 
          self.description = iprot.readString();
5056 
        else:
5057 
          iprot.skip(ftype)
5058 
      else:
5059 
        iprot.skip(ftype)
5060 
      iprot.readFieldEnd()
5061 
    iprot.readStructEnd()
5062 
 
5063 
  def write(self, oprot):
5064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5066 
      return
5067 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5068 
    if self.transactionId is not None:
94 ashish 5069 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5070 
      oprot.writeI64(self.transactionId)
5071 
      oprot.writeFieldEnd()
3431 rajveer 5072 
    if self.status is not None:
94 ashish 5073 
      oprot.writeFieldBegin('status', TType.I32, 2)
5074 
      oprot.writeI32(self.status)
5075 
      oprot.writeFieldEnd()
3431 rajveer 5076 
    if self.description is not None:
94 ashish 5077 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5078 
      oprot.writeString(self.description)
5079 
      oprot.writeFieldEnd()
5080 
    oprot.writeFieldStop()
5081 
    oprot.writeStructEnd()
5082 
 
3431 rajveer 5083 
  def validate(self):
5084 
    return
5085 
 
5086 
 
94 ashish 5087 
  def __repr__(self):
5088 
    L = ['%s=%r' % (key, value)
5089 
      for key, value in self.__dict__.iteritems()]
5090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5091 
 
5092 
  def __eq__(self, other):
5093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5094 
 
5095 
  def __ne__(self, other):
5096 
    return not (self == other)
5097 
 
5098 
class changeTransactionStatus_result:
5099 
  """
5100 
  Attributes:
5101 
   - success
5102 
   - ex
5103 
  """
5104 
 
5105 
  thrift_spec = (
5106 
    (0, TType.BOOL, 'success', None, None, ), # 0
5107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5108 
  )
5109 
 
5110 
  def __init__(self, success=None, ex=None,):
5111 
    self.success = success
5112 
    self.ex = ex
5113 
 
5114 
  def read(self, iprot):
5115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5117 
      return
5118 
    iprot.readStructBegin()
5119 
    while True:
5120 
      (fname, ftype, fid) = iprot.readFieldBegin()
5121 
      if ftype == TType.STOP:
5122 
        break
5123 
      if fid == 0:
5124 
        if ftype == TType.BOOL:
5125 
          self.success = iprot.readBool();
5126 
        else:
5127 
          iprot.skip(ftype)
5128 
      elif fid == 1:
5129 
        if ftype == TType.STRUCT:
5130 
          self.ex = TransactionServiceException()
5131 
          self.ex.read(iprot)
5132 
        else:
5133 
          iprot.skip(ftype)
5134 
      else:
5135 
        iprot.skip(ftype)
5136 
      iprot.readFieldEnd()
5137 
    iprot.readStructEnd()
5138 
 
5139 
  def write(self, oprot):
5140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5142 
      return
5143 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5144 
    if self.success is not None:
94 ashish 5145 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5146 
      oprot.writeBool(self.success)
5147 
      oprot.writeFieldEnd()
3431 rajveer 5148 
    if self.ex is not None:
94 ashish 5149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5150 
      self.ex.write(oprot)
5151 
      oprot.writeFieldEnd()
5152 
    oprot.writeFieldStop()
5153 
    oprot.writeStructEnd()
5154 
 
3431 rajveer 5155 
  def validate(self):
5156 
    return
5157 
 
5158 
 
94 ashish 5159 
  def __repr__(self):
5160 
    L = ['%s=%r' % (key, value)
5161 
      for key, value in self.__dict__.iteritems()]
5162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5163 
 
5164 
  def __eq__(self, other):
5165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5166 
 
5167 
  def __ne__(self, other):
5168 
    return not (self == other)
5169 
 
1398 varun.gupt 5170 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5171 
  """
5172 
  Attributes:
5173 
   - transactionId
5174 
  """
5175 
 
5176 
  thrift_spec = (
5177 
    None, # 0
5178 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5179 
  )
5180 
 
5181 
  def __init__(self, transactionId=None,):
5182 
    self.transactionId = transactionId
5183 
 
5184 
  def read(self, iprot):
5185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5187 
      return
5188 
    iprot.readStructBegin()
5189 
    while True:
5190 
      (fname, ftype, fid) = iprot.readFieldBegin()
5191 
      if ftype == TType.STOP:
5192 
        break
5193 
      if fid == 1:
5194 
        if ftype == TType.I64:
5195 
          self.transactionId = iprot.readI64();
5196 
        else:
5197 
          iprot.skip(ftype)
5198 
      else:
5199 
        iprot.skip(ftype)
5200 
      iprot.readFieldEnd()
5201 
    iprot.readStructEnd()
5202 
 
5203 
  def write(self, oprot):
5204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5206 
      return
1398 varun.gupt 5207 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5208 
    if self.transactionId is not None:
1382 varun.gupt 5209 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5210 
      oprot.writeI64(self.transactionId)
5211 
      oprot.writeFieldEnd()
5212 
    oprot.writeFieldStop()
5213 
    oprot.writeStructEnd()
5214 
 
3431 rajveer 5215 
  def validate(self):
5216 
    return
5217 
 
5218 
 
1382 varun.gupt 5219 
  def __repr__(self):
5220 
    L = ['%s=%r' % (key, value)
5221 
      for key, value in self.__dict__.iteritems()]
5222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5223 
 
5224 
  def __eq__(self, other):
5225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5226 
 
5227 
  def __ne__(self, other):
5228 
    return not (self == other)
5229 
 
1398 varun.gupt 5230 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5231 
  """
5232 
  Attributes:
5233 
   - success
5234 
   - ex
5235 
  """
5236 
 
5237 
  thrift_spec = (
5238 
    (0, TType.BOOL, 'success', None, None, ), # 0
5239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5240 
  )
5241 
 
5242 
  def __init__(self, success=None, ex=None,):
5243 
    self.success = success
5244 
    self.ex = ex
5245 
 
5246 
  def read(self, iprot):
5247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5249 
      return
5250 
    iprot.readStructBegin()
5251 
    while True:
5252 
      (fname, ftype, fid) = iprot.readFieldBegin()
5253 
      if ftype == TType.STOP:
5254 
        break
5255 
      if fid == 0:
5256 
        if ftype == TType.BOOL:
5257 
          self.success = iprot.readBool();
5258 
        else:
5259 
          iprot.skip(ftype)
5260 
      elif fid == 1:
5261 
        if ftype == TType.STRUCT:
5262 
          self.ex = TransactionServiceException()
5263 
          self.ex.read(iprot)
5264 
        else:
5265 
          iprot.skip(ftype)
5266 
      else:
5267 
        iprot.skip(ftype)
5268 
      iprot.readFieldEnd()
5269 
    iprot.readStructEnd()
5270 
 
5271 
  def write(self, oprot):
5272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5274 
      return
1398 varun.gupt 5275 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5276 
    if self.success is not None:
1382 varun.gupt 5277 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5278 
      oprot.writeBool(self.success)
5279 
      oprot.writeFieldEnd()
3431 rajveer 5280 
    if self.ex is not None:
1382 varun.gupt 5281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5282 
      self.ex.write(oprot)
5283 
      oprot.writeFieldEnd()
5284 
    oprot.writeFieldStop()
5285 
    oprot.writeStructEnd()
5286 
 
3431 rajveer 5287 
  def validate(self):
5288 
    return
5289 
 
5290 
 
1382 varun.gupt 5291 
  def __repr__(self):
5292 
    L = ['%s=%r' % (key, value)
5293 
      for key, value in self.__dict__.iteritems()]
5294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5295 
 
5296 
  def __eq__(self, other):
5297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5298 
 
5299 
  def __ne__(self, other):
5300 
    return not (self == other)
5301 
 
483 rajveer 5302 
class getAllOrders_args:
94 ashish 5303 
  """
5304 
  Attributes:
483 rajveer 5305 
   - status
5306 
   - from_date
5307 
   - to_date
5308 
   - warehouse_id
94 ashish 5309 
  """
5310 
 
5311 
  thrift_spec = (
5312 
    None, # 0
483 rajveer 5313 
    (1, TType.I32, 'status', None, None, ), # 1
5314 
    (2, TType.I64, 'from_date', None, None, ), # 2
5315 
    (3, TType.I64, 'to_date', None, None, ), # 3
5316 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5317 
  )
5318 
 
483 rajveer 5319 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5320 
    self.status = status
5321 
    self.from_date = from_date
5322 
    self.to_date = to_date
5323 
    self.warehouse_id = warehouse_id
94 ashish 5324 
 
5325 
  def read(self, iprot):
5326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5328 
      return
5329 
    iprot.readStructBegin()
5330 
    while True:
5331 
      (fname, ftype, fid) = iprot.readFieldBegin()
5332 
      if ftype == TType.STOP:
5333 
        break
5334 
      if fid == 1:
483 rajveer 5335 
        if ftype == TType.I32:
5336 
          self.status = iprot.readI32();
94 ashish 5337 
        else:
5338 
          iprot.skip(ftype)
483 rajveer 5339 
      elif fid == 2:
5340 
        if ftype == TType.I64:
5341 
          self.from_date = iprot.readI64();
94 ashish 5342 
        else:
5343 
          iprot.skip(ftype)
483 rajveer 5344 
      elif fid == 3:
5345 
        if ftype == TType.I64:
5346 
          self.to_date = iprot.readI64();
94 ashish 5347 
        else:
5348 
          iprot.skip(ftype)
483 rajveer 5349 
      elif fid == 4:
94 ashish 5350 
        if ftype == TType.I64:
483 rajveer 5351 
          self.warehouse_id = iprot.readI64();
94 ashish 5352 
        else:
5353 
          iprot.skip(ftype)
5354 
      else:
5355 
        iprot.skip(ftype)
5356 
      iprot.readFieldEnd()
5357 
    iprot.readStructEnd()
5358 
 
5359 
  def write(self, oprot):
5360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5362 
      return
483 rajveer 5363 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5364 
    if self.status is not None:
483 rajveer 5365 
      oprot.writeFieldBegin('status', TType.I32, 1)
5366 
      oprot.writeI32(self.status)
94 ashish 5367 
      oprot.writeFieldEnd()
3431 rajveer 5368 
    if self.from_date is not None:
483 rajveer 5369 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5370 
      oprot.writeI64(self.from_date)
94 ashish 5371 
      oprot.writeFieldEnd()
3431 rajveer 5372 
    if self.to_date is not None:
483 rajveer 5373 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5374 
      oprot.writeI64(self.to_date)
94 ashish 5375 
      oprot.writeFieldEnd()
3431 rajveer 5376 
    if self.warehouse_id is not None:
483 rajveer 5377 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5378 
      oprot.writeI64(self.warehouse_id)
94 ashish 5379 
      oprot.writeFieldEnd()
5380 
    oprot.writeFieldStop()
5381 
    oprot.writeStructEnd()
5382 
 
3431 rajveer 5383 
  def validate(self):
5384 
    return
5385 
 
5386 
 
94 ashish 5387 
  def __repr__(self):
5388 
    L = ['%s=%r' % (key, value)
5389 
      for key, value in self.__dict__.iteritems()]
5390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5391 
 
5392 
  def __eq__(self, other):
5393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5394 
 
5395 
  def __ne__(self, other):
5396 
    return not (self == other)
5397 
 
483 rajveer 5398 
class getAllOrders_result:
94 ashish 5399 
  """
5400 
  Attributes:
5401 
   - success
5402 
   - ex
5403 
  """
5404 
 
5405 
  thrift_spec = (
483 rajveer 5406 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5407 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5408 
  )
5409 
 
5410 
  def __init__(self, success=None, ex=None,):
5411 
    self.success = success
5412 
    self.ex = ex
5413 
 
5414 
  def read(self, iprot):
5415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5417 
      return
5418 
    iprot.readStructBegin()
5419 
    while True:
5420 
      (fname, ftype, fid) = iprot.readFieldBegin()
5421 
      if ftype == TType.STOP:
5422 
        break
5423 
      if fid == 0:
483 rajveer 5424 
        if ftype == TType.LIST:
5425 
          self.success = []
685 chandransh 5426 
          (_etype31, _size28) = iprot.readListBegin()
5427 
          for _i32 in xrange(_size28):
5428 
            _elem33 = Order()
5429 
            _elem33.read(iprot)
5430 
            self.success.append(_elem33)
483 rajveer 5431 
          iprot.readListEnd()
94 ashish 5432 
        else:
5433 
          iprot.skip(ftype)
5434 
      elif fid == 1:
5435 
        if ftype == TType.STRUCT:
5436 
          self.ex = TransactionServiceException()
5437 
          self.ex.read(iprot)
5438 
        else:
5439 
          iprot.skip(ftype)
5440 
      else:
5441 
        iprot.skip(ftype)
5442 
      iprot.readFieldEnd()
5443 
    iprot.readStructEnd()
5444 
 
5445 
  def write(self, oprot):
5446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5448 
      return
483 rajveer 5449 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5450 
    if self.success is not None:
483 rajveer 5451 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5452 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5453 
      for iter34 in self.success:
5454 
        iter34.write(oprot)
483 rajveer 5455 
      oprot.writeListEnd()
94 ashish 5456 
      oprot.writeFieldEnd()
3431 rajveer 5457 
    if self.ex is not None:
94 ashish 5458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5459 
      self.ex.write(oprot)
5460 
      oprot.writeFieldEnd()
5461 
    oprot.writeFieldStop()
5462 
    oprot.writeStructEnd()
5463 
 
3431 rajveer 5464 
  def validate(self):
5465 
    return
5466 
 
5467 
 
94 ashish 5468 
  def __repr__(self):
5469 
    L = ['%s=%r' % (key, value)
5470 
      for key, value in self.__dict__.iteritems()]
5471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5472 
 
5473 
  def __eq__(self, other):
5474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5475 
 
5476 
  def __ne__(self, other):
5477 
    return not (self == other)
5478 
 
4133 chandransh 5479 
class getOrdersInBatch_args:
5480 
  """
5481 
  Attributes:
5482 
   - statuses
5483 
   - offset
5484 
   - limit
5485 
   - warehouse_id
5486 
  """
5487 
 
5488 
  thrift_spec = (
5489 
    None, # 0
5490 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5491 
    (2, TType.I64, 'offset', None, None, ), # 2
5492 
    (3, TType.I64, 'limit', None, None, ), # 3
5493 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5494 
  )
5495 
 
5496 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5497 
    self.statuses = statuses
5498 
    self.offset = offset
5499 
    self.limit = limit
5500 
    self.warehouse_id = warehouse_id
5501 
 
5502 
  def read(self, iprot):
5503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5505 
      return
5506 
    iprot.readStructBegin()
5507 
    while True:
5508 
      (fname, ftype, fid) = iprot.readFieldBegin()
5509 
      if ftype == TType.STOP:
5510 
        break
5511 
      if fid == 1:
5512 
        if ftype == TType.LIST:
5513 
          self.statuses = []
5514 
          (_etype38, _size35) = iprot.readListBegin()
5515 
          for _i39 in xrange(_size35):
5516 
            _elem40 = iprot.readI32();
5517 
            self.statuses.append(_elem40)
5518 
          iprot.readListEnd()
5519 
        else:
5520 
          iprot.skip(ftype)
5521 
      elif fid == 2:
5522 
        if ftype == TType.I64:
5523 
          self.offset = iprot.readI64();
5524 
        else:
5525 
          iprot.skip(ftype)
5526 
      elif fid == 3:
5527 
        if ftype == TType.I64:
5528 
          self.limit = iprot.readI64();
5529 
        else:
5530 
          iprot.skip(ftype)
5531 
      elif fid == 4:
5532 
        if ftype == TType.I64:
5533 
          self.warehouse_id = iprot.readI64();
5534 
        else:
5535 
          iprot.skip(ftype)
5536 
      else:
5537 
        iprot.skip(ftype)
5538 
      iprot.readFieldEnd()
5539 
    iprot.readStructEnd()
5540 
 
5541 
  def write(self, oprot):
5542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5544 
      return
5545 
    oprot.writeStructBegin('getOrdersInBatch_args')
5546 
    if self.statuses is not None:
5547 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5548 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5549 
      for iter41 in self.statuses:
5550 
        oprot.writeI32(iter41)
5551 
      oprot.writeListEnd()
5552 
      oprot.writeFieldEnd()
5553 
    if self.offset is not None:
5554 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5555 
      oprot.writeI64(self.offset)
5556 
      oprot.writeFieldEnd()
5557 
    if self.limit is not None:
5558 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5559 
      oprot.writeI64(self.limit)
5560 
      oprot.writeFieldEnd()
5561 
    if self.warehouse_id is not None:
5562 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5563 
      oprot.writeI64(self.warehouse_id)
5564 
      oprot.writeFieldEnd()
5565 
    oprot.writeFieldStop()
5566 
    oprot.writeStructEnd()
5567 
 
5568 
  def validate(self):
5569 
    return
5570 
 
5571 
 
5572 
  def __repr__(self):
5573 
    L = ['%s=%r' % (key, value)
5574 
      for key, value in self.__dict__.iteritems()]
5575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5576 
 
5577 
  def __eq__(self, other):
5578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5579 
 
5580 
  def __ne__(self, other):
5581 
    return not (self == other)
5582 
 
5583 
class getOrdersInBatch_result:
5584 
  """
5585 
  Attributes:
5586 
   - success
5587 
   - ex
5588 
  """
5589 
 
5590 
  thrift_spec = (
5591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5593 
  )
5594 
 
5595 
  def __init__(self, success=None, ex=None,):
5596 
    self.success = success
5597 
    self.ex = ex
5598 
 
5599 
  def read(self, iprot):
5600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5602 
      return
5603 
    iprot.readStructBegin()
5604 
    while True:
5605 
      (fname, ftype, fid) = iprot.readFieldBegin()
5606 
      if ftype == TType.STOP:
5607 
        break
5608 
      if fid == 0:
5609 
        if ftype == TType.LIST:
5610 
          self.success = []
5611 
          (_etype45, _size42) = iprot.readListBegin()
5612 
          for _i46 in xrange(_size42):
5613 
            _elem47 = Order()
5614 
            _elem47.read(iprot)
5615 
            self.success.append(_elem47)
5616 
          iprot.readListEnd()
5617 
        else:
5618 
          iprot.skip(ftype)
5619 
      elif fid == 1:
5620 
        if ftype == TType.STRUCT:
5621 
          self.ex = TransactionServiceException()
5622 
          self.ex.read(iprot)
5623 
        else:
5624 
          iprot.skip(ftype)
5625 
      else:
5626 
        iprot.skip(ftype)
5627 
      iprot.readFieldEnd()
5628 
    iprot.readStructEnd()
5629 
 
5630 
  def write(self, oprot):
5631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5633 
      return
5634 
    oprot.writeStructBegin('getOrdersInBatch_result')
5635 
    if self.success is not None:
5636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5638 
      for iter48 in self.success:
5639 
        iter48.write(oprot)
5640 
      oprot.writeListEnd()
5641 
      oprot.writeFieldEnd()
5642 
    if self.ex is not None:
5643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5644 
      self.ex.write(oprot)
5645 
      oprot.writeFieldEnd()
5646 
    oprot.writeFieldStop()
5647 
    oprot.writeStructEnd()
5648 
 
5649 
  def validate(self):
5650 
    return
5651 
 
5652 
 
5653 
  def __repr__(self):
5654 
    L = ['%s=%r' % (key, value)
5655 
      for key, value in self.__dict__.iteritems()]
5656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5657 
 
5658 
  def __eq__(self, other):
5659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5660 
 
5661 
  def __ne__(self, other):
5662 
    return not (self == other)
5663 
 
5664 
class getOrderCount_args:
5665 
  """
5666 
  Attributes:
5667 
   - statuses
5668 
   - warehouseId
5669 
  """
5670 
 
5671 
  thrift_spec = (
5672 
    None, # 0
5673 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5674 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5675 
  )
5676 
 
5677 
  def __init__(self, statuses=None, warehouseId=None,):
5678 
    self.statuses = statuses
5679 
    self.warehouseId = warehouseId
5680 
 
5681 
  def read(self, iprot):
5682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5684 
      return
5685 
    iprot.readStructBegin()
5686 
    while True:
5687 
      (fname, ftype, fid) = iprot.readFieldBegin()
5688 
      if ftype == TType.STOP:
5689 
        break
5690 
      if fid == 1:
5691 
        if ftype == TType.LIST:
5692 
          self.statuses = []
5693 
          (_etype52, _size49) = iprot.readListBegin()
5694 
          for _i53 in xrange(_size49):
5695 
            _elem54 = iprot.readI32();
5696 
            self.statuses.append(_elem54)
5697 
          iprot.readListEnd()
5698 
        else:
5699 
          iprot.skip(ftype)
5700 
      elif fid == 2:
5701 
        if ftype == TType.I64:
5702 
          self.warehouseId = iprot.readI64();
5703 
        else:
5704 
          iprot.skip(ftype)
5705 
      else:
5706 
        iprot.skip(ftype)
5707 
      iprot.readFieldEnd()
5708 
    iprot.readStructEnd()
5709 
 
5710 
  def write(self, oprot):
5711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5713 
      return
5714 
    oprot.writeStructBegin('getOrderCount_args')
5715 
    if self.statuses is not None:
5716 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5717 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5718 
      for iter55 in self.statuses:
5719 
        oprot.writeI32(iter55)
5720 
      oprot.writeListEnd()
5721 
      oprot.writeFieldEnd()
5722 
    if self.warehouseId is not None:
5723 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5724 
      oprot.writeI64(self.warehouseId)
5725 
      oprot.writeFieldEnd()
5726 
    oprot.writeFieldStop()
5727 
    oprot.writeStructEnd()
5728 
 
5729 
  def validate(self):
5730 
    return
5731 
 
5732 
 
5733 
  def __repr__(self):
5734 
    L = ['%s=%r' % (key, value)
5735 
      for key, value in self.__dict__.iteritems()]
5736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5737 
 
5738 
  def __eq__(self, other):
5739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5740 
 
5741 
  def __ne__(self, other):
5742 
    return not (self == other)
5743 
 
5744 
class getOrderCount_result:
5745 
  """
5746 
  Attributes:
5747 
   - success
5748 
   - ex
5749 
  """
5750 
 
5751 
  thrift_spec = (
5752 
    (0, TType.I32, 'success', None, None, ), # 0
5753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5754 
  )
5755 
 
5756 
  def __init__(self, success=None, ex=None,):
5757 
    self.success = success
5758 
    self.ex = ex
5759 
 
5760 
  def read(self, iprot):
5761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5763 
      return
5764 
    iprot.readStructBegin()
5765 
    while True:
5766 
      (fname, ftype, fid) = iprot.readFieldBegin()
5767 
      if ftype == TType.STOP:
5768 
        break
5769 
      if fid == 0:
5770 
        if ftype == TType.I32:
5771 
          self.success = iprot.readI32();
5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      elif fid == 1:
5775 
        if ftype == TType.STRUCT:
5776 
          self.ex = TransactionServiceException()
5777 
          self.ex.read(iprot)
5778 
        else:
5779 
          iprot.skip(ftype)
5780 
      else:
5781 
        iprot.skip(ftype)
5782 
      iprot.readFieldEnd()
5783 
    iprot.readStructEnd()
5784 
 
5785 
  def write(self, oprot):
5786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5788 
      return
5789 
    oprot.writeStructBegin('getOrderCount_result')
5790 
    if self.success is not None:
5791 
      oprot.writeFieldBegin('success', TType.I32, 0)
5792 
      oprot.writeI32(self.success)
5793 
      oprot.writeFieldEnd()
5794 
    if self.ex is not None:
5795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5796 
      self.ex.write(oprot)
5797 
      oprot.writeFieldEnd()
5798 
    oprot.writeFieldStop()
5799 
    oprot.writeStructEnd()
5800 
 
5801 
  def validate(self):
5802 
    return
5803 
 
5804 
 
5805 
  def __repr__(self):
5806 
    L = ['%s=%r' % (key, value)
5807 
      for key, value in self.__dict__.iteritems()]
5808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5809 
 
5810 
  def __eq__(self, other):
5811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5812 
 
5813 
  def __ne__(self, other):
5814 
    return not (self == other)
5815 
 
999 varun.gupt 5816 
class getOrdersByBillingDate_args:
5817 
  """
5818 
  Attributes:
5819 
   - status
5820 
   - start_billing_date
5821 
   - end_billing_date
5822 
   - warehouse_id
5823 
  """
5824 
 
5825 
  thrift_spec = (
5826 
    None, # 0
5827 
    (1, TType.I32, 'status', None, None, ), # 1
5828 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5829 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5830 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5831 
  )
5832 
 
5833 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5834 
    self.status = status
5835 
    self.start_billing_date = start_billing_date
5836 
    self.end_billing_date = end_billing_date
5837 
    self.warehouse_id = warehouse_id
5838 
 
5839 
  def read(self, iprot):
5840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5842 
      return
5843 
    iprot.readStructBegin()
5844 
    while True:
5845 
      (fname, ftype, fid) = iprot.readFieldBegin()
5846 
      if ftype == TType.STOP:
5847 
        break
5848 
      if fid == 1:
5849 
        if ftype == TType.I32:
5850 
          self.status = iprot.readI32();
5851 
        else:
5852 
          iprot.skip(ftype)
5853 
      elif fid == 2:
5854 
        if ftype == TType.I64:
5855 
          self.start_billing_date = iprot.readI64();
5856 
        else:
5857 
          iprot.skip(ftype)
5858 
      elif fid == 3:
5859 
        if ftype == TType.I64:
5860 
          self.end_billing_date = iprot.readI64();
5861 
        else:
5862 
          iprot.skip(ftype)
5863 
      elif fid == 4:
5864 
        if ftype == TType.I64:
5865 
          self.warehouse_id = iprot.readI64();
5866 
        else:
5867 
          iprot.skip(ftype)
5868 
      else:
5869 
        iprot.skip(ftype)
5870 
      iprot.readFieldEnd()
5871 
    iprot.readStructEnd()
5872 
 
5873 
  def write(self, oprot):
5874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5876 
      return
5877 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5878 
    if self.status is not None:
999 varun.gupt 5879 
      oprot.writeFieldBegin('status', TType.I32, 1)
5880 
      oprot.writeI32(self.status)
5881 
      oprot.writeFieldEnd()
3431 rajveer 5882 
    if self.start_billing_date is not None:
999 varun.gupt 5883 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5884 
      oprot.writeI64(self.start_billing_date)
5885 
      oprot.writeFieldEnd()
3431 rajveer 5886 
    if self.end_billing_date is not None:
999 varun.gupt 5887 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5888 
      oprot.writeI64(self.end_billing_date)
5889 
      oprot.writeFieldEnd()
3431 rajveer 5890 
    if self.warehouse_id is not None:
999 varun.gupt 5891 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5892 
      oprot.writeI64(self.warehouse_id)
5893 
      oprot.writeFieldEnd()
5894 
    oprot.writeFieldStop()
5895 
    oprot.writeStructEnd()
5896 
 
3431 rajveer 5897 
  def validate(self):
5898 
    return
5899 
 
5900 
 
999 varun.gupt 5901 
  def __repr__(self):
5902 
    L = ['%s=%r' % (key, value)
5903 
      for key, value in self.__dict__.iteritems()]
5904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5905 
 
5906 
  def __eq__(self, other):
5907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5908 
 
5909 
  def __ne__(self, other):
5910 
    return not (self == other)
5911 
 
5912 
class getOrdersByBillingDate_result:
5913 
  """
5914 
  Attributes:
5915 
   - success
5916 
   - ex
5917 
  """
5918 
 
5919 
  thrift_spec = (
5920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5922 
  )
5923 
 
5924 
  def __init__(self, success=None, ex=None,):
5925 
    self.success = success
5926 
    self.ex = ex
5927 
 
5928 
  def read(self, iprot):
5929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5931 
      return
5932 
    iprot.readStructBegin()
5933 
    while True:
5934 
      (fname, ftype, fid) = iprot.readFieldBegin()
5935 
      if ftype == TType.STOP:
5936 
        break
5937 
      if fid == 0:
5938 
        if ftype == TType.LIST:
5939 
          self.success = []
4133 chandransh 5940 
          (_etype59, _size56) = iprot.readListBegin()
5941 
          for _i60 in xrange(_size56):
5942 
            _elem61 = Order()
5943 
            _elem61.read(iprot)
5944 
            self.success.append(_elem61)
999 varun.gupt 5945 
          iprot.readListEnd()
5946 
        else:
5947 
          iprot.skip(ftype)
5948 
      elif fid == 1:
5949 
        if ftype == TType.STRUCT:
5950 
          self.ex = TransactionServiceException()
5951 
          self.ex.read(iprot)
5952 
        else:
5953 
          iprot.skip(ftype)
5954 
      else:
5955 
        iprot.skip(ftype)
5956 
      iprot.readFieldEnd()
5957 
    iprot.readStructEnd()
5958 
 
5959 
  def write(self, oprot):
5960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5962 
      return
5963 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5964 
    if self.success is not None:
999 varun.gupt 5965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5967 
      for iter62 in self.success:
5968 
        iter62.write(oprot)
999 varun.gupt 5969 
      oprot.writeListEnd()
5970 
      oprot.writeFieldEnd()
3431 rajveer 5971 
    if self.ex is not None:
999 varun.gupt 5972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5973 
      self.ex.write(oprot)
5974 
      oprot.writeFieldEnd()
5975 
    oprot.writeFieldStop()
5976 
    oprot.writeStructEnd()
5977 
 
3431 rajveer 5978 
  def validate(self):
5979 
    return
5980 
 
5981 
 
999 varun.gupt 5982 
  def __repr__(self):
5983 
    L = ['%s=%r' % (key, value)
5984 
      for key, value in self.__dict__.iteritems()]
5985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5986 
 
5987 
  def __eq__(self, other):
5988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5989 
 
5990 
  def __ne__(self, other):
5991 
    return not (self == other)
5992 
 
3427 chandransh 5993 
class getOrdersByShippingDate_args:
5994 
  """
5995 
  Attributes:
5996 
   - fromShippingDate
5997 
   - toShippingDate
5998 
   - providerId
5999 
   - warehouseId
3451 chandransh 6000 
   - cod
3427 chandransh 6001 
  """
6002 
 
6003 
  thrift_spec = (
6004 
    None, # 0
6005 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6006 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6007 
    (3, TType.I64, 'providerId', None, None, ), # 3
6008 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6009 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6010 
  )
6011 
 
3451 chandransh 6012 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6013 
    self.fromShippingDate = fromShippingDate
6014 
    self.toShippingDate = toShippingDate
6015 
    self.providerId = providerId
6016 
    self.warehouseId = warehouseId
3451 chandransh 6017 
    self.cod = cod
3427 chandransh 6018 
 
6019 
  def read(self, iprot):
6020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6022 
      return
6023 
    iprot.readStructBegin()
6024 
    while True:
6025 
      (fname, ftype, fid) = iprot.readFieldBegin()
6026 
      if ftype == TType.STOP:
6027 
        break
6028 
      if fid == 1:
6029 
        if ftype == TType.I64:
6030 
          self.fromShippingDate = iprot.readI64();
6031 
        else:
6032 
          iprot.skip(ftype)
6033 
      elif fid == 2:
6034 
        if ftype == TType.I64:
6035 
          self.toShippingDate = iprot.readI64();
6036 
        else:
6037 
          iprot.skip(ftype)
6038 
      elif fid == 3:
6039 
        if ftype == TType.I64:
6040 
          self.providerId = iprot.readI64();
6041 
        else:
6042 
          iprot.skip(ftype)
6043 
      elif fid == 4:
6044 
        if ftype == TType.I64:
6045 
          self.warehouseId = iprot.readI64();
6046 
        else:
6047 
          iprot.skip(ftype)
3451 chandransh 6048 
      elif fid == 5:
6049 
        if ftype == TType.BOOL:
6050 
          self.cod = iprot.readBool();
6051 
        else:
6052 
          iprot.skip(ftype)
3427 chandransh 6053 
      else:
6054 
        iprot.skip(ftype)
6055 
      iprot.readFieldEnd()
6056 
    iprot.readStructEnd()
6057 
 
6058 
  def write(self, oprot):
6059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6061 
      return
6062 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6063 
    if self.fromShippingDate is not None:
3427 chandransh 6064 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6065 
      oprot.writeI64(self.fromShippingDate)
6066 
      oprot.writeFieldEnd()
3431 rajveer 6067 
    if self.toShippingDate is not None:
3427 chandransh 6068 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6069 
      oprot.writeI64(self.toShippingDate)
6070 
      oprot.writeFieldEnd()
3431 rajveer 6071 
    if self.providerId is not None:
3427 chandransh 6072 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6073 
      oprot.writeI64(self.providerId)
6074 
      oprot.writeFieldEnd()
3431 rajveer 6075 
    if self.warehouseId is not None:
3427 chandransh 6076 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6077 
      oprot.writeI64(self.warehouseId)
6078 
      oprot.writeFieldEnd()
3451 chandransh 6079 
    if self.cod is not None:
6080 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6081 
      oprot.writeBool(self.cod)
6082 
      oprot.writeFieldEnd()
3427 chandransh 6083 
    oprot.writeFieldStop()
6084 
    oprot.writeStructEnd()
6085 
 
3431 rajveer 6086 
  def validate(self):
6087 
    return
6088 
 
6089 
 
3427 chandransh 6090 
  def __repr__(self):
6091 
    L = ['%s=%r' % (key, value)
6092 
      for key, value in self.__dict__.iteritems()]
6093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6094 
 
6095 
  def __eq__(self, other):
6096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6097 
 
6098 
  def __ne__(self, other):
6099 
    return not (self == other)
6100 
 
6101 
class getOrdersByShippingDate_result:
6102 
  """
6103 
  Attributes:
6104 
   - success
6105 
   - ex
6106 
  """
6107 
 
6108 
  thrift_spec = (
6109 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6111 
  )
6112 
 
6113 
  def __init__(self, success=None, ex=None,):
6114 
    self.success = success
6115 
    self.ex = ex
6116 
 
6117 
  def read(self, iprot):
6118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6120 
      return
6121 
    iprot.readStructBegin()
6122 
    while True:
6123 
      (fname, ftype, fid) = iprot.readFieldBegin()
6124 
      if ftype == TType.STOP:
6125 
        break
6126 
      if fid == 0:
6127 
        if ftype == TType.LIST:
6128 
          self.success = []
4133 chandransh 6129 
          (_etype66, _size63) = iprot.readListBegin()
6130 
          for _i67 in xrange(_size63):
6131 
            _elem68 = Order()
6132 
            _elem68.read(iprot)
6133 
            self.success.append(_elem68)
3427 chandransh 6134 
          iprot.readListEnd()
6135 
        else:
6136 
          iprot.skip(ftype)
6137 
      elif fid == 1:
6138 
        if ftype == TType.STRUCT:
6139 
          self.ex = TransactionServiceException()
6140 
          self.ex.read(iprot)
6141 
        else:
6142 
          iprot.skip(ftype)
6143 
      else:
6144 
        iprot.skip(ftype)
6145 
      iprot.readFieldEnd()
6146 
    iprot.readStructEnd()
6147 
 
6148 
  def write(self, oprot):
6149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6151 
      return
6152 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6153 
    if self.success is not None:
3427 chandransh 6154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6156 
      for iter69 in self.success:
6157 
        iter69.write(oprot)
3427 chandransh 6158 
      oprot.writeListEnd()
6159 
      oprot.writeFieldEnd()
3431 rajveer 6160 
    if self.ex is not None:
3427 chandransh 6161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6162 
      self.ex.write(oprot)
6163 
      oprot.writeFieldEnd()
6164 
    oprot.writeFieldStop()
6165 
    oprot.writeStructEnd()
6166 
 
3431 rajveer 6167 
  def validate(self):
6168 
    return
6169 
 
6170 
 
3427 chandransh 6171 
  def __repr__(self):
6172 
    L = ['%s=%r' % (key, value)
6173 
      for key, value in self.__dict__.iteritems()]
6174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6175 
 
6176 
  def __eq__(self, other):
6177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6178 
 
6179 
  def __ne__(self, other):
6180 
    return not (self == other)
6181 
 
1382 varun.gupt 6182 
class getReturnableOrdersForCustomer_args:
6183 
  """
6184 
  Attributes:
6185 
   - customer_id
6186 
   - limit
6187 
  """
6188 
 
6189 
  thrift_spec = (
6190 
    None, # 0
6191 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6192 
    (2, TType.I64, 'limit', None, None, ), # 2
6193 
  )
6194 
 
6195 
  def __init__(self, customer_id=None, limit=None,):
6196 
    self.customer_id = customer_id
6197 
    self.limit = limit
6198 
 
6199 
  def read(self, iprot):
6200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6202 
      return
6203 
    iprot.readStructBegin()
6204 
    while True:
6205 
      (fname, ftype, fid) = iprot.readFieldBegin()
6206 
      if ftype == TType.STOP:
6207 
        break
6208 
      if fid == 1:
6209 
        if ftype == TType.I64:
6210 
          self.customer_id = iprot.readI64();
6211 
        else:
6212 
          iprot.skip(ftype)
6213 
      elif fid == 2:
6214 
        if ftype == TType.I64:
6215 
          self.limit = iprot.readI64();
6216 
        else:
6217 
          iprot.skip(ftype)
6218 
      else:
6219 
        iprot.skip(ftype)
6220 
      iprot.readFieldEnd()
6221 
    iprot.readStructEnd()
6222 
 
6223 
  def write(self, oprot):
6224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6226 
      return
6227 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6228 
    if self.customer_id is not None:
1382 varun.gupt 6229 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6230 
      oprot.writeI64(self.customer_id)
6231 
      oprot.writeFieldEnd()
3431 rajveer 6232 
    if self.limit is not None:
1382 varun.gupt 6233 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6234 
      oprot.writeI64(self.limit)
6235 
      oprot.writeFieldEnd()
6236 
    oprot.writeFieldStop()
6237 
    oprot.writeStructEnd()
6238 
 
3431 rajveer 6239 
  def validate(self):
6240 
    return
6241 
 
6242 
 
1382 varun.gupt 6243 
  def __repr__(self):
6244 
    L = ['%s=%r' % (key, value)
6245 
      for key, value in self.__dict__.iteritems()]
6246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6247 
 
6248 
  def __eq__(self, other):
6249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6250 
 
6251 
  def __ne__(self, other):
6252 
    return not (self == other)
6253 
 
6254 
class getReturnableOrdersForCustomer_result:
6255 
  """
6256 
  Attributes:
6257 
   - success
6258 
   - ex
6259 
  """
6260 
 
6261 
  thrift_spec = (
6262 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6264 
  )
6265 
 
6266 
  def __init__(self, success=None, ex=None,):
6267 
    self.success = success
6268 
    self.ex = ex
6269 
 
6270 
  def read(self, iprot):
6271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6273 
      return
6274 
    iprot.readStructBegin()
6275 
    while True:
6276 
      (fname, ftype, fid) = iprot.readFieldBegin()
6277 
      if ftype == TType.STOP:
6278 
        break
6279 
      if fid == 0:
6280 
        if ftype == TType.LIST:
6281 
          self.success = []
4133 chandransh 6282 
          (_etype73, _size70) = iprot.readListBegin()
6283 
          for _i74 in xrange(_size70):
6284 
            _elem75 = iprot.readI64();
6285 
            self.success.append(_elem75)
1382 varun.gupt 6286 
          iprot.readListEnd()
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      elif fid == 1:
6290 
        if ftype == TType.STRUCT:
6291 
          self.ex = TransactionServiceException()
6292 
          self.ex.read(iprot)
6293 
        else:
6294 
          iprot.skip(ftype)
6295 
      else:
6296 
        iprot.skip(ftype)
6297 
      iprot.readFieldEnd()
6298 
    iprot.readStructEnd()
6299 
 
6300 
  def write(self, oprot):
6301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6303 
      return
6304 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6305 
    if self.success is not None:
1382 varun.gupt 6306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6307 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6308 
      for iter76 in self.success:
6309 
        oprot.writeI64(iter76)
1382 varun.gupt 6310 
      oprot.writeListEnd()
6311 
      oprot.writeFieldEnd()
3431 rajveer 6312 
    if self.ex is not None:
1382 varun.gupt 6313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6314 
      self.ex.write(oprot)
6315 
      oprot.writeFieldEnd()
6316 
    oprot.writeFieldStop()
6317 
    oprot.writeStructEnd()
6318 
 
3431 rajveer 6319 
  def validate(self):
6320 
    return
6321 
 
6322 
 
1382 varun.gupt 6323 
  def __repr__(self):
6324 
    L = ['%s=%r' % (key, value)
6325 
      for key, value in self.__dict__.iteritems()]
6326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6327 
 
6328 
  def __eq__(self, other):
6329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6330 
 
6331 
  def __ne__(self, other):
6332 
    return not (self == other)
6333 
 
6334 
class getCancellableOrdersForCustomer_args:
6335 
  """
6336 
  Attributes:
6337 
   - customer_id
6338 
   - limit
6339 
  """
6340 
 
6341 
  thrift_spec = (
6342 
    None, # 0
6343 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6344 
    (2, TType.I64, 'limit', None, None, ), # 2
6345 
  )
6346 
 
6347 
  def __init__(self, customer_id=None, limit=None,):
6348 
    self.customer_id = customer_id
6349 
    self.limit = limit
6350 
 
6351 
  def read(self, iprot):
6352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6354 
      return
6355 
    iprot.readStructBegin()
6356 
    while True:
6357 
      (fname, ftype, fid) = iprot.readFieldBegin()
6358 
      if ftype == TType.STOP:
6359 
        break
6360 
      if fid == 1:
6361 
        if ftype == TType.I64:
6362 
          self.customer_id = iprot.readI64();
6363 
        else:
6364 
          iprot.skip(ftype)
6365 
      elif fid == 2:
6366 
        if ftype == TType.I64:
6367 
          self.limit = iprot.readI64();
6368 
        else:
6369 
          iprot.skip(ftype)
6370 
      else:
6371 
        iprot.skip(ftype)
6372 
      iprot.readFieldEnd()
6373 
    iprot.readStructEnd()
6374 
 
6375 
  def write(self, oprot):
6376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6378 
      return
6379 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6380 
    if self.customer_id is not None:
1382 varun.gupt 6381 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6382 
      oprot.writeI64(self.customer_id)
6383 
      oprot.writeFieldEnd()
3431 rajveer 6384 
    if self.limit is not None:
1382 varun.gupt 6385 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6386 
      oprot.writeI64(self.limit)
6387 
      oprot.writeFieldEnd()
6388 
    oprot.writeFieldStop()
6389 
    oprot.writeStructEnd()
6390 
 
3431 rajveer 6391 
  def validate(self):
6392 
    return
6393 
 
6394 
 
1382 varun.gupt 6395 
  def __repr__(self):
6396 
    L = ['%s=%r' % (key, value)
6397 
      for key, value in self.__dict__.iteritems()]
6398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6399 
 
6400 
  def __eq__(self, other):
6401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6402 
 
6403 
  def __ne__(self, other):
6404 
    return not (self == other)
6405 
 
6406 
class getCancellableOrdersForCustomer_result:
6407 
  """
6408 
  Attributes:
6409 
   - success
6410 
   - ex
6411 
  """
6412 
 
6413 
  thrift_spec = (
6414 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6416 
  )
6417 
 
6418 
  def __init__(self, success=None, ex=None,):
6419 
    self.success = success
6420 
    self.ex = ex
6421 
 
6422 
  def read(self, iprot):
6423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6425 
      return
6426 
    iprot.readStructBegin()
6427 
    while True:
6428 
      (fname, ftype, fid) = iprot.readFieldBegin()
6429 
      if ftype == TType.STOP:
6430 
        break
6431 
      if fid == 0:
6432 
        if ftype == TType.LIST:
6433 
          self.success = []
4133 chandransh 6434 
          (_etype80, _size77) = iprot.readListBegin()
6435 
          for _i81 in xrange(_size77):
6436 
            _elem82 = iprot.readI64();
6437 
            self.success.append(_elem82)
1382 varun.gupt 6438 
          iprot.readListEnd()
6439 
        else:
6440 
          iprot.skip(ftype)
6441 
      elif fid == 1:
6442 
        if ftype == TType.STRUCT:
6443 
          self.ex = TransactionServiceException()
6444 
          self.ex.read(iprot)
6445 
        else:
6446 
          iprot.skip(ftype)
6447 
      else:
6448 
        iprot.skip(ftype)
6449 
      iprot.readFieldEnd()
6450 
    iprot.readStructEnd()
6451 
 
6452 
  def write(self, oprot):
6453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6455 
      return
6456 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6457 
    if self.success is not None:
1382 varun.gupt 6458 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6459 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6460 
      for iter83 in self.success:
6461 
        oprot.writeI64(iter83)
1382 varun.gupt 6462 
      oprot.writeListEnd()
6463 
      oprot.writeFieldEnd()
3431 rajveer 6464 
    if self.ex is not None:
1382 varun.gupt 6465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6466 
      self.ex.write(oprot)
6467 
      oprot.writeFieldEnd()
6468 
    oprot.writeFieldStop()
6469 
    oprot.writeStructEnd()
6470 
 
3431 rajveer 6471 
  def validate(self):
6472 
    return
6473 
 
6474 
 
1382 varun.gupt 6475 
  def __repr__(self):
6476 
    L = ['%s=%r' % (key, value)
6477 
      for key, value in self.__dict__.iteritems()]
6478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6479 
 
6480 
  def __eq__(self, other):
6481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6482 
 
6483 
  def __ne__(self, other):
6484 
    return not (self == other)
6485 
 
483 rajveer 6486 
class changeOrderStatus_args:
94 ashish 6487 
  """
6488 
  Attributes:
483 rajveer 6489 
   - orderId
6490 
   - status
6491 
   - description
94 ashish 6492 
  """
6493 
 
6494 
  thrift_spec = (
6495 
    None, # 0
483 rajveer 6496 
    (1, TType.I64, 'orderId', None, None, ), # 1
6497 
    (2, TType.I32, 'status', None, None, ), # 2
6498 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6499 
  )
6500 
 
483 rajveer 6501 
  def __init__(self, orderId=None, status=None, description=None,):
6502 
    self.orderId = orderId
6503 
    self.status = status
6504 
    self.description = description
94 ashish 6505 
 
6506 
  def read(self, iprot):
6507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6509 
      return
6510 
    iprot.readStructBegin()
6511 
    while True:
6512 
      (fname, ftype, fid) = iprot.readFieldBegin()
6513 
      if ftype == TType.STOP:
6514 
        break
6515 
      if fid == 1:
6516 
        if ftype == TType.I64:
483 rajveer 6517 
          self.orderId = iprot.readI64();
94 ashish 6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      elif fid == 2:
483 rajveer 6521 
        if ftype == TType.I32:
6522 
          self.status = iprot.readI32();
94 ashish 6523 
        else:
6524 
          iprot.skip(ftype)
483 rajveer 6525 
      elif fid == 3:
6526 
        if ftype == TType.STRING:
6527 
          self.description = iprot.readString();
6528 
        else:
6529 
          iprot.skip(ftype)
94 ashish 6530 
      else:
6531 
        iprot.skip(ftype)
6532 
      iprot.readFieldEnd()
6533 
    iprot.readStructEnd()
6534 
 
6535 
  def write(self, oprot):
6536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6538 
      return
483 rajveer 6539 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6540 
    if self.orderId is not None:
483 rajveer 6541 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6542 
      oprot.writeI64(self.orderId)
94 ashish 6543 
      oprot.writeFieldEnd()
3431 rajveer 6544 
    if self.status is not None:
483 rajveer 6545 
      oprot.writeFieldBegin('status', TType.I32, 2)
6546 
      oprot.writeI32(self.status)
94 ashish 6547 
      oprot.writeFieldEnd()
3431 rajveer 6548 
    if self.description is not None:
483 rajveer 6549 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6550 
      oprot.writeString(self.description)
6551 
      oprot.writeFieldEnd()
94 ashish 6552 
    oprot.writeFieldStop()
6553 
    oprot.writeStructEnd()
6554 
 
3431 rajveer 6555 
  def validate(self):
6556 
    return
6557 
 
6558 
 
94 ashish 6559 
  def __repr__(self):
6560 
    L = ['%s=%r' % (key, value)
6561 
      for key, value in self.__dict__.iteritems()]
6562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6563 
 
6564 
  def __eq__(self, other):
6565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6566 
 
6567 
  def __ne__(self, other):
6568 
    return not (self == other)
6569 
 
483 rajveer 6570 
class changeOrderStatus_result:
94 ashish 6571 
  """
6572 
  Attributes:
6573 
   - success
6574 
   - ex
6575 
  """
6576 
 
6577 
  thrift_spec = (
6578 
    (0, TType.BOOL, 'success', None, None, ), # 0
6579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6580 
  )
6581 
 
6582 
  def __init__(self, success=None, ex=None,):
6583 
    self.success = success
6584 
    self.ex = ex
6585 
 
6586 
  def read(self, iprot):
6587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6589 
      return
6590 
    iprot.readStructBegin()
6591 
    while True:
6592 
      (fname, ftype, fid) = iprot.readFieldBegin()
6593 
      if ftype == TType.STOP:
6594 
        break
6595 
      if fid == 0:
6596 
        if ftype == TType.BOOL:
6597 
          self.success = iprot.readBool();
6598 
        else:
6599 
          iprot.skip(ftype)
6600 
      elif fid == 1:
6601 
        if ftype == TType.STRUCT:
6602 
          self.ex = TransactionServiceException()
6603 
          self.ex.read(iprot)
6604 
        else:
6605 
          iprot.skip(ftype)
6606 
      else:
6607 
        iprot.skip(ftype)
6608 
      iprot.readFieldEnd()
6609 
    iprot.readStructEnd()
6610 
 
6611 
  def write(self, oprot):
6612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6614 
      return
483 rajveer 6615 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6616 
    if self.success is not None:
94 ashish 6617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6618 
      oprot.writeBool(self.success)
6619 
      oprot.writeFieldEnd()
3431 rajveer 6620 
    if self.ex is not None:
94 ashish 6621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6622 
      self.ex.write(oprot)
6623 
      oprot.writeFieldEnd()
6624 
    oprot.writeFieldStop()
6625 
    oprot.writeStructEnd()
6626 
 
3431 rajveer 6627 
  def validate(self):
6628 
    return
6629 
 
6630 
 
94 ashish 6631 
  def __repr__(self):
6632 
    L = ['%s=%r' % (key, value)
6633 
      for key, value in self.__dict__.iteritems()]
6634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6635 
 
6636 
  def __eq__(self, other):
6637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6638 
 
6639 
  def __ne__(self, other):
6640 
    return not (self == other)
6641 
 
3064 chandransh 6642 
class getOrdersForTransaction_args:
494 rajveer 6643 
  """
6644 
  Attributes:
3064 chandransh 6645 
   - transactionId
6646 
   - customerId
494 rajveer 6647 
  """
6648 
 
6649 
  thrift_spec = (
6650 
    None, # 0
3064 chandransh 6651 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6652 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6653 
  )
6654 
 
3064 chandransh 6655 
  def __init__(self, transactionId=None, customerId=None,):
6656 
    self.transactionId = transactionId
6657 
    self.customerId = customerId
494 rajveer 6658 
 
6659 
  def read(self, iprot):
6660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6662 
      return
6663 
    iprot.readStructBegin()
6664 
    while True:
6665 
      (fname, ftype, fid) = iprot.readFieldBegin()
6666 
      if ftype == TType.STOP:
6667 
        break
6668 
      if fid == 1:
6669 
        if ftype == TType.I64:
3064 chandransh 6670 
          self.transactionId = iprot.readI64();
494 rajveer 6671 
        else:
6672 
          iprot.skip(ftype)
6673 
      elif fid == 2:
3064 chandransh 6674 
        if ftype == TType.I64:
6675 
          self.customerId = iprot.readI64();
494 rajveer 6676 
        else:
6677 
          iprot.skip(ftype)
6678 
      else:
6679 
        iprot.skip(ftype)
6680 
      iprot.readFieldEnd()
6681 
    iprot.readStructEnd()
6682 
 
6683 
  def write(self, oprot):
6684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6686 
      return
3064 chandransh 6687 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6688 
    if self.transactionId is not None:
3064 chandransh 6689 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6690 
      oprot.writeI64(self.transactionId)
494 rajveer 6691 
      oprot.writeFieldEnd()
3431 rajveer 6692 
    if self.customerId is not None:
3064 chandransh 6693 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6694 
      oprot.writeI64(self.customerId)
494 rajveer 6695 
      oprot.writeFieldEnd()
6696 
    oprot.writeFieldStop()
6697 
    oprot.writeStructEnd()
6698 
 
3431 rajveer 6699 
  def validate(self):
6700 
    return
6701 
 
6702 
 
494 rajveer 6703 
  def __repr__(self):
6704 
    L = ['%s=%r' % (key, value)
6705 
      for key, value in self.__dict__.iteritems()]
6706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6707 
 
6708 
  def __eq__(self, other):
6709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6710 
 
6711 
  def __ne__(self, other):
6712 
    return not (self == other)
6713 
 
3064 chandransh 6714 
class getOrdersForTransaction_result:
494 rajveer 6715 
  """
6716 
  Attributes:
6717 
   - success
6718 
   - ex
6719 
  """
6720 
 
6721 
  thrift_spec = (
3064 chandransh 6722 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6724 
  )
6725 
 
6726 
  def __init__(self, success=None, ex=None,):
6727 
    self.success = success
6728 
    self.ex = ex
6729 
 
6730 
  def read(self, iprot):
6731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6733 
      return
6734 
    iprot.readStructBegin()
6735 
    while True:
6736 
      (fname, ftype, fid) = iprot.readFieldBegin()
6737 
      if ftype == TType.STOP:
6738 
        break
6739 
      if fid == 0:
3064 chandransh 6740 
        if ftype == TType.LIST:
6741 
          self.success = []
4133 chandransh 6742 
          (_etype87, _size84) = iprot.readListBegin()
6743 
          for _i88 in xrange(_size84):
6744 
            _elem89 = Order()
6745 
            _elem89.read(iprot)
6746 
            self.success.append(_elem89)
3064 chandransh 6747 
          iprot.readListEnd()
494 rajveer 6748 
        else:
6749 
          iprot.skip(ftype)
6750 
      elif fid == 1:
6751 
        if ftype == TType.STRUCT:
6752 
          self.ex = TransactionServiceException()
6753 
          self.ex.read(iprot)
6754 
        else:
6755 
          iprot.skip(ftype)
6756 
      else:
6757 
        iprot.skip(ftype)
6758 
      iprot.readFieldEnd()
6759 
    iprot.readStructEnd()
6760 
 
6761 
  def write(self, oprot):
6762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6764 
      return
3064 chandransh 6765 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6766 
    if self.success is not None:
3064 chandransh 6767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6769 
      for iter90 in self.success:
6770 
        iter90.write(oprot)
3064 chandransh 6771 
      oprot.writeListEnd()
494 rajveer 6772 
      oprot.writeFieldEnd()
3431 rajveer 6773 
    if self.ex is not None:
494 rajveer 6774 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6775 
      self.ex.write(oprot)
6776 
      oprot.writeFieldEnd()
6777 
    oprot.writeFieldStop()
6778 
    oprot.writeStructEnd()
6779 
 
3431 rajveer 6780 
  def validate(self):
6781 
    return
6782 
 
6783 
 
494 rajveer 6784 
  def __repr__(self):
6785 
    L = ['%s=%r' % (key, value)
6786 
      for key, value in self.__dict__.iteritems()]
6787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6788 
 
6789 
  def __eq__(self, other):
6790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6791 
 
6792 
  def __ne__(self, other):
6793 
    return not (self == other)
6794 
 
3064 chandransh 6795 
class getOrdersForCustomer_args:
1149 chandransh 6796 
  """
6797 
  Attributes:
3064 chandransh 6798 
   - customerId
6799 
   - from_date
6800 
   - to_date
6801 
   - statuses
1149 chandransh 6802 
  """
6803 
 
6804 
  thrift_spec = (
6805 
    None, # 0
3064 chandransh 6806 
    (1, TType.I64, 'customerId', None, None, ), # 1
6807 
    (2, TType.I64, 'from_date', None, None, ), # 2
6808 
    (3, TType.I64, 'to_date', None, None, ), # 3
6809 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6810 
  )
6811 
 
3064 chandransh 6812 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6813 
    self.customerId = customerId
6814 
    self.from_date = from_date
6815 
    self.to_date = to_date
6816 
    self.statuses = statuses
1149 chandransh 6817 
 
6818 
  def read(self, iprot):
6819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6821 
      return
6822 
    iprot.readStructBegin()
6823 
    while True:
6824 
      (fname, ftype, fid) = iprot.readFieldBegin()
6825 
      if ftype == TType.STOP:
6826 
        break
6827 
      if fid == 1:
6828 
        if ftype == TType.I64:
3064 chandransh 6829 
          self.customerId = iprot.readI64();
1149 chandransh 6830 
        else:
6831 
          iprot.skip(ftype)
6832 
      elif fid == 2:
6833 
        if ftype == TType.I64:
3064 chandransh 6834 
          self.from_date = iprot.readI64();
1149 chandransh 6835 
        else:
6836 
          iprot.skip(ftype)
2783 chandransh 6837 
      elif fid == 3:
6838 
        if ftype == TType.I64:
3064 chandransh 6839 
          self.to_date = iprot.readI64();
2783 chandransh 6840 
        else:
6841 
          iprot.skip(ftype)
6842 
      elif fid == 4:
3064 chandransh 6843 
        if ftype == TType.LIST:
6844 
          self.statuses = []
4133 chandransh 6845 
          (_etype94, _size91) = iprot.readListBegin()
6846 
          for _i95 in xrange(_size91):
6847 
            _elem96 = iprot.readI32();
6848 
            self.statuses.append(_elem96)
3064 chandransh 6849 
          iprot.readListEnd()
2783 chandransh 6850 
        else:
6851 
          iprot.skip(ftype)
1149 chandransh 6852 
      else:
6853 
        iprot.skip(ftype)
6854 
      iprot.readFieldEnd()
6855 
    iprot.readStructEnd()
6856 
 
6857 
  def write(self, oprot):
6858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6860 
      return
3064 chandransh 6861 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6862 
    if self.customerId is not None:
3064 chandransh 6863 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6864 
      oprot.writeI64(self.customerId)
1149 chandransh 6865 
      oprot.writeFieldEnd()
3431 rajveer 6866 
    if self.from_date is not None:
3064 chandransh 6867 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6868 
      oprot.writeI64(self.from_date)
1149 chandransh 6869 
      oprot.writeFieldEnd()
3431 rajveer 6870 
    if self.to_date is not None:
3064 chandransh 6871 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6872 
      oprot.writeI64(self.to_date)
2783 chandransh 6873 
      oprot.writeFieldEnd()
3431 rajveer 6874 
    if self.statuses is not None:
3064 chandransh 6875 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6876 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6877 
      for iter97 in self.statuses:
6878 
        oprot.writeI32(iter97)
3064 chandransh 6879 
      oprot.writeListEnd()
2783 chandransh 6880 
      oprot.writeFieldEnd()
1149 chandransh 6881 
    oprot.writeFieldStop()
6882 
    oprot.writeStructEnd()
6883 
 
3431 rajveer 6884 
  def validate(self):
6885 
    return
6886 
 
6887 
 
1149 chandransh 6888 
  def __repr__(self):
6889 
    L = ['%s=%r' % (key, value)
6890 
      for key, value in self.__dict__.iteritems()]
6891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6892 
 
6893 
  def __eq__(self, other):
6894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6895 
 
6896 
  def __ne__(self, other):
6897 
    return not (self == other)
6898 
 
3064 chandransh 6899 
class getOrdersForCustomer_result:
1149 chandransh 6900 
  """
6901 
  Attributes:
6902 
   - success
6903 
   - ex
6904 
  """
6905 
 
6906 
  thrift_spec = (
3064 chandransh 6907 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6909 
  )
6910 
 
6911 
  def __init__(self, success=None, ex=None,):
6912 
    self.success = success
6913 
    self.ex = ex
6914 
 
6915 
  def read(self, iprot):
6916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6918 
      return
6919 
    iprot.readStructBegin()
6920 
    while True:
6921 
      (fname, ftype, fid) = iprot.readFieldBegin()
6922 
      if ftype == TType.STOP:
6923 
        break
6924 
      if fid == 0:
3064 chandransh 6925 
        if ftype == TType.LIST:
6926 
          self.success = []
4133 chandransh 6927 
          (_etype101, _size98) = iprot.readListBegin()
6928 
          for _i102 in xrange(_size98):
6929 
            _elem103 = Order()
6930 
            _elem103.read(iprot)
6931 
            self.success.append(_elem103)
3064 chandransh 6932 
          iprot.readListEnd()
1149 chandransh 6933 
        else:
6934 
          iprot.skip(ftype)
6935 
      elif fid == 1:
6936 
        if ftype == TType.STRUCT:
6937 
          self.ex = TransactionServiceException()
6938 
          self.ex.read(iprot)
6939 
        else:
6940 
          iprot.skip(ftype)
6941 
      else:
6942 
        iprot.skip(ftype)
6943 
      iprot.readFieldEnd()
6944 
    iprot.readStructEnd()
6945 
 
6946 
  def write(self, oprot):
6947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6949 
      return
3064 chandransh 6950 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6951 
    if self.success is not None:
3064 chandransh 6952 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6953 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6954 
      for iter104 in self.success:
6955 
        iter104.write(oprot)
3064 chandransh 6956 
      oprot.writeListEnd()
1149 chandransh 6957 
      oprot.writeFieldEnd()
3431 rajveer 6958 
    if self.ex is not None:
1149 chandransh 6959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6960 
      self.ex.write(oprot)
6961 
      oprot.writeFieldEnd()
6962 
    oprot.writeFieldStop()
6963 
    oprot.writeStructEnd()
6964 
 
3431 rajveer 6965 
  def validate(self):
6966 
    return
6967 
 
6968 
 
1149 chandransh 6969 
  def __repr__(self):
6970 
    L = ['%s=%r' % (key, value)
6971 
      for key, value in self.__dict__.iteritems()]
6972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6973 
 
6974 
  def __eq__(self, other):
6975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6976 
 
6977 
  def __ne__(self, other):
6978 
    return not (self == other)
6979 
 
3064 chandransh 6980 
class createOrder_args:
921 rajveer 6981 
  """
6982 
  Attributes:
3064 chandransh 6983 
   - order
921 rajveer 6984 
  """
6985 
 
6986 
  thrift_spec = (
6987 
    None, # 0
3064 chandransh 6988 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6989 
  )
6990 
 
3064 chandransh 6991 
  def __init__(self, order=None,):
6992 
    self.order = order
921 rajveer 6993 
 
6994 
  def read(self, iprot):
6995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6997 
      return
6998 
    iprot.readStructBegin()
6999 
    while True:
7000 
      (fname, ftype, fid) = iprot.readFieldBegin()
7001 
      if ftype == TType.STOP:
7002 
        break
7003 
      if fid == 1:
3064 chandransh 7004 
        if ftype == TType.STRUCT:
7005 
          self.order = Order()
7006 
          self.order.read(iprot)
921 rajveer 7007 
        else:
7008 
          iprot.skip(ftype)
7009 
      else:
7010 
        iprot.skip(ftype)
7011 
      iprot.readFieldEnd()
7012 
    iprot.readStructEnd()
7013 
 
7014 
  def write(self, oprot):
7015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7017 
      return
3064 chandransh 7018 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7019 
    if self.order is not None:
3064 chandransh 7020 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7021 
      self.order.write(oprot)
921 rajveer 7022 
      oprot.writeFieldEnd()
7023 
    oprot.writeFieldStop()
7024 
    oprot.writeStructEnd()
7025 
 
3431 rajveer 7026 
  def validate(self):
7027 
    return
7028 
 
7029 
 
921 rajveer 7030 
  def __repr__(self):
7031 
    L = ['%s=%r' % (key, value)
7032 
      for key, value in self.__dict__.iteritems()]
7033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7034 
 
7035 
  def __eq__(self, other):
7036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7037 
 
7038 
  def __ne__(self, other):
7039 
    return not (self == other)
7040 
 
3064 chandransh 7041 
class createOrder_result:
921 rajveer 7042 
  """
7043 
  Attributes:
7044 
   - success
7045 
   - ex
7046 
  """
7047 
 
7048 
  thrift_spec = (
3064 chandransh 7049 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7051 
  )
7052 
 
7053 
  def __init__(self, success=None, ex=None,):
7054 
    self.success = success
7055 
    self.ex = ex
7056 
 
7057 
  def read(self, iprot):
7058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7060 
      return
7061 
    iprot.readStructBegin()
7062 
    while True:
7063 
      (fname, ftype, fid) = iprot.readFieldBegin()
7064 
      if ftype == TType.STOP:
7065 
        break
7066 
      if fid == 0:
3064 chandransh 7067 
        if ftype == TType.I64:
7068 
          self.success = iprot.readI64();
921 rajveer 7069 
        else:
7070 
          iprot.skip(ftype)
7071 
      elif fid == 1:
7072 
        if ftype == TType.STRUCT:
7073 
          self.ex = TransactionServiceException()
7074 
          self.ex.read(iprot)
7075 
        else:
7076 
          iprot.skip(ftype)
7077 
      else:
7078 
        iprot.skip(ftype)
7079 
      iprot.readFieldEnd()
7080 
    iprot.readStructEnd()
7081 
 
7082 
  def write(self, oprot):
7083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7085 
      return
3064 chandransh 7086 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7087 
    if self.success is not None:
3064 chandransh 7088 
      oprot.writeFieldBegin('success', TType.I64, 0)
7089 
      oprot.writeI64(self.success)
921 rajveer 7090 
      oprot.writeFieldEnd()
3431 rajveer 7091 
    if self.ex is not None:
921 rajveer 7092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7093 
      self.ex.write(oprot)
7094 
      oprot.writeFieldEnd()
7095 
    oprot.writeFieldStop()
7096 
    oprot.writeStructEnd()
7097 
 
3431 rajveer 7098 
  def validate(self):
7099 
    return
7100 
 
7101 
 
921 rajveer 7102 
  def __repr__(self):
7103 
    L = ['%s=%r' % (key, value)
7104 
      for key, value in self.__dict__.iteritems()]
7105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7106 
 
7107 
  def __eq__(self, other):
7108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7109 
 
7110 
  def __ne__(self, other):
7111 
    return not (self == other)
7112 
 
3064 chandransh 7113 
class getOrder_args:
921 rajveer 7114 
  """
7115 
  Attributes:
3064 chandransh 7116 
   - id
921 rajveer 7117 
  """
7118 
 
7119 
  thrift_spec = (
7120 
    None, # 0
3064 chandransh 7121 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7122 
  )
7123 
 
3064 chandransh 7124 
  def __init__(self, id=None,):
7125 
    self.id = id
921 rajveer 7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 1:
7137 
        if ftype == TType.I64:
3064 chandransh 7138 
          self.id = iprot.readI64();
921 rajveer 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_args')
3431 rajveer 7151 
    if self.id is not None:
3064 chandransh 7152 
      oprot.writeFieldBegin('id', TType.I64, 1)
7153 
      oprot.writeI64(self.id)
921 rajveer 7154 
      oprot.writeFieldEnd()
7155 
    oprot.writeFieldStop()
7156 
    oprot.writeStructEnd()
7157 
 
3431 rajveer 7158 
  def validate(self):
7159 
    return
7160 
 
7161 
 
921 rajveer 7162 
  def __repr__(self):
7163 
    L = ['%s=%r' % (key, value)
7164 
      for key, value in self.__dict__.iteritems()]
7165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7166 
 
7167 
  def __eq__(self, other):
7168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7169 
 
7170 
  def __ne__(self, other):
7171 
    return not (self == other)
7172 
 
3064 chandransh 7173 
class getOrder_result:
921 rajveer 7174 
  """
7175 
  Attributes:
7176 
   - success
7177 
   - ex
7178 
  """
7179 
 
7180 
  thrift_spec = (
3064 chandransh 7181 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7183 
  )
7184 
 
7185 
  def __init__(self, success=None, ex=None,):
7186 
    self.success = success
7187 
    self.ex = ex
7188 
 
7189 
  def read(self, iprot):
7190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7192 
      return
7193 
    iprot.readStructBegin()
7194 
    while True:
7195 
      (fname, ftype, fid) = iprot.readFieldBegin()
7196 
      if ftype == TType.STOP:
7197 
        break
7198 
      if fid == 0:
3064 chandransh 7199 
        if ftype == TType.STRUCT:
7200 
          self.success = Order()
7201 
          self.success.read(iprot)
921 rajveer 7202 
        else:
7203 
          iprot.skip(ftype)
7204 
      elif fid == 1:
7205 
        if ftype == TType.STRUCT:
7206 
          self.ex = TransactionServiceException()
7207 
          self.ex.read(iprot)
7208 
        else:
7209 
          iprot.skip(ftype)
7210 
      else:
7211 
        iprot.skip(ftype)
7212 
      iprot.readFieldEnd()
7213 
    iprot.readStructEnd()
7214 
 
7215 
  def write(self, oprot):
7216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7218 
      return
3064 chandransh 7219 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7220 
    if self.success is not None:
3064 chandransh 7221 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7222 
      self.success.write(oprot)
921 rajveer 7223 
      oprot.writeFieldEnd()
3431 rajveer 7224 
    if self.ex is not None:
921 rajveer 7225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7226 
      self.ex.write(oprot)
7227 
      oprot.writeFieldEnd()
7228 
    oprot.writeFieldStop()
7229 
    oprot.writeStructEnd()
7230 
 
3431 rajveer 7231 
  def validate(self):
7232 
    return
7233 
 
7234 
 
921 rajveer 7235 
  def __repr__(self):
7236 
    L = ['%s=%r' % (key, value)
7237 
      for key, value in self.__dict__.iteritems()]
7238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7239 
 
7240 
  def __eq__(self, other):
7241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7242 
 
7243 
  def __ne__(self, other):
7244 
    return not (self == other)
7245 
 
3064 chandransh 7246 
class getLineItemsForOrder_args:
94 ashish 7247 
  """
7248 
  Attributes:
3064 chandransh 7249 
   - orderId
94 ashish 7250 
  """
7251 
 
7252 
  thrift_spec = (
7253 
    None, # 0
3064 chandransh 7254 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7255 
  )
7256 
 
3064 chandransh 7257 
  def __init__(self, orderId=None,):
7258 
    self.orderId = orderId
94 ashish 7259 
 
7260 
  def read(self, iprot):
7261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7263 
      return
7264 
    iprot.readStructBegin()
7265 
    while True:
7266 
      (fname, ftype, fid) = iprot.readFieldBegin()
7267 
      if ftype == TType.STOP:
7268 
        break
7269 
      if fid == 1:
7270 
        if ftype == TType.I64:
3064 chandransh 7271 
          self.orderId = iprot.readI64();
94 ashish 7272 
        else:
7273 
          iprot.skip(ftype)
7274 
      else:
7275 
        iprot.skip(ftype)
7276 
      iprot.readFieldEnd()
7277 
    iprot.readStructEnd()
7278 
 
7279 
  def write(self, oprot):
7280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7282 
      return
3064 chandransh 7283 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7284 
    if self.orderId is not None:
3064 chandransh 7285 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7286 
      oprot.writeI64(self.orderId)
94 ashish 7287 
      oprot.writeFieldEnd()
7288 
    oprot.writeFieldStop()
7289 
    oprot.writeStructEnd()
7290 
 
3431 rajveer 7291 
  def validate(self):
7292 
    return
7293 
 
7294 
 
94 ashish 7295 
  def __repr__(self):
7296 
    L = ['%s=%r' % (key, value)
7297 
      for key, value in self.__dict__.iteritems()]
7298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7299 
 
7300 
  def __eq__(self, other):
7301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7302 
 
7303 
  def __ne__(self, other):
7304 
    return not (self == other)
7305 
 
3064 chandransh 7306 
class getLineItemsForOrder_result:
94 ashish 7307 
  """
7308 
  Attributes:
7309 
   - success
7310 
   - ex
7311 
  """
7312 
 
7313 
  thrift_spec = (
3064 chandransh 7314 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7316 
  )
7317 
 
7318 
  def __init__(self, success=None, ex=None,):
7319 
    self.success = success
7320 
    self.ex = ex
7321 
 
7322 
  def read(self, iprot):
7323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7325 
      return
7326 
    iprot.readStructBegin()
7327 
    while True:
7328 
      (fname, ftype, fid) = iprot.readFieldBegin()
7329 
      if ftype == TType.STOP:
7330 
        break
7331 
      if fid == 0:
483 rajveer 7332 
        if ftype == TType.LIST:
7333 
          self.success = []
4133 chandransh 7334 
          (_etype108, _size105) = iprot.readListBegin()
7335 
          for _i109 in xrange(_size105):
7336 
            _elem110 = LineItem()
7337 
            _elem110.read(iprot)
7338 
            self.success.append(_elem110)
483 rajveer 7339 
          iprot.readListEnd()
94 ashish 7340 
        else:
7341 
          iprot.skip(ftype)
7342 
      elif fid == 1:
7343 
        if ftype == TType.STRUCT:
7344 
          self.ex = TransactionServiceException()
7345 
          self.ex.read(iprot)
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      else:
7349 
        iprot.skip(ftype)
7350 
      iprot.readFieldEnd()
7351 
    iprot.readStructEnd()
7352 
 
7353 
  def write(self, oprot):
7354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7356 
      return
3064 chandransh 7357 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7358 
    if self.success is not None:
483 rajveer 7359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7361 
      for iter111 in self.success:
7362 
        iter111.write(oprot)
483 rajveer 7363 
      oprot.writeListEnd()
94 ashish 7364 
      oprot.writeFieldEnd()
3431 rajveer 7365 
    if self.ex is not None:
94 ashish 7366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7367 
      self.ex.write(oprot)
7368 
      oprot.writeFieldEnd()
7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
3431 rajveer 7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
94 ashish 7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
3064 chandransh 7387 
class getOrderForCustomer_args:
94 ashish 7388 
  """
7389 
  Attributes:
3064 chandransh 7390 
   - orderId
483 rajveer 7391 
   - customerId
94 ashish 7392 
  """
7393 
 
7394 
  thrift_spec = (
7395 
    None, # 0
3064 chandransh 7396 
    (1, TType.I64, 'orderId', None, None, ), # 1
7397 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7398 
  )
7399 
 
3064 chandransh 7400 
  def __init__(self, orderId=None, customerId=None,):
7401 
    self.orderId = orderId
483 rajveer 7402 
    self.customerId = customerId
94 ashish 7403 
 
7404 
  def read(self, iprot):
7405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7407 
      return
7408 
    iprot.readStructBegin()
7409 
    while True:
7410 
      (fname, ftype, fid) = iprot.readFieldBegin()
7411 
      if ftype == TType.STOP:
7412 
        break
7413 
      if fid == 1:
7414 
        if ftype == TType.I64:
3064 chandransh 7415 
          self.orderId = iprot.readI64();
94 ashish 7416 
        else:
7417 
          iprot.skip(ftype)
7418 
      elif fid == 2:
7419 
        if ftype == TType.I64:
3064 chandransh 7420 
          self.customerId = iprot.readI64();
94 ashish 7421 
        else:
7422 
          iprot.skip(ftype)
7423 
      else:
7424 
        iprot.skip(ftype)
7425 
      iprot.readFieldEnd()
7426 
    iprot.readStructEnd()
7427 
 
7428 
  def write(self, oprot):
7429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7431 
      return
3064 chandransh 7432 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7433 
    if self.orderId is not None:
3064 chandransh 7434 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7435 
      oprot.writeI64(self.orderId)
7436 
      oprot.writeFieldEnd()
3431 rajveer 7437 
    if self.customerId is not None:
3064 chandransh 7438 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7439 
      oprot.writeI64(self.customerId)
94 ashish 7440 
      oprot.writeFieldEnd()
7441 
    oprot.writeFieldStop()
7442 
    oprot.writeStructEnd()
7443 
 
3431 rajveer 7444 
  def validate(self):
7445 
    return
7446 
 
7447 
 
94 ashish 7448 
  def __repr__(self):
7449 
    L = ['%s=%r' % (key, value)
7450 
      for key, value in self.__dict__.iteritems()]
7451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7452 
 
7453 
  def __eq__(self, other):
7454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7455 
 
7456 
  def __ne__(self, other):
7457 
    return not (self == other)
7458 
 
3064 chandransh 7459 
class getOrderForCustomer_result:
94 ashish 7460 
  """
7461 
  Attributes:
7462 
   - success
7463 
   - ex
7464 
  """
7465 
 
7466 
  thrift_spec = (
3064 chandransh 7467 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7469 
  )
7470 
 
7471 
  def __init__(self, success=None, ex=None,):
7472 
    self.success = success
7473 
    self.ex = ex
7474 
 
7475 
  def read(self, iprot):
7476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7478 
      return
7479 
    iprot.readStructBegin()
7480 
    while True:
7481 
      (fname, ftype, fid) = iprot.readFieldBegin()
7482 
      if ftype == TType.STOP:
7483 
        break
7484 
      if fid == 0:
3064 chandransh 7485 
        if ftype == TType.STRUCT:
7486 
          self.success = Order()
7487 
          self.success.read(iprot)
94 ashish 7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      elif fid == 1:
7491 
        if ftype == TType.STRUCT:
7492 
          self.ex = TransactionServiceException()
7493 
          self.ex.read(iprot)
7494 
        else:
7495 
          iprot.skip(ftype)
7496 
      else:
7497 
        iprot.skip(ftype)
7498 
      iprot.readFieldEnd()
7499 
    iprot.readStructEnd()
7500 
 
7501 
  def write(self, oprot):
7502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7504 
      return
3064 chandransh 7505 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7506 
    if self.success is not None:
3064 chandransh 7507 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7508 
      self.success.write(oprot)
94 ashish 7509 
      oprot.writeFieldEnd()
3431 rajveer 7510 
    if self.ex is not None:
94 ashish 7511 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7512 
      self.ex.write(oprot)
7513 
      oprot.writeFieldEnd()
7514 
    oprot.writeFieldStop()
7515 
    oprot.writeStructEnd()
7516 
 
3431 rajveer 7517 
  def validate(self):
7518 
    return
7519 
 
7520 
 
94 ashish 7521 
  def __repr__(self):
7522 
    L = ['%s=%r' % (key, value)
7523 
      for key, value in self.__dict__.iteritems()]
7524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7525 
 
7526 
  def __eq__(self, other):
7527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7528 
 
7529 
  def __ne__(self, other):
7530 
    return not (self == other)
7531 
 
3064 chandransh 7532 
class getAlerts_args:
94 ashish 7533 
  """
7534 
  Attributes:
3064 chandransh 7535 
   - orderId
7536 
   - valid
94 ashish 7537 
  """
7538 
 
7539 
  thrift_spec = (
7540 
    None, # 0
3064 chandransh 7541 
    (1, TType.I64, 'orderId', None, None, ), # 1
7542 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7543 
  )
7544 
 
3064 chandransh 7545 
  def __init__(self, orderId=None, valid=None,):
7546 
    self.orderId = orderId
7547 
    self.valid = valid
94 ashish 7548 
 
7549 
  def read(self, iprot):
7550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7552 
      return
7553 
    iprot.readStructBegin()
7554 
    while True:
7555 
      (fname, ftype, fid) = iprot.readFieldBegin()
7556 
      if ftype == TType.STOP:
7557 
        break
7558 
      if fid == 1:
3064 chandransh 7559 
        if ftype == TType.I64:
7560 
          self.orderId = iprot.readI64();
94 ashish 7561 
        else:
7562 
          iprot.skip(ftype)
3064 chandransh 7563 
      elif fid == 2:
7564 
        if ftype == TType.BOOL:
7565 
          self.valid = iprot.readBool();
7566 
        else:
7567 
          iprot.skip(ftype)
94 ashish 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_args')
3431 rajveer 7578 
    if self.orderId is not None:
3064 chandransh 7579 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7580 
      oprot.writeI64(self.orderId)
94 ashish 7581 
      oprot.writeFieldEnd()
3431 rajveer 7582 
    if self.valid is not None:
3064 chandransh 7583 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7584 
      oprot.writeBool(self.valid)
7585 
      oprot.writeFieldEnd()
94 ashish 7586 
    oprot.writeFieldStop()
7587 
    oprot.writeStructEnd()
7588 
 
3431 rajveer 7589 
  def validate(self):
7590 
    return
7591 
 
7592 
 
94 ashish 7593 
  def __repr__(self):
7594 
    L = ['%s=%r' % (key, value)
7595 
      for key, value in self.__dict__.iteritems()]
7596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7597 
 
7598 
  def __eq__(self, other):
7599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7600 
 
7601 
  def __ne__(self, other):
7602 
    return not (self == other)
7603 
 
3064 chandransh 7604 
class getAlerts_result:
94 ashish 7605 
  """
7606 
  Attributes:
7607 
   - success
7608 
  """
7609 
 
7610 
  thrift_spec = (
3064 chandransh 7611 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7612 
  )
7613 
 
3064 chandransh 7614 
  def __init__(self, success=None,):
94 ashish 7615 
    self.success = success
7616 
 
7617 
  def read(self, iprot):
7618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7620 
      return
7621 
    iprot.readStructBegin()
7622 
    while True:
7623 
      (fname, ftype, fid) = iprot.readFieldBegin()
7624 
      if ftype == TType.STOP:
7625 
        break
7626 
      if fid == 0:
3064 chandransh 7627 
        if ftype == TType.LIST:
7628 
          self.success = []
4133 chandransh 7629 
          (_etype115, _size112) = iprot.readListBegin()
7630 
          for _i116 in xrange(_size112):
7631 
            _elem117 = Alert()
7632 
            _elem117.read(iprot)
7633 
            self.success.append(_elem117)
3064 chandransh 7634 
          iprot.readListEnd()
94 ashish 7635 
        else:
7636 
          iprot.skip(ftype)
7637 
      else:
7638 
        iprot.skip(ftype)
7639 
      iprot.readFieldEnd()
7640 
    iprot.readStructEnd()
7641 
 
7642 
  def write(self, oprot):
7643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7645 
      return
3064 chandransh 7646 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7647 
    if self.success is not None:
3064 chandransh 7648 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7649 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7650 
      for iter118 in self.success:
7651 
        iter118.write(oprot)
3064 chandransh 7652 
      oprot.writeListEnd()
94 ashish 7653 
      oprot.writeFieldEnd()
7654 
    oprot.writeFieldStop()
7655 
    oprot.writeStructEnd()
7656 
 
3431 rajveer 7657 
  def validate(self):
7658 
    return
7659 
 
7660 
 
94 ashish 7661 
  def __repr__(self):
7662 
    L = ['%s=%r' % (key, value)
7663 
      for key, value in self.__dict__.iteritems()]
7664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7665 
 
7666 
  def __eq__(self, other):
7667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7668 
 
7669 
  def __ne__(self, other):
7670 
    return not (self == other)
7671 
 
3064 chandransh 7672 
class setAlert_args:
94 ashish 7673 
  """
7674 
  Attributes:
3064 chandransh 7675 
   - orderId
7676 
   - unset
7677 
   - type
7678 
   - comment
94 ashish 7679 
  """
7680 
 
7681 
  thrift_spec = (
7682 
    None, # 0
3064 chandransh 7683 
    (1, TType.I64, 'orderId', None, None, ), # 1
7684 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7685 
    (3, TType.I64, 'type', None, None, ), # 3
7686 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7687 
  )
7688 
 
3064 chandransh 7689 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7690 
    self.orderId = orderId
7691 
    self.unset = unset
7692 
    self.type = type
7693 
    self.comment = comment
94 ashish 7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 1:
7705 
        if ftype == TType.I64:
3064 chandransh 7706 
          self.orderId = iprot.readI64();
94 ashish 7707 
        else:
7708 
          iprot.skip(ftype)
3064 chandransh 7709 
      elif fid == 2:
7710 
        if ftype == TType.BOOL:
7711 
          self.unset = iprot.readBool();
7712 
        else:
7713 
          iprot.skip(ftype)
7714 
      elif fid == 3:
7715 
        if ftype == TType.I64:
7716 
          self.type = iprot.readI64();
7717 
        else:
7718 
          iprot.skip(ftype)
7719 
      elif fid == 4:
7720 
        if ftype == TType.STRING:
7721 
          self.comment = iprot.readString();
7722 
        else:
7723 
          iprot.skip(ftype)
94 ashish 7724 
      else:
7725 
        iprot.skip(ftype)
7726 
      iprot.readFieldEnd()
7727 
    iprot.readStructEnd()
7728 
 
7729 
  def write(self, oprot):
7730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7732 
      return
3064 chandransh 7733 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7734 
    if self.orderId is not None:
3064 chandransh 7735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7736 
      oprot.writeI64(self.orderId)
94 ashish 7737 
      oprot.writeFieldEnd()
3431 rajveer 7738 
    if self.unset is not None:
3064 chandransh 7739 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7740 
      oprot.writeBool(self.unset)
7741 
      oprot.writeFieldEnd()
3431 rajveer 7742 
    if self.type is not None:
3064 chandransh 7743 
      oprot.writeFieldBegin('type', TType.I64, 3)
7744 
      oprot.writeI64(self.type)
7745 
      oprot.writeFieldEnd()
3431 rajveer 7746 
    if self.comment is not None:
3064 chandransh 7747 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7748 
      oprot.writeString(self.comment)
7749 
      oprot.writeFieldEnd()
94 ashish 7750 
    oprot.writeFieldStop()
7751 
    oprot.writeStructEnd()
7752 
 
3431 rajveer 7753 
  def validate(self):
7754 
    return
7755 
 
7756 
 
94 ashish 7757 
  def __repr__(self):
7758 
    L = ['%s=%r' % (key, value)
7759 
      for key, value in self.__dict__.iteritems()]
7760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7761 
 
7762 
  def __eq__(self, other):
7763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7764 
 
7765 
  def __ne__(self, other):
7766 
    return not (self == other)
7767 
 
3064 chandransh 7768 
class setAlert_result:
7769 
 
7770 
  thrift_spec = (
7771 
  )
7772 
 
7773 
  def read(self, iprot):
7774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7776 
      return
7777 
    iprot.readStructBegin()
7778 
    while True:
7779 
      (fname, ftype, fid) = iprot.readFieldBegin()
7780 
      if ftype == TType.STOP:
7781 
        break
7782 
      else:
7783 
        iprot.skip(ftype)
7784 
      iprot.readFieldEnd()
7785 
    iprot.readStructEnd()
7786 
 
7787 
  def write(self, oprot):
7788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7790 
      return
7791 
    oprot.writeStructBegin('setAlert_result')
7792 
    oprot.writeFieldStop()
7793 
    oprot.writeStructEnd()
7794 
 
3431 rajveer 7795 
  def validate(self):
7796 
    return
7797 
 
7798 
 
3064 chandransh 7799 
  def __repr__(self):
7800 
    L = ['%s=%r' % (key, value)
7801 
      for key, value in self.__dict__.iteritems()]
7802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7803 
 
7804 
  def __eq__(self, other):
7805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7806 
 
7807 
  def __ne__(self, other):
7808 
    return not (self == other)
7809 
 
7810 
class getValidOrderCount_args:
7811 
 
7812 
  thrift_spec = (
7813 
  )
7814 
 
7815 
  def read(self, iprot):
7816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7818 
      return
7819 
    iprot.readStructBegin()
7820 
    while True:
7821 
      (fname, ftype, fid) = iprot.readFieldBegin()
7822 
      if ftype == TType.STOP:
7823 
        break
7824 
      else:
7825 
        iprot.skip(ftype)
7826 
      iprot.readFieldEnd()
7827 
    iprot.readStructEnd()
7828 
 
7829 
  def write(self, oprot):
7830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7832 
      return
7833 
    oprot.writeStructBegin('getValidOrderCount_args')
7834 
    oprot.writeFieldStop()
7835 
    oprot.writeStructEnd()
7836 
 
3431 rajveer 7837 
  def validate(self):
7838 
    return
7839 
 
7840 
 
3064 chandransh 7841 
  def __repr__(self):
7842 
    L = ['%s=%r' % (key, value)
7843 
      for key, value in self.__dict__.iteritems()]
7844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7845 
 
7846 
  def __eq__(self, other):
7847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7848 
 
7849 
  def __ne__(self, other):
7850 
    return not (self == other)
7851 
 
7852 
class getValidOrderCount_result:
94 ashish 7853 
  """
7854 
  Attributes:
7855 
   - success
7856 
  """
7857 
 
7858 
  thrift_spec = (
3064 chandransh 7859 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7860 
  )
7861 
 
3064 chandransh 7862 
  def __init__(self, success=None,):
94 ashish 7863 
    self.success = success
7864 
 
7865 
  def read(self, iprot):
7866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7868 
      return
7869 
    iprot.readStructBegin()
7870 
    while True:
7871 
      (fname, ftype, fid) = iprot.readFieldBegin()
7872 
      if ftype == TType.STOP:
7873 
        break
7874 
      if fid == 0:
3064 chandransh 7875 
        if ftype == TType.I64:
7876 
          self.success = iprot.readI64();
94 ashish 7877 
        else:
7878 
          iprot.skip(ftype)
7879 
      else:
7880 
        iprot.skip(ftype)
7881 
      iprot.readFieldEnd()
7882 
    iprot.readStructEnd()
7883 
 
7884 
  def write(self, oprot):
7885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7887 
      return
3064 chandransh 7888 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7889 
    if self.success is not None:
3064 chandransh 7890 
      oprot.writeFieldBegin('success', TType.I64, 0)
7891 
      oprot.writeI64(self.success)
94 ashish 7892 
      oprot.writeFieldEnd()
7893 
    oprot.writeFieldStop()
7894 
    oprot.writeStructEnd()
7895 
 
3431 rajveer 7896 
  def validate(self):
7897 
    return
7898 
 
7899 
 
94 ashish 7900 
  def __repr__(self):
7901 
    L = ['%s=%r' % (key, value)
7902 
      for key, value in self.__dict__.iteritems()]
7903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7904 
 
7905 
  def __eq__(self, other):
7906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7907 
 
7908 
  def __ne__(self, other):
7909 
    return not (self == other)
7910 
 
3064 chandransh 7911 
class getNoOfCustomersWithSuccessfulTransaction_args:
7912 
 
7913 
  thrift_spec = (
7914 
  )
7915 
 
7916 
  def read(self, iprot):
7917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7919 
      return
7920 
    iprot.readStructBegin()
7921 
    while True:
7922 
      (fname, ftype, fid) = iprot.readFieldBegin()
7923 
      if ftype == TType.STOP:
7924 
        break
7925 
      else:
7926 
        iprot.skip(ftype)
7927 
      iprot.readFieldEnd()
7928 
    iprot.readStructEnd()
7929 
 
7930 
  def write(self, oprot):
7931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7933 
      return
7934 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7935 
    oprot.writeFieldStop()
7936 
    oprot.writeStructEnd()
7937 
 
3431 rajveer 7938 
  def validate(self):
7939 
    return
7940 
 
7941 
 
3064 chandransh 7942 
  def __repr__(self):
7943 
    L = ['%s=%r' % (key, value)
7944 
      for key, value in self.__dict__.iteritems()]
7945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7946 
 
7947 
  def __eq__(self, other):
7948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7949 
 
7950 
  def __ne__(self, other):
7951 
    return not (self == other)
7952 
 
7953 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7954 
  """
7955 
  Attributes:
3064 chandransh 7956 
   - success
94 ashish 7957 
  """
7958 
 
7959 
  thrift_spec = (
3064 chandransh 7960 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7961 
  )
7962 
 
3064 chandransh 7963 
  def __init__(self, success=None,):
7964 
    self.success = success
94 ashish 7965 
 
7966 
  def read(self, iprot):
7967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7969 
      return
7970 
    iprot.readStructBegin()
7971 
    while True:
7972 
      (fname, ftype, fid) = iprot.readFieldBegin()
7973 
      if ftype == TType.STOP:
7974 
        break
3064 chandransh 7975 
      if fid == 0:
94 ashish 7976 
        if ftype == TType.I64:
3064 chandransh 7977 
          self.success = iprot.readI64();
94 ashish 7978 
        else:
7979 
          iprot.skip(ftype)
7980 
      else:
7981 
        iprot.skip(ftype)
7982 
      iprot.readFieldEnd()
7983 
    iprot.readStructEnd()
7984 
 
7985 
  def write(self, oprot):
7986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7988 
      return
3064 chandransh 7989 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7990 
    if self.success is not None:
3064 chandransh 7991 
      oprot.writeFieldBegin('success', TType.I64, 0)
7992 
      oprot.writeI64(self.success)
94 ashish 7993 
      oprot.writeFieldEnd()
7994 
    oprot.writeFieldStop()
7995 
    oprot.writeStructEnd()
7996 
 
3431 rajveer 7997 
  def validate(self):
7998 
    return
7999 
 
8000 
 
94 ashish 8001 
  def __repr__(self):
8002 
    L = ['%s=%r' % (key, value)
8003 
      for key, value in self.__dict__.iteritems()]
8004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8005 
 
8006 
  def __eq__(self, other):
8007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8008 
 
8009 
  def __ne__(self, other):
8010 
    return not (self == other)
8011 
 
3064 chandransh 8012 
class getValidOrdersAmountRange_args:
8013 
 
8014 
  thrift_spec = (
8015 
  )
8016 
 
8017 
  def read(self, iprot):
8018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8020 
      return
8021 
    iprot.readStructBegin()
8022 
    while True:
8023 
      (fname, ftype, fid) = iprot.readFieldBegin()
8024 
      if ftype == TType.STOP:
8025 
        break
8026 
      else:
8027 
        iprot.skip(ftype)
8028 
      iprot.readFieldEnd()
8029 
    iprot.readStructEnd()
8030 
 
8031 
  def write(self, oprot):
8032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8034 
      return
8035 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8036 
    oprot.writeFieldStop()
8037 
    oprot.writeStructEnd()
8038 
 
3431 rajveer 8039 
  def validate(self):
8040 
    return
8041 
 
8042 
 
3064 chandransh 8043 
  def __repr__(self):
8044 
    L = ['%s=%r' % (key, value)
8045 
      for key, value in self.__dict__.iteritems()]
8046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8047 
 
8048 
  def __eq__(self, other):
8049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8050 
 
8051 
  def __ne__(self, other):
8052 
    return not (self == other)
8053 
 
8054 
class getValidOrdersAmountRange_result:
94 ashish 8055 
  """
8056 
  Attributes:
8057 
   - success
8058 
  """
8059 
 
8060 
  thrift_spec = (
3064 chandransh 8061 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8062 
  )
8063 
 
3064 chandransh 8064 
  def __init__(self, success=None,):
94 ashish 8065 
    self.success = success
8066 
 
8067 
  def read(self, iprot):
8068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8070 
      return
8071 
    iprot.readStructBegin()
8072 
    while True:
8073 
      (fname, ftype, fid) = iprot.readFieldBegin()
8074 
      if ftype == TType.STOP:
8075 
        break
8076 
      if fid == 0:
483 rajveer 8077 
        if ftype == TType.LIST:
8078 
          self.success = []
4133 chandransh 8079 
          (_etype122, _size119) = iprot.readListBegin()
8080 
          for _i123 in xrange(_size119):
8081 
            _elem124 = iprot.readDouble();
8082 
            self.success.append(_elem124)
483 rajveer 8083 
          iprot.readListEnd()
94 ashish 8084 
        else:
8085 
          iprot.skip(ftype)
8086 
      else:
8087 
        iprot.skip(ftype)
8088 
      iprot.readFieldEnd()
8089 
    iprot.readStructEnd()
8090 
 
8091 
  def write(self, oprot):
8092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8094 
      return
3064 chandransh 8095 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8096 
    if self.success is not None:
483 rajveer 8097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8098 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8099 
      for iter125 in self.success:
8100 
        oprot.writeDouble(iter125)
483 rajveer 8101 
      oprot.writeListEnd()
94 ashish 8102 
      oprot.writeFieldEnd()
8103 
    oprot.writeFieldStop()
8104 
    oprot.writeStructEnd()
8105 
 
3431 rajveer 8106 
  def validate(self):
8107 
    return
8108 
 
8109 
 
94 ashish 8110 
  def __repr__(self):
8111 
    L = ['%s=%r' % (key, value)
8112 
      for key, value in self.__dict__.iteritems()]
8113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8114 
 
8115 
  def __eq__(self, other):
8116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8117 
 
8118 
  def __ne__(self, other):
8119 
    return not (self == other)
8120 
 
3064 chandransh 8121 
class getValidOrders_args:
1528 ankur.sing 8122 
  """
8123 
  Attributes:
3064 chandransh 8124 
   - limit
1528 ankur.sing 8125 
  """
8126 
 
8127 
  thrift_spec = (
8128 
    None, # 0
3064 chandransh 8129 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8130 
  )
8131 
 
3064 chandransh 8132 
  def __init__(self, limit=None,):
8133 
    self.limit = limit
1528 ankur.sing 8134 
 
8135 
  def read(self, iprot):
8136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8138 
      return
8139 
    iprot.readStructBegin()
8140 
    while True:
8141 
      (fname, ftype, fid) = iprot.readFieldBegin()
8142 
      if ftype == TType.STOP:
8143 
        break
8144 
      if fid == 1:
8145 
        if ftype == TType.I64:
3064 chandransh 8146 
          self.limit = iprot.readI64();
1528 ankur.sing 8147 
        else:
8148 
          iprot.skip(ftype)
8149 
      else:
8150 
        iprot.skip(ftype)
8151 
      iprot.readFieldEnd()
8152 
    iprot.readStructEnd()
8153 
 
8154 
  def write(self, oprot):
8155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8157 
      return
3064 chandransh 8158 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8159 
    if self.limit is not None:
3064 chandransh 8160 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8161 
      oprot.writeI64(self.limit)
1528 ankur.sing 8162 
      oprot.writeFieldEnd()
8163 
    oprot.writeFieldStop()
8164 
    oprot.writeStructEnd()
8165 
 
3431 rajveer 8166 
  def validate(self):
8167 
    return
8168 
 
8169 
 
1528 ankur.sing 8170 
  def __repr__(self):
8171 
    L = ['%s=%r' % (key, value)
8172 
      for key, value in self.__dict__.iteritems()]
8173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8174 
 
8175 
  def __eq__(self, other):
8176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8177 
 
8178 
  def __ne__(self, other):
8179 
    return not (self == other)
8180 
 
3064 chandransh 8181 
class getValidOrders_result:
1528 ankur.sing 8182 
  """
8183 
  Attributes:
8184 
   - success
8185 
  """
8186 
 
8187 
  thrift_spec = (
3064 chandransh 8188 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8189 
  )
8190 
 
3064 chandransh 8191 
  def __init__(self, success=None,):
1528 ankur.sing 8192 
    self.success = success
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 == 0:
3064 chandransh 8204 
        if ftype == TType.LIST:
8205 
          self.success = []
4133 chandransh 8206 
          (_etype129, _size126) = iprot.readListBegin()
8207 
          for _i130 in xrange(_size126):
8208 
            _elem131 = Order()
8209 
            _elem131.read(iprot)
8210 
            self.success.append(_elem131)
3064 chandransh 8211 
          iprot.readListEnd()
1528 ankur.sing 8212 
        else:
8213 
          iprot.skip(ftype)
8214 
      else:
8215 
        iprot.skip(ftype)
8216 
      iprot.readFieldEnd()
8217 
    iprot.readStructEnd()
8218 
 
8219 
  def write(self, oprot):
8220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8222 
      return
3064 chandransh 8223 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8224 
    if self.success is not None:
3064 chandransh 8225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8227 
      for iter132 in self.success:
8228 
        iter132.write(oprot)
3064 chandransh 8229 
      oprot.writeListEnd()
1528 ankur.sing 8230 
      oprot.writeFieldEnd()
8231 
    oprot.writeFieldStop()
8232 
    oprot.writeStructEnd()
8233 
 
3431 rajveer 8234 
  def validate(self):
8235 
    return
8236 
 
8237 
 
1528 ankur.sing 8238 
  def __repr__(self):
8239 
    L = ['%s=%r' % (key, value)
8240 
      for key, value in self.__dict__.iteritems()]
8241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8242 
 
8243 
  def __eq__(self, other):
8244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8245 
 
8246 
  def __ne__(self, other):
8247 
    return not (self == other)
8248 
 
1220 chandransh 8249 
class batchOrders_args:
8250 
  """
8251 
  Attributes:
8252 
   - warehouseId
8253 
  """
8254 
 
8255 
  thrift_spec = (
8256 
    None, # 0
8257 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8258 
  )
8259 
 
8260 
  def __init__(self, warehouseId=None,):
8261 
    self.warehouseId = warehouseId
8262 
 
8263 
  def read(self, iprot):
8264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8266 
      return
8267 
    iprot.readStructBegin()
8268 
    while True:
8269 
      (fname, ftype, fid) = iprot.readFieldBegin()
8270 
      if ftype == TType.STOP:
8271 
        break
8272 
      if fid == 1:
8273 
        if ftype == TType.I64:
8274 
          self.warehouseId = iprot.readI64();
8275 
        else:
8276 
          iprot.skip(ftype)
8277 
      else:
8278 
        iprot.skip(ftype)
8279 
      iprot.readFieldEnd()
8280 
    iprot.readStructEnd()
8281 
 
8282 
  def write(self, oprot):
8283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8285 
      return
8286 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8287 
    if self.warehouseId is not None:
1220 chandransh 8288 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8289 
      oprot.writeI64(self.warehouseId)
8290 
      oprot.writeFieldEnd()
8291 
    oprot.writeFieldStop()
8292 
    oprot.writeStructEnd()
8293 
 
3431 rajveer 8294 
  def validate(self):
8295 
    return
8296 
 
8297 
 
1220 chandransh 8298 
  def __repr__(self):
8299 
    L = ['%s=%r' % (key, value)
8300 
      for key, value in self.__dict__.iteritems()]
8301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8302 
 
8303 
  def __eq__(self, other):
8304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8305 
 
8306 
  def __ne__(self, other):
8307 
    return not (self == other)
8308 
 
8309 
class batchOrders_result:
8310 
  """
8311 
  Attributes:
8312 
   - success
8313 
   - ex
8314 
  """
8315 
 
8316 
  thrift_spec = (
8317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8319 
  )
8320 
 
8321 
  def __init__(self, success=None, ex=None,):
8322 
    self.success = success
8323 
    self.ex = ex
8324 
 
8325 
  def read(self, iprot):
8326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8328 
      return
8329 
    iprot.readStructBegin()
8330 
    while True:
8331 
      (fname, ftype, fid) = iprot.readFieldBegin()
8332 
      if ftype == TType.STOP:
8333 
        break
8334 
      if fid == 0:
8335 
        if ftype == TType.LIST:
8336 
          self.success = []
4133 chandransh 8337 
          (_etype136, _size133) = iprot.readListBegin()
8338 
          for _i137 in xrange(_size133):
8339 
            _elem138 = Order()
8340 
            _elem138.read(iprot)
8341 
            self.success.append(_elem138)
1220 chandransh 8342 
          iprot.readListEnd()
8343 
        else:
8344 
          iprot.skip(ftype)
8345 
      elif fid == 1:
8346 
        if ftype == TType.STRUCT:
8347 
          self.ex = TransactionServiceException()
8348 
          self.ex.read(iprot)
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
8360 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8361 
    if self.success is not None:
1220 chandransh 8362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8364 
      for iter139 in self.success:
8365 
        iter139.write(oprot)
1220 chandransh 8366 
      oprot.writeListEnd()
8367 
      oprot.writeFieldEnd()
3431 rajveer 8368 
    if self.ex is not None:
1220 chandransh 8369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8370 
      self.ex.write(oprot)
8371 
      oprot.writeFieldEnd()
8372 
    oprot.writeFieldStop()
8373 
    oprot.writeStructEnd()
8374 
 
3431 rajveer 8375 
  def validate(self):
8376 
    return
8377 
 
8378 
 
1220 chandransh 8379 
  def __repr__(self):
8380 
    L = ['%s=%r' % (key, value)
8381 
      for key, value in self.__dict__.iteritems()]
8382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8383 
 
8384 
  def __eq__(self, other):
8385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8386 
 
8387 
  def __ne__(self, other):
8388 
    return not (self == other)
8389 
 
1208 chandransh 8390 
class markOrderAsOutOfStock_args:
8391 
  """
8392 
  Attributes:
8393 
   - orderId
8394 
  """
8395 
 
8396 
  thrift_spec = (
8397 
    None, # 0
8398 
    (1, TType.I64, 'orderId', None, None, ), # 1
8399 
  )
8400 
 
8401 
  def __init__(self, orderId=None,):
8402 
    self.orderId = orderId
8403 
 
8404 
  def read(self, iprot):
8405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8407 
      return
8408 
    iprot.readStructBegin()
8409 
    while True:
8410 
      (fname, ftype, fid) = iprot.readFieldBegin()
8411 
      if ftype == TType.STOP:
8412 
        break
8413 
      if fid == 1:
8414 
        if ftype == TType.I64:
8415 
          self.orderId = iprot.readI64();
8416 
        else:
8417 
          iprot.skip(ftype)
8418 
      else:
8419 
        iprot.skip(ftype)
8420 
      iprot.readFieldEnd()
8421 
    iprot.readStructEnd()
8422 
 
8423 
  def write(self, oprot):
8424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8426 
      return
8427 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8428 
    if self.orderId is not None:
1208 chandransh 8429 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8430 
      oprot.writeI64(self.orderId)
8431 
      oprot.writeFieldEnd()
8432 
    oprot.writeFieldStop()
8433 
    oprot.writeStructEnd()
8434 
 
3431 rajveer 8435 
  def validate(self):
8436 
    return
8437 
 
8438 
 
1208 chandransh 8439 
  def __repr__(self):
8440 
    L = ['%s=%r' % (key, value)
8441 
      for key, value in self.__dict__.iteritems()]
8442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8443 
 
8444 
  def __eq__(self, other):
8445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8446 
 
8447 
  def __ne__(self, other):
8448 
    return not (self == other)
8449 
 
8450 
class markOrderAsOutOfStock_result:
8451 
  """
8452 
  Attributes:
8453 
   - success
8454 
   - ex
8455 
  """
8456 
 
8457 
  thrift_spec = (
8458 
    (0, TType.BOOL, 'success', None, None, ), # 0
8459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8460 
  )
8461 
 
8462 
  def __init__(self, success=None, ex=None,):
8463 
    self.success = success
8464 
    self.ex = ex
8465 
 
8466 
  def read(self, iprot):
8467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8469 
      return
8470 
    iprot.readStructBegin()
8471 
    while True:
8472 
      (fname, ftype, fid) = iprot.readFieldBegin()
8473 
      if ftype == TType.STOP:
8474 
        break
8475 
      if fid == 0:
8476 
        if ftype == TType.BOOL:
8477 
          self.success = iprot.readBool();
8478 
        else:
8479 
          iprot.skip(ftype)
8480 
      elif fid == 1:
8481 
        if ftype == TType.STRUCT:
8482 
          self.ex = TransactionServiceException()
8483 
          self.ex.read(iprot)
8484 
        else:
8485 
          iprot.skip(ftype)
8486 
      else:
8487 
        iprot.skip(ftype)
8488 
      iprot.readFieldEnd()
8489 
    iprot.readStructEnd()
8490 
 
8491 
  def write(self, oprot):
8492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8494 
      return
8495 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8496 
    if self.success is not None:
1208 chandransh 8497 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8498 
      oprot.writeBool(self.success)
8499 
      oprot.writeFieldEnd()
3431 rajveer 8500 
    if self.ex is not None:
1208 chandransh 8501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8502 
      self.ex.write(oprot)
8503 
      oprot.writeFieldEnd()
8504 
    oprot.writeFieldStop()
8505 
    oprot.writeStructEnd()
8506 
 
3431 rajveer 8507 
  def validate(self):
8508 
    return
8509 
 
8510 
 
1208 chandransh 8511 
  def __repr__(self):
8512 
    L = ['%s=%r' % (key, value)
8513 
      for key, value in self.__dict__.iteritems()]
8514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8515 
 
8516 
  def __eq__(self, other):
8517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8518 
 
8519 
  def __ne__(self, other):
8520 
    return not (self == other)
8521 
 
3064 chandransh 8522 
class verifyOrder_args:
759 chandransh 8523 
  """
8524 
  Attributes:
3064 chandransh 8525 
   - orderId
759 chandransh 8526 
  """
8527 
 
8528 
  thrift_spec = (
8529 
    None, # 0
3064 chandransh 8530 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8531 
  )
8532 
 
3064 chandransh 8533 
  def __init__(self, orderId=None,):
8534 
    self.orderId = orderId
759 chandransh 8535 
 
8536 
  def read(self, iprot):
8537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8539 
      return
8540 
    iprot.readStructBegin()
8541 
    while True:
8542 
      (fname, ftype, fid) = iprot.readFieldBegin()
8543 
      if ftype == TType.STOP:
8544 
        break
8545 
      if fid == 1:
8546 
        if ftype == TType.I64:
3064 chandransh 8547 
          self.orderId = iprot.readI64();
759 chandransh 8548 
        else:
8549 
          iprot.skip(ftype)
8550 
      else:
8551 
        iprot.skip(ftype)
8552 
      iprot.readFieldEnd()
8553 
    iprot.readStructEnd()
8554 
 
8555 
  def write(self, oprot):
8556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8558 
      return
3064 chandransh 8559 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8560 
    if self.orderId is not None:
3064 chandransh 8561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8562 
      oprot.writeI64(self.orderId)
759 chandransh 8563 
      oprot.writeFieldEnd()
8564 
    oprot.writeFieldStop()
8565 
    oprot.writeStructEnd()
8566 
 
3431 rajveer 8567 
  def validate(self):
8568 
    return
8569 
 
8570 
 
759 chandransh 8571 
  def __repr__(self):
8572 
    L = ['%s=%r' % (key, value)
8573 
      for key, value in self.__dict__.iteritems()]
8574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8575 
 
8576 
  def __eq__(self, other):
8577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8578 
 
8579 
  def __ne__(self, other):
8580 
    return not (self == other)
8581 
 
3064 chandransh 8582 
class verifyOrder_result:
759 chandransh 8583 
  """
8584 
  Attributes:
8585 
   - success
8586 
   - ex
8587 
  """
8588 
 
8589 
  thrift_spec = (
8590 
    (0, TType.BOOL, 'success', None, None, ), # 0
8591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8592 
  )
8593 
 
8594 
  def __init__(self, success=None, ex=None,):
8595 
    self.success = success
8596 
    self.ex = ex
8597 
 
8598 
  def read(self, iprot):
8599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8601 
      return
8602 
    iprot.readStructBegin()
8603 
    while True:
8604 
      (fname, ftype, fid) = iprot.readFieldBegin()
8605 
      if ftype == TType.STOP:
8606 
        break
8607 
      if fid == 0:
8608 
        if ftype == TType.BOOL:
8609 
          self.success = iprot.readBool();
8610 
        else:
8611 
          iprot.skip(ftype)
8612 
      elif fid == 1:
8613 
        if ftype == TType.STRUCT:
8614 
          self.ex = TransactionServiceException()
8615 
          self.ex.read(iprot)
8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
3064 chandransh 8627 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8628 
    if self.success is not None:
759 chandransh 8629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8630 
      oprot.writeBool(self.success)
8631 
      oprot.writeFieldEnd()
3431 rajveer 8632 
    if self.ex is not None:
759 chandransh 8633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8634 
      self.ex.write(oprot)
8635 
      oprot.writeFieldEnd()
8636 
    oprot.writeFieldStop()
8637 
    oprot.writeStructEnd()
8638 
 
3431 rajveer 8639 
  def validate(self):
8640 
    return
8641 
 
8642 
 
759 chandransh 8643 
  def __repr__(self):
8644 
    L = ['%s=%r' % (key, value)
8645 
      for key, value in self.__dict__.iteritems()]
8646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8647 
 
8648 
  def __eq__(self, other):
8649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8650 
 
8651 
  def __ne__(self, other):
8652 
    return not (self == other)
8653 
 
3064 chandransh 8654 
class acceptOrder_args:
1113 chandransh 8655 
  """
8656 
  Attributes:
3064 chandransh 8657 
   - orderId
1113 chandransh 8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    None, # 0
3064 chandransh 8662 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8663 
  )
8664 
 
3064 chandransh 8665 
  def __init__(self, orderId=None,):
8666 
    self.orderId = orderId
1113 chandransh 8667 
 
8668 
  def read(self, iprot):
8669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8671 
      return
8672 
    iprot.readStructBegin()
8673 
    while True:
8674 
      (fname, ftype, fid) = iprot.readFieldBegin()
8675 
      if ftype == TType.STOP:
8676 
        break
8677 
      if fid == 1:
8678 
        if ftype == TType.I64:
3064 chandransh 8679 
          self.orderId = iprot.readI64();
1113 chandransh 8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      else:
8683 
        iprot.skip(ftype)
8684 
      iprot.readFieldEnd()
8685 
    iprot.readStructEnd()
8686 
 
8687 
  def write(self, oprot):
8688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8690 
      return
3064 chandransh 8691 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8692 
    if self.orderId is not None:
3064 chandransh 8693 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8694 
      oprot.writeI64(self.orderId)
1113 chandransh 8695 
      oprot.writeFieldEnd()
8696 
    oprot.writeFieldStop()
8697 
    oprot.writeStructEnd()
8698 
 
3431 rajveer 8699 
  def validate(self):
8700 
    return
8701 
 
8702 
 
1113 chandransh 8703 
  def __repr__(self):
8704 
    L = ['%s=%r' % (key, value)
8705 
      for key, value in self.__dict__.iteritems()]
8706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8707 
 
8708 
  def __eq__(self, other):
8709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8710 
 
8711 
  def __ne__(self, other):
8712 
    return not (self == other)
8713 
 
3064 chandransh 8714 
class acceptOrder_result:
1113 chandransh 8715 
  """
8716 
  Attributes:
8717 
   - success
8718 
   - ex
8719 
  """
8720 
 
8721 
  thrift_spec = (
3064 chandransh 8722 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8724 
  )
8725 
 
8726 
  def __init__(self, success=None, ex=None,):
8727 
    self.success = success
8728 
    self.ex = ex
8729 
 
8730 
  def read(self, iprot):
8731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8733 
      return
8734 
    iprot.readStructBegin()
8735 
    while True:
8736 
      (fname, ftype, fid) = iprot.readFieldBegin()
8737 
      if ftype == TType.STOP:
8738 
        break
8739 
      if fid == 0:
3064 chandransh 8740 
        if ftype == TType.BOOL:
8741 
          self.success = iprot.readBool();
1113 chandransh 8742 
        else:
8743 
          iprot.skip(ftype)
8744 
      elif fid == 1:
8745 
        if ftype == TType.STRUCT:
8746 
          self.ex = TransactionServiceException()
8747 
          self.ex.read(iprot)
8748 
        else:
8749 
          iprot.skip(ftype)
8750 
      else:
8751 
        iprot.skip(ftype)
8752 
      iprot.readFieldEnd()
8753 
    iprot.readStructEnd()
8754 
 
8755 
  def write(self, oprot):
8756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8758 
      return
3064 chandransh 8759 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8760 
    if self.success is not None:
3064 chandransh 8761 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8762 
      oprot.writeBool(self.success)
1113 chandransh 8763 
      oprot.writeFieldEnd()
3431 rajveer 8764 
    if self.ex is not None:
1113 chandransh 8765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8766 
      self.ex.write(oprot)
8767 
      oprot.writeFieldEnd()
8768 
    oprot.writeFieldStop()
8769 
    oprot.writeStructEnd()
8770 
 
3431 rajveer 8771 
  def validate(self):
8772 
    return
8773 
 
8774 
 
1113 chandransh 8775 
  def __repr__(self):
8776 
    L = ['%s=%r' % (key, value)
8777 
      for key, value in self.__dict__.iteritems()]
8778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8779 
 
8780 
  def __eq__(self, other):
8781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8782 
 
8783 
  def __ne__(self, other):
8784 
    return not (self == other)
8785 
 
3064 chandransh 8786 
class addBillingDetails_args:
1135 chandransh 8787 
  """
8788 
  Attributes:
3064 chandransh 8789 
   - orderId
8790 
   - invoice_number
4283 anupam.sin 8791 
   - imeiNumber
8792 
   - itemNumber
3064 chandransh 8793 
   - billed_by
4264 rajveer 8794 
   - jacketNumber
4283 anupam.sin 8795 
   - billingType
8796 
   - vendorId
1135 chandransh 8797 
  """
8798 
 
8799 
  thrift_spec = (
8800 
    None, # 0
3064 chandransh 8801 
    (1, TType.I64, 'orderId', None, None, ), # 1
8802 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8803 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8804 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8805 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8806 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8807 
    (7, TType.I64, 'billingType', None, None, ), # 7
8808 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8809 
  )
8810 
 
4283 anupam.sin 8811 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8812 
    self.orderId = orderId
8813 
    self.invoice_number = invoice_number
4283 anupam.sin 8814 
    self.imeiNumber = imeiNumber
8815 
    self.itemNumber = itemNumber
3064 chandransh 8816 
    self.billed_by = billed_by
4264 rajveer 8817 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8818 
    self.billingType = billingType
8819 
    self.vendorId = vendorId
1135 chandransh 8820 
 
8821 
  def read(self, iprot):
8822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8824 
      return
8825 
    iprot.readStructBegin()
8826 
    while True:
8827 
      (fname, ftype, fid) = iprot.readFieldBegin()
8828 
      if ftype == TType.STOP:
8829 
        break
8830 
      if fid == 1:
8831 
        if ftype == TType.I64:
3064 chandransh 8832 
          self.orderId = iprot.readI64();
1135 chandransh 8833 
        else:
8834 
          iprot.skip(ftype)
8835 
      elif fid == 2:
3064 chandransh 8836 
        if ftype == TType.STRING:
8837 
          self.invoice_number = iprot.readString();
1135 chandransh 8838 
        else:
8839 
          iprot.skip(ftype)
3064 chandransh 8840 
      elif fid == 3:
4264 rajveer 8841 
        if ftype == TType.I64:
3064 chandransh 8842 
          self.imeiNumber = iprot.readI64();
8843 
        else:
8844 
          iprot.skip(ftype)
8845 
      elif fid == 4:
8846 
        if ftype == TType.STRING:
8847 
          self.itemNumber = iprot.readString();
8848 
        else:
8849 
          iprot.skip(ftype)
8850 
      elif fid == 5:
8851 
        if ftype == TType.STRING:
4283 anupam.sin 8852 
          self.billed_by = iprot.readString();
3064 chandransh 8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      elif fid == 6:
8856 
        if ftype == TType.I64:
4283 anupam.sin 8857 
          self.jacketNumber = iprot.readI64();
8858 
        else:
8859 
          iprot.skip(ftype)
8860 
      elif fid == 7:
8861 
        if ftype == TType.I64:
3064 chandransh 8862 
          self.billingType = iprot.readI64();
8863 
        else:
8864 
          iprot.skip(ftype)
4283 anupam.sin 8865 
      elif fid == 8:
8866 
        if ftype == TType.I64:
8867 
          self.vendorId = iprot.readI64();
8868 
        else:
8869 
          iprot.skip(ftype)
1246 chandransh 8870 
      else:
8871 
        iprot.skip(ftype)
8872 
      iprot.readFieldEnd()
8873 
    iprot.readStructEnd()
8874 
 
8875 
  def write(self, oprot):
8876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8878 
      return
4283 anupam.sin 8879 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8880 
    if self.orderId is not None:
3064 chandransh 8881 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8882 
      oprot.writeI64(self.orderId)
1246 chandransh 8883 
      oprot.writeFieldEnd()
4283 anupam.sin 8884 
    if self.invoice_number is not None:
8885 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8886 
      oprot.writeString(self.invoice_number)
1246 chandransh 8887 
      oprot.writeFieldEnd()
3431 rajveer 8888 
    if self.imeiNumber is not None:
3064 chandransh 8889 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8890 
      oprot.writeI64(self.imeiNumber)
8891 
      oprot.writeFieldEnd()
3431 rajveer 8892 
    if self.itemNumber is not None:
3064 chandransh 8893 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8894 
      oprot.writeString(self.itemNumber)
8895 
      oprot.writeFieldEnd()
4283 anupam.sin 8896 
    if self.billed_by is not None:
8897 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8898 
      oprot.writeString(self.billed_by)
3064 chandransh 8899 
      oprot.writeFieldEnd()
4283 anupam.sin 8900 
    if self.jacketNumber is not None:
8901 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8902 
      oprot.writeI64(self.jacketNumber)
8903 
      oprot.writeFieldEnd()
3431 rajveer 8904 
    if self.billingType is not None:
4283 anupam.sin 8905 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8906 
      oprot.writeI64(self.billingType)
8907 
      oprot.writeFieldEnd()
4283 anupam.sin 8908 
    if self.vendorId is not None:
8909 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8910 
      oprot.writeI64(self.vendorId)
8911 
      oprot.writeFieldEnd()
1246 chandransh 8912 
    oprot.writeFieldStop()
8913 
    oprot.writeStructEnd()
8914 
 
3431 rajveer 8915 
  def validate(self):
8916 
    return
8917 
 
8918 
 
1246 chandransh 8919 
  def __repr__(self):
8920 
    L = ['%s=%r' % (key, value)
8921 
      for key, value in self.__dict__.iteritems()]
8922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8923 
 
8924 
  def __eq__(self, other):
8925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8926 
 
8927 
  def __ne__(self, other):
8928 
    return not (self == other)
8929 
 
4283 anupam.sin 8930 
class addBillingDetails_result:
1246 chandransh 8931 
  """
8932 
  Attributes:
3064 chandransh 8933 
   - success
1246 chandransh 8934 
   - ex
8935 
  """
8936 
 
8937 
  thrift_spec = (
3064 chandransh 8938 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8940 
  )
8941 
 
3064 chandransh 8942 
  def __init__(self, success=None, ex=None,):
8943 
    self.success = success
1246 chandransh 8944 
    self.ex = ex
8945 
 
8946 
  def read(self, iprot):
8947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8949 
      return
8950 
    iprot.readStructBegin()
8951 
    while True:
8952 
      (fname, ftype, fid) = iprot.readFieldBegin()
8953 
      if ftype == TType.STOP:
8954 
        break
3064 chandransh 8955 
      if fid == 0:
8956 
        if ftype == TType.BOOL:
8957 
          self.success = iprot.readBool();
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      elif fid == 1:
1246 chandransh 8961 
        if ftype == TType.STRUCT:
8962 
          self.ex = TransactionServiceException()
8963 
          self.ex.read(iprot)
8964 
        else:
8965 
          iprot.skip(ftype)
8966 
      else:
8967 
        iprot.skip(ftype)
8968 
      iprot.readFieldEnd()
8969 
    iprot.readStructEnd()
8970 
 
8971 
  def write(self, oprot):
8972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8974 
      return
4283 anupam.sin 8975 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8976 
    if self.success is not None:
3064 chandransh 8977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8978 
      oprot.writeBool(self.success)
8979 
      oprot.writeFieldEnd()
3431 rajveer 8980 
    if self.ex is not None:
1246 chandransh 8981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8982 
      self.ex.write(oprot)
8983 
      oprot.writeFieldEnd()
8984 
    oprot.writeFieldStop()
8985 
    oprot.writeStructEnd()
8986 
 
3431 rajveer 8987 
  def validate(self):
8988 
    return
8989 
 
8990 
 
1246 chandransh 8991 
  def __repr__(self):
8992 
    L = ['%s=%r' % (key, value)
8993 
      for key, value in self.__dict__.iteritems()]
8994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8995 
 
8996 
  def __eq__(self, other):
8997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8998 
 
8999 
  def __ne__(self, other):
9000 
    return not (self == other)
9001 
 
3064 chandransh 9002 
class markOrdersAsManifested_args:
1408 ankur.sing 9003 
  """
9004 
  Attributes:
3064 chandransh 9005 
   - warehouseId
1408 ankur.sing 9006 
   - providerId
3064 chandransh 9007 
   - cod
1408 ankur.sing 9008 
  """
9009 
 
9010 
  thrift_spec = (
9011 
    None, # 0
3064 chandransh 9012 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9013 
    (2, TType.I64, 'providerId', None, None, ), # 2
9014 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9015 
  )
9016 
 
3064 chandransh 9017 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9018 
    self.warehouseId = warehouseId
1408 ankur.sing 9019 
    self.providerId = providerId
3064 chandransh 9020 
    self.cod = cod
1408 ankur.sing 9021 
 
9022 
  def read(self, iprot):
9023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9025 
      return
9026 
    iprot.readStructBegin()
9027 
    while True:
9028 
      (fname, ftype, fid) = iprot.readFieldBegin()
9029 
      if ftype == TType.STOP:
9030 
        break
9031 
      if fid == 1:
9032 
        if ftype == TType.I64:
3064 chandransh 9033 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9034 
        else:
9035 
          iprot.skip(ftype)
9036 
      elif fid == 2:
9037 
        if ftype == TType.I64:
3064 chandransh 9038 
          self.providerId = iprot.readI64();
1408 ankur.sing 9039 
        else:
9040 
          iprot.skip(ftype)
3064 chandransh 9041 
      elif fid == 3:
9042 
        if ftype == TType.BOOL:
9043 
          self.cod = iprot.readBool();
9044 
        else:
9045 
          iprot.skip(ftype)
1408 ankur.sing 9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
3064 chandransh 9055 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9056 
    if self.warehouseId is not None:
3064 chandransh 9057 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9058 
      oprot.writeI64(self.warehouseId)
9059 
      oprot.writeFieldEnd()
3431 rajveer 9060 
    if self.providerId is not None:
3064 chandransh 9061 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9062 
      oprot.writeI64(self.providerId)
9063 
      oprot.writeFieldEnd()
3431 rajveer 9064 
    if self.cod is not None:
3064 chandransh 9065 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9066 
      oprot.writeBool(self.cod)
1408 ankur.sing 9067 
      oprot.writeFieldEnd()
9068 
    oprot.writeFieldStop()
9069 
    oprot.writeStructEnd()
9070 
 
3431 rajveer 9071 
  def validate(self):
9072 
    return
9073 
 
9074 
 
1408 ankur.sing 9075 
  def __repr__(self):
9076 
    L = ['%s=%r' % (key, value)
9077 
      for key, value in self.__dict__.iteritems()]
9078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9079 
 
9080 
  def __eq__(self, other):
9081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9082 
 
9083 
  def __ne__(self, other):
9084 
    return not (self == other)
9085 
 
3064 chandransh 9086 
class markOrdersAsManifested_result:
1408 ankur.sing 9087 
  """
9088 
  Attributes:
9089 
   - success
3064 chandransh 9090 
   - ex
1408 ankur.sing 9091 
  """
9092 
 
9093 
  thrift_spec = (
3064 chandransh 9094 
    (0, TType.BOOL, 'success', None, None, ), # 0
9095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9096 
  )
9097 
 
3064 chandransh 9098 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9099 
    self.success = success
3064 chandransh 9100 
    self.ex = ex
1408 ankur.sing 9101 
 
9102 
  def read(self, iprot):
9103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9105 
      return
9106 
    iprot.readStructBegin()
9107 
    while True:
9108 
      (fname, ftype, fid) = iprot.readFieldBegin()
9109 
      if ftype == TType.STOP:
9110 
        break
9111 
      if fid == 0:
3064 chandransh 9112 
        if ftype == TType.BOOL:
9113 
          self.success = iprot.readBool();
1408 ankur.sing 9114 
        else:
9115 
          iprot.skip(ftype)
3064 chandransh 9116 
      elif fid == 1:
9117 
        if ftype == TType.STRUCT:
9118 
          self.ex = TransactionServiceException()
9119 
          self.ex.read(iprot)
9120 
        else:
9121 
          iprot.skip(ftype)
1408 ankur.sing 9122 
      else:
9123 
        iprot.skip(ftype)
9124 
      iprot.readFieldEnd()
9125 
    iprot.readStructEnd()
9126 
 
9127 
  def write(self, oprot):
9128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9130 
      return
3064 chandransh 9131 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9132 
    if self.success is not None:
3064 chandransh 9133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9134 
      oprot.writeBool(self.success)
1408 ankur.sing 9135 
      oprot.writeFieldEnd()
3431 rajveer 9136 
    if self.ex is not None:
3064 chandransh 9137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9138 
      self.ex.write(oprot)
9139 
      oprot.writeFieldEnd()
1408 ankur.sing 9140 
    oprot.writeFieldStop()
9141 
    oprot.writeStructEnd()
9142 
 
3431 rajveer 9143 
  def validate(self):
9144 
    return
9145 
 
9146 
 
1408 ankur.sing 9147 
  def __repr__(self):
9148 
    L = ['%s=%r' % (key, value)
9149 
      for key, value in self.__dict__.iteritems()]
9150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9151 
 
9152 
  def __eq__(self, other):
9153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9154 
 
9155 
  def __ne__(self, other):
9156 
    return not (self == other)
9157 
 
3064 chandransh 9158 
class markOrdersAsPickedUp_args:
304 ashish 9159 
  """
9160 
  Attributes:
3064 chandransh 9161 
   - providerId
9162 
   - pickupDetails
304 ashish 9163 
  """
94 ashish 9164 
 
304 ashish 9165 
  thrift_spec = (
9166 
    None, # 0
3064 chandransh 9167 
    (1, TType.I64, 'providerId', None, None, ), # 1
9168 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9169 
  )
9170 
 
3064 chandransh 9171 
  def __init__(self, providerId=None, pickupDetails=None,):
9172 
    self.providerId = providerId
9173 
    self.pickupDetails = pickupDetails
304 ashish 9174 
 
9175 
  def read(self, iprot):
9176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9178 
      return
9179 
    iprot.readStructBegin()
9180 
    while True:
9181 
      (fname, ftype, fid) = iprot.readFieldBegin()
9182 
      if ftype == TType.STOP:
9183 
        break
9184 
      if fid == 1:
9185 
        if ftype == TType.I64:
3064 chandransh 9186 
          self.providerId = iprot.readI64();
304 ashish 9187 
        else:
9188 
          iprot.skip(ftype)
9189 
      elif fid == 2:
3064 chandransh 9190 
        if ftype == TType.MAP:
9191 
          self.pickupDetails = {}
4133 chandransh 9192 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9193 
          for _i144 in xrange(_size140):
9194 
            _key145 = iprot.readString();
9195 
            _val146 = iprot.readString();
9196 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9197 
          iprot.readMapEnd()
304 ashish 9198 
        else:
9199 
          iprot.skip(ftype)
9200 
      else:
9201 
        iprot.skip(ftype)
9202 
      iprot.readFieldEnd()
9203 
    iprot.readStructEnd()
9204 
 
9205 
  def write(self, oprot):
9206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9208 
      return
3064 chandransh 9209 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9210 
    if self.providerId is not None:
3064 chandransh 9211 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9212 
      oprot.writeI64(self.providerId)
304 ashish 9213 
      oprot.writeFieldEnd()
3431 rajveer 9214 
    if self.pickupDetails is not None:
3064 chandransh 9215 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9216 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9217 
      for kiter147,viter148 in self.pickupDetails.items():
9218 
        oprot.writeString(kiter147)
9219 
        oprot.writeString(viter148)
3064 chandransh 9220 
      oprot.writeMapEnd()
304 ashish 9221 
      oprot.writeFieldEnd()
9222 
    oprot.writeFieldStop()
9223 
    oprot.writeStructEnd()
9224 
 
3431 rajveer 9225 
  def validate(self):
9226 
    return
9227 
 
9228 
 
304 ashish 9229 
  def __repr__(self):
9230 
    L = ['%s=%r' % (key, value)
9231 
      for key, value in self.__dict__.iteritems()]
9232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9233 
 
9234 
  def __eq__(self, other):
9235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9236 
 
9237 
  def __ne__(self, other):
9238 
    return not (self == other)
9239 
 
3064 chandransh 9240 
class markOrdersAsPickedUp_result:
304 ashish 9241 
  """
9242 
  Attributes:
9243 
   - success
3064 chandransh 9244 
   - ex
304 ashish 9245 
  """
9246 
 
9247 
  thrift_spec = (
3064 chandransh 9248 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9250 
  )
9251 
 
3064 chandransh 9252 
  def __init__(self, success=None, ex=None,):
304 ashish 9253 
    self.success = success
3064 chandransh 9254 
    self.ex = ex
304 ashish 9255 
 
9256 
  def read(self, iprot):
9257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9259 
      return
9260 
    iprot.readStructBegin()
9261 
    while True:
9262 
      (fname, ftype, fid) = iprot.readFieldBegin()
9263 
      if ftype == TType.STOP:
9264 
        break
9265 
      if fid == 0:
9266 
        if ftype == TType.LIST:
9267 
          self.success = []
4133 chandransh 9268 
          (_etype152, _size149) = iprot.readListBegin()
9269 
          for _i153 in xrange(_size149):
9270 
            _elem154 = Order()
9271 
            _elem154.read(iprot)
9272 
            self.success.append(_elem154)
304 ashish 9273 
          iprot.readListEnd()
9274 
        else:
9275 
          iprot.skip(ftype)
3064 chandransh 9276 
      elif fid == 1:
9277 
        if ftype == TType.STRUCT:
9278 
          self.ex = TransactionServiceException()
9279 
          self.ex.read(iprot)
9280 
        else:
9281 
          iprot.skip(ftype)
304 ashish 9282 
      else:
9283 
        iprot.skip(ftype)
9284 
      iprot.readFieldEnd()
9285 
    iprot.readStructEnd()
9286 
 
9287 
  def write(self, oprot):
9288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9290 
      return
3064 chandransh 9291 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9292 
    if self.success is not None:
304 ashish 9293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9295 
      for iter155 in self.success:
9296 
        iter155.write(oprot)
304 ashish 9297 
      oprot.writeListEnd()
9298 
      oprot.writeFieldEnd()
3431 rajveer 9299 
    if self.ex is not None:
3064 chandransh 9300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9301 
      self.ex.write(oprot)
9302 
      oprot.writeFieldEnd()
304 ashish 9303 
    oprot.writeFieldStop()
9304 
    oprot.writeStructEnd()
9305 
 
3431 rajveer 9306 
  def validate(self):
9307 
    return
9308 
 
9309 
 
304 ashish 9310 
  def __repr__(self):
9311 
    L = ['%s=%r' % (key, value)
9312 
      for key, value in self.__dict__.iteritems()]
9313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9314 
 
9315 
  def __eq__(self, other):
9316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9317 
 
9318 
  def __ne__(self, other):
9319 
    return not (self == other)
9320 
 
3064 chandransh 9321 
class markOrdersAsDelivered_args:
304 ashish 9322 
  """
9323 
  Attributes:
3064 chandransh 9324 
   - providerId
9325 
   - deliveredOrders
304 ashish 9326 
  """
9327 
 
9328 
  thrift_spec = (
9329 
    None, # 0
3064 chandransh 9330 
    (1, TType.I64, 'providerId', None, None, ), # 1
9331 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9332 
  )
9333 
 
3064 chandransh 9334 
  def __init__(self, providerId=None, deliveredOrders=None,):
9335 
    self.providerId = providerId
9336 
    self.deliveredOrders = deliveredOrders
304 ashish 9337 
 
9338 
  def read(self, iprot):
9339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9341 
      return
9342 
    iprot.readStructBegin()
9343 
    while True:
9344 
      (fname, ftype, fid) = iprot.readFieldBegin()
9345 
      if ftype == TType.STOP:
9346 
        break
9347 
      if fid == 1:
9348 
        if ftype == TType.I64:
3064 chandransh 9349 
          self.providerId = iprot.readI64();
304 ashish 9350 
        else:
9351 
          iprot.skip(ftype)
9352 
      elif fid == 2:
3064 chandransh 9353 
        if ftype == TType.MAP:
9354 
          self.deliveredOrders = {}
4133 chandransh 9355 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9356 
          for _i160 in xrange(_size156):
9357 
            _key161 = iprot.readString();
9358 
            _val162 = iprot.readString();
9359 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9360 
          iprot.readMapEnd()
304 ashish 9361 
        else:
9362 
          iprot.skip(ftype)
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_args')
3431 rajveer 9373 
    if self.providerId is not None:
3064 chandransh 9374 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9375 
      oprot.writeI64(self.providerId)
304 ashish 9376 
      oprot.writeFieldEnd()
3431 rajveer 9377 
    if self.deliveredOrders is not None:
3064 chandransh 9378 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9379 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9380 
      for kiter163,viter164 in self.deliveredOrders.items():
9381 
        oprot.writeString(kiter163)
9382 
        oprot.writeString(viter164)
3064 chandransh 9383 
      oprot.writeMapEnd()
304 ashish 9384 
      oprot.writeFieldEnd()
9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
304 ashish 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
3064 chandransh 9403 
class markOrdersAsDelivered_result:
9404 
  """
9405 
  Attributes:
9406 
   - ex
9407 
  """
304 ashish 9408 
 
9409 
  thrift_spec = (
3064 chandransh 9410 
    None, # 0
9411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9412 
  )
9413 
 
3064 chandransh 9414 
  def __init__(self, ex=None,):
9415 
    self.ex = ex
304 ashish 9416 
 
1596 ankur.sing 9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
3064 chandransh 9426 
      if fid == 1:
9427 
        if ftype == TType.STRUCT:
9428 
          self.ex = TransactionServiceException()
9429 
          self.ex.read(iprot)
9430 
        else:
9431 
          iprot.skip(ftype)
1596 ankur.sing 9432 
      else:
9433 
        iprot.skip(ftype)
9434 
      iprot.readFieldEnd()
9435 
    iprot.readStructEnd()
9436 
 
9437 
  def write(self, oprot):
9438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9440 
      return
3064 chandransh 9441 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9442 
    if self.ex is not None:
3064 chandransh 9443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9444 
      self.ex.write(oprot)
9445 
      oprot.writeFieldEnd()
1596 ankur.sing 9446 
    oprot.writeFieldStop()
9447 
    oprot.writeStructEnd()
9448 
 
3431 rajveer 9449 
  def validate(self):
9450 
    return
9451 
 
9452 
 
1596 ankur.sing 9453 
  def __repr__(self):
9454 
    L = ['%s=%r' % (key, value)
9455 
      for key, value in self.__dict__.iteritems()]
9456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9457 
 
9458 
  def __eq__(self, other):
9459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9460 
 
9461 
  def __ne__(self, other):
9462 
    return not (self == other)
9463 
 
3064 chandransh 9464 
class markOrdersAsFailed_args:
1596 ankur.sing 9465 
  """
9466 
  Attributes:
3064 chandransh 9467 
   - providerId
9468 
   - returnedOrders
1596 ankur.sing 9469 
  """
9470 
 
9471 
  thrift_spec = (
3064 chandransh 9472 
    None, # 0
9473 
    (1, TType.I64, 'providerId', None, None, ), # 1
9474 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9475 
  )
9476 
 
3064 chandransh 9477 
  def __init__(self, providerId=None, returnedOrders=None,):
9478 
    self.providerId = providerId
9479 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9480 
 
9481 
  def read(self, iprot):
9482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9484 
      return
9485 
    iprot.readStructBegin()
9486 
    while True:
9487 
      (fname, ftype, fid) = iprot.readFieldBegin()
9488 
      if ftype == TType.STOP:
9489 
        break
3064 chandransh 9490 
      if fid == 1:
1596 ankur.sing 9491 
        if ftype == TType.I64:
3064 chandransh 9492 
          self.providerId = iprot.readI64();
1596 ankur.sing 9493 
        else:
9494 
          iprot.skip(ftype)
3064 chandransh 9495 
      elif fid == 2:
9496 
        if ftype == TType.MAP:
9497 
          self.returnedOrders = {}
4133 chandransh 9498 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9499 
          for _i169 in xrange(_size165):
9500 
            _key170 = iprot.readString();
9501 
            _val171 = iprot.readString();
9502 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9503 
          iprot.readMapEnd()
9504 
        else:
9505 
          iprot.skip(ftype)
1596 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_args')
3431 rajveer 9516 
    if self.providerId is not None:
3064 chandransh 9517 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9518 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9519 
      oprot.writeFieldEnd()
3431 rajveer 9520 
    if self.returnedOrders is not None:
3064 chandransh 9521 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9522 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9523 
      for kiter172,viter173 in self.returnedOrders.items():
9524 
        oprot.writeString(kiter172)
9525 
        oprot.writeString(viter173)
3064 chandransh 9526 
      oprot.writeMapEnd()
9527 
      oprot.writeFieldEnd()
1596 ankur.sing 9528 
    oprot.writeFieldStop()
9529 
    oprot.writeStructEnd()
9530 
 
3431 rajveer 9531 
  def validate(self):
9532 
    return
9533 
 
9534 
 
1596 ankur.sing 9535 
  def __repr__(self):
9536 
    L = ['%s=%r' % (key, value)
9537 
      for key, value in self.__dict__.iteritems()]
9538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9539 
 
9540 
  def __eq__(self, other):
9541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9542 
 
9543 
  def __ne__(self, other):
9544 
    return not (self == other)
9545 
 
3064 chandransh 9546 
class markOrdersAsFailed_result:
9547 
  """
9548 
  Attributes:
9549 
   - ex
9550 
  """
1596 ankur.sing 9551 
 
1627 ankur.sing 9552 
  thrift_spec = (
3064 chandransh 9553 
    None, # 0
9554 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9555 
  )
9556 
 
3064 chandransh 9557 
  def __init__(self, ex=None,):
9558 
    self.ex = ex
9559 
 
1627 ankur.sing 9560 
  def read(self, iprot):
9561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9563 
      return
9564 
    iprot.readStructBegin()
9565 
    while True:
9566 
      (fname, ftype, fid) = iprot.readFieldBegin()
9567 
      if ftype == TType.STOP:
9568 
        break
3064 chandransh 9569 
      if fid == 1:
9570 
        if ftype == TType.STRUCT:
9571 
          self.ex = TransactionServiceException()
9572 
          self.ex.read(iprot)
9573 
        else:
9574 
          iprot.skip(ftype)
1627 ankur.sing 9575 
      else:
9576 
        iprot.skip(ftype)
9577 
      iprot.readFieldEnd()
9578 
    iprot.readStructEnd()
9579 
 
9580 
  def write(self, oprot):
9581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9583 
      return
3064 chandransh 9584 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9585 
    if self.ex is not None:
3064 chandransh 9586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9587 
      self.ex.write(oprot)
9588 
      oprot.writeFieldEnd()
1627 ankur.sing 9589 
    oprot.writeFieldStop()
9590 
    oprot.writeStructEnd()
9591 
 
3431 rajveer 9592 
  def validate(self):
9593 
    return
9594 
 
9595 
 
1627 ankur.sing 9596 
  def __repr__(self):
9597 
    L = ['%s=%r' % (key, value)
9598 
      for key, value in self.__dict__.iteritems()]
9599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9600 
 
9601 
  def __eq__(self, other):
9602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9603 
 
9604 
  def __ne__(self, other):
9605 
    return not (self == other)
9606 
 
3064 chandransh 9607 
class updateNonDeliveryReason_args:
1627 ankur.sing 9608 
  """
9609 
  Attributes:
3064 chandransh 9610 
   - providerId
9611 
   - undeliveredOrders
1627 ankur.sing 9612 
  """
9613 
 
9614 
  thrift_spec = (
3064 chandransh 9615 
    None, # 0
9616 
    (1, TType.I64, 'providerId', None, None, ), # 1
9617 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9618 
  )
9619 
 
3064 chandransh 9620 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9621 
    self.providerId = providerId
9622 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9623 
 
9624 
  def read(self, iprot):
9625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9627 
      return
9628 
    iprot.readStructBegin()
9629 
    while True:
9630 
      (fname, ftype, fid) = iprot.readFieldBegin()
9631 
      if ftype == TType.STOP:
9632 
        break
3064 chandransh 9633 
      if fid == 1:
1627 ankur.sing 9634 
        if ftype == TType.I64:
3064 chandransh 9635 
          self.providerId = iprot.readI64();
1627 ankur.sing 9636 
        else:
9637 
          iprot.skip(ftype)
3064 chandransh 9638 
      elif fid == 2:
9639 
        if ftype == TType.MAP:
9640 
          self.undeliveredOrders = {}
4133 chandransh 9641 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9642 
          for _i178 in xrange(_size174):
9643 
            _key179 = iprot.readString();
9644 
            _val180 = iprot.readString();
9645 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9646 
          iprot.readMapEnd()
9647 
        else:
9648 
          iprot.skip(ftype)
1627 ankur.sing 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_args')
3431 rajveer 9659 
    if self.providerId is not None:
3064 chandransh 9660 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9661 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9662 
      oprot.writeFieldEnd()
3431 rajveer 9663 
    if self.undeliveredOrders is not None:
3064 chandransh 9664 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9666 
      for kiter181,viter182 in self.undeliveredOrders.items():
9667 
        oprot.writeString(kiter181)
9668 
        oprot.writeString(viter182)
3064 chandransh 9669 
      oprot.writeMapEnd()
9670 
      oprot.writeFieldEnd()
1627 ankur.sing 9671 
    oprot.writeFieldStop()
9672 
    oprot.writeStructEnd()
9673 
 
3431 rajveer 9674 
  def validate(self):
9675 
    return
9676 
 
9677 
 
1627 ankur.sing 9678 
  def __repr__(self):
9679 
    L = ['%s=%r' % (key, value)
9680 
      for key, value in self.__dict__.iteritems()]
9681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9682 
 
9683 
  def __eq__(self, other):
9684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9685 
 
9686 
  def __ne__(self, other):
9687 
    return not (self == other)
9688 
 
3064 chandransh 9689 
class updateNonDeliveryReason_result:
1627 ankur.sing 9690 
  """
9691 
  Attributes:
3064 chandransh 9692 
   - ex
1627 ankur.sing 9693 
  """
9694 
 
9695 
  thrift_spec = (
3064 chandransh 9696 
    None, # 0
9697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9698 
  )
9699 
 
3064 chandransh 9700 
  def __init__(self, ex=None,):
9701 
    self.ex = ex
1627 ankur.sing 9702 
 
9703 
  def read(self, iprot):
9704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9706 
      return
9707 
    iprot.readStructBegin()
9708 
    while True:
9709 
      (fname, ftype, fid) = iprot.readFieldBegin()
9710 
      if ftype == TType.STOP:
9711 
        break
3064 chandransh 9712 
      if fid == 1:
9713 
        if ftype == TType.STRUCT:
9714 
          self.ex = TransactionServiceException()
9715 
          self.ex.read(iprot)
1627 ankur.sing 9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
3064 chandransh 9727 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9728 
    if self.ex is not None:
3064 chandransh 9729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9730 
      self.ex.write(oprot)
1627 ankur.sing 9731 
      oprot.writeFieldEnd()
9732 
    oprot.writeFieldStop()
9733 
    oprot.writeStructEnd()
9734 
 
3431 rajveer 9735 
  def validate(self):
9736 
    return
9737 
 
9738 
 
1627 ankur.sing 9739 
  def __repr__(self):
9740 
    L = ['%s=%r' % (key, value)
9741 
      for key, value in self.__dict__.iteritems()]
9742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9743 
 
9744 
  def __eq__(self, other):
9745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9746 
 
9747 
  def __ne__(self, other):
9748 
    return not (self == other)
9749 
 
3064 chandransh 9750 
class getUndeliveredOrders_args:
1886 ankur.sing 9751 
  """
9752 
  Attributes:
3064 chandransh 9753 
   - providerId
9754 
   - warehouseId
1886 ankur.sing 9755 
  """
1627 ankur.sing 9756 
 
1886 ankur.sing 9757 
  thrift_spec = (
9758 
    None, # 0
3064 chandransh 9759 
    (1, TType.I64, 'providerId', None, None, ), # 1
9760 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9761 
  )
9762 
 
3064 chandransh 9763 
  def __init__(self, providerId=None, warehouseId=None,):
9764 
    self.providerId = providerId
9765 
    self.warehouseId = warehouseId
1886 ankur.sing 9766 
 
9767 
  def read(self, iprot):
9768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9770 
      return
9771 
    iprot.readStructBegin()
9772 
    while True:
9773 
      (fname, ftype, fid) = iprot.readFieldBegin()
9774 
      if ftype == TType.STOP:
9775 
        break
9776 
      if fid == 1:
9777 
        if ftype == TType.I64:
3064 chandransh 9778 
          self.providerId = iprot.readI64();
1886 ankur.sing 9779 
        else:
9780 
          iprot.skip(ftype)
3064 chandransh 9781 
      elif fid == 2:
9782 
        if ftype == TType.I64:
9783 
          self.warehouseId = iprot.readI64();
9784 
        else:
9785 
          iprot.skip(ftype)
1886 ankur.sing 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_args')
3431 rajveer 9796 
    if self.providerId is not None:
3064 chandransh 9797 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9798 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9799 
      oprot.writeFieldEnd()
3431 rajveer 9800 
    if self.warehouseId is not None:
3064 chandransh 9801 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9802 
      oprot.writeI64(self.warehouseId)
9803 
      oprot.writeFieldEnd()
1886 ankur.sing 9804 
    oprot.writeFieldStop()
9805 
    oprot.writeStructEnd()
9806 
 
3431 rajveer 9807 
  def validate(self):
9808 
    return
9809 
 
9810 
 
1886 ankur.sing 9811 
  def __repr__(self):
9812 
    L = ['%s=%r' % (key, value)
9813 
      for key, value in self.__dict__.iteritems()]
9814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9815 
 
9816 
  def __eq__(self, other):
9817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9818 
 
9819 
  def __ne__(self, other):
9820 
    return not (self == other)
9821 
 
3064 chandransh 9822 
class getUndeliveredOrders_result:
1886 ankur.sing 9823 
  """
9824 
  Attributes:
9825 
   - success
9826 
  """
9827 
 
9828 
  thrift_spec = (
9829 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9830 
  )
9831 
 
9832 
  def __init__(self, success=None,):
9833 
    self.success = success
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 == 0:
9845 
        if ftype == TType.LIST:
9846 
          self.success = []
4133 chandransh 9847 
          (_etype186, _size183) = iprot.readListBegin()
9848 
          for _i187 in xrange(_size183):
9849 
            _elem188 = Order()
9850 
            _elem188.read(iprot)
9851 
            self.success.append(_elem188)
1886 ankur.sing 9852 
          iprot.readListEnd()
9853 
        else:
9854 
          iprot.skip(ftype)
9855 
      else:
9856 
        iprot.skip(ftype)
9857 
      iprot.readFieldEnd()
9858 
    iprot.readStructEnd()
9859 
 
9860 
  def write(self, oprot):
9861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9863 
      return
3064 chandransh 9864 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9865 
    if self.success is not None:
1886 ankur.sing 9866 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9867 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9868 
      for iter189 in self.success:
9869 
        iter189.write(oprot)
1886 ankur.sing 9870 
      oprot.writeListEnd()
9871 
      oprot.writeFieldEnd()
9872 
    oprot.writeFieldStop()
9873 
    oprot.writeStructEnd()
9874 
 
3431 rajveer 9875 
  def validate(self):
9876 
    return
9877 
 
9878 
 
1886 ankur.sing 9879 
  def __repr__(self):
9880 
    L = ['%s=%r' % (key, value)
9881 
      for key, value in self.__dict__.iteritems()]
9882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9883 
 
9884 
  def __eq__(self, other):
9885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9886 
 
9887 
  def __ne__(self, other):
9888 
    return not (self == other)
9889 
 
2536 chandransh 9890 
class toggleDOAFlag_args:
9891 
  """
9892 
  Attributes:
9893 
   - orderId
9894 
  """
1886 ankur.sing 9895 
 
2536 chandransh 9896 
  thrift_spec = (
9897 
    None, # 0
9898 
    (1, TType.I64, 'orderId', None, None, ), # 1
9899 
  )
9900 
 
9901 
  def __init__(self, orderId=None,):
9902 
    self.orderId = orderId
9903 
 
9904 
  def read(self, iprot):
9905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9907 
      return
9908 
    iprot.readStructBegin()
9909 
    while True:
9910 
      (fname, ftype, fid) = iprot.readFieldBegin()
9911 
      if ftype == TType.STOP:
9912 
        break
9913 
      if fid == 1:
9914 
        if ftype == TType.I64:
9915 
          self.orderId = iprot.readI64();
9916 
        else:
9917 
          iprot.skip(ftype)
9918 
      else:
9919 
        iprot.skip(ftype)
9920 
      iprot.readFieldEnd()
9921 
    iprot.readStructEnd()
9922 
 
9923 
  def write(self, oprot):
9924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9926 
      return
9927 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9928 
    if self.orderId is not None:
2536 chandransh 9929 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9930 
      oprot.writeI64(self.orderId)
9931 
      oprot.writeFieldEnd()
9932 
    oprot.writeFieldStop()
9933 
    oprot.writeStructEnd()
9934 
 
3431 rajveer 9935 
  def validate(self):
9936 
    return
9937 
 
9938 
 
2536 chandransh 9939 
  def __repr__(self):
9940 
    L = ['%s=%r' % (key, value)
9941 
      for key, value in self.__dict__.iteritems()]
9942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9943 
 
9944 
  def __eq__(self, other):
9945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9946 
 
9947 
  def __ne__(self, other):
9948 
    return not (self == other)
9949 
 
9950 
class toggleDOAFlag_result:
9951 
  """
9952 
  Attributes:
9953 
   - success
9954 
   - ex
9955 
  """
9956 
 
9957 
  thrift_spec = (
9958 
    (0, TType.BOOL, 'success', None, None, ), # 0
9959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9960 
  )
9961 
 
9962 
  def __init__(self, success=None, ex=None,):
9963 
    self.success = success
9964 
    self.ex = ex
9965 
 
9966 
  def read(self, iprot):
9967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9969 
      return
9970 
    iprot.readStructBegin()
9971 
    while True:
9972 
      (fname, ftype, fid) = iprot.readFieldBegin()
9973 
      if ftype == TType.STOP:
9974 
        break
9975 
      if fid == 0:
9976 
        if ftype == TType.BOOL:
9977 
          self.success = iprot.readBool();
9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      elif fid == 1:
9981 
        if ftype == TType.STRUCT:
9982 
          self.ex = TransactionServiceException()
9983 
          self.ex.read(iprot)
9984 
        else:
9985 
          iprot.skip(ftype)
9986 
      else:
9987 
        iprot.skip(ftype)
9988 
      iprot.readFieldEnd()
9989 
    iprot.readStructEnd()
9990 
 
9991 
  def write(self, oprot):
9992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9994 
      return
9995 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9996 
    if self.success is not None:
2536 chandransh 9997 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9998 
      oprot.writeBool(self.success)
9999 
      oprot.writeFieldEnd()
3431 rajveer 10000 
    if self.ex is not None:
2536 chandransh 10001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10002 
      self.ex.write(oprot)
10003 
      oprot.writeFieldEnd()
10004 
    oprot.writeFieldStop()
10005 
    oprot.writeStructEnd()
10006 
 
3431 rajveer 10007 
  def validate(self):
10008 
    return
10009 
 
10010 
 
2536 chandransh 10011 
  def __repr__(self):
10012 
    L = ['%s=%r' % (key, value)
10013 
      for key, value in self.__dict__.iteritems()]
10014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10015 
 
10016 
  def __eq__(self, other):
10017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10018 
 
10019 
  def __ne__(self, other):
10020 
    return not (self == other)
10021 
 
10022 
class requestPickupNumber_args:
10023 
  """
10024 
  Attributes:
10025 
   - orderId
10026 
  """
10027 
 
10028 
  thrift_spec = (
10029 
    None, # 0
10030 
    (1, TType.I64, 'orderId', None, None, ), # 1
10031 
  )
10032 
 
10033 
  def __init__(self, orderId=None,):
10034 
    self.orderId = orderId
10035 
 
10036 
  def read(self, iprot):
10037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10039 
      return
10040 
    iprot.readStructBegin()
10041 
    while True:
10042 
      (fname, ftype, fid) = iprot.readFieldBegin()
10043 
      if ftype == TType.STOP:
10044 
        break
10045 
      if fid == 1:
10046 
        if ftype == TType.I64:
10047 
          self.orderId = iprot.readI64();
10048 
        else:
10049 
          iprot.skip(ftype)
10050 
      else:
10051 
        iprot.skip(ftype)
10052 
      iprot.readFieldEnd()
10053 
    iprot.readStructEnd()
10054 
 
10055 
  def write(self, oprot):
10056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10058 
      return
10059 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10060 
    if self.orderId is not None:
2536 chandransh 10061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10062 
      oprot.writeI64(self.orderId)
10063 
      oprot.writeFieldEnd()
10064 
    oprot.writeFieldStop()
10065 
    oprot.writeStructEnd()
10066 
 
3431 rajveer 10067 
  def validate(self):
10068 
    return
10069 
 
10070 
 
2536 chandransh 10071 
  def __repr__(self):
10072 
    L = ['%s=%r' % (key, value)
10073 
      for key, value in self.__dict__.iteritems()]
10074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10075 
 
10076 
  def __eq__(self, other):
10077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10078 
 
10079 
  def __ne__(self, other):
10080 
    return not (self == other)
10081 
 
10082 
class requestPickupNumber_result:
10083 
  """
10084 
  Attributes:
10085 
   - success
10086 
   - ex
10087 
  """
10088 
 
10089 
  thrift_spec = (
10090 
    (0, TType.BOOL, 'success', None, None, ), # 0
10091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10092 
  )
10093 
 
10094 
  def __init__(self, success=None, ex=None,):
10095 
    self.success = success
10096 
    self.ex = ex
10097 
 
10098 
  def read(self, iprot):
10099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10101 
      return
10102 
    iprot.readStructBegin()
10103 
    while True:
10104 
      (fname, ftype, fid) = iprot.readFieldBegin()
10105 
      if ftype == TType.STOP:
10106 
        break
10107 
      if fid == 0:
10108 
        if ftype == TType.BOOL:
10109 
          self.success = iprot.readBool();
10110 
        else:
10111 
          iprot.skip(ftype)
10112 
      elif fid == 1:
10113 
        if ftype == TType.STRUCT:
10114 
          self.ex = TransactionServiceException()
10115 
          self.ex.read(iprot)
10116 
        else:
10117 
          iprot.skip(ftype)
10118 
      else:
10119 
        iprot.skip(ftype)
10120 
      iprot.readFieldEnd()
10121 
    iprot.readStructEnd()
10122 
 
10123 
  def write(self, oprot):
10124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10126 
      return
10127 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10128 
    if self.success is not None:
2536 chandransh 10129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10130 
      oprot.writeBool(self.success)
10131 
      oprot.writeFieldEnd()
3431 rajveer 10132 
    if self.ex is not None:
2536 chandransh 10133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10134 
      self.ex.write(oprot)
10135 
      oprot.writeFieldEnd()
10136 
    oprot.writeFieldStop()
10137 
    oprot.writeStructEnd()
10138 
 
3431 rajveer 10139 
  def validate(self):
10140 
    return
10141 
 
10142 
 
2536 chandransh 10143 
  def __repr__(self):
10144 
    L = ['%s=%r' % (key, value)
10145 
      for key, value in self.__dict__.iteritems()]
10146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10147 
 
10148 
  def __eq__(self, other):
10149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10150 
 
10151 
  def __ne__(self, other):
10152 
    return not (self == other)
10153 
 
10154 
class authorizePickup_args:
10155 
  """
10156 
  Attributes:
10157 
   - orderId
10158 
   - pickupNumber
10159 
  """
10160 
 
10161 
  thrift_spec = (
10162 
    None, # 0
10163 
    (1, TType.I64, 'orderId', None, None, ), # 1
10164 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10165 
  )
10166 
 
10167 
  def __init__(self, orderId=None, pickupNumber=None,):
10168 
    self.orderId = orderId
10169 
    self.pickupNumber = pickupNumber
10170 
 
10171 
  def read(self, iprot):
10172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10174 
      return
10175 
    iprot.readStructBegin()
10176 
    while True:
10177 
      (fname, ftype, fid) = iprot.readFieldBegin()
10178 
      if ftype == TType.STOP:
10179 
        break
10180 
      if fid == 1:
10181 
        if ftype == TType.I64:
10182 
          self.orderId = iprot.readI64();
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      elif fid == 2:
10186 
        if ftype == TType.STRING:
10187 
          self.pickupNumber = iprot.readString();
10188 
        else:
10189 
          iprot.skip(ftype)
10190 
      else:
10191 
        iprot.skip(ftype)
10192 
      iprot.readFieldEnd()
10193 
    iprot.readStructEnd()
10194 
 
10195 
  def write(self, oprot):
10196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10198 
      return
10199 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10200 
    if self.orderId is not None:
2536 chandransh 10201 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10202 
      oprot.writeI64(self.orderId)
10203 
      oprot.writeFieldEnd()
3431 rajveer 10204 
    if self.pickupNumber is not None:
2536 chandransh 10205 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10206 
      oprot.writeString(self.pickupNumber)
10207 
      oprot.writeFieldEnd()
10208 
    oprot.writeFieldStop()
10209 
    oprot.writeStructEnd()
10210 
 
3431 rajveer 10211 
  def validate(self):
10212 
    return
10213 
 
10214 
 
2536 chandransh 10215 
  def __repr__(self):
10216 
    L = ['%s=%r' % (key, value)
10217 
      for key, value in self.__dict__.iteritems()]
10218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10219 
 
10220 
  def __eq__(self, other):
10221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10222 
 
10223 
  def __ne__(self, other):
10224 
    return not (self == other)
10225 
 
10226 
class authorizePickup_result:
10227 
  """
10228 
  Attributes:
10229 
   - success
10230 
   - ex
10231 
  """
10232 
 
10233 
  thrift_spec = (
10234 
    (0, TType.BOOL, 'success', None, None, ), # 0
10235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10236 
  )
10237 
 
10238 
  def __init__(self, success=None, ex=None,):
10239 
    self.success = success
10240 
    self.ex = ex
10241 
 
10242 
  def read(self, iprot):
10243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10245 
      return
10246 
    iprot.readStructBegin()
10247 
    while True:
10248 
      (fname, ftype, fid) = iprot.readFieldBegin()
10249 
      if ftype == TType.STOP:
10250 
        break
10251 
      if fid == 0:
10252 
        if ftype == TType.BOOL:
10253 
          self.success = iprot.readBool();
10254 
        else:
10255 
          iprot.skip(ftype)
10256 
      elif fid == 1:
10257 
        if ftype == TType.STRUCT:
10258 
          self.ex = TransactionServiceException()
10259 
          self.ex.read(iprot)
10260 
        else:
10261 
          iprot.skip(ftype)
10262 
      else:
10263 
        iprot.skip(ftype)
10264 
      iprot.readFieldEnd()
10265 
    iprot.readStructEnd()
10266 
 
10267 
  def write(self, oprot):
10268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10270 
      return
10271 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10272 
    if self.success is not None:
2536 chandransh 10273 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10274 
      oprot.writeBool(self.success)
10275 
      oprot.writeFieldEnd()
3431 rajveer 10276 
    if self.ex is not None:
2536 chandransh 10277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10278 
      self.ex.write(oprot)
10279 
      oprot.writeFieldEnd()
10280 
    oprot.writeFieldStop()
10281 
    oprot.writeStructEnd()
10282 
 
3431 rajveer 10283 
  def validate(self):
10284 
    return
10285 
 
10286 
 
2536 chandransh 10287 
  def __repr__(self):
10288 
    L = ['%s=%r' % (key, value)
10289 
      for key, value in self.__dict__.iteritems()]
10290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10291 
 
10292 
  def __eq__(self, other):
10293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10294 
 
10295 
  def __ne__(self, other):
10296 
    return not (self == other)
10297 
 
2764 chandransh 10298 
class markDoasAsPickedUp_args:
10299 
  """
10300 
  Attributes:
10301 
   - providerId
10302 
   - pickupDetails
10303 
  """
10304 
 
10305 
  thrift_spec = (
10306 
    None, # 0
10307 
    (1, TType.I64, 'providerId', None, None, ), # 1
10308 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10309 
  )
10310 
 
10311 
  def __init__(self, providerId=None, pickupDetails=None,):
10312 
    self.providerId = providerId
10313 
    self.pickupDetails = pickupDetails
10314 
 
10315 
  def read(self, iprot):
10316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10318 
      return
10319 
    iprot.readStructBegin()
10320 
    while True:
10321 
      (fname, ftype, fid) = iprot.readFieldBegin()
10322 
      if ftype == TType.STOP:
10323 
        break
10324 
      if fid == 1:
10325 
        if ftype == TType.I64:
10326 
          self.providerId = iprot.readI64();
10327 
        else:
10328 
          iprot.skip(ftype)
10329 
      elif fid == 2:
10330 
        if ftype == TType.MAP:
10331 
          self.pickupDetails = {}
4133 chandransh 10332 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10333 
          for _i194 in xrange(_size190):
10334 
            _key195 = iprot.readString();
10335 
            _val196 = iprot.readString();
10336 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10337 
          iprot.readMapEnd()
10338 
        else:
10339 
          iprot.skip(ftype)
10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
10349 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10350 
    if self.providerId is not None:
2764 chandransh 10351 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10352 
      oprot.writeI64(self.providerId)
10353 
      oprot.writeFieldEnd()
3431 rajveer 10354 
    if self.pickupDetails is not None:
2764 chandransh 10355 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10356 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10357 
      for kiter197,viter198 in self.pickupDetails.items():
10358 
        oprot.writeString(kiter197)
10359 
        oprot.writeString(viter198)
2764 chandransh 10360 
      oprot.writeMapEnd()
10361 
      oprot.writeFieldEnd()
10362 
    oprot.writeFieldStop()
10363 
    oprot.writeStructEnd()
10364 
 
3431 rajveer 10365 
  def validate(self):
10366 
    return
10367 
 
10368 
 
2764 chandransh 10369 
  def __repr__(self):
10370 
    L = ['%s=%r' % (key, value)
10371 
      for key, value in self.__dict__.iteritems()]
10372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10373 
 
10374 
  def __eq__(self, other):
10375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10376 
 
10377 
  def __ne__(self, other):
10378 
    return not (self == other)
10379 
 
10380 
class markDoasAsPickedUp_result:
10381 
  """
10382 
  Attributes:
10383 
   - success
10384 
  """
10385 
 
10386 
  thrift_spec = (
10387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10388 
  )
10389 
 
10390 
  def __init__(self, success=None,):
10391 
    self.success = success
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 == 0:
10403 
        if ftype == TType.LIST:
10404 
          self.success = []
4133 chandransh 10405 
          (_etype202, _size199) = iprot.readListBegin()
10406 
          for _i203 in xrange(_size199):
10407 
            _elem204 = Order()
10408 
            _elem204.read(iprot)
10409 
            self.success.append(_elem204)
2764 chandransh 10410 
          iprot.readListEnd()
10411 
        else:
10412 
          iprot.skip(ftype)
10413 
      else:
10414 
        iprot.skip(ftype)
10415 
      iprot.readFieldEnd()
10416 
    iprot.readStructEnd()
10417 
 
10418 
  def write(self, oprot):
10419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10421 
      return
10422 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10423 
    if self.success is not None:
2764 chandransh 10424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10426 
      for iter205 in self.success:
10427 
        iter205.write(oprot)
2764 chandransh 10428 
      oprot.writeListEnd()
10429 
      oprot.writeFieldEnd()
10430 
    oprot.writeFieldStop()
10431 
    oprot.writeStructEnd()
10432 
 
3431 rajveer 10433 
  def validate(self):
10434 
    return
10435 
 
10436 
 
2764 chandransh 10437 
  def __repr__(self):
10438 
    L = ['%s=%r' % (key, value)
10439 
      for key, value in self.__dict__.iteritems()]
10440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10441 
 
10442 
  def __eq__(self, other):
10443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10444 
 
10445 
  def __ne__(self, other):
10446 
    return not (self == other)
10447 
 
2616 chandransh 10448 
class receiveReturn_args:
2591 chandransh 10449 
  """
10450 
  Attributes:
10451 
   - orderId
10452 
  """
2536 chandransh 10453 
 
2591 chandransh 10454 
  thrift_spec = (
10455 
    None, # 0
10456 
    (1, TType.I64, 'orderId', None, None, ), # 1
10457 
  )
10458 
 
10459 
  def __init__(self, orderId=None,):
10460 
    self.orderId = orderId
10461 
 
10462 
  def read(self, iprot):
10463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10465 
      return
10466 
    iprot.readStructBegin()
10467 
    while True:
10468 
      (fname, ftype, fid) = iprot.readFieldBegin()
10469 
      if ftype == TType.STOP:
10470 
        break
10471 
      if fid == 1:
10472 
        if ftype == TType.I64:
10473 
          self.orderId = iprot.readI64();
10474 
        else:
10475 
          iprot.skip(ftype)
10476 
      else:
10477 
        iprot.skip(ftype)
10478 
      iprot.readFieldEnd()
10479 
    iprot.readStructEnd()
10480 
 
10481 
  def write(self, oprot):
10482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10484 
      return
2616 chandransh 10485 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10486 
    if self.orderId is not None:
2591 chandransh 10487 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10488 
      oprot.writeI64(self.orderId)
10489 
      oprot.writeFieldEnd()
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
3431 rajveer 10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
2591 chandransh 10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
2616 chandransh 10508 
class receiveReturn_result:
2591 chandransh 10509 
  """
10510 
  Attributes:
10511 
   - success
10512 
   - ex
10513 
  """
10514 
 
10515 
  thrift_spec = (
10516 
    (0, TType.BOOL, 'success', None, None, ), # 0
10517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10518 
  )
10519 
 
10520 
  def __init__(self, success=None, ex=None,):
10521 
    self.success = success
10522 
    self.ex = ex
10523 
 
10524 
  def read(self, iprot):
10525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10527 
      return
10528 
    iprot.readStructBegin()
10529 
    while True:
10530 
      (fname, ftype, fid) = iprot.readFieldBegin()
10531 
      if ftype == TType.STOP:
10532 
        break
10533 
      if fid == 0:
10534 
        if ftype == TType.BOOL:
10535 
          self.success = iprot.readBool();
10536 
        else:
10537 
          iprot.skip(ftype)
10538 
      elif fid == 1:
10539 
        if ftype == TType.STRUCT:
10540 
          self.ex = TransactionServiceException()
10541 
          self.ex.read(iprot)
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      else:
10545 
        iprot.skip(ftype)
10546 
      iprot.readFieldEnd()
10547 
    iprot.readStructEnd()
10548 
 
10549 
  def write(self, oprot):
10550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10552 
      return
2616 chandransh 10553 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10554 
    if self.success is not None:
2591 chandransh 10555 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10556 
      oprot.writeBool(self.success)
10557 
      oprot.writeFieldEnd()
3431 rajveer 10558 
    if self.ex is not None:
2591 chandransh 10559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10560 
      self.ex.write(oprot)
10561 
      oprot.writeFieldEnd()
10562 
    oprot.writeFieldStop()
10563 
    oprot.writeStructEnd()
10564 
 
3431 rajveer 10565 
  def validate(self):
10566 
    return
10567 
 
10568 
 
2591 chandransh 10569 
  def __repr__(self):
10570 
    L = ['%s=%r' % (key, value)
10571 
      for key, value in self.__dict__.iteritems()]
10572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10573 
 
10574 
  def __eq__(self, other):
10575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10576 
 
10577 
  def __ne__(self, other):
10578 
    return not (self == other)
10579 
 
10580 
class validateDoa_args:
10581 
  """
10582 
  Attributes:
10583 
   - orderId
10584 
   - isValid
10585 
  """
10586 
 
10587 
  thrift_spec = (
10588 
    None, # 0
10589 
    (1, TType.I64, 'orderId', None, None, ), # 1
10590 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10591 
  )
10592 
 
10593 
  def __init__(self, orderId=None, isValid=None,):
10594 
    self.orderId = orderId
10595 
    self.isValid = isValid
10596 
 
10597 
  def read(self, iprot):
10598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10600 
      return
10601 
    iprot.readStructBegin()
10602 
    while True:
10603 
      (fname, ftype, fid) = iprot.readFieldBegin()
10604 
      if ftype == TType.STOP:
10605 
        break
10606 
      if fid == 1:
10607 
        if ftype == TType.I64:
10608 
          self.orderId = iprot.readI64();
10609 
        else:
10610 
          iprot.skip(ftype)
10611 
      elif fid == 2:
10612 
        if ftype == TType.BOOL:
10613 
          self.isValid = iprot.readBool();
10614 
        else:
10615 
          iprot.skip(ftype)
10616 
      else:
10617 
        iprot.skip(ftype)
10618 
      iprot.readFieldEnd()
10619 
    iprot.readStructEnd()
10620 
 
10621 
  def write(self, oprot):
10622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10624 
      return
10625 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10626 
    if self.orderId is not None:
2591 chandransh 10627 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10628 
      oprot.writeI64(self.orderId)
10629 
      oprot.writeFieldEnd()
3431 rajveer 10630 
    if self.isValid is not None:
2591 chandransh 10631 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10632 
      oprot.writeBool(self.isValid)
10633 
      oprot.writeFieldEnd()
10634 
    oprot.writeFieldStop()
10635 
    oprot.writeStructEnd()
10636 
 
3431 rajveer 10637 
  def validate(self):
10638 
    return
10639 
 
10640 
 
2591 chandransh 10641 
  def __repr__(self):
10642 
    L = ['%s=%r' % (key, value)
10643 
      for key, value in self.__dict__.iteritems()]
10644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10645 
 
10646 
  def __eq__(self, other):
10647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10648 
 
10649 
  def __ne__(self, other):
10650 
    return not (self == other)
10651 
 
10652 
class validateDoa_result:
10653 
  """
10654 
  Attributes:
10655 
   - success
10656 
   - ex
10657 
  """
10658 
 
10659 
  thrift_spec = (
10660 
    (0, TType.BOOL, 'success', None, None, ), # 0
10661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10662 
  )
10663 
 
10664 
  def __init__(self, success=None, ex=None,):
10665 
    self.success = success
10666 
    self.ex = ex
10667 
 
10668 
  def read(self, iprot):
10669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10671 
      return
10672 
    iprot.readStructBegin()
10673 
    while True:
10674 
      (fname, ftype, fid) = iprot.readFieldBegin()
10675 
      if ftype == TType.STOP:
10676 
        break
10677 
      if fid == 0:
10678 
        if ftype == TType.BOOL:
10679 
          self.success = iprot.readBool();
10680 
        else:
10681 
          iprot.skip(ftype)
10682 
      elif fid == 1:
10683 
        if ftype == TType.STRUCT:
10684 
          self.ex = TransactionServiceException()
10685 
          self.ex.read(iprot)
10686 
        else:
10687 
          iprot.skip(ftype)
10688 
      else:
10689 
        iprot.skip(ftype)
10690 
      iprot.readFieldEnd()
10691 
    iprot.readStructEnd()
10692 
 
10693 
  def write(self, oprot):
10694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10696 
      return
10697 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10698 
    if self.success is not None:
2591 chandransh 10699 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10700 
      oprot.writeBool(self.success)
10701 
      oprot.writeFieldEnd()
3431 rajveer 10702 
    if self.ex is not None:
2591 chandransh 10703 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10704 
      self.ex.write(oprot)
10705 
      oprot.writeFieldEnd()
10706 
    oprot.writeFieldStop()
10707 
    oprot.writeStructEnd()
10708 
 
3431 rajveer 10709 
  def validate(self):
10710 
    return
10711 
 
10712 
 
2591 chandransh 10713 
  def __repr__(self):
10714 
    L = ['%s=%r' % (key, value)
10715 
      for key, value in self.__dict__.iteritems()]
10716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10717 
 
10718 
  def __eq__(self, other):
10719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10720 
 
10721 
  def __ne__(self, other):
10722 
    return not (self == other)
10723 
 
2616 chandransh 10724 
class reshipOrder_args:
10725 
  """
10726 
  Attributes:
10727 
   - orderId
10728 
  """
2591 chandransh 10729 
 
2616 chandransh 10730 
  thrift_spec = (
10731 
    None, # 0
10732 
    (1, TType.I64, 'orderId', None, None, ), # 1
10733 
  )
10734 
 
10735 
  def __init__(self, orderId=None,):
10736 
    self.orderId = orderId
10737 
 
10738 
  def read(self, iprot):
10739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10741 
      return
10742 
    iprot.readStructBegin()
10743 
    while True:
10744 
      (fname, ftype, fid) = iprot.readFieldBegin()
10745 
      if ftype == TType.STOP:
10746 
        break
10747 
      if fid == 1:
10748 
        if ftype == TType.I64:
10749 
          self.orderId = iprot.readI64();
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
10761 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10762 
    if self.orderId is not None:
2616 chandransh 10763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10764 
      oprot.writeI64(self.orderId)
10765 
      oprot.writeFieldEnd()
10766 
    oprot.writeFieldStop()
10767 
    oprot.writeStructEnd()
10768 
 
3431 rajveer 10769 
  def validate(self):
10770 
    return
10771 
 
10772 
 
2616 chandransh 10773 
  def __repr__(self):
10774 
    L = ['%s=%r' % (key, value)
10775 
      for key, value in self.__dict__.iteritems()]
10776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10777 
 
10778 
  def __eq__(self, other):
10779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10780 
 
10781 
  def __ne__(self, other):
10782 
    return not (self == other)
10783 
 
10784 
class reshipOrder_result:
10785 
  """
10786 
  Attributes:
10787 
   - success
10788 
   - ex
10789 
  """
10790 
 
10791 
  thrift_spec = (
10792 
    (0, TType.I64, 'success', None, None, ), # 0
10793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10794 
  )
10795 
 
10796 
  def __init__(self, success=None, ex=None,):
10797 
    self.success = success
10798 
    self.ex = ex
10799 
 
10800 
  def read(self, iprot):
10801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10803 
      return
10804 
    iprot.readStructBegin()
10805 
    while True:
10806 
      (fname, ftype, fid) = iprot.readFieldBegin()
10807 
      if ftype == TType.STOP:
10808 
        break
10809 
      if fid == 0:
10810 
        if ftype == TType.I64:
10811 
          self.success = iprot.readI64();
10812 
        else:
10813 
          iprot.skip(ftype)
10814 
      elif fid == 1:
10815 
        if ftype == TType.STRUCT:
10816 
          self.ex = TransactionServiceException()
10817 
          self.ex.read(iprot)
10818 
        else:
10819 
          iprot.skip(ftype)
10820 
      else:
10821 
        iprot.skip(ftype)
10822 
      iprot.readFieldEnd()
10823 
    iprot.readStructEnd()
10824 
 
10825 
  def write(self, oprot):
10826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10828 
      return
10829 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10830 
    if self.success is not None:
2616 chandransh 10831 
      oprot.writeFieldBegin('success', TType.I64, 0)
10832 
      oprot.writeI64(self.success)
10833 
      oprot.writeFieldEnd()
3431 rajveer 10834 
    if self.ex is not None:
2616 chandransh 10835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10836 
      self.ex.write(oprot)
10837 
      oprot.writeFieldEnd()
10838 
    oprot.writeFieldStop()
10839 
    oprot.writeStructEnd()
10840 
 
3431 rajveer 10841 
  def validate(self):
10842 
    return
10843 
 
10844 
 
2616 chandransh 10845 
  def __repr__(self):
10846 
    L = ['%s=%r' % (key, value)
10847 
      for key, value in self.__dict__.iteritems()]
10848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10849 
 
10850 
  def __eq__(self, other):
10851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10852 
 
10853 
  def __ne__(self, other):
10854 
    return not (self == other)
10855 
 
10856 
class refundOrder_args:
10857 
  """
10858 
  Attributes:
10859 
   - orderId
3226 chandransh 10860 
   - refundedBy
10861 
   - reason
2616 chandransh 10862 
  """
10863 
 
10864 
  thrift_spec = (
10865 
    None, # 0
10866 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10867 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10868 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10869 
  )
10870 
 
3226 chandransh 10871 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10872 
    self.orderId = orderId
3226 chandransh 10873 
    self.refundedBy = refundedBy
10874 
    self.reason = reason
2616 chandransh 10875 
 
10876 
  def read(self, iprot):
10877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10879 
      return
10880 
    iprot.readStructBegin()
10881 
    while True:
10882 
      (fname, ftype, fid) = iprot.readFieldBegin()
10883 
      if ftype == TType.STOP:
10884 
        break
10885 
      if fid == 1:
10886 
        if ftype == TType.I64:
10887 
          self.orderId = iprot.readI64();
10888 
        else:
10889 
          iprot.skip(ftype)
3226 chandransh 10890 
      elif fid == 2:
10891 
        if ftype == TType.STRING:
10892 
          self.refundedBy = iprot.readString();
10893 
        else:
10894 
          iprot.skip(ftype)
10895 
      elif fid == 3:
10896 
        if ftype == TType.STRING:
10897 
          self.reason = iprot.readString();
10898 
        else:
10899 
          iprot.skip(ftype)
2616 chandransh 10900 
      else:
10901 
        iprot.skip(ftype)
10902 
      iprot.readFieldEnd()
10903 
    iprot.readStructEnd()
10904 
 
10905 
  def write(self, oprot):
10906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10908 
      return
10909 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10910 
    if self.orderId is not None:
2616 chandransh 10911 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10912 
      oprot.writeI64(self.orderId)
10913 
      oprot.writeFieldEnd()
3431 rajveer 10914 
    if self.refundedBy is not None:
3226 chandransh 10915 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10916 
      oprot.writeString(self.refundedBy)
10917 
      oprot.writeFieldEnd()
3431 rajveer 10918 
    if self.reason is not None:
3226 chandransh 10919 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10920 
      oprot.writeString(self.reason)
10921 
      oprot.writeFieldEnd()
2616 chandransh 10922 
    oprot.writeFieldStop()
10923 
    oprot.writeStructEnd()
10924 
 
3431 rajveer 10925 
  def validate(self):
10926 
    return
10927 
 
10928 
 
2616 chandransh 10929 
  def __repr__(self):
10930 
    L = ['%s=%r' % (key, value)
10931 
      for key, value in self.__dict__.iteritems()]
10932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10933 
 
10934 
  def __eq__(self, other):
10935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10936 
 
10937 
  def __ne__(self, other):
10938 
    return not (self == other)
10939 
 
10940 
class refundOrder_result:
10941 
  """
10942 
  Attributes:
10943 
   - success
10944 
   - ex
10945 
  """
10946 
 
10947 
  thrift_spec = (
10948 
    (0, TType.BOOL, 'success', None, None, ), # 0
10949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10950 
  )
10951 
 
10952 
  def __init__(self, success=None, ex=None,):
10953 
    self.success = success
10954 
    self.ex = ex
10955 
 
10956 
  def read(self, iprot):
10957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10959 
      return
10960 
    iprot.readStructBegin()
10961 
    while True:
10962 
      (fname, ftype, fid) = iprot.readFieldBegin()
10963 
      if ftype == TType.STOP:
10964 
        break
10965 
      if fid == 0:
10966 
        if ftype == TType.BOOL:
10967 
          self.success = iprot.readBool();
10968 
        else:
10969 
          iprot.skip(ftype)
10970 
      elif fid == 1:
10971 
        if ftype == TType.STRUCT:
10972 
          self.ex = TransactionServiceException()
10973 
          self.ex.read(iprot)
10974 
        else:
10975 
          iprot.skip(ftype)
10976 
      else:
10977 
        iprot.skip(ftype)
10978 
      iprot.readFieldEnd()
10979 
    iprot.readStructEnd()
10980 
 
10981 
  def write(self, oprot):
10982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10984 
      return
10985 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10986 
    if self.success is not None:
2616 chandransh 10987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10988 
      oprot.writeBool(self.success)
10989 
      oprot.writeFieldEnd()
3431 rajveer 10990 
    if self.ex is not None:
2616 chandransh 10991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10992 
      self.ex.write(oprot)
10993 
      oprot.writeFieldEnd()
10994 
    oprot.writeFieldStop()
10995 
    oprot.writeStructEnd()
10996 
 
3431 rajveer 10997 
  def validate(self):
10998 
    return
10999 
 
11000 
 
2616 chandransh 11001 
  def __repr__(self):
11002 
    L = ['%s=%r' % (key, value)
11003 
      for key, value in self.__dict__.iteritems()]
11004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11005 
 
11006 
  def __eq__(self, other):
11007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11008 
 
11009 
  def __ne__(self, other):
11010 
    return not (self == other)
11011 
 
2690 chandransh 11012 
class getReturnOrders_args:
11013 
  """
11014 
  Attributes:
11015 
   - warehouseId
11016 
   - fromDate
11017 
   - toDate
11018 
  """
2616 chandransh 11019 
 
2690 chandransh 11020 
  thrift_spec = (
11021 
    None, # 0
11022 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11023 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11024 
    (3, TType.I64, 'toDate', None, None, ), # 3
11025 
  )
11026 
 
11027 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11028 
    self.warehouseId = warehouseId
11029 
    self.fromDate = fromDate
11030 
    self.toDate = toDate
11031 
 
11032 
  def read(self, iprot):
11033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11035 
      return
11036 
    iprot.readStructBegin()
11037 
    while True:
11038 
      (fname, ftype, fid) = iprot.readFieldBegin()
11039 
      if ftype == TType.STOP:
11040 
        break
11041 
      if fid == 1:
11042 
        if ftype == TType.I64:
11043 
          self.warehouseId = iprot.readI64();
11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      elif fid == 2:
11047 
        if ftype == TType.I64:
11048 
          self.fromDate = iprot.readI64();
11049 
        else:
11050 
          iprot.skip(ftype)
11051 
      elif fid == 3:
11052 
        if ftype == TType.I64:
11053 
          self.toDate = iprot.readI64();
11054 
        else:
11055 
          iprot.skip(ftype)
11056 
      else:
11057 
        iprot.skip(ftype)
11058 
      iprot.readFieldEnd()
11059 
    iprot.readStructEnd()
11060 
 
11061 
  def write(self, oprot):
11062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11064 
      return
11065 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11066 
    if self.warehouseId is not None:
2690 chandransh 11067 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11068 
      oprot.writeI64(self.warehouseId)
11069 
      oprot.writeFieldEnd()
3431 rajveer 11070 
    if self.fromDate is not None:
2690 chandransh 11071 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11072 
      oprot.writeI64(self.fromDate)
11073 
      oprot.writeFieldEnd()
3431 rajveer 11074 
    if self.toDate is not None:
2690 chandransh 11075 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11076 
      oprot.writeI64(self.toDate)
11077 
      oprot.writeFieldEnd()
11078 
    oprot.writeFieldStop()
11079 
    oprot.writeStructEnd()
11080 
 
3431 rajveer 11081 
  def validate(self):
11082 
    return
11083 
 
11084 
 
2690 chandransh 11085 
  def __repr__(self):
11086 
    L = ['%s=%r' % (key, value)
11087 
      for key, value in self.__dict__.iteritems()]
11088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11089 
 
11090 
  def __eq__(self, other):
11091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11092 
 
11093 
  def __ne__(self, other):
11094 
    return not (self == other)
11095 
 
11096 
class getReturnOrders_result:
11097 
  """
11098 
  Attributes:
11099 
   - success
11100 
  """
11101 
 
11102 
  thrift_spec = (
11103 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11104 
  )
11105 
 
11106 
  def __init__(self, success=None,):
11107 
    self.success = success
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 == 0:
11119 
        if ftype == TType.LIST:
11120 
          self.success = []
4133 chandransh 11121 
          (_etype209, _size206) = iprot.readListBegin()
11122 
          for _i210 in xrange(_size206):
11123 
            _elem211 = ReturnOrder()
11124 
            _elem211.read(iprot)
11125 
            self.success.append(_elem211)
2690 chandransh 11126 
          iprot.readListEnd()
11127 
        else:
11128 
          iprot.skip(ftype)
11129 
      else:
11130 
        iprot.skip(ftype)
11131 
      iprot.readFieldEnd()
11132 
    iprot.readStructEnd()
11133 
 
11134 
  def write(self, oprot):
11135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11137 
      return
11138 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11139 
    if self.success is not None:
2690 chandransh 11140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11142 
      for iter212 in self.success:
11143 
        iter212.write(oprot)
2690 chandransh 11144 
      oprot.writeListEnd()
11145 
      oprot.writeFieldEnd()
11146 
    oprot.writeFieldStop()
11147 
    oprot.writeStructEnd()
11148 
 
3431 rajveer 11149 
  def validate(self):
11150 
    return
11151 
 
11152 
 
2690 chandransh 11153 
  def __repr__(self):
11154 
    L = ['%s=%r' % (key, value)
11155 
      for key, value in self.__dict__.iteritems()]
11156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11157 
 
11158 
  def __eq__(self, other):
11159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11160 
 
11161 
  def __ne__(self, other):
11162 
    return not (self == other)
11163 
 
2700 chandransh 11164 
class getReturnOrder_args:
11165 
  """
11166 
  Attributes:
11167 
   - id
11168 
  """
11169 
 
11170 
  thrift_spec = (
11171 
    None, # 0
11172 
    (1, TType.I64, 'id', None, None, ), # 1
11173 
  )
11174 
 
11175 
  def __init__(self, id=None,):
11176 
    self.id = id
11177 
 
11178 
  def read(self, iprot):
11179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11181 
      return
11182 
    iprot.readStructBegin()
11183 
    while True:
11184 
      (fname, ftype, fid) = iprot.readFieldBegin()
11185 
      if ftype == TType.STOP:
11186 
        break
11187 
      if fid == 1:
11188 
        if ftype == TType.I64:
11189 
          self.id = iprot.readI64();
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_args')
3431 rajveer 11202 
    if self.id is not None:
2700 chandransh 11203 
      oprot.writeFieldBegin('id', TType.I64, 1)
11204 
      oprot.writeI64(self.id)
11205 
      oprot.writeFieldEnd()
11206 
    oprot.writeFieldStop()
11207 
    oprot.writeStructEnd()
11208 
 
3431 rajveer 11209 
  def validate(self):
11210 
    return
11211 
 
11212 
 
2700 chandransh 11213 
  def __repr__(self):
11214 
    L = ['%s=%r' % (key, value)
11215 
      for key, value in self.__dict__.iteritems()]
11216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11217 
 
11218 
  def __eq__(self, other):
11219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11220 
 
11221 
  def __ne__(self, other):
11222 
    return not (self == other)
11223 
 
11224 
class getReturnOrder_result:
11225 
  """
11226 
  Attributes:
11227 
   - success
11228 
   - ex
11229 
  """
11230 
 
11231 
  thrift_spec = (
11232 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11234 
  )
11235 
 
11236 
  def __init__(self, success=None, ex=None,):
11237 
    self.success = success
11238 
    self.ex = ex
11239 
 
11240 
  def read(self, iprot):
11241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11243 
      return
11244 
    iprot.readStructBegin()
11245 
    while True:
11246 
      (fname, ftype, fid) = iprot.readFieldBegin()
11247 
      if ftype == TType.STOP:
11248 
        break
11249 
      if fid == 0:
11250 
        if ftype == TType.STRUCT:
11251 
          self.success = ReturnOrder()
11252 
          self.success.read(iprot)
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      elif fid == 1:
11256 
        if ftype == TType.STRUCT:
11257 
          self.ex = TransactionServiceException()
11258 
          self.ex.read(iprot)
11259 
        else:
11260 
          iprot.skip(ftype)
11261 
      else:
11262 
        iprot.skip(ftype)
11263 
      iprot.readFieldEnd()
11264 
    iprot.readStructEnd()
11265 
 
11266 
  def write(self, oprot):
11267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11269 
      return
11270 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11271 
    if self.success is not None:
2700 chandransh 11272 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11273 
      self.success.write(oprot)
11274 
      oprot.writeFieldEnd()
3431 rajveer 11275 
    if self.ex is not None:
2700 chandransh 11276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11277 
      self.ex.write(oprot)
11278 
      oprot.writeFieldEnd()
11279 
    oprot.writeFieldStop()
11280 
    oprot.writeStructEnd()
11281 
 
3431 rajveer 11282 
  def validate(self):
11283 
    return
11284 
 
11285 
 
2700 chandransh 11286 
  def __repr__(self):
11287 
    L = ['%s=%r' % (key, value)
11288 
      for key, value in self.__dict__.iteritems()]
11289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11290 
 
11291 
  def __eq__(self, other):
11292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11293 
 
11294 
  def __ne__(self, other):
11295 
    return not (self == other)
11296 
 
2690 chandransh 11297 
class processReturn_args:
11298 
  """
11299 
  Attributes:
11300 
   - returnOrderId
11301 
  """
11302 
 
11303 
  thrift_spec = (
11304 
    None, # 0
11305 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11306 
  )
11307 
 
11308 
  def __init__(self, returnOrderId=None,):
11309 
    self.returnOrderId = returnOrderId
11310 
 
11311 
  def read(self, iprot):
11312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11314 
      return
11315 
    iprot.readStructBegin()
11316 
    while True:
11317 
      (fname, ftype, fid) = iprot.readFieldBegin()
11318 
      if ftype == TType.STOP:
11319 
        break
11320 
      if fid == 1:
11321 
        if ftype == TType.I64:
11322 
          self.returnOrderId = iprot.readI64();
11323 
        else:
11324 
          iprot.skip(ftype)
11325 
      else:
11326 
        iprot.skip(ftype)
11327 
      iprot.readFieldEnd()
11328 
    iprot.readStructEnd()
11329 
 
11330 
  def write(self, oprot):
11331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11333 
      return
11334 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11335 
    if self.returnOrderId is not None:
2690 chandransh 11336 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11337 
      oprot.writeI64(self.returnOrderId)
11338 
      oprot.writeFieldEnd()
11339 
    oprot.writeFieldStop()
11340 
    oprot.writeStructEnd()
11341 
 
3431 rajveer 11342 
  def validate(self):
11343 
    return
11344 
 
11345 
 
2690 chandransh 11346 
  def __repr__(self):
11347 
    L = ['%s=%r' % (key, value)
11348 
      for key, value in self.__dict__.iteritems()]
11349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11350 
 
11351 
  def __eq__(self, other):
11352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11353 
 
11354 
  def __ne__(self, other):
11355 
    return not (self == other)
11356 
 
11357 
class processReturn_result:
11358 
  """
11359 
  Attributes:
11360 
   - ex
11361 
  """
11362 
 
11363 
  thrift_spec = (
11364 
    None, # 0
11365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11366 
  )
11367 
 
11368 
  def __init__(self, ex=None,):
11369 
    self.ex = ex
11370 
 
11371 
  def read(self, iprot):
11372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11374 
      return
11375 
    iprot.readStructBegin()
11376 
    while True:
11377 
      (fname, ftype, fid) = iprot.readFieldBegin()
11378 
      if ftype == TType.STOP:
11379 
        break
11380 
      if fid == 1:
11381 
        if ftype == TType.STRUCT:
11382 
          self.ex = TransactionServiceException()
11383 
          self.ex.read(iprot)
11384 
        else:
11385 
          iprot.skip(ftype)
11386 
      else:
11387 
        iprot.skip(ftype)
11388 
      iprot.readFieldEnd()
11389 
    iprot.readStructEnd()
11390 
 
11391 
  def write(self, oprot):
11392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11394 
      return
11395 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11396 
    if self.ex is not None:
2690 chandransh 11397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11398 
      self.ex.write(oprot)
11399 
      oprot.writeFieldEnd()
11400 
    oprot.writeFieldStop()
11401 
    oprot.writeStructEnd()
11402 
 
3431 rajveer 11403 
  def validate(self):
11404 
    return
11405 
 
11406 
 
2690 chandransh 11407 
  def __repr__(self):
11408 
    L = ['%s=%r' % (key, value)
11409 
      for key, value in self.__dict__.iteritems()]
11410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11411 
 
11412 
  def __eq__(self, other):
11413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11414 
 
11415 
  def __ne__(self, other):
11416 
    return not (self == other)
11417 
 
2819 chandransh 11418 
class createPurchaseOrder_args:
11419 
  """
11420 
  Attributes:
11421 
   - warehouseId
11422 
  """
2690 chandransh 11423 
 
2819 chandransh 11424 
  thrift_spec = (
11425 
    None, # 0
11426 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11427 
  )
11428 
 
11429 
  def __init__(self, warehouseId=None,):
11430 
    self.warehouseId = warehouseId
11431 
 
11432 
  def read(self, iprot):
11433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11435 
      return
11436 
    iprot.readStructBegin()
11437 
    while True:
11438 
      (fname, ftype, fid) = iprot.readFieldBegin()
11439 
      if ftype == TType.STOP:
11440 
        break
11441 
      if fid == 1:
11442 
        if ftype == TType.I64:
11443 
          self.warehouseId = iprot.readI64();
11444 
        else:
11445 
          iprot.skip(ftype)
11446 
      else:
11447 
        iprot.skip(ftype)
11448 
      iprot.readFieldEnd()
11449 
    iprot.readStructEnd()
11450 
 
11451 
  def write(self, oprot):
11452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11454 
      return
11455 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11456 
    if self.warehouseId is not None:
2819 chandransh 11457 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11458 
      oprot.writeI64(self.warehouseId)
11459 
      oprot.writeFieldEnd()
11460 
    oprot.writeFieldStop()
11461 
    oprot.writeStructEnd()
11462 
 
3431 rajveer 11463 
  def validate(self):
11464 
    return
11465 
 
11466 
 
2819 chandransh 11467 
  def __repr__(self):
11468 
    L = ['%s=%r' % (key, value)
11469 
      for key, value in self.__dict__.iteritems()]
11470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11471 
 
11472 
  def __eq__(self, other):
11473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11474 
 
11475 
  def __ne__(self, other):
11476 
    return not (self == other)
11477 
 
11478 
class createPurchaseOrder_result:
11479 
  """
11480 
  Attributes:
11481 
   - success
11482 
   - ex
11483 
  """
11484 
 
11485 
  thrift_spec = (
11486 
    (0, TType.I64, 'success', None, None, ), # 0
11487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11488 
  )
11489 
 
11490 
  def __init__(self, success=None, ex=None,):
11491 
    self.success = success
11492 
    self.ex = ex
11493 
 
11494 
  def read(self, iprot):
11495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11497 
      return
11498 
    iprot.readStructBegin()
11499 
    while True:
11500 
      (fname, ftype, fid) = iprot.readFieldBegin()
11501 
      if ftype == TType.STOP:
11502 
        break
11503 
      if fid == 0:
11504 
        if ftype == TType.I64:
11505 
          self.success = iprot.readI64();
11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      elif fid == 1:
11509 
        if ftype == TType.STRUCT:
11510 
          self.ex = TransactionServiceException()
11511 
          self.ex.read(iprot)
11512 
        else:
11513 
          iprot.skip(ftype)
11514 
      else:
11515 
        iprot.skip(ftype)
11516 
      iprot.readFieldEnd()
11517 
    iprot.readStructEnd()
11518 
 
11519 
  def write(self, oprot):
11520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11522 
      return
11523 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11524 
    if self.success is not None:
2819 chandransh 11525 
      oprot.writeFieldBegin('success', TType.I64, 0)
11526 
      oprot.writeI64(self.success)
11527 
      oprot.writeFieldEnd()
3431 rajveer 11528 
    if self.ex is not None:
2819 chandransh 11529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11530 
      self.ex.write(oprot)
11531 
      oprot.writeFieldEnd()
11532 
    oprot.writeFieldStop()
11533 
    oprot.writeStructEnd()
11534 
 
3431 rajveer 11535 
  def validate(self):
11536 
    return
11537 
 
11538 
 
2819 chandransh 11539 
  def __repr__(self):
11540 
    L = ['%s=%r' % (key, value)
11541 
      for key, value in self.__dict__.iteritems()]
11542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11543 
 
11544 
  def __eq__(self, other):
11545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11546 
 
11547 
  def __ne__(self, other):
11548 
    return not (self == other)
3451 chandransh 11549 
 
11550 
class updateWeight_args:
11551 
  """
11552 
  Attributes:
11553 
   - orderId
11554 
   - weight
11555 
  """
11556 
 
11557 
  thrift_spec = (
11558 
    None, # 0
11559 
    (1, TType.I64, 'orderId', None, None, ), # 1
11560 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11561 
  )
11562 
 
11563 
  def __init__(self, orderId=None, weight=None,):
11564 
    self.orderId = orderId
11565 
    self.weight = weight
11566 
 
11567 
  def read(self, iprot):
11568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11570 
      return
11571 
    iprot.readStructBegin()
11572 
    while True:
11573 
      (fname, ftype, fid) = iprot.readFieldBegin()
11574 
      if ftype == TType.STOP:
11575 
        break
11576 
      if fid == 1:
11577 
        if ftype == TType.I64:
11578 
          self.orderId = iprot.readI64();
11579 
        else:
11580 
          iprot.skip(ftype)
11581 
      elif fid == 2:
11582 
        if ftype == TType.DOUBLE:
11583 
          self.weight = iprot.readDouble();
11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      else:
11587 
        iprot.skip(ftype)
11588 
      iprot.readFieldEnd()
11589 
    iprot.readStructEnd()
11590 
 
11591 
  def write(self, oprot):
11592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11594 
      return
11595 
    oprot.writeStructBegin('updateWeight_args')
11596 
    if self.orderId is not None:
11597 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11598 
      oprot.writeI64(self.orderId)
11599 
      oprot.writeFieldEnd()
11600 
    if self.weight is not None:
11601 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11602 
      oprot.writeDouble(self.weight)
11603 
      oprot.writeFieldEnd()
11604 
    oprot.writeFieldStop()
11605 
    oprot.writeStructEnd()
11606 
 
11607 
  def validate(self):
11608 
    return
11609 
 
11610 
 
11611 
  def __repr__(self):
11612 
    L = ['%s=%r' % (key, value)
11613 
      for key, value in self.__dict__.iteritems()]
11614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11615 
 
11616 
  def __eq__(self, other):
11617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11618 
 
11619 
  def __ne__(self, other):
11620 
    return not (self == other)
11621 
 
11622 
class updateWeight_result:
11623 
  """
11624 
  Attributes:
11625 
   - success
11626 
   - ex
11627 
  """
11628 
 
11629 
  thrift_spec = (
11630 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11632 
  )
11633 
 
11634 
  def __init__(self, success=None, ex=None,):
11635 
    self.success = success
11636 
    self.ex = ex
11637 
 
11638 
  def read(self, iprot):
11639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11641 
      return
11642 
    iprot.readStructBegin()
11643 
    while True:
11644 
      (fname, ftype, fid) = iprot.readFieldBegin()
11645 
      if ftype == TType.STOP:
11646 
        break
11647 
      if fid == 0:
11648 
        if ftype == TType.STRUCT:
11649 
          self.success = Order()
11650 
          self.success.read(iprot)
11651 
        else:
11652 
          iprot.skip(ftype)
11653 
      elif fid == 1:
11654 
        if ftype == TType.STRUCT:
11655 
          self.ex = TransactionServiceException()
11656 
          self.ex.read(iprot)
11657 
        else:
11658 
          iprot.skip(ftype)
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('updateWeight_result')
11669 
    if self.success is not None:
11670 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11671 
      self.success.write(oprot)
11672 
      oprot.writeFieldEnd()
11673 
    if self.ex is not None:
11674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11675 
      self.ex.write(oprot)
11676 
      oprot.writeFieldEnd()
11677 
    oprot.writeFieldStop()
11678 
    oprot.writeStructEnd()
11679 
 
11680 
  def validate(self):
11681 
    return
11682 
 
11683 
 
11684 
  def __repr__(self):
11685 
    L = ['%s=%r' % (key, value)
11686 
      for key, value in self.__dict__.iteritems()]
11687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11688 
 
11689 
  def __eq__(self, other):
11690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11691 
 
11692 
  def __ne__(self, other):
11693 
    return not (self == other)
3469 chandransh 11694 
 
11695 
class changeItem_args:
11696 
  """
11697 
  Attributes:
11698 
   - orderId
11699 
   - itemId
11700 
  """
11701 
 
11702 
  thrift_spec = (
11703 
    None, # 0
11704 
    (1, TType.I64, 'orderId', None, None, ), # 1
11705 
    (2, TType.I64, 'itemId', None, None, ), # 2
11706 
  )
11707 
 
11708 
  def __init__(self, orderId=None, itemId=None,):
11709 
    self.orderId = orderId
11710 
    self.itemId = itemId
11711 
 
11712 
  def read(self, iprot):
11713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11715 
      return
11716 
    iprot.readStructBegin()
11717 
    while True:
11718 
      (fname, ftype, fid) = iprot.readFieldBegin()
11719 
      if ftype == TType.STOP:
11720 
        break
11721 
      if fid == 1:
11722 
        if ftype == TType.I64:
11723 
          self.orderId = iprot.readI64();
11724 
        else:
11725 
          iprot.skip(ftype)
11726 
      elif fid == 2:
11727 
        if ftype == TType.I64:
11728 
          self.itemId = iprot.readI64();
11729 
        else:
11730 
          iprot.skip(ftype)
11731 
      else:
11732 
        iprot.skip(ftype)
11733 
      iprot.readFieldEnd()
11734 
    iprot.readStructEnd()
11735 
 
11736 
  def write(self, oprot):
11737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11739 
      return
11740 
    oprot.writeStructBegin('changeItem_args')
11741 
    if self.orderId is not None:
11742 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11743 
      oprot.writeI64(self.orderId)
11744 
      oprot.writeFieldEnd()
11745 
    if self.itemId is not None:
11746 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11747 
      oprot.writeI64(self.itemId)
11748 
      oprot.writeFieldEnd()
11749 
    oprot.writeFieldStop()
11750 
    oprot.writeStructEnd()
11751 
 
11752 
  def validate(self):
11753 
    return
11754 
 
11755 
 
11756 
  def __repr__(self):
11757 
    L = ['%s=%r' % (key, value)
11758 
      for key, value in self.__dict__.iteritems()]
11759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11760 
 
11761 
  def __eq__(self, other):
11762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11763 
 
11764 
  def __ne__(self, other):
11765 
    return not (self == other)
11766 
 
11767 
class changeItem_result:
11768 
  """
11769 
  Attributes:
11770 
   - success
11771 
   - ex
11772 
  """
11773 
 
11774 
  thrift_spec = (
11775 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11777 
  )
11778 
 
11779 
  def __init__(self, success=None, ex=None,):
11780 
    self.success = success
11781 
    self.ex = ex
11782 
 
11783 
  def read(self, iprot):
11784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11786 
      return
11787 
    iprot.readStructBegin()
11788 
    while True:
11789 
      (fname, ftype, fid) = iprot.readFieldBegin()
11790 
      if ftype == TType.STOP:
11791 
        break
11792 
      if fid == 0:
11793 
        if ftype == TType.STRUCT:
11794 
          self.success = Order()
11795 
          self.success.read(iprot)
11796 
        else:
11797 
          iprot.skip(ftype)
11798 
      elif fid == 1:
11799 
        if ftype == TType.STRUCT:
11800 
          self.ex = TransactionServiceException()
11801 
          self.ex.read(iprot)
11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
11813 
    oprot.writeStructBegin('changeItem_result')
11814 
    if self.success is not None:
11815 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11816 
      self.success.write(oprot)
11817 
      oprot.writeFieldEnd()
11818 
    if self.ex is not None:
11819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11820 
      self.ex.write(oprot)
11821 
      oprot.writeFieldEnd()
11822 
    oprot.writeFieldStop()
11823 
    oprot.writeStructEnd()
11824 
 
11825 
  def validate(self):
11826 
    return
11827 
 
11828 
 
11829 
  def __repr__(self):
11830 
    L = ['%s=%r' % (key, value)
11831 
      for key, value in self.__dict__.iteritems()]
11832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11833 
 
11834 
  def __eq__(self, other):
11835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11836 
 
11837 
  def __ne__(self, other):
11838 
    return not (self == other)
11839 
 
11840 
class shiftToWarehouse_args:
11841 
  """
11842 
  Attributes:
11843 
   - orderId
11844 
   - warehouseId
11845 
  """
11846 
 
11847 
  thrift_spec = (
11848 
    None, # 0
11849 
    (1, TType.I64, 'orderId', None, None, ), # 1
11850 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11851 
  )
11852 
 
11853 
  def __init__(self, orderId=None, warehouseId=None,):
11854 
    self.orderId = orderId
11855 
    self.warehouseId = warehouseId
11856 
 
11857 
  def read(self, iprot):
11858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11860 
      return
11861 
    iprot.readStructBegin()
11862 
    while True:
11863 
      (fname, ftype, fid) = iprot.readFieldBegin()
11864 
      if ftype == TType.STOP:
11865 
        break
11866 
      if fid == 1:
11867 
        if ftype == TType.I64:
11868 
          self.orderId = iprot.readI64();
11869 
        else:
11870 
          iprot.skip(ftype)
11871 
      elif fid == 2:
11872 
        if ftype == TType.I64:
11873 
          self.warehouseId = iprot.readI64();
11874 
        else:
11875 
          iprot.skip(ftype)
11876 
      else:
11877 
        iprot.skip(ftype)
11878 
      iprot.readFieldEnd()
11879 
    iprot.readStructEnd()
11880 
 
11881 
  def write(self, oprot):
11882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11884 
      return
11885 
    oprot.writeStructBegin('shiftToWarehouse_args')
11886 
    if self.orderId is not None:
11887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11888 
      oprot.writeI64(self.orderId)
11889 
      oprot.writeFieldEnd()
11890 
    if self.warehouseId is not None:
11891 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11892 
      oprot.writeI64(self.warehouseId)
11893 
      oprot.writeFieldEnd()
11894 
    oprot.writeFieldStop()
11895 
    oprot.writeStructEnd()
11896 
 
11897 
  def validate(self):
11898 
    return
11899 
 
11900 
 
11901 
  def __repr__(self):
11902 
    L = ['%s=%r' % (key, value)
11903 
      for key, value in self.__dict__.iteritems()]
11904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11905 
 
11906 
  def __eq__(self, other):
11907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11908 
 
11909 
  def __ne__(self, other):
11910 
    return not (self == other)
11911 
 
11912 
class shiftToWarehouse_result:
11913 
  """
11914 
  Attributes:
11915 
   - success
11916 
   - ex
11917 
  """
11918 
 
11919 
  thrift_spec = (
11920 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11922 
  )
11923 
 
11924 
  def __init__(self, success=None, ex=None,):
11925 
    self.success = success
11926 
    self.ex = ex
11927 
 
11928 
  def read(self, iprot):
11929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11931 
      return
11932 
    iprot.readStructBegin()
11933 
    while True:
11934 
      (fname, ftype, fid) = iprot.readFieldBegin()
11935 
      if ftype == TType.STOP:
11936 
        break
11937 
      if fid == 0:
11938 
        if ftype == TType.STRUCT:
11939 
          self.success = Order()
11940 
          self.success.read(iprot)
11941 
        else:
11942 
          iprot.skip(ftype)
11943 
      elif fid == 1:
11944 
        if ftype == TType.STRUCT:
11945 
          self.ex = TransactionServiceException()
11946 
          self.ex.read(iprot)
11947 
        else:
11948 
          iprot.skip(ftype)
11949 
      else:
11950 
        iprot.skip(ftype)
11951 
      iprot.readFieldEnd()
11952 
    iprot.readStructEnd()
11953 
 
11954 
  def write(self, oprot):
11955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11957 
      return
11958 
    oprot.writeStructBegin('shiftToWarehouse_result')
11959 
    if self.success is not None:
11960 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11961 
      self.success.write(oprot)
11962 
      oprot.writeFieldEnd()
11963 
    if self.ex is not None:
11964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11965 
      self.ex.write(oprot)
11966 
      oprot.writeFieldEnd()
11967 
    oprot.writeFieldStop()
11968 
    oprot.writeStructEnd()
11969 
 
11970 
  def validate(self):
11971 
    return
11972 
 
11973 
 
11974 
  def __repr__(self):
11975 
    L = ['%s=%r' % (key, value)
11976 
      for key, value in self.__dict__.iteritems()]
11977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11978 
 
11979 
  def __eq__(self, other):
11980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11981 
 
11982 
  def __ne__(self, other):
11983 
    return not (self == other)
3553 chandransh 11984 
 
11985 
class addDelayReason_args:
11986 
  """
11987 
  Attributes:
11988 
   - orderId
11989 
   - delayReason
3986 chandransh 11990 
   - furtherDelay
3553 chandransh 11991 
  """
11992 
 
11993 
  thrift_spec = (
11994 
    None, # 0
11995 
    (1, TType.I64, 'orderId', None, None, ), # 1
11996 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11997 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11998 
  )
11999 
 
3986 chandransh 12000 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12001 
    self.orderId = orderId
12002 
    self.delayReason = delayReason
3986 chandransh 12003 
    self.furtherDelay = furtherDelay
3553 chandransh 12004 
 
12005 
  def read(self, iprot):
12006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12008 
      return
12009 
    iprot.readStructBegin()
12010 
    while True:
12011 
      (fname, ftype, fid) = iprot.readFieldBegin()
12012 
      if ftype == TType.STOP:
12013 
        break
12014 
      if fid == 1:
12015 
        if ftype == TType.I64:
12016 
          self.orderId = iprot.readI64();
12017 
        else:
12018 
          iprot.skip(ftype)
12019 
      elif fid == 2:
12020 
        if ftype == TType.I32:
12021 
          self.delayReason = iprot.readI32();
12022 
        else:
12023 
          iprot.skip(ftype)
3986 chandransh 12024 
      elif fid == 3:
12025 
        if ftype == TType.I64:
12026 
          self.furtherDelay = iprot.readI64();
12027 
        else:
12028 
          iprot.skip(ftype)
3553 chandransh 12029 
      else:
12030 
        iprot.skip(ftype)
12031 
      iprot.readFieldEnd()
12032 
    iprot.readStructEnd()
12033 
 
12034 
  def write(self, oprot):
12035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12037 
      return
12038 
    oprot.writeStructBegin('addDelayReason_args')
12039 
    if self.orderId is not None:
12040 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12041 
      oprot.writeI64(self.orderId)
12042 
      oprot.writeFieldEnd()
12043 
    if self.delayReason is not None:
12044 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12045 
      oprot.writeI32(self.delayReason)
12046 
      oprot.writeFieldEnd()
3986 chandransh 12047 
    if self.furtherDelay is not None:
12048 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12049 
      oprot.writeI64(self.furtherDelay)
12050 
      oprot.writeFieldEnd()
3553 chandransh 12051 
    oprot.writeFieldStop()
12052 
    oprot.writeStructEnd()
12053 
 
12054 
  def validate(self):
12055 
    return
12056 
 
12057 
 
12058 
  def __repr__(self):
12059 
    L = ['%s=%r' % (key, value)
12060 
      for key, value in self.__dict__.iteritems()]
12061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12062 
 
12063 
  def __eq__(self, other):
12064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12065 
 
12066 
  def __ne__(self, other):
12067 
    return not (self == other)
12068 
 
12069 
class addDelayReason_result:
12070 
  """
12071 
  Attributes:
12072 
   - success
12073 
   - ex
12074 
  """
12075 
 
12076 
  thrift_spec = (
12077 
    (0, TType.BOOL, 'success', None, None, ), # 0
12078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12079 
  )
12080 
 
12081 
  def __init__(self, success=None, ex=None,):
12082 
    self.success = success
12083 
    self.ex = ex
12084 
 
12085 
  def read(self, iprot):
12086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12088 
      return
12089 
    iprot.readStructBegin()
12090 
    while True:
12091 
      (fname, ftype, fid) = iprot.readFieldBegin()
12092 
      if ftype == TType.STOP:
12093 
        break
12094 
      if fid == 0:
12095 
        if ftype == TType.BOOL:
12096 
          self.success = iprot.readBool();
12097 
        else:
12098 
          iprot.skip(ftype)
12099 
      elif fid == 1:
12100 
        if ftype == TType.STRUCT:
12101 
          self.ex = TransactionServiceException()
12102 
          self.ex.read(iprot)
12103 
        else:
12104 
          iprot.skip(ftype)
12105 
      else:
12106 
        iprot.skip(ftype)
12107 
      iprot.readFieldEnd()
12108 
    iprot.readStructEnd()
12109 
 
12110 
  def write(self, oprot):
12111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12113 
      return
12114 
    oprot.writeStructBegin('addDelayReason_result')
12115 
    if self.success is not None:
12116 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12117 
      oprot.writeBool(self.success)
12118 
      oprot.writeFieldEnd()
12119 
    if self.ex is not None:
12120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12121 
      self.ex.write(oprot)
12122 
      oprot.writeFieldEnd()
12123 
    oprot.writeFieldStop()
12124 
    oprot.writeStructEnd()
12125 
 
12126 
  def validate(self):
12127 
    return
12128 
 
12129 
 
12130 
  def __repr__(self):
12131 
    L = ['%s=%r' % (key, value)
12132 
      for key, value in self.__dict__.iteritems()]
12133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12134 
 
12135 
  def __eq__(self, other):
12136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12137 
 
12138 
  def __ne__(self, other):
12139 
    return not (self == other)
3956 chandransh 12140 
 
12141 
class reconcileCodCollection_args:
12142 
  """
12143 
  Attributes:
12144 
   - collectedAmountMap
12145 
   - xferBy
12146 
   - xferTxnId
12147 
   - xferDate
12148 
  """
12149 
 
12150 
  thrift_spec = (
12151 
    None, # 0
12152 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12153 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12154 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12155 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12156 
  )
12157 
 
12158 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12159 
    self.collectedAmountMap = collectedAmountMap
12160 
    self.xferBy = xferBy
12161 
    self.xferTxnId = xferTxnId
12162 
    self.xferDate = xferDate
12163 
 
12164 
  def read(self, iprot):
12165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12167 
      return
12168 
    iprot.readStructBegin()
12169 
    while True:
12170 
      (fname, ftype, fid) = iprot.readFieldBegin()
12171 
      if ftype == TType.STOP:
12172 
        break
12173 
      if fid == 1:
12174 
        if ftype == TType.MAP:
12175 
          self.collectedAmountMap = {}
4133 chandransh 12176 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12177 
          for _i217 in xrange(_size213):
12178 
            _key218 = iprot.readString();
12179 
            _val219 = iprot.readDouble();
12180 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12181 
          iprot.readMapEnd()
12182 
        else:
12183 
          iprot.skip(ftype)
12184 
      elif fid == 2:
12185 
        if ftype == TType.STRING:
12186 
          self.xferBy = iprot.readString();
12187 
        else:
12188 
          iprot.skip(ftype)
12189 
      elif fid == 3:
12190 
        if ftype == TType.STRING:
12191 
          self.xferTxnId = iprot.readString();
12192 
        else:
12193 
          iprot.skip(ftype)
12194 
      elif fid == 4:
12195 
        if ftype == TType.I64:
12196 
          self.xferDate = iprot.readI64();
12197 
        else:
12198 
          iprot.skip(ftype)
12199 
      else:
12200 
        iprot.skip(ftype)
12201 
      iprot.readFieldEnd()
12202 
    iprot.readStructEnd()
12203 
 
12204 
  def write(self, oprot):
12205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12207 
      return
12208 
    oprot.writeStructBegin('reconcileCodCollection_args')
12209 
    if self.collectedAmountMap is not None:
12210 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12211 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12212 
      for kiter220,viter221 in self.collectedAmountMap.items():
12213 
        oprot.writeString(kiter220)
12214 
        oprot.writeDouble(viter221)
3956 chandransh 12215 
      oprot.writeMapEnd()
12216 
      oprot.writeFieldEnd()
12217 
    if self.xferBy is not None:
12218 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12219 
      oprot.writeString(self.xferBy)
12220 
      oprot.writeFieldEnd()
12221 
    if self.xferTxnId is not None:
12222 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12223 
      oprot.writeString(self.xferTxnId)
12224 
      oprot.writeFieldEnd()
12225 
    if self.xferDate is not None:
12226 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12227 
      oprot.writeI64(self.xferDate)
12228 
      oprot.writeFieldEnd()
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
12247 
class reconcileCodCollection_result:
12248 
  """
12249 
  Attributes:
12250 
   - success
12251 
   - ex
12252 
  """
12253 
 
12254 
  thrift_spec = (
12255 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12257 
  )
12258 
 
12259 
  def __init__(self, success=None, ex=None,):
12260 
    self.success = success
12261 
    self.ex = ex
12262 
 
12263 
  def read(self, iprot):
12264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12266 
      return
12267 
    iprot.readStructBegin()
12268 
    while True:
12269 
      (fname, ftype, fid) = iprot.readFieldBegin()
12270 
      if ftype == TType.STOP:
12271 
        break
12272 
      if fid == 0:
12273 
        if ftype == TType.MAP:
12274 
          self.success = {}
4133 chandransh 12275 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12276 
          for _i226 in xrange(_size222):
12277 
            _key227 = iprot.readString();
12278 
            _val228 = iprot.readString();
12279 
            self.success[_key227] = _val228
3956 chandransh 12280 
          iprot.readMapEnd()
12281 
        else:
12282 
          iprot.skip(ftype)
12283 
      elif fid == 1:
12284 
        if ftype == TType.STRUCT:
12285 
          self.ex = TransactionServiceException()
12286 
          self.ex.read(iprot)
12287 
        else:
12288 
          iprot.skip(ftype)
12289 
      else:
12290 
        iprot.skip(ftype)
12291 
      iprot.readFieldEnd()
12292 
    iprot.readStructEnd()
12293 
 
12294 
  def write(self, oprot):
12295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12297 
      return
12298 
    oprot.writeStructBegin('reconcileCodCollection_result')
12299 
    if self.success is not None:
12300 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12301 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12302 
      for kiter229,viter230 in self.success.items():
12303 
        oprot.writeString(kiter229)
12304 
        oprot.writeString(viter230)
3956 chandransh 12305 
      oprot.writeMapEnd()
12306 
      oprot.writeFieldEnd()
12307 
    if self.ex is not None:
12308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12309 
      self.ex.write(oprot)
12310 
      oprot.writeFieldEnd()
12311 
    oprot.writeFieldStop()
12312 
    oprot.writeStructEnd()
12313 
 
12314 
  def validate(self):
12315 
    return
12316 
 
12317 
 
12318 
  def __repr__(self):
12319 
    L = ['%s=%r' % (key, value)
12320 
      for key, value in self.__dict__.iteritems()]
12321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12322 
 
12323 
  def __eq__(self, other):
12324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12325 
 
12326 
  def __ne__(self, other):
12327 
    return not (self == other)
4008 mandeep.dh 12328 
 
12329 
class getTransactionsRequiringExtraProcessing_args:
12330 
  """
12331 
  Attributes:
12332 
   - category
12333 
  """
12334 
 
12335 
  thrift_spec = (
12336 
    None, # 0
12337 
    (1, TType.I32, 'category', None, None, ), # 1
12338 
  )
12339 
 
12340 
  def __init__(self, category=None,):
12341 
    self.category = category
12342 
 
12343 
  def read(self, iprot):
12344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12346 
      return
12347 
    iprot.readStructBegin()
12348 
    while True:
12349 
      (fname, ftype, fid) = iprot.readFieldBegin()
12350 
      if ftype == TType.STOP:
12351 
        break
12352 
      if fid == 1:
12353 
        if ftype == TType.I32:
12354 
          self.category = iprot.readI32();
12355 
        else:
12356 
          iprot.skip(ftype)
12357 
      else:
12358 
        iprot.skip(ftype)
12359 
      iprot.readFieldEnd()
12360 
    iprot.readStructEnd()
12361 
 
12362 
  def write(self, oprot):
12363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12365 
      return
12366 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12367 
    if self.category is not None:
12368 
      oprot.writeFieldBegin('category', TType.I32, 1)
12369 
      oprot.writeI32(self.category)
12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
12374 
  def validate(self):
12375 
    return
12376 
 
12377 
 
12378 
  def __repr__(self):
12379 
    L = ['%s=%r' % (key, value)
12380 
      for key, value in self.__dict__.iteritems()]
12381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12382 
 
12383 
  def __eq__(self, other):
12384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12385 
 
12386 
  def __ne__(self, other):
12387 
    return not (self == other)
12388 
 
12389 
class getTransactionsRequiringExtraProcessing_result:
12390 
  """
12391 
  Attributes:
12392 
   - success
12393 
  """
12394 
 
12395 
  thrift_spec = (
12396 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12397 
  )
12398 
 
12399 
  def __init__(self, success=None,):
12400 
    self.success = success
12401 
 
12402 
  def read(self, iprot):
12403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12405 
      return
12406 
    iprot.readStructBegin()
12407 
    while True:
12408 
      (fname, ftype, fid) = iprot.readFieldBegin()
12409 
      if ftype == TType.STOP:
12410 
        break
12411 
      if fid == 0:
12412 
        if ftype == TType.LIST:
12413 
          self.success = []
4133 chandransh 12414 
          (_etype234, _size231) = iprot.readListBegin()
12415 
          for _i235 in xrange(_size231):
12416 
            _elem236 = iprot.readI64();
12417 
            self.success.append(_elem236)
4008 mandeep.dh 12418 
          iprot.readListEnd()
12419 
        else:
12420 
          iprot.skip(ftype)
12421 
      else:
12422 
        iprot.skip(ftype)
12423 
      iprot.readFieldEnd()
12424 
    iprot.readStructEnd()
12425 
 
12426 
  def write(self, oprot):
12427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12429 
      return
12430 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12431 
    if self.success is not None:
12432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12433 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12434 
      for iter237 in self.success:
12435 
        oprot.writeI64(iter237)
4008 mandeep.dh 12436 
      oprot.writeListEnd()
12437 
      oprot.writeFieldEnd()
12438 
    oprot.writeFieldStop()
12439 
    oprot.writeStructEnd()
12440 
 
12441 
  def validate(self):
12442 
    return
12443 
 
12444 
 
12445 
  def __repr__(self):
12446 
    L = ['%s=%r' % (key, value)
12447 
      for key, value in self.__dict__.iteritems()]
12448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12449 
 
12450 
  def __eq__(self, other):
12451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12452 
 
12453 
  def __ne__(self, other):
12454 
    return not (self == other)
12455 
 
12456 
class markTransactionAsProcessed_args:
12457 
  """
12458 
  Attributes:
12459 
   - transactionId
12460 
   - category
12461 
  """
12462 
 
12463 
  thrift_spec = (
12464 
    None, # 0
12465 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12466 
    (2, TType.I32, 'category', None, None, ), # 2
12467 
  )
12468 
 
12469 
  def __init__(self, transactionId=None, category=None,):
12470 
    self.transactionId = transactionId
12471 
    self.category = category
12472 
 
12473 
  def read(self, iprot):
12474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12476 
      return
12477 
    iprot.readStructBegin()
12478 
    while True:
12479 
      (fname, ftype, fid) = iprot.readFieldBegin()
12480 
      if ftype == TType.STOP:
12481 
        break
12482 
      if fid == 1:
12483 
        if ftype == TType.I64:
12484 
          self.transactionId = iprot.readI64();
12485 
        else:
12486 
          iprot.skip(ftype)
12487 
      elif fid == 2:
12488 
        if ftype == TType.I32:
12489 
          self.category = iprot.readI32();
12490 
        else:
12491 
          iprot.skip(ftype)
12492 
      else:
12493 
        iprot.skip(ftype)
12494 
      iprot.readFieldEnd()
12495 
    iprot.readStructEnd()
12496 
 
12497 
  def write(self, oprot):
12498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12500 
      return
12501 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12502 
    if self.transactionId is not None:
12503 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12504 
      oprot.writeI64(self.transactionId)
12505 
      oprot.writeFieldEnd()
12506 
    if self.category is not None:
12507 
      oprot.writeFieldBegin('category', TType.I32, 2)
12508 
      oprot.writeI32(self.category)
12509 
      oprot.writeFieldEnd()
12510 
    oprot.writeFieldStop()
12511 
    oprot.writeStructEnd()
12512 
 
12513 
  def validate(self):
12514 
    return
12515 
 
12516 
 
12517 
  def __repr__(self):
12518 
    L = ['%s=%r' % (key, value)
12519 
      for key, value in self.__dict__.iteritems()]
12520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12521 
 
12522 
  def __eq__(self, other):
12523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12524 
 
12525 
  def __ne__(self, other):
12526 
    return not (self == other)
12527 
 
12528 
class markTransactionAsProcessed_result:
12529 
 
12530 
  thrift_spec = (
12531 
  )
12532 
 
12533 
  def read(self, iprot):
12534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12536 
      return
12537 
    iprot.readStructBegin()
12538 
    while True:
12539 
      (fname, ftype, fid) = iprot.readFieldBegin()
12540 
      if ftype == TType.STOP:
12541 
        break
12542 
      else:
12543 
        iprot.skip(ftype)
12544 
      iprot.readFieldEnd()
12545 
    iprot.readStructEnd()
12546 
 
12547 
  def write(self, oprot):
12548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12550 
      return
12551 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12552 
    oprot.writeFieldStop()
12553 
    oprot.writeStructEnd()
12554 
 
12555 
  def validate(self):
12556 
    return
12557 
 
12558 
 
12559 
  def __repr__(self):
12560 
    L = ['%s=%r' % (key, value)
12561 
      for key, value in self.__dict__.iteritems()]
12562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12563 
 
12564 
  def __eq__(self, other):
12565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12566 
 
12567 
  def __ne__(self, other):
12568 
    return not (self == other)
4018 chandransh 12569 
 
12570 
class getItemWiseRiskyOrdersCount_args:
12571 
 
12572 
  thrift_spec = (
12573 
  )
12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
12584 
      else:
12585 
        iprot.skip(ftype)
12586 
      iprot.readFieldEnd()
12587 
    iprot.readStructEnd()
12588 
 
12589 
  def write(self, oprot):
12590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12592 
      return
12593 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
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)
12611 
 
12612 
class getItemWiseRiskyOrdersCount_result:
12613 
  """
12614 
  Attributes:
12615 
   - success
12616 
  """
12617 
 
12618 
  thrift_spec = (
12619 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12620 
  )
12621 
 
12622 
  def __init__(self, success=None,):
12623 
    self.success = success
12624 
 
12625 
  def read(self, iprot):
12626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12628 
      return
12629 
    iprot.readStructBegin()
12630 
    while True:
12631 
      (fname, ftype, fid) = iprot.readFieldBegin()
12632 
      if ftype == TType.STOP:
12633 
        break
12634 
      if fid == 0:
12635 
        if ftype == TType.MAP:
12636 
          self.success = {}
4133 chandransh 12637 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12638 
          for _i242 in xrange(_size238):
12639 
            _key243 = iprot.readI64();
12640 
            _val244 = iprot.readI64();
12641 
            self.success[_key243] = _val244
4018 chandransh 12642 
          iprot.readMapEnd()
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('getItemWiseRiskyOrdersCount_result')
12655 
    if self.success is not None:
12656 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12657 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12658 
      for kiter245,viter246 in self.success.items():
12659 
        oprot.writeI64(kiter245)
12660 
        oprot.writeI64(viter246)
4018 chandransh 12661 
      oprot.writeMapEnd()
12662 
      oprot.writeFieldEnd()
12663 
    oprot.writeFieldStop()
12664 
    oprot.writeStructEnd()
12665 
 
12666 
  def validate(self):
12667 
    return
12668 
 
12669 
 
12670 
  def __repr__(self):
12671 
    L = ['%s=%r' % (key, value)
12672 
      for key, value in self.__dict__.iteritems()]
12673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12674 
 
12675 
  def __eq__(self, other):
12676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12677 
 
12678 
  def __ne__(self, other):
12679 
    return not (self == other)
4247 rajveer 12680 
 
4295 varun.gupt 12681 
class getOrdersForItemIds_args:
12682 
  """
12683 
  Attributes:
12684 
   - itemIds
12685 
  """
12686 
 
12687 
  thrift_spec = (
12688 
    None, # 0
12689 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12690 
  )
12691 
 
12692 
  def __init__(self, itemIds=None,):
12693 
    self.itemIds = itemIds
12694 
 
12695 
  def read(self, iprot):
12696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12698 
      return
12699 
    iprot.readStructBegin()
12700 
    while True:
12701 
      (fname, ftype, fid) = iprot.readFieldBegin()
12702 
      if ftype == TType.STOP:
12703 
        break
12704 
      if fid == 1:
12705 
        if ftype == TType.LIST:
12706 
          self.itemIds = []
12707 
          (_etype250, _size247) = iprot.readListBegin()
12708 
          for _i251 in xrange(_size247):
12709 
            _elem252 = iprot.readI64();
12710 
            self.itemIds.append(_elem252)
12711 
          iprot.readListEnd()
12712 
        else:
12713 
          iprot.skip(ftype)
12714 
      else:
12715 
        iprot.skip(ftype)
12716 
      iprot.readFieldEnd()
12717 
    iprot.readStructEnd()
12718 
 
12719 
  def write(self, oprot):
12720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12722 
      return
12723 
    oprot.writeStructBegin('getOrdersForItemIds_args')
12724 
    if self.itemIds is not None:
12725 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12726 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12727 
      for iter253 in self.itemIds:
12728 
        oprot.writeI64(iter253)
12729 
      oprot.writeListEnd()
12730 
      oprot.writeFieldEnd()
12731 
    oprot.writeFieldStop()
12732 
    oprot.writeStructEnd()
12733 
 
12734 
  def validate(self):
12735 
    return
12736 
 
12737 
 
12738 
  def __repr__(self):
12739 
    L = ['%s=%r' % (key, value)
12740 
      for key, value in self.__dict__.iteritems()]
12741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12742 
 
12743 
  def __eq__(self, other):
12744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12745 
 
12746 
  def __ne__(self, other):
12747 
    return not (self == other)
12748 
 
12749 
class getOrdersForItemIds_result:
12750 
  """
12751 
  Attributes:
12752 
   - success
12753 
  """
12754 
 
12755 
  thrift_spec = (
12756 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12757 
  )
12758 
 
12759 
  def __init__(self, success=None,):
12760 
    self.success = success
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 == 0:
12772 
        if ftype == TType.LIST:
12773 
          self.success = []
12774 
          (_etype257, _size254) = iprot.readListBegin()
12775 
          for _i258 in xrange(_size254):
12776 
            _elem259 = Order()
12777 
            _elem259.read(iprot)
12778 
            self.success.append(_elem259)
12779 
          iprot.readListEnd()
12780 
        else:
12781 
          iprot.skip(ftype)
12782 
      else:
12783 
        iprot.skip(ftype)
12784 
      iprot.readFieldEnd()
12785 
    iprot.readStructEnd()
12786 
 
12787 
  def write(self, oprot):
12788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12790 
      return
12791 
    oprot.writeStructBegin('getOrdersForItemIds_result')
12792 
    if self.success is not None:
12793 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12794 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12795 
      for iter260 in self.success:
12796 
        iter260.write(oprot)
12797 
      oprot.writeListEnd()
12798 
      oprot.writeFieldEnd()
12799 
    oprot.writeFieldStop()
12800 
    oprot.writeStructEnd()
12801 
 
12802 
  def validate(self):
12803 
    return
12804 
 
12805 
 
12806 
  def __repr__(self):
12807 
    L = ['%s=%r' % (key, value)
12808 
      for key, value in self.__dict__.iteritems()]
12809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12810 
 
12811 
  def __eq__(self, other):
12812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12813 
 
12814 
  def __ne__(self, other):
12815 
    return not (self == other)
12816 
 
4247 rajveer 12817 
class markOrderCancellationRequestReceived_args:
12818 
  """
12819 
  Attributes:
12820 
   - orderId
12821 
  """
12822 
 
12823 
  thrift_spec = (
12824 
    None, # 0
12825 
    (1, TType.I64, 'orderId', None, None, ), # 1
12826 
  )
12827 
 
12828 
  def __init__(self, orderId=None,):
12829 
    self.orderId = orderId
12830 
 
12831 
  def read(self, iprot):
12832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12834 
      return
12835 
    iprot.readStructBegin()
12836 
    while True:
12837 
      (fname, ftype, fid) = iprot.readFieldBegin()
12838 
      if ftype == TType.STOP:
12839 
        break
12840 
      if fid == 1:
12841 
        if ftype == TType.I64:
12842 
          self.orderId = iprot.readI64();
12843 
        else:
12844 
          iprot.skip(ftype)
12845 
      else:
12846 
        iprot.skip(ftype)
12847 
      iprot.readFieldEnd()
12848 
    iprot.readStructEnd()
12849 
 
12850 
  def write(self, oprot):
12851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12853 
      return
12854 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12855 
    if self.orderId is not None:
12856 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12857 
      oprot.writeI64(self.orderId)
12858 
      oprot.writeFieldEnd()
12859 
    oprot.writeFieldStop()
12860 
    oprot.writeStructEnd()
12861 
 
12862 
  def validate(self):
12863 
    return
12864 
 
12865 
 
12866 
  def __repr__(self):
12867 
    L = ['%s=%r' % (key, value)
12868 
      for key, value in self.__dict__.iteritems()]
12869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12870 
 
12871 
  def __eq__(self, other):
12872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12873 
 
12874 
  def __ne__(self, other):
12875 
    return not (self == other)
12876 
 
12877 
class markOrderCancellationRequestReceived_result:
12878 
  """
12879 
  Attributes:
12880 
   - ex
12881 
  """
12882 
 
12883 
  thrift_spec = (
12884 
    None, # 0
12885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12886 
  )
12887 
 
12888 
  def __init__(self, ex=None,):
12889 
    self.ex = ex
12890 
 
12891 
  def read(self, iprot):
12892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12894 
      return
12895 
    iprot.readStructBegin()
12896 
    while True:
12897 
      (fname, ftype, fid) = iprot.readFieldBegin()
12898 
      if ftype == TType.STOP:
12899 
        break
12900 
      if fid == 1:
12901 
        if ftype == TType.STRUCT:
12902 
          self.ex = TransactionServiceException()
12903 
          self.ex.read(iprot)
12904 
        else:
12905 
          iprot.skip(ftype)
12906 
      else:
12907 
        iprot.skip(ftype)
12908 
      iprot.readFieldEnd()
12909 
    iprot.readStructEnd()
12910 
 
12911 
  def write(self, oprot):
12912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12914 
      return
12915 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12916 
    if self.ex is not None:
12917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12918 
      self.ex.write(oprot)
12919 
      oprot.writeFieldEnd()
12920 
    oprot.writeFieldStop()
12921 
    oprot.writeStructEnd()
12922 
 
12923 
  def validate(self):
12924 
    return
12925 
 
12926 
 
12927 
  def __repr__(self):
12928 
    L = ['%s=%r' % (key, value)
12929 
      for key, value in self.__dict__.iteritems()]
12930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12931 
 
12932 
  def __eq__(self, other):
12933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12934 
 
12935 
  def __ne__(self, other):
12936 
    return not (self == other)
12937 
 
12938 
class markOrderCancellationRequestConfirmed_args:
12939 
  """
12940 
  Attributes:
12941 
   - orderId
12942 
  """
12943 
 
12944 
  thrift_spec = (
12945 
    None, # 0
12946 
    (1, TType.I64, 'orderId', None, None, ), # 1
12947 
  )
12948 
 
12949 
  def __init__(self, orderId=None,):
12950 
    self.orderId = orderId
12951 
 
12952 
  def read(self, iprot):
12953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12955 
      return
12956 
    iprot.readStructBegin()
12957 
    while True:
12958 
      (fname, ftype, fid) = iprot.readFieldBegin()
12959 
      if ftype == TType.STOP:
12960 
        break
12961 
      if fid == 1:
12962 
        if ftype == TType.I64:
12963 
          self.orderId = iprot.readI64();
12964 
        else:
12965 
          iprot.skip(ftype)
12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
12975 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12976 
    if self.orderId is not None:
12977 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12978 
      oprot.writeI64(self.orderId)
12979 
      oprot.writeFieldEnd()
12980 
    oprot.writeFieldStop()
12981 
    oprot.writeStructEnd()
12982 
 
12983 
  def validate(self):
12984 
    return
12985 
 
12986 
 
12987 
  def __repr__(self):
12988 
    L = ['%s=%r' % (key, value)
12989 
      for key, value in self.__dict__.iteritems()]
12990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12991 
 
12992 
  def __eq__(self, other):
12993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12994 
 
12995 
  def __ne__(self, other):
12996 
    return not (self == other)
12997 
 
12998 
class markOrderCancellationRequestConfirmed_result:
12999 
  """
13000 
  Attributes:
13001 
   - ex
13002 
  """
13003 
 
13004 
  thrift_spec = (
13005 
    None, # 0
13006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13007 
  )
13008 
 
13009 
  def __init__(self, ex=None,):
13010 
    self.ex = ex
13011 
 
13012 
  def read(self, iprot):
13013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13015 
      return
13016 
    iprot.readStructBegin()
13017 
    while True:
13018 
      (fname, ftype, fid) = iprot.readFieldBegin()
13019 
      if ftype == TType.STOP:
13020 
        break
13021 
      if fid == 1:
13022 
        if ftype == TType.STRUCT:
13023 
          self.ex = TransactionServiceException()
13024 
          self.ex.read(iprot)
13025 
        else:
13026 
          iprot.skip(ftype)
13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
13036 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13037 
    if self.ex is not None:
13038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13039 
      self.ex.write(oprot)
13040 
      oprot.writeFieldEnd()
13041 
    oprot.writeFieldStop()
13042 
    oprot.writeStructEnd()
13043 
 
13044 
  def validate(self):
13045 
    return
13046 
 
13047 
 
13048 
  def __repr__(self):
13049 
    L = ['%s=%r' % (key, value)
13050 
      for key, value in self.__dict__.iteritems()]
13051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13052 
 
13053 
  def __eq__(self, other):
13054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13055 
 
13056 
  def __ne__(self, other):
13057 
    return not (self == other)
13058 
 
13059 
class markOrderCancellationRequestDenied_args:
13060 
  """
13061 
  Attributes:
13062 
   - orderId
13063 
  """
13064 
 
13065 
  thrift_spec = (
13066 
    None, # 0
13067 
    (1, TType.I64, 'orderId', None, None, ), # 1
13068 
  )
13069 
 
13070 
  def __init__(self, orderId=None,):
13071 
    self.orderId = orderId
13072 
 
13073 
  def read(self, iprot):
13074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13076 
      return
13077 
    iprot.readStructBegin()
13078 
    while True:
13079 
      (fname, ftype, fid) = iprot.readFieldBegin()
13080 
      if ftype == TType.STOP:
13081 
        break
13082 
      if fid == 1:
13083 
        if ftype == TType.I64:
13084 
          self.orderId = iprot.readI64();
13085 
        else:
13086 
          iprot.skip(ftype)
13087 
      else:
13088 
        iprot.skip(ftype)
13089 
      iprot.readFieldEnd()
13090 
    iprot.readStructEnd()
13091 
 
13092 
  def write(self, oprot):
13093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13095 
      return
13096 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13097 
    if self.orderId is not None:
13098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13099 
      oprot.writeI64(self.orderId)
13100 
      oprot.writeFieldEnd()
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
13119 
class markOrderCancellationRequestDenied_result:
13120 
  """
13121 
  Attributes:
13122 
   - ex
13123 
  """
13124 
 
13125 
  thrift_spec = (
13126 
    None, # 0
13127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13128 
  )
13129 
 
13130 
  def __init__(self, ex=None,):
13131 
    self.ex = ex
13132 
 
13133 
  def read(self, iprot):
13134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13136 
      return
13137 
    iprot.readStructBegin()
13138 
    while True:
13139 
      (fname, ftype, fid) = iprot.readFieldBegin()
13140 
      if ftype == TType.STOP:
13141 
        break
13142 
      if fid == 1:
13143 
        if ftype == TType.STRUCT:
13144 
          self.ex = TransactionServiceException()
13145 
          self.ex.read(iprot)
13146 
        else:
13147 
          iprot.skip(ftype)
13148 
      else:
13149 
        iprot.skip(ftype)
13150 
      iprot.readFieldEnd()
13151 
    iprot.readStructEnd()
13152 
 
13153 
  def write(self, oprot):
13154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13156 
      return
13157 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13158 
    if self.ex is not None:
13159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13160 
      self.ex.write(oprot)
13161 
      oprot.writeFieldEnd()
13162 
    oprot.writeFieldStop()
13163 
    oprot.writeStructEnd()
13164 
 
13165 
  def validate(self):
13166 
    return
13167 
 
13168 
 
13169 
  def __repr__(self):
13170 
    L = ['%s=%r' % (key, value)
13171 
      for key, value in self.__dict__.iteritems()]
13172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13173 
 
13174 
  def __eq__(self, other):
13175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13176 
 
13177 
  def __ne__(self, other):
13178 
    return not (self == other)
13179 
 
4258 rajveer 13180 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13181 
  """
13182 
  Attributes:
4258 rajveer 13183 
   - transactionId
4247 rajveer 13184 
  """
13185 
 
13186 
  thrift_spec = (
13187 
    None, # 0
4258 rajveer 13188 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13189 
  )
13190 
 
4258 rajveer 13191 
  def __init__(self, transactionId=None,):
13192 
    self.transactionId = transactionId
4247 rajveer 13193 
 
13194 
  def read(self, iprot):
13195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13197 
      return
13198 
    iprot.readStructBegin()
13199 
    while True:
13200 
      (fname, ftype, fid) = iprot.readFieldBegin()
13201 
      if ftype == TType.STOP:
13202 
        break
13203 
      if fid == 1:
13204 
        if ftype == TType.I64:
4258 rajveer 13205 
          self.transactionId = iprot.readI64();
4247 rajveer 13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      else:
13209 
        iprot.skip(ftype)
13210 
      iprot.readFieldEnd()
13211 
    iprot.readStructEnd()
13212 
 
13213 
  def write(self, oprot):
13214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13216 
      return
4258 rajveer 13217 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13218 
    if self.transactionId is not None:
13219 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13220 
      oprot.writeI64(self.transactionId)
4247 rajveer 13221 
      oprot.writeFieldEnd()
13222 
    oprot.writeFieldStop()
13223 
    oprot.writeStructEnd()
13224 
 
13225 
  def validate(self):
13226 
    return
13227 
 
13228 
 
13229 
  def __repr__(self):
13230 
    L = ['%s=%r' % (key, value)
13231 
      for key, value in self.__dict__.iteritems()]
13232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13233 
 
13234 
  def __eq__(self, other):
13235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13236 
 
13237 
  def __ne__(self, other):
13238 
    return not (self == other)
13239 
 
4258 rajveer 13240 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13241 
  """
13242 
  Attributes:
13243 
   - ex
13244 
  """
13245 
 
13246 
  thrift_spec = (
13247 
    None, # 0
13248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13249 
  )
13250 
 
13251 
  def __init__(self, ex=None,):
13252 
    self.ex = ex
13253 
 
13254 
  def read(self, iprot):
13255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13257 
      return
13258 
    iprot.readStructBegin()
13259 
    while True:
13260 
      (fname, ftype, fid) = iprot.readFieldBegin()
13261 
      if ftype == TType.STOP:
13262 
        break
13263 
      if fid == 1:
13264 
        if ftype == TType.STRUCT:
13265 
          self.ex = TransactionServiceException()
13266 
          self.ex.read(iprot)
13267 
        else:
13268 
          iprot.skip(ftype)
13269 
      else:
13270 
        iprot.skip(ftype)
13271 
      iprot.readFieldEnd()
13272 
    iprot.readStructEnd()
13273 
 
13274 
  def write(self, oprot):
13275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13277 
      return
4258 rajveer 13278 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13279 
    if self.ex is not None:
13280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13281 
      self.ex.write(oprot)
13282 
      oprot.writeFieldEnd()
13283 
    oprot.writeFieldStop()
13284 
    oprot.writeStructEnd()
13285 
 
13286 
  def validate(self):
13287 
    return
13288 
 
13289 
 
13290 
  def __repr__(self):
13291 
    L = ['%s=%r' % (key, value)
13292 
      for key, value in self.__dict__.iteritems()]
13293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13294 
 
13295 
  def __eq__(self, other):
13296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13297 
 
13298 
  def __ne__(self, other):
13299 
    return not (self == other)
4259 anupam.sin 13300 
 
13301 
class refundTransaction_args:
13302 
  """
13303 
  Attributes:
13304 
   - transactionId
13305 
   - refundedBy
13306 
   - reason
13307 
  """
13308 
 
13309 
  thrift_spec = (
13310 
    None, # 0
13311 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13312 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13313 
    (3, TType.STRING, 'reason', None, None, ), # 3
13314 
  )
13315 
 
13316 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13317 
    self.transactionId = transactionId
13318 
    self.refundedBy = refundedBy
13319 
    self.reason = reason
13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      if fid == 1:
13331 
        if ftype == TType.I64:
13332 
          self.transactionId = iprot.readI64();
13333 
        else:
13334 
          iprot.skip(ftype)
13335 
      elif fid == 2:
13336 
        if ftype == TType.STRING:
13337 
          self.refundedBy = iprot.readString();
13338 
        else:
13339 
          iprot.skip(ftype)
13340 
      elif fid == 3:
13341 
        if ftype == TType.STRING:
13342 
          self.reason = iprot.readString();
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_args')
13355 
    if self.transactionId is not None:
13356 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13357 
      oprot.writeI64(self.transactionId)
13358 
      oprot.writeFieldEnd()
13359 
    if self.refundedBy is not None:
13360 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13361 
      oprot.writeString(self.refundedBy)
13362 
      oprot.writeFieldEnd()
13363 
    if self.reason is not None:
13364 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13365 
      oprot.writeString(self.reason)
13366 
      oprot.writeFieldEnd()
13367 
    oprot.writeFieldStop()
13368 
    oprot.writeStructEnd()
13369 
 
13370 
  def validate(self):
13371 
    return
13372 
 
13373 
 
13374 
  def __repr__(self):
13375 
    L = ['%s=%r' % (key, value)
13376 
      for key, value in self.__dict__.iteritems()]
13377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13378 
 
13379 
  def __eq__(self, other):
13380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13381 
 
13382 
  def __ne__(self, other):
13383 
    return not (self == other)
13384 
 
13385 
class refundTransaction_result:
13386 
  """
13387 
  Attributes:
13388 
   - ex
13389 
  """
13390 
 
13391 
  thrift_spec = (
13392 
    None, # 0
13393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13394 
  )
13395 
 
13396 
  def __init__(self, ex=None,):
13397 
    self.ex = ex
13398 
 
13399 
  def read(self, iprot):
13400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13402 
      return
13403 
    iprot.readStructBegin()
13404 
    while True:
13405 
      (fname, ftype, fid) = iprot.readFieldBegin()
13406 
      if ftype == TType.STOP:
13407 
        break
13408 
      if fid == 1:
13409 
        if ftype == TType.STRUCT:
13410 
          self.ex = TransactionServiceException()
13411 
          self.ex.read(iprot)
13412 
        else:
13413 
          iprot.skip(ftype)
13414 
      else:
13415 
        iprot.skip(ftype)
13416 
      iprot.readFieldEnd()
13417 
    iprot.readStructEnd()
13418 
 
13419 
  def write(self, oprot):
13420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13422 
      return
13423 
    oprot.writeStructBegin('refundTransaction_result')
13424 
    if self.ex is not None:
13425 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13426 
      self.ex.write(oprot)
13427 
      oprot.writeFieldEnd()
13428 
    oprot.writeFieldStop()
13429 
    oprot.writeStructEnd()
13430 
 
13431 
  def validate(self):
13432 
    return
13433 
 
13434 
 
13435 
  def __repr__(self):
13436 
    L = ['%s=%r' % (key, value)
13437 
      for key, value in self.__dict__.iteritems()]
13438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13439 
 
13440 
  def __eq__(self, other):
13441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13442 
 
13443 
  def __ne__(self, other):
13444 
    return not (self == other)
4285 rajveer 13445 
 
4324 mandeep.dh 13446 
class updateShipmentAddress_args:
13447 
  """
13448 
  Attributes:
13449 
   - orderId
13450 
   - addressId
13451 
  """
13452 
 
13453 
  thrift_spec = (
13454 
    None, # 0
13455 
    (1, TType.I64, 'orderId', None, None, ), # 1
13456 
    (2, TType.I64, 'addressId', None, None, ), # 2
13457 
  )
13458 
 
13459 
  def __init__(self, orderId=None, addressId=None,):
13460 
    self.orderId = orderId
13461 
    self.addressId = addressId
13462 
 
13463 
  def read(self, iprot):
13464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13466 
      return
13467 
    iprot.readStructBegin()
13468 
    while True:
13469 
      (fname, ftype, fid) = iprot.readFieldBegin()
13470 
      if ftype == TType.STOP:
13471 
        break
13472 
      if fid == 1:
13473 
        if ftype == TType.I64:
13474 
          self.orderId = iprot.readI64();
13475 
        else:
13476 
          iprot.skip(ftype)
13477 
      elif fid == 2:
13478 
        if ftype == TType.I64:
13479 
          self.addressId = iprot.readI64();
13480 
        else:
13481 
          iprot.skip(ftype)
13482 
      else:
13483 
        iprot.skip(ftype)
13484 
      iprot.readFieldEnd()
13485 
    iprot.readStructEnd()
13486 
 
13487 
  def write(self, oprot):
13488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13490 
      return
13491 
    oprot.writeStructBegin('updateShipmentAddress_args')
13492 
    if self.orderId is not None:
13493 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13494 
      oprot.writeI64(self.orderId)
13495 
      oprot.writeFieldEnd()
13496 
    if self.addressId is not None:
13497 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
13498 
      oprot.writeI64(self.addressId)
13499 
      oprot.writeFieldEnd()
13500 
    oprot.writeFieldStop()
13501 
    oprot.writeStructEnd()
13502 
 
13503 
  def validate(self):
13504 
    return
13505 
 
13506 
 
13507 
  def __repr__(self):
13508 
    L = ['%s=%r' % (key, value)
13509 
      for key, value in self.__dict__.iteritems()]
13510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13511 
 
13512 
  def __eq__(self, other):
13513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13514 
 
13515 
  def __ne__(self, other):
13516 
    return not (self == other)
13517 
 
13518 
class updateShipmentAddress_result:
13519 
  """
13520 
  Attributes:
13521 
   - ex
13522 
  """
13523 
 
13524 
  thrift_spec = (
13525 
    None, # 0
13526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13527 
  )
13528 
 
13529 
  def __init__(self, ex=None,):
13530 
    self.ex = ex
13531 
 
13532 
  def read(self, iprot):
13533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13535 
      return
13536 
    iprot.readStructBegin()
13537 
    while True:
13538 
      (fname, ftype, fid) = iprot.readFieldBegin()
13539 
      if ftype == TType.STOP:
13540 
        break
13541 
      if fid == 1:
13542 
        if ftype == TType.STRUCT:
13543 
          self.ex = TransactionServiceException()
13544 
          self.ex.read(iprot)
13545 
        else:
13546 
          iprot.skip(ftype)
13547 
      else:
13548 
        iprot.skip(ftype)
13549 
      iprot.readFieldEnd()
13550 
    iprot.readStructEnd()
13551 
 
13552 
  def write(self, oprot):
13553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13555 
      return
13556 
    oprot.writeStructBegin('updateShipmentAddress_result')
13557 
    if self.ex is not None:
13558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13559 
      self.ex.write(oprot)
13560 
      oprot.writeFieldEnd()
13561 
    oprot.writeFieldStop()
13562 
    oprot.writeStructEnd()
13563 
 
13564 
  def validate(self):
13565 
    return
13566 
 
13567 
 
13568 
  def __repr__(self):
13569 
    L = ['%s=%r' % (key, value)
13570 
      for key, value in self.__dict__.iteritems()]
13571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13572 
 
13573 
  def __eq__(self, other):
13574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13575 
 
13576 
  def __ne__(self, other):
13577 
    return not (self == other)
13578 
 
4285 rajveer 13579 
class acceptOrdersForItemId_args:
13580 
  """
13581 
  Attributes:
13582 
   - itemId
13583 
   - inventory
13584 
  """
13585 
 
13586 
  thrift_spec = (
13587 
    None, # 0
13588 
    (1, TType.I64, 'itemId', None, None, ), # 1
13589 
    (2, TType.I64, 'inventory', None, None, ), # 2
13590 
  )
13591 
 
13592 
  def __init__(self, itemId=None, inventory=None,):
13593 
    self.itemId = itemId
13594 
    self.inventory = inventory
13595 
 
13596 
  def read(self, iprot):
13597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13599 
      return
13600 
    iprot.readStructBegin()
13601 
    while True:
13602 
      (fname, ftype, fid) = iprot.readFieldBegin()
13603 
      if ftype == TType.STOP:
13604 
        break
13605 
      if fid == 1:
13606 
        if ftype == TType.I64:
13607 
          self.itemId = iprot.readI64();
13608 
        else:
13609 
          iprot.skip(ftype)
13610 
      elif fid == 2:
13611 
        if ftype == TType.I64:
13612 
          self.inventory = iprot.readI64();
13613 
        else:
13614 
          iprot.skip(ftype)
13615 
      else:
13616 
        iprot.skip(ftype)
13617 
      iprot.readFieldEnd()
13618 
    iprot.readStructEnd()
13619 
 
13620 
  def write(self, oprot):
13621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13623 
      return
13624 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13625 
    if self.itemId is not None:
13626 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13627 
      oprot.writeI64(self.itemId)
13628 
      oprot.writeFieldEnd()
13629 
    if self.inventory is not None:
13630 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13631 
      oprot.writeI64(self.inventory)
13632 
      oprot.writeFieldEnd()
13633 
    oprot.writeFieldStop()
13634 
    oprot.writeStructEnd()
13635 
 
13636 
  def validate(self):
13637 
    return
13638 
 
13639 
 
13640 
  def __repr__(self):
13641 
    L = ['%s=%r' % (key, value)
13642 
      for key, value in self.__dict__.iteritems()]
13643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13644 
 
13645 
  def __eq__(self, other):
13646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13647 
 
13648 
  def __ne__(self, other):
13649 
    return not (self == other)
13650 
 
13651 
class acceptOrdersForItemId_result:
13652 
  """
13653 
  Attributes:
13654 
   - success
13655 
   - ex
13656 
  """
13657 
 
13658 
  thrift_spec = (
13659 
    (0, TType.BOOL, 'success', None, None, ), # 0
13660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13661 
  )
13662 
 
13663 
  def __init__(self, success=None, ex=None,):
13664 
    self.success = success
13665 
    self.ex = ex
13666 
 
13667 
  def read(self, iprot):
13668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13670 
      return
13671 
    iprot.readStructBegin()
13672 
    while True:
13673 
      (fname, ftype, fid) = iprot.readFieldBegin()
13674 
      if ftype == TType.STOP:
13675 
        break
13676 
      if fid == 0:
13677 
        if ftype == TType.BOOL:
13678 
          self.success = iprot.readBool();
13679 
        else:
13680 
          iprot.skip(ftype)
13681 
      elif fid == 1:
13682 
        if ftype == TType.STRUCT:
13683 
          self.ex = TransactionServiceException()
13684 
          self.ex.read(iprot)
13685 
        else:
13686 
          iprot.skip(ftype)
13687 
      else:
13688 
        iprot.skip(ftype)
13689 
      iprot.readFieldEnd()
13690 
    iprot.readStructEnd()
13691 
 
13692 
  def write(self, oprot):
13693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13695 
      return
13696 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13697 
    if self.success is not None:
13698 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13699 
      oprot.writeBool(self.success)
13700 
      oprot.writeFieldEnd()
13701 
    if self.ex is not None:
13702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13703 
      self.ex.write(oprot)
13704 
      oprot.writeFieldEnd()
13705 
    oprot.writeFieldStop()
13706 
    oprot.writeStructEnd()
13707 
 
13708 
  def validate(self):
13709 
    return
13710 
 
13711 
 
13712 
  def __repr__(self):
13713 
    L = ['%s=%r' % (key, value)
13714 
      for key, value in self.__dict__.iteritems()]
13715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13716 
 
13717 
  def __eq__(self, other):
13718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13719 
 
13720 
  def __ne__(self, other):
13721 
    return not (self == other)
4303 rajveer 13722 
 
13723 
class markOrdersAsPORaised_args:
13724 
  """
13725 
  Attributes:
13726 
   - vendorId
13727 
   - itemId
13728 
   - quantity
13729 
   - estimate
13730 
  """
13731 
 
13732 
  thrift_spec = (
13733 
    None, # 0
13734 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13735 
    (2, TType.I64, 'itemId', None, None, ), # 2
13736 
    (3, TType.I64, 'quantity', None, None, ), # 3
13737 
    (4, TType.I64, 'estimate', None, None, ), # 4
13738 
  )
13739 
 
13740 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
13741 
    self.vendorId = vendorId
13742 
    self.itemId = itemId
13743 
    self.quantity = quantity
13744 
    self.estimate = estimate
13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
13755 
      if fid == 1:
13756 
        if ftype == TType.I64:
13757 
          self.vendorId = iprot.readI64();
13758 
        else:
13759 
          iprot.skip(ftype)
13760 
      elif fid == 2:
13761 
        if ftype == TType.I64:
13762 
          self.itemId = iprot.readI64();
13763 
        else:
13764 
          iprot.skip(ftype)
13765 
      elif fid == 3:
13766 
        if ftype == TType.I64:
13767 
          self.quantity = iprot.readI64();
13768 
        else:
13769 
          iprot.skip(ftype)
13770 
      elif fid == 4:
13771 
        if ftype == TType.I64:
13772 
          self.estimate = iprot.readI64();
13773 
        else:
13774 
          iprot.skip(ftype)
13775 
      else:
13776 
        iprot.skip(ftype)
13777 
      iprot.readFieldEnd()
13778 
    iprot.readStructEnd()
13779 
 
13780 
  def write(self, oprot):
13781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13783 
      return
13784 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
13785 
    if self.vendorId is not None:
13786 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13787 
      oprot.writeI64(self.vendorId)
13788 
      oprot.writeFieldEnd()
13789 
    if self.itemId is not None:
13790 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13791 
      oprot.writeI64(self.itemId)
13792 
      oprot.writeFieldEnd()
13793 
    if self.quantity is not None:
13794 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13795 
      oprot.writeI64(self.quantity)
13796 
      oprot.writeFieldEnd()
13797 
    if self.estimate is not None:
13798 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13799 
      oprot.writeI64(self.estimate)
13800 
      oprot.writeFieldEnd()
13801 
    oprot.writeFieldStop()
13802 
    oprot.writeStructEnd()
13803 
 
13804 
  def validate(self):
13805 
    return
13806 
 
13807 
 
13808 
  def __repr__(self):
13809 
    L = ['%s=%r' % (key, value)
13810 
      for key, value in self.__dict__.iteritems()]
13811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13812 
 
13813 
  def __eq__(self, other):
13814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13815 
 
13816 
  def __ne__(self, other):
13817 
    return not (self == other)
13818 
 
13819 
class markOrdersAsPORaised_result:
13820 
  """
13821 
  Attributes:
13822 
   - ex
13823 
  """
13824 
 
13825 
  thrift_spec = (
13826 
    None, # 0
13827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13828 
  )
13829 
 
13830 
  def __init__(self, ex=None,):
13831 
    self.ex = ex
13832 
 
13833 
  def read(self, iprot):
13834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13836 
      return
13837 
    iprot.readStructBegin()
13838 
    while True:
13839 
      (fname, ftype, fid) = iprot.readFieldBegin()
13840 
      if ftype == TType.STOP:
13841 
        break
13842 
      if fid == 1:
13843 
        if ftype == TType.STRUCT:
13844 
          self.ex = TransactionServiceException()
13845 
          self.ex.read(iprot)
13846 
        else:
13847 
          iprot.skip(ftype)
13848 
      else:
13849 
        iprot.skip(ftype)
13850 
      iprot.readFieldEnd()
13851 
    iprot.readStructEnd()
13852 
 
13853 
  def write(self, oprot):
13854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13856 
      return
13857 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
13858 
    if self.ex is not None:
13859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13860 
      self.ex.write(oprot)
13861 
      oprot.writeFieldEnd()
13862 
    oprot.writeFieldStop()
13863 
    oprot.writeStructEnd()
13864 
 
13865 
  def validate(self):
13866 
    return
13867 
 
13868 
 
13869 
  def __repr__(self):
13870 
    L = ['%s=%r' % (key, value)
13871 
      for key, value in self.__dict__.iteritems()]
13872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13873 
 
13874 
  def __eq__(self, other):
13875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13876 
 
13877 
  def __ne__(self, other):
13878 
    return not (self == other)
13879 
 
13880 
class markOrdersAsReversalInitiated_args:
13881 
  """
13882 
  Attributes:
13883 
   - vendorId
13884 
   - itemId
13885 
   - quantity
13886 
   - estimate
13887 
  """
13888 
 
13889 
  thrift_spec = (
13890 
    None, # 0
13891 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13892 
    (2, TType.I64, 'itemId', None, None, ), # 2
13893 
    (3, TType.I64, 'quantity', None, None, ), # 3
13894 
    (4, TType.I64, 'estimate', None, None, ), # 4
13895 
  )
13896 
 
13897 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
13898 
    self.vendorId = vendorId
13899 
    self.itemId = itemId
13900 
    self.quantity = quantity
13901 
    self.estimate = estimate
13902 
 
13903 
  def read(self, iprot):
13904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13906 
      return
13907 
    iprot.readStructBegin()
13908 
    while True:
13909 
      (fname, ftype, fid) = iprot.readFieldBegin()
13910 
      if ftype == TType.STOP:
13911 
        break
13912 
      if fid == 1:
13913 
        if ftype == TType.I64:
13914 
          self.vendorId = iprot.readI64();
13915 
        else:
13916 
          iprot.skip(ftype)
13917 
      elif fid == 2:
13918 
        if ftype == TType.I64:
13919 
          self.itemId = iprot.readI64();
13920 
        else:
13921 
          iprot.skip(ftype)
13922 
      elif fid == 3:
13923 
        if ftype == TType.I64:
13924 
          self.quantity = iprot.readI64();
13925 
        else:
13926 
          iprot.skip(ftype)
13927 
      elif fid == 4:
13928 
        if ftype == TType.I64:
13929 
          self.estimate = iprot.readI64();
13930 
        else:
13931 
          iprot.skip(ftype)
13932 
      else:
13933 
        iprot.skip(ftype)
13934 
      iprot.readFieldEnd()
13935 
    iprot.readStructEnd()
13936 
 
13937 
  def write(self, oprot):
13938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13940 
      return
13941 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
13942 
    if self.vendorId is not None:
13943 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13944 
      oprot.writeI64(self.vendorId)
13945 
      oprot.writeFieldEnd()
13946 
    if self.itemId is not None:
13947 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13948 
      oprot.writeI64(self.itemId)
13949 
      oprot.writeFieldEnd()
13950 
    if self.quantity is not None:
13951 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13952 
      oprot.writeI64(self.quantity)
13953 
      oprot.writeFieldEnd()
13954 
    if self.estimate is not None:
13955 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13956 
      oprot.writeI64(self.estimate)
13957 
      oprot.writeFieldEnd()
13958 
    oprot.writeFieldStop()
13959 
    oprot.writeStructEnd()
13960 
 
13961 
  def validate(self):
13962 
    return
13963 
 
13964 
 
13965 
  def __repr__(self):
13966 
    L = ['%s=%r' % (key, value)
13967 
      for key, value in self.__dict__.iteritems()]
13968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13969 
 
13970 
  def __eq__(self, other):
13971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13972 
 
13973 
  def __ne__(self, other):
13974 
    return not (self == other)
13975 
 
13976 
class markOrdersAsReversalInitiated_result:
13977 
  """
13978 
  Attributes:
13979 
   - ex
13980 
  """
13981 
 
13982 
  thrift_spec = (
13983 
    None, # 0
13984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13985 
  )
13986 
 
13987 
  def __init__(self, ex=None,):
13988 
    self.ex = ex
13989 
 
13990 
  def read(self, iprot):
13991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13993 
      return
13994 
    iprot.readStructBegin()
13995 
    while True:
13996 
      (fname, ftype, fid) = iprot.readFieldBegin()
13997 
      if ftype == TType.STOP:
13998 
        break
13999 
      if fid == 1:
14000 
        if ftype == TType.STRUCT:
14001 
          self.ex = TransactionServiceException()
14002 
          self.ex.read(iprot)
14003 
        else:
14004 
          iprot.skip(ftype)
14005 
      else:
14006 
        iprot.skip(ftype)
14007 
      iprot.readFieldEnd()
14008 
    iprot.readStructEnd()
14009 
 
14010 
  def write(self, oprot):
14011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14013 
      return
14014 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14015 
    if self.ex is not None:
14016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14017 
      self.ex.write(oprot)
14018 
      oprot.writeFieldEnd()
14019 
    oprot.writeFieldStop()
14020 
    oprot.writeStructEnd()
14021 
 
14022 
  def validate(self):
14023 
    return
14024 
 
14025 
 
14026 
  def __repr__(self):
14027 
    L = ['%s=%r' % (key, value)
14028 
      for key, value in self.__dict__.iteritems()]
14029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14030 
 
14031 
  def __eq__(self, other):
14032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14033 
 
14034 
  def __ne__(self, other):
14035 
    return not (self == other)
14036 
 
14037 
class markOrdersAsNotAvailabke_args:
14038 
  """
14039 
  Attributes:
14040 
   - vendorId
14041 
   - itemId
14042 
   - quantity
14043 
   - estimate
14044 
  """
14045 
 
14046 
  thrift_spec = (
14047 
    None, # 0
14048 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14049 
    (2, TType.I64, 'itemId', None, None, ), # 2
14050 
    (3, TType.I64, 'quantity', None, None, ), # 3
14051 
    (4, TType.I64, 'estimate', None, None, ), # 4
14052 
  )
14053 
 
14054 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None,):
14055 
    self.vendorId = vendorId
14056 
    self.itemId = itemId
14057 
    self.quantity = quantity
14058 
    self.estimate = estimate
14059 
 
14060 
  def read(self, iprot):
14061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14063 
      return
14064 
    iprot.readStructBegin()
14065 
    while True:
14066 
      (fname, ftype, fid) = iprot.readFieldBegin()
14067 
      if ftype == TType.STOP:
14068 
        break
14069 
      if fid == 1:
14070 
        if ftype == TType.I64:
14071 
          self.vendorId = iprot.readI64();
14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      elif fid == 2:
14075 
        if ftype == TType.I64:
14076 
          self.itemId = iprot.readI64();
14077 
        else:
14078 
          iprot.skip(ftype)
14079 
      elif fid == 3:
14080 
        if ftype == TType.I64:
14081 
          self.quantity = iprot.readI64();
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      elif fid == 4:
14085 
        if ftype == TType.I64:
14086 
          self.estimate = iprot.readI64();
14087 
        else:
14088 
          iprot.skip(ftype)
14089 
      else:
14090 
        iprot.skip(ftype)
14091 
      iprot.readFieldEnd()
14092 
    iprot.readStructEnd()
14093 
 
14094 
  def write(self, oprot):
14095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14097 
      return
14098 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14099 
    if self.vendorId is not None:
14100 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14101 
      oprot.writeI64(self.vendorId)
14102 
      oprot.writeFieldEnd()
14103 
    if self.itemId is not None:
14104 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14105 
      oprot.writeI64(self.itemId)
14106 
      oprot.writeFieldEnd()
14107 
    if self.quantity is not None:
14108 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14109 
      oprot.writeI64(self.quantity)
14110 
      oprot.writeFieldEnd()
14111 
    if self.estimate is not None:
14112 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14113 
      oprot.writeI64(self.estimate)
14114 
      oprot.writeFieldEnd()
14115 
    oprot.writeFieldStop()
14116 
    oprot.writeStructEnd()
14117 
 
14118 
  def validate(self):
14119 
    return
14120 
 
14121 
 
14122 
  def __repr__(self):
14123 
    L = ['%s=%r' % (key, value)
14124 
      for key, value in self.__dict__.iteritems()]
14125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14126 
 
14127 
  def __eq__(self, other):
14128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14129 
 
14130 
  def __ne__(self, other):
14131 
    return not (self == other)
14132 
 
14133 
class markOrdersAsNotAvailabke_result:
14134 
  """
14135 
  Attributes:
14136 
   - ex
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    None, # 0
14141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14142 
  )
14143 
 
14144 
  def __init__(self, ex=None,):
14145 
    self.ex = ex
14146 
 
14147 
  def read(self, iprot):
14148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14150 
      return
14151 
    iprot.readStructBegin()
14152 
    while True:
14153 
      (fname, ftype, fid) = iprot.readFieldBegin()
14154 
      if ftype == TType.STOP:
14155 
        break
14156 
      if fid == 1:
14157 
        if ftype == TType.STRUCT:
14158 
          self.ex = TransactionServiceException()
14159 
          self.ex.read(iprot)
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      else:
14163 
        iprot.skip(ftype)
14164 
      iprot.readFieldEnd()
14165 
    iprot.readStructEnd()
14166 
 
14167 
  def write(self, oprot):
14168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14170 
      return
14171 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14172 
    if self.ex is not None:
14173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14174 
      self.ex.write(oprot)
14175 
      oprot.writeFieldEnd()
14176 
    oprot.writeFieldStop()
14177 
    oprot.writeStructEnd()
14178 
 
14179 
  def validate(self):
14180 
    return
14181 
 
14182 
 
14183 
  def __repr__(self):
14184 
    L = ['%s=%r' % (key, value)
14185 
      for key, value in self.__dict__.iteritems()]
14186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14187 
 
14188 
  def __eq__(self, other):
14189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14190 
 
14191 
  def __ne__(self, other):
14192 
    return not (self == other)