Subversion Repositories SmartDukaan

Rev

Rev 4324 | Rev 4386 | 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 
 
4369 rajveer 747 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 748 
    """
749 
    Parameters:
750 
     - vendorId
751 
     - itemId
752 
     - quantity
753 
     - estimate
4369 rajveer 754 
     - isReminder
4303 rajveer 755 
    """
756 
    pass
4285 rajveer 757 
 
4369 rajveer 758 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 759 
    """
760 
    Parameters:
761 
     - vendorId
762 
     - itemId
763 
     - quantity
764 
     - estimate
4369 rajveer 765 
     - isReminder
4303 rajveer 766 
    """
767 
    pass
768 
 
4369 rajveer 769 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 770 
    """
771 
    Parameters:
772 
     - vendorId
773 
     - itemId
774 
     - quantity
775 
     - estimate
4369 rajveer 776 
     - isReminder
4303 rajveer 777 
    """
778 
    pass
779 
 
4369 rajveer 780 
  def markOrdersAsTimeout(self, vendorId):
781 
    """
782 
    Parameters:
783 
     - vendorId
784 
    """
785 
    pass
4303 rajveer 786 
 
4369 rajveer 787 
 
3376 rajveer 788 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 789 
  def __init__(self, iprot, oprot=None):
3376 rajveer 790 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 791 
 
792 
  def createTransaction(self, transaction):
793 
    """
794 
    Parameters:
795 
     - transaction
796 
    """
797 
    self.send_createTransaction(transaction)
132 ashish 798 
    return self.recv_createTransaction()
94 ashish 799 
 
800 
  def send_createTransaction(self, transaction):
801 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
802 
    args = createTransaction_args()
803 
    args.transaction = transaction
804 
    args.write(self._oprot)
805 
    self._oprot.writeMessageEnd()
806 
    self._oprot.trans.flush()
807 
 
808 
  def recv_createTransaction(self, ):
809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
810 
    if mtype == TMessageType.EXCEPTION:
811 
      x = TApplicationException()
812 
      x.read(self._iprot)
813 
      self._iprot.readMessageEnd()
814 
      raise x
815 
    result = createTransaction_result()
816 
    result.read(self._iprot)
817 
    self._iprot.readMessageEnd()
3431 rajveer 818 
    if result.success is not None:
132 ashish 819 
      return result.success
3431 rajveer 820 
    if result.ex is not None:
94 ashish 821 
      raise result.ex
132 ashish 822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 823 
 
824 
  def getTransaction(self, id):
825 
    """
826 
    Parameters:
827 
     - id
828 
    """
829 
    self.send_getTransaction(id)
830 
    return self.recv_getTransaction()
831 
 
832 
  def send_getTransaction(self, id):
833 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
834 
    args = getTransaction_args()
835 
    args.id = id
836 
    args.write(self._oprot)
837 
    self._oprot.writeMessageEnd()
838 
    self._oprot.trans.flush()
839 
 
840 
  def recv_getTransaction(self, ):
841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
842 
    if mtype == TMessageType.EXCEPTION:
843 
      x = TApplicationException()
844 
      x.read(self._iprot)
845 
      self._iprot.readMessageEnd()
846 
      raise x
847 
    result = getTransaction_result()
848 
    result.read(self._iprot)
849 
    self._iprot.readMessageEnd()
3431 rajveer 850 
    if result.success is not None:
94 ashish 851 
      return result.success
3431 rajveer 852 
    if result.ex is not None:
94 ashish 853 
      raise result.ex
854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
855 
 
856 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
857 
    """
858 
    Parameters:
859 
     - customerId
860 
     - from_date
861 
     - to_date
862 
     - status
863 
    """
864 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
865 
    return self.recv_getTransactionsForCustomer()
866 
 
867 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
868 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
869 
    args = getTransactionsForCustomer_args()
870 
    args.customerId = customerId
871 
    args.from_date = from_date
872 
    args.to_date = to_date
873 
    args.status = status
874 
    args.write(self._oprot)
875 
    self._oprot.writeMessageEnd()
876 
    self._oprot.trans.flush()
877 
 
878 
  def recv_getTransactionsForCustomer(self, ):
879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
880 
    if mtype == TMessageType.EXCEPTION:
881 
      x = TApplicationException()
882 
      x.read(self._iprot)
883 
      self._iprot.readMessageEnd()
884 
      raise x
885 
    result = getTransactionsForCustomer_result()
886 
    result.read(self._iprot)
887 
    self._iprot.readMessageEnd()
3431 rajveer 888 
    if result.success is not None:
94 ashish 889 
      return result.success
3431 rajveer 890 
    if result.ex is not None:
94 ashish 891 
      raise result.ex
892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
893 
 
132 ashish 894 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
895 
    """
896 
    Parameters:
897 
     - shoppingCartId
898 
    """
899 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
900 
    return self.recv_getTransactionsForShoppingCartId()
901 
 
902 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
903 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
904 
    args = getTransactionsForShoppingCartId_args()
905 
    args.shoppingCartId = shoppingCartId
906 
    args.write(self._oprot)
907 
    self._oprot.writeMessageEnd()
908 
    self._oprot.trans.flush()
909 
 
910 
  def recv_getTransactionsForShoppingCartId(self, ):
911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
912 
    if mtype == TMessageType.EXCEPTION:
913 
      x = TApplicationException()
914 
      x.read(self._iprot)
915 
      self._iprot.readMessageEnd()
916 
      raise x
917 
    result = getTransactionsForShoppingCartId_result()
918 
    result.read(self._iprot)
919 
    self._iprot.readMessageEnd()
3431 rajveer 920 
    if result.success is not None:
132 ashish 921 
      return result.success
3431 rajveer 922 
    if result.ex is not None:
132 ashish 923 
      raise result.ex
924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
925 
 
94 ashish 926 
  def getTransactionStatus(self, transactionId):
927 
    """
928 
    Parameters:
929 
     - transactionId
930 
    """
931 
    self.send_getTransactionStatus(transactionId)
932 
    return self.recv_getTransactionStatus()
933 
 
934 
  def send_getTransactionStatus(self, transactionId):
935 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
936 
    args = getTransactionStatus_args()
937 
    args.transactionId = transactionId
938 
    args.write(self._oprot)
939 
    self._oprot.writeMessageEnd()
940 
    self._oprot.trans.flush()
941 
 
942 
  def recv_getTransactionStatus(self, ):
943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
944 
    if mtype == TMessageType.EXCEPTION:
945 
      x = TApplicationException()
946 
      x.read(self._iprot)
947 
      self._iprot.readMessageEnd()
948 
      raise x
949 
    result = getTransactionStatus_result()
950 
    result.read(self._iprot)
951 
    self._iprot.readMessageEnd()
3431 rajveer 952 
    if result.success is not None:
94 ashish 953 
      return result.success
3431 rajveer 954 
    if result.ex is not None:
94 ashish 955 
      raise result.ex
956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
957 
 
958 
  def changeTransactionStatus(self, transactionId, status, description):
959 
    """
960 
    Parameters:
961 
     - transactionId
962 
     - status
963 
     - description
964 
    """
965 
    self.send_changeTransactionStatus(transactionId, status, description)
966 
    return self.recv_changeTransactionStatus()
967 
 
968 
  def send_changeTransactionStatus(self, transactionId, status, description):
969 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
970 
    args = changeTransactionStatus_args()
971 
    args.transactionId = transactionId
972 
    args.status = status
973 
    args.description = description
974 
    args.write(self._oprot)
975 
    self._oprot.writeMessageEnd()
976 
    self._oprot.trans.flush()
977 
 
978 
  def recv_changeTransactionStatus(self, ):
979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
980 
    if mtype == TMessageType.EXCEPTION:
981 
      x = TApplicationException()
982 
      x.read(self._iprot)
983 
      self._iprot.readMessageEnd()
984 
      raise x
985 
    result = changeTransactionStatus_result()
986 
    result.read(self._iprot)
987 
    self._iprot.readMessageEnd()
3431 rajveer 988 
    if result.success is not None:
94 ashish 989 
      return result.success
3431 rajveer 990 
    if result.ex is not None:
94 ashish 991 
      raise result.ex
992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
993 
 
1398 varun.gupt 994 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 995 
    """
996 
    Parameters:
997 
     - transactionId
998 
    """
1398 varun.gupt 999 
    self.send_enqueueTransactionInfoEmail(transactionId)
1000 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1001 
 
1398 varun.gupt 1002 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1003 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1004 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1005 
    args.transactionId = transactionId
1006 
    args.write(self._oprot)
1007 
    self._oprot.writeMessageEnd()
1008 
    self._oprot.trans.flush()
1009 
 
1398 varun.gupt 1010 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1012 
    if mtype == TMessageType.EXCEPTION:
1013 
      x = TApplicationException()
1014 
      x.read(self._iprot)
1015 
      self._iprot.readMessageEnd()
1016 
      raise x
1398 varun.gupt 1017 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1018 
    result.read(self._iprot)
1019 
    self._iprot.readMessageEnd()
3431 rajveer 1020 
    if result.success is not None:
1382 varun.gupt 1021 
      return result.success
3431 rajveer 1022 
    if result.ex is not None:
1382 varun.gupt 1023 
      raise result.ex
1398 varun.gupt 1024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1025 
 
483 rajveer 1026 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1027 
    """
1028 
    Parameters:
483 rajveer 1029 
     - status
1030 
     - from_date
1031 
     - to_date
1032 
     - warehouse_id
94 ashish 1033 
    """
483 rajveer 1034 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1035 
    return self.recv_getAllOrders()
94 ashish 1036 
 
483 rajveer 1037 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1038 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1039 
    args = getAllOrders_args()
1040 
    args.status = status
1041 
    args.from_date = from_date
1042 
    args.to_date = to_date
1043 
    args.warehouse_id = warehouse_id
94 ashish 1044 
    args.write(self._oprot)
1045 
    self._oprot.writeMessageEnd()
1046 
    self._oprot.trans.flush()
1047 
 
483 rajveer 1048 
  def recv_getAllOrders(self, ):
94 ashish 1049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1050 
    if mtype == TMessageType.EXCEPTION:
1051 
      x = TApplicationException()
1052 
      x.read(self._iprot)
1053 
      self._iprot.readMessageEnd()
1054 
      raise x
483 rajveer 1055 
    result = getAllOrders_result()
94 ashish 1056 
    result.read(self._iprot)
1057 
    self._iprot.readMessageEnd()
3431 rajveer 1058 
    if result.success is not None:
94 ashish 1059 
      return result.success
3431 rajveer 1060 
    if result.ex is not None:
94 ashish 1061 
      raise result.ex
483 rajveer 1062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1063 
 
4133 chandransh 1064 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1065 
    """
1066 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1067 
    Pass the status as null and the limit as 0 to ignore them.
1068 
 
1069 
    Parameters:
1070 
     - statuses
1071 
     - offset
1072 
     - limit
1073 
     - warehouse_id
1074 
    """
1075 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1076 
    return self.recv_getOrdersInBatch()
1077 
 
1078 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1079 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1080 
    args = getOrdersInBatch_args()
1081 
    args.statuses = statuses
1082 
    args.offset = offset
1083 
    args.limit = limit
1084 
    args.warehouse_id = warehouse_id
1085 
    args.write(self._oprot)
1086 
    self._oprot.writeMessageEnd()
1087 
    self._oprot.trans.flush()
1088 
 
1089 
  def recv_getOrdersInBatch(self, ):
1090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1091 
    if mtype == TMessageType.EXCEPTION:
1092 
      x = TApplicationException()
1093 
      x.read(self._iprot)
1094 
      self._iprot.readMessageEnd()
1095 
      raise x
1096 
    result = getOrdersInBatch_result()
1097 
    result.read(self._iprot)
1098 
    self._iprot.readMessageEnd()
1099 
    if result.success is not None:
1100 
      return result.success
1101 
    if result.ex is not None:
1102 
      raise result.ex
1103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1104 
 
1105 
  def getOrderCount(self, statuses, warehouseId):
1106 
    """
1107 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1108 
 
1109 
    Parameters:
1110 
     - statuses
1111 
     - warehouseId
1112 
    """
1113 
    self.send_getOrderCount(statuses, warehouseId)
1114 
    return self.recv_getOrderCount()
1115 
 
1116 
  def send_getOrderCount(self, statuses, warehouseId):
1117 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1118 
    args = getOrderCount_args()
1119 
    args.statuses = statuses
1120 
    args.warehouseId = warehouseId
1121 
    args.write(self._oprot)
1122 
    self._oprot.writeMessageEnd()
1123 
    self._oprot.trans.flush()
1124 
 
1125 
  def recv_getOrderCount(self, ):
1126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1127 
    if mtype == TMessageType.EXCEPTION:
1128 
      x = TApplicationException()
1129 
      x.read(self._iprot)
1130 
      self._iprot.readMessageEnd()
1131 
      raise x
1132 
    result = getOrderCount_result()
1133 
    result.read(self._iprot)
1134 
    self._iprot.readMessageEnd()
1135 
    if result.success is not None:
1136 
      return result.success
1137 
    if result.ex is not None:
1138 
      raise result.ex
1139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1140 
 
999 varun.gupt 1141 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1142 
    """
1132 chandransh 1143 
    Returns orders within a range of their billing dates
3431 rajveer 1144 
 
999 varun.gupt 1145 
    Parameters:
1146 
     - status
1147 
     - start_billing_date
1148 
     - end_billing_date
1149 
     - warehouse_id
1150 
    """
1151 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1152 
    return self.recv_getOrdersByBillingDate()
1153 
 
1154 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1155 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1156 
    args = getOrdersByBillingDate_args()
1157 
    args.status = status
1158 
    args.start_billing_date = start_billing_date
1159 
    args.end_billing_date = end_billing_date
1160 
    args.warehouse_id = warehouse_id
1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_getOrdersByBillingDate(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = getOrdersByBillingDate_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
3431 rajveer 1175 
    if result.success is not None:
999 varun.gupt 1176 
      return result.success
3431 rajveer 1177 
    if result.ex is not None:
999 varun.gupt 1178 
      raise result.ex
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1180 
 
3451 chandransh 1181 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1182 
    """
1183 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1184 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1185 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1186 
 
3427 chandransh 1187 
    Parameters:
1188 
     - fromShippingDate
1189 
     - toShippingDate
1190 
     - providerId
1191 
     - warehouseId
3451 chandransh 1192 
     - cod
3427 chandransh 1193 
    """
3451 chandransh 1194 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1195 
    return self.recv_getOrdersByShippingDate()
1196 
 
3451 chandransh 1197 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1198 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1199 
    args = getOrdersByShippingDate_args()
1200 
    args.fromShippingDate = fromShippingDate
1201 
    args.toShippingDate = toShippingDate
1202 
    args.providerId = providerId
1203 
    args.warehouseId = warehouseId
3451 chandransh 1204 
    args.cod = cod
3427 chandransh 1205 
    args.write(self._oprot)
1206 
    self._oprot.writeMessageEnd()
1207 
    self._oprot.trans.flush()
1208 
 
1209 
  def recv_getOrdersByShippingDate(self, ):
1210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1211 
    if mtype == TMessageType.EXCEPTION:
1212 
      x = TApplicationException()
1213 
      x.read(self._iprot)
1214 
      self._iprot.readMessageEnd()
1215 
      raise x
1216 
    result = getOrdersByShippingDate_result()
1217 
    result.read(self._iprot)
1218 
    self._iprot.readMessageEnd()
3431 rajveer 1219 
    if result.success is not None:
3427 chandransh 1220 
      return result.success
3431 rajveer 1221 
    if result.ex is not None:
3427 chandransh 1222 
      raise result.ex
1223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1224 
 
1382 varun.gupt 1225 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1226 
    """
1227 
    Returns order ids for orders which can be returned
3431 rajveer 1228 
 
1382 varun.gupt 1229 
    Parameters:
1230 
     - customer_id
1231 
     - limit
1232 
    """
1233 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1234 
    return self.recv_getReturnableOrdersForCustomer()
1235 
 
1236 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1237 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1238 
    args = getReturnableOrdersForCustomer_args()
1239 
    args.customer_id = customer_id
1240 
    args.limit = limit
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_getReturnableOrdersForCustomer(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = getReturnableOrdersForCustomer_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
3431 rajveer 1255 
    if result.success is not None:
1382 varun.gupt 1256 
      return result.success
3431 rajveer 1257 
    if result.ex is not None:
1382 varun.gupt 1258 
      raise result.ex
1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1260 
 
1261 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1262 
    """
1263 
    Returns order ids for orders which can be cancelled
3431 rajveer 1264 
 
1382 varun.gupt 1265 
    Parameters:
1266 
     - customer_id
1267 
     - limit
1268 
    """
1269 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1270 
    return self.recv_getCancellableOrdersForCustomer()
1271 
 
1272 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1273 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1274 
    args = getCancellableOrdersForCustomer_args()
1275 
    args.customer_id = customer_id
1276 
    args.limit = limit
1277 
    args.write(self._oprot)
1278 
    self._oprot.writeMessageEnd()
1279 
    self._oprot.trans.flush()
1280 
 
1281 
  def recv_getCancellableOrdersForCustomer(self, ):
1282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1283 
    if mtype == TMessageType.EXCEPTION:
1284 
      x = TApplicationException()
1285 
      x.read(self._iprot)
1286 
      self._iprot.readMessageEnd()
1287 
      raise x
1288 
    result = getCancellableOrdersForCustomer_result()
1289 
    result.read(self._iprot)
1290 
    self._iprot.readMessageEnd()
3431 rajveer 1291 
    if result.success is not None:
1382 varun.gupt 1292 
      return result.success
3431 rajveer 1293 
    if result.ex is not None:
1382 varun.gupt 1294 
      raise result.ex
1295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1296 
 
483 rajveer 1297 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1298 
    """
1299 
    Parameters:
483 rajveer 1300 
     - orderId
1301 
     - status
1302 
     - description
94 ashish 1303 
    """
483 rajveer 1304 
    self.send_changeOrderStatus(orderId, status, description)
1305 
    return self.recv_changeOrderStatus()
94 ashish 1306 
 
483 rajveer 1307 
  def send_changeOrderStatus(self, orderId, status, description):
1308 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1309 
    args = changeOrderStatus_args()
1310 
    args.orderId = orderId
1311 
    args.status = status
1312 
    args.description = description
94 ashish 1313 
    args.write(self._oprot)
1314 
    self._oprot.writeMessageEnd()
1315 
    self._oprot.trans.flush()
1316 
 
483 rajveer 1317 
  def recv_changeOrderStatus(self, ):
94 ashish 1318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1319 
    if mtype == TMessageType.EXCEPTION:
1320 
      x = TApplicationException()
1321 
      x.read(self._iprot)
1322 
      self._iprot.readMessageEnd()
1323 
      raise x
483 rajveer 1324 
    result = changeOrderStatus_result()
94 ashish 1325 
    result.read(self._iprot)
1326 
    self._iprot.readMessageEnd()
3431 rajveer 1327 
    if result.success is not None:
94 ashish 1328 
      return result.success
3431 rajveer 1329 
    if result.ex is not None:
94 ashish 1330 
      raise result.ex
483 rajveer 1331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1332 
 
1528 ankur.sing 1333 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1334 
    """
1528 ankur.sing 1335 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1336 
    only user who owns the transaction can view its order details.
3431 rajveer 1337 
 
94 ashish 1338 
    Parameters:
1339 
     - transactionId
1528 ankur.sing 1340 
     - customerId
94 ashish 1341 
    """
1528 ankur.sing 1342 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1343 
    return self.recv_getOrdersForTransaction()
94 ashish 1344 
 
1528 ankur.sing 1345 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1346 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1347 
    args = getOrdersForTransaction_args()
94 ashish 1348 
    args.transactionId = transactionId
1528 ankur.sing 1349 
    args.customerId = customerId
94 ashish 1350 
    args.write(self._oprot)
1351 
    self._oprot.writeMessageEnd()
1352 
    self._oprot.trans.flush()
1353 
 
483 rajveer 1354 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1356 
    if mtype == TMessageType.EXCEPTION:
1357 
      x = TApplicationException()
1358 
      x.read(self._iprot)
1359 
      self._iprot.readMessageEnd()
1360 
      raise x
483 rajveer 1361 
    result = getOrdersForTransaction_result()
94 ashish 1362 
    result.read(self._iprot)
1363 
    self._iprot.readMessageEnd()
3431 rajveer 1364 
    if result.success is not None:
94 ashish 1365 
      return result.success
3431 rajveer 1366 
    if result.ex is not None:
94 ashish 1367 
      raise result.ex
483 rajveer 1368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1369 
 
3014 chandransh 1370 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1371 
    """
3014 chandransh 1372 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1373 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1374 
 
94 ashish 1375 
    Parameters:
483 rajveer 1376 
     - customerId
1377 
     - from_date
1378 
     - to_date
3014 chandransh 1379 
     - statuses
94 ashish 1380 
    """
3014 chandransh 1381 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1382 
    return self.recv_getOrdersForCustomer()
94 ashish 1383 
 
3014 chandransh 1384 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1385 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1386 
    args = getOrdersForCustomer_args()
1387 
    args.customerId = customerId
1388 
    args.from_date = from_date
1389 
    args.to_date = to_date
3014 chandransh 1390 
    args.statuses = statuses
94 ashish 1391 
    args.write(self._oprot)
1392 
    self._oprot.writeMessageEnd()
1393 
    self._oprot.trans.flush()
1394 
 
483 rajveer 1395 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1397 
    if mtype == TMessageType.EXCEPTION:
1398 
      x = TApplicationException()
1399 
      x.read(self._iprot)
1400 
      self._iprot.readMessageEnd()
1401 
      raise x
483 rajveer 1402 
    result = getOrdersForCustomer_result()
94 ashish 1403 
    result.read(self._iprot)
1404 
    self._iprot.readMessageEnd()
3431 rajveer 1405 
    if result.success is not None:
94 ashish 1406 
      return result.success
3431 rajveer 1407 
    if result.ex is not None:
94 ashish 1408 
      raise result.ex
483 rajveer 1409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1410 
 
483 rajveer 1411 
  def createOrder(self, order):
94 ashish 1412 
    """
1413 
    Parameters:
483 rajveer 1414 
     - order
94 ashish 1415 
    """
483 rajveer 1416 
    self.send_createOrder(order)
1417 
    return self.recv_createOrder()
94 ashish 1418 
 
483 rajveer 1419 
  def send_createOrder(self, order):
1420 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1421 
    args = createOrder_args()
1422 
    args.order = order
94 ashish 1423 
    args.write(self._oprot)
1424 
    self._oprot.writeMessageEnd()
1425 
    self._oprot.trans.flush()
1426 
 
483 rajveer 1427 
  def recv_createOrder(self, ):
94 ashish 1428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1429 
    if mtype == TMessageType.EXCEPTION:
1430 
      x = TApplicationException()
1431 
      x.read(self._iprot)
1432 
      self._iprot.readMessageEnd()
1433 
      raise x
483 rajveer 1434 
    result = createOrder_result()
94 ashish 1435 
    result.read(self._iprot)
1436 
    self._iprot.readMessageEnd()
3431 rajveer 1437 
    if result.success is not None:
94 ashish 1438 
      return result.success
3431 rajveer 1439 
    if result.ex is not None:
94 ashish 1440 
      raise result.ex
483 rajveer 1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1442 
 
483 rajveer 1443 
  def getOrder(self, id):
94 ashish 1444 
    """
1445 
    Parameters:
483 rajveer 1446 
     - id
94 ashish 1447 
    """
483 rajveer 1448 
    self.send_getOrder(id)
1449 
    return self.recv_getOrder()
94 ashish 1450 
 
483 rajveer 1451 
  def send_getOrder(self, id):
1452 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1453 
    args = getOrder_args()
1454 
    args.id = id
94 ashish 1455 
    args.write(self._oprot)
1456 
    self._oprot.writeMessageEnd()
1457 
    self._oprot.trans.flush()
1458 
 
483 rajveer 1459 
  def recv_getOrder(self, ):
94 ashish 1460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1461 
    if mtype == TMessageType.EXCEPTION:
1462 
      x = TApplicationException()
1463 
      x.read(self._iprot)
1464 
      self._iprot.readMessageEnd()
1465 
      raise x
483 rajveer 1466 
    result = getOrder_result()
94 ashish 1467 
    result.read(self._iprot)
1468 
    self._iprot.readMessageEnd()
3431 rajveer 1469 
    if result.success is not None:
94 ashish 1470 
      return result.success
3431 rajveer 1471 
    if result.ex is not None:
94 ashish 1472 
      raise result.ex
483 rajveer 1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1474 
 
483 rajveer 1475 
  def getLineItemsForOrder(self, orderId):
94 ashish 1476 
    """
1477 
    Parameters:
483 rajveer 1478 
     - orderId
94 ashish 1479 
    """
483 rajveer 1480 
    self.send_getLineItemsForOrder(orderId)
1481 
    return self.recv_getLineItemsForOrder()
94 ashish 1482 
 
483 rajveer 1483 
  def send_getLineItemsForOrder(self, orderId):
1484 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1485 
    args = getLineItemsForOrder_args()
1486 
    args.orderId = orderId
94 ashish 1487 
    args.write(self._oprot)
1488 
    self._oprot.writeMessageEnd()
1489 
    self._oprot.trans.flush()
1490 
 
483 rajveer 1491 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1493 
    if mtype == TMessageType.EXCEPTION:
1494 
      x = TApplicationException()
1495 
      x.read(self._iprot)
1496 
      self._iprot.readMessageEnd()
1497 
      raise x
483 rajveer 1498 
    result = getLineItemsForOrder_result()
94 ashish 1499 
    result.read(self._iprot)
1500 
    self._iprot.readMessageEnd()
3431 rajveer 1501 
    if result.success is not None:
94 ashish 1502 
      return result.success
3431 rajveer 1503 
    if result.ex is not None:
94 ashish 1504 
      raise result.ex
483 rajveer 1505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1506 
 
1528 ankur.sing 1507 
  def getOrderForCustomer(self, orderId, customerId):
1508 
    """
1509 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1510 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1511 
 
1528 ankur.sing 1512 
    Parameters:
1513 
     - orderId
1514 
     - customerId
1515 
    """
1516 
    self.send_getOrderForCustomer(orderId, customerId)
1517 
    return self.recv_getOrderForCustomer()
1518 
 
1519 
  def send_getOrderForCustomer(self, orderId, customerId):
1520 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1521 
    args = getOrderForCustomer_args()
1522 
    args.orderId = orderId
1523 
    args.customerId = customerId
1524 
    args.write(self._oprot)
1525 
    self._oprot.writeMessageEnd()
1526 
    self._oprot.trans.flush()
1527 
 
1528 
  def recv_getOrderForCustomer(self, ):
1529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1530 
    if mtype == TMessageType.EXCEPTION:
1531 
      x = TApplicationException()
1532 
      x.read(self._iprot)
1533 
      self._iprot.readMessageEnd()
1534 
      raise x
1535 
    result = getOrderForCustomer_result()
1536 
    result.read(self._iprot)
1537 
    self._iprot.readMessageEnd()
3431 rajveer 1538 
    if result.success is not None:
1528 ankur.sing 1539 
      return result.success
3431 rajveer 1540 
    if result.ex is not None:
1528 ankur.sing 1541 
      raise result.ex
1542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1543 
 
3064 chandransh 1544 
  def getAlerts(self, orderId, valid):
1545 
    """
1546 
    Parameters:
1547 
     - orderId
1548 
     - valid
1549 
    """
1550 
    self.send_getAlerts(orderId, valid)
1551 
    return self.recv_getAlerts()
1552 
 
1553 
  def send_getAlerts(self, orderId, valid):
1554 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1555 
    args = getAlerts_args()
1556 
    args.orderId = orderId
1557 
    args.valid = valid
1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_getAlerts(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = getAlerts_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
3431 rajveer 1572 
    if result.success is not None:
3064 chandransh 1573 
      return result.success
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1575 
 
1576 
  def setAlert(self, orderId, unset, type, comment):
1577 
    """
1578 
    Parameters:
1579 
     - orderId
1580 
     - unset
1581 
     - type
1582 
     - comment
1583 
    """
1584 
    self.send_setAlert(orderId, unset, type, comment)
1585 
    self.recv_setAlert()
1586 
 
1587 
  def send_setAlert(self, orderId, unset, type, comment):
1588 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1589 
    args = setAlert_args()
1590 
    args.orderId = orderId
1591 
    args.unset = unset
1592 
    args.type = type
1593 
    args.comment = comment
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_setAlert(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = setAlert_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
1608 
    return
1609 
 
1610 
  def getValidOrderCount(self, ):
1611 
    """
1612 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1613 
    """
1614 
    self.send_getValidOrderCount()
1615 
    return self.recv_getValidOrderCount()
1616 
 
1617 
  def send_getValidOrderCount(self, ):
1618 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1619 
    args = getValidOrderCount_args()
1620 
    args.write(self._oprot)
1621 
    self._oprot.writeMessageEnd()
1622 
    self._oprot.trans.flush()
1623 
 
1624 
  def recv_getValidOrderCount(self, ):
1625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1626 
    if mtype == TMessageType.EXCEPTION:
1627 
      x = TApplicationException()
1628 
      x.read(self._iprot)
1629 
      self._iprot.readMessageEnd()
1630 
      raise x
1631 
    result = getValidOrderCount_result()
1632 
    result.read(self._iprot)
1633 
    self._iprot.readMessageEnd()
3431 rajveer 1634 
    if result.success is not None:
3064 chandransh 1635 
      return result.success
1636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1637 
 
1638 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1639 
    """
1640 
    Returns the number of distinct customers who have done successful transactions
1641 
    """
1642 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1643 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1644 
 
1645 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1646 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1647 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
1652 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
1659 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
3431 rajveer 1662 
    if result.success is not None:
3064 chandransh 1663 
      return result.success
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1665 
 
1666 
  def getValidOrdersAmountRange(self, ):
1667 
    """
1668 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1669 
    List contains two values, first minimum amount and second maximum amount.
1670 
    """
1671 
    self.send_getValidOrdersAmountRange()
1672 
    return self.recv_getValidOrdersAmountRange()
1673 
 
1674 
  def send_getValidOrdersAmountRange(self, ):
1675 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1676 
    args = getValidOrdersAmountRange_args()
1677 
    args.write(self._oprot)
1678 
    self._oprot.writeMessageEnd()
1679 
    self._oprot.trans.flush()
1680 
 
1681 
  def recv_getValidOrdersAmountRange(self, ):
1682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1683 
    if mtype == TMessageType.EXCEPTION:
1684 
      x = TApplicationException()
1685 
      x.read(self._iprot)
1686 
      self._iprot.readMessageEnd()
1687 
      raise x
1688 
    result = getValidOrdersAmountRange_result()
1689 
    result.read(self._iprot)
1690 
    self._iprot.readMessageEnd()
3431 rajveer 1691 
    if result.success is not None:
3064 chandransh 1692 
      return result.success
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1694 
 
1695 
  def getValidOrders(self, limit):
1696 
    """
1697 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1698 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1699 
 
3064 chandransh 1700 
    Parameters:
1701 
     - limit
1702 
    """
1703 
    self.send_getValidOrders(limit)
1704 
    return self.recv_getValidOrders()
1705 
 
1706 
  def send_getValidOrders(self, limit):
1707 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1708 
    args = getValidOrders_args()
1709 
    args.limit = limit
1710 
    args.write(self._oprot)
1711 
    self._oprot.writeMessageEnd()
1712 
    self._oprot.trans.flush()
1713 
 
1714 
  def recv_getValidOrders(self, ):
1715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1716 
    if mtype == TMessageType.EXCEPTION:
1717 
      x = TApplicationException()
1718 
      x.read(self._iprot)
1719 
      self._iprot.readMessageEnd()
1720 
      raise x
1721 
    result = getValidOrders_result()
1722 
    result.read(self._iprot)
1723 
    self._iprot.readMessageEnd()
3431 rajveer 1724 
    if result.success is not None:
3064 chandransh 1725 
      return result.success
1726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1727 
 
1220 chandransh 1728 
  def batchOrders(self, warehouseId):
1729 
    """
1730 
    Create a batch of all the pending orders for the given warehouse.
1731 
    The returned list is orderd by created_timestamp.
1732 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1733 
 
1220 chandransh 1734 
    Parameters:
1735 
     - warehouseId
1736 
    """
1737 
    self.send_batchOrders(warehouseId)
1738 
    return self.recv_batchOrders()
1739 
 
1740 
  def send_batchOrders(self, warehouseId):
1741 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1742 
    args = batchOrders_args()
1743 
    args.warehouseId = warehouseId
1744 
    args.write(self._oprot)
1745 
    self._oprot.writeMessageEnd()
1746 
    self._oprot.trans.flush()
1747 
 
1748 
  def recv_batchOrders(self, ):
1749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1750 
    if mtype == TMessageType.EXCEPTION:
1751 
      x = TApplicationException()
1752 
      x.read(self._iprot)
1753 
      self._iprot.readMessageEnd()
1754 
      raise x
1755 
    result = batchOrders_result()
1756 
    result.read(self._iprot)
1757 
    self._iprot.readMessageEnd()
3431 rajveer 1758 
    if result.success is not None:
1220 chandransh 1759 
      return result.success
3431 rajveer 1760 
    if result.ex is not None:
1220 chandransh 1761 
      raise result.ex
1762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1763 
 
1208 chandransh 1764 
  def markOrderAsOutOfStock(self, orderId):
1765 
    """
1766 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1767 
 
1208 chandransh 1768 
    Parameters:
1769 
     - orderId
1770 
    """
1771 
    self.send_markOrderAsOutOfStock(orderId)
1772 
    return self.recv_markOrderAsOutOfStock()
1773 
 
1774 
  def send_markOrderAsOutOfStock(self, orderId):
1775 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1776 
    args = markOrderAsOutOfStock_args()
1777 
    args.orderId = orderId
1778 
    args.write(self._oprot)
1779 
    self._oprot.writeMessageEnd()
1780 
    self._oprot.trans.flush()
1781 
 
1782 
  def recv_markOrderAsOutOfStock(self, ):
1783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1784 
    if mtype == TMessageType.EXCEPTION:
1785 
      x = TApplicationException()
1786 
      x.read(self._iprot)
1787 
      self._iprot.readMessageEnd()
1788 
      raise x
1789 
    result = markOrderAsOutOfStock_result()
1790 
    result.read(self._iprot)
1791 
    self._iprot.readMessageEnd()
3431 rajveer 1792 
    if result.success is not None:
1208 chandransh 1793 
      return result.success
3431 rajveer 1794 
    if result.ex is not None:
1208 chandransh 1795 
      raise result.ex
1796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1797 
 
3064 chandransh 1798 
  def verifyOrder(self, orderId):
759 chandransh 1799 
    """
3064 chandransh 1800 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1801 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1802 
    used for all other orders as well.
1803 
    Throws an exception if no such order exists.
3431 rajveer 1804 
 
759 chandransh 1805 
    Parameters:
3064 chandransh 1806 
     - orderId
759 chandransh 1807 
    """
3064 chandransh 1808 
    self.send_verifyOrder(orderId)
1809 
    return self.recv_verifyOrder()
759 chandransh 1810 
 
3064 chandransh 1811 
  def send_verifyOrder(self, orderId):
1812 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1813 
    args = verifyOrder_args()
1814 
    args.orderId = orderId
759 chandransh 1815 
    args.write(self._oprot)
1816 
    self._oprot.writeMessageEnd()
1817 
    self._oprot.trans.flush()
1818 
 
3064 chandransh 1819 
  def recv_verifyOrder(self, ):
759 chandransh 1820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1821 
    if mtype == TMessageType.EXCEPTION:
1822 
      x = TApplicationException()
1823 
      x.read(self._iprot)
1824 
      self._iprot.readMessageEnd()
1825 
      raise x
3064 chandransh 1826 
    result = verifyOrder_result()
759 chandransh 1827 
    result.read(self._iprot)
1828 
    self._iprot.readMessageEnd()
3431 rajveer 1829 
    if result.success is not None:
759 chandransh 1830 
      return result.success
3431 rajveer 1831 
    if result.ex is not None:
759 chandransh 1832 
      raise result.ex
3064 chandransh 1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1834 
 
3064 chandransh 1835 
  def acceptOrder(self, orderId):
1113 chandransh 1836 
    """
3064 chandransh 1837 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1838 
    given order is not a COD order, it also captures the payment if the same has
1839 
    not been captured.
1840 
    Throws an exception if no such order exists.
3431 rajveer 1841 
 
1113 chandransh 1842 
    Parameters:
3064 chandransh 1843 
     - orderId
1113 chandransh 1844 
    """
3064 chandransh 1845 
    self.send_acceptOrder(orderId)
1846 
    return self.recv_acceptOrder()
1113 chandransh 1847 
 
3064 chandransh 1848 
  def send_acceptOrder(self, orderId):
1849 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1850 
    args = acceptOrder_args()
1851 
    args.orderId = orderId
1113 chandransh 1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
3064 chandransh 1856 
  def recv_acceptOrder(self, ):
1113 chandransh 1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
3064 chandransh 1863 
    result = acceptOrder_result()
1113 chandransh 1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
3431 rajveer 1866 
    if result.success is not None:
1113 chandransh 1867 
      return result.success
3431 rajveer 1868 
    if result.ex is not None:
1113 chandransh 1869 
      raise result.ex
3064 chandransh 1870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1871 
 
4283 anupam.sin 1872 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1873 
    """
3064 chandransh 1874 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1875 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1876 
    the IMEI no. if a -1 is supplied.
1877 
    Also, it generates an invoice number for the order, marks the order as
1878 
    BILLED and sets the billing timestamp.
1879 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1880 
 
1135 chandransh 1881 
    Parameters:
3064 chandransh 1882 
     - orderId
1883 
     - invoice_number
4283 anupam.sin 1884 
     - imeiNumber
1885 
     - itemNumber
3064 chandransh 1886 
     - billed_by
4264 rajveer 1887 
     - jacketNumber
4283 anupam.sin 1888 
     - billingType
1889 
     - vendorId
1135 chandransh 1890 
    """
4283 anupam.sin 1891 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1892 
    return self.recv_addBillingDetails()
1135 chandransh 1893 
 
4283 anupam.sin 1894 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1895 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1896 
    args = addBillingDetails_args()
1897 
    args.orderId = orderId
1898 
    args.invoice_number = invoice_number
4283 anupam.sin 1899 
    args.imeiNumber = imeiNumber
1900 
    args.itemNumber = itemNumber
3064 chandransh 1901 
    args.billed_by = billed_by
4264 rajveer 1902 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1903 
    args.billingType = billingType
1904 
    args.vendorId = vendorId
1135 chandransh 1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
3064 chandransh 1909 
  def recv_addBillingDetails(self, ):
1135 chandransh 1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
3064 chandransh 1916 
    result = addBillingDetails_result()
1135 chandransh 1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
3431 rajveer 1919 
    if result.success is not None:
3064 chandransh 1920 
      return result.success
3431 rajveer 1921 
    if result.ex is not None:
1135 chandransh 1922 
      raise result.ex
3064 chandransh 1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1924 
 
3064 chandransh 1925 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1926 
    """
3064 chandransh 1927 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1928 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1929 
 
1408 ankur.sing 1930 
    Parameters:
3064 chandransh 1931 
     - warehouseId
1408 ankur.sing 1932 
     - providerId
3064 chandransh 1933 
     - cod
1408 ankur.sing 1934 
    """
3064 chandransh 1935 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1936 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1937 
 
3064 chandransh 1938 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1939 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1940 
    args = markOrdersAsManifested_args()
1941 
    args.warehouseId = warehouseId
1408 ankur.sing 1942 
    args.providerId = providerId
3064 chandransh 1943 
    args.cod = cod
1408 ankur.sing 1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
3064 chandransh 1948 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
3064 chandransh 1955 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
3431 rajveer 1958 
    if result.success is not None:
1408 ankur.sing 1959 
      return result.success
3431 rajveer 1960 
    if result.ex is not None:
3064 chandransh 1961 
      raise result.ex
1962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1963 
 
3064 chandransh 1964 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1965 
    """
3064 chandransh 1966 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1967 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1968 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1969 
 
94 ashish 1970 
    Parameters:
3064 chandransh 1971 
     - providerId
1972 
     - pickupDetails
304 ashish 1973 
    """
3064 chandransh 1974 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1975 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1976 
 
3064 chandransh 1977 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1978 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1979 
    args = markOrdersAsPickedUp_args()
1980 
    args.providerId = providerId
1981 
    args.pickupDetails = pickupDetails
304 ashish 1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
3064 chandransh 1986 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
3064 chandransh 1993 
    result = markOrdersAsPickedUp_result()
304 ashish 1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
3431 rajveer 1996 
    if result.success is not None:
304 ashish 1997 
      return result.success
3431 rajveer 1998 
    if result.ex is not None:
3064 chandransh 1999 
      raise result.ex
2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2001 
 
3064 chandransh 2002 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2003 
    """
3064 chandransh 2004 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2005 
    the name of the receiver.
2006 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2007 
 
304 ashish 2008 
    Parameters:
3064 chandransh 2009 
     - providerId
2010 
     - deliveredOrders
304 ashish 2011 
    """
3064 chandransh 2012 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2013 
    self.recv_markOrdersAsDelivered()
304 ashish 2014 
 
3064 chandransh 2015 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2016 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2017 
    args = markOrdersAsDelivered_args()
2018 
    args.providerId = providerId
2019 
    args.deliveredOrders = deliveredOrders
304 ashish 2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
3064 chandransh 2024 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
3064 chandransh 2031 
    result = markOrdersAsDelivered_result()
304 ashish 2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
3431 rajveer 2034 
    if result.ex is not None:
3064 chandransh 2035 
      raise result.ex
304 ashish 2036 
    return
2037 
 
3064 chandransh 2038 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2039 
    """
3064 chandransh 2040 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2041 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2042 
 
3064 chandransh 2043 
    Parameters:
2044 
     - providerId
2045 
     - returnedOrders
1596 ankur.sing 2046 
    """
3064 chandransh 2047 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2048 
    self.recv_markOrdersAsFailed()
304 ashish 2049 
 
3064 chandransh 2050 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2051 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2052 
    args = markOrdersAsFailed_args()
2053 
    args.providerId = providerId
2054 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
3064 chandransh 2059 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
3064 chandransh 2066 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
3431 rajveer 2069 
    if result.ex is not None:
3064 chandransh 2070 
      raise result.ex
2071 
    return
1596 ankur.sing 2072 
 
3064 chandransh 2073 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2074 
    """
3064 chandransh 2075 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2076 
 
3064 chandransh 2077 
    Parameters:
2078 
     - providerId
2079 
     - undeliveredOrders
1627 ankur.sing 2080 
    """
3064 chandransh 2081 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2082 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2083 
 
3064 chandransh 2084 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2085 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2086 
    args = updateNonDeliveryReason_args()
2087 
    args.providerId = providerId
2088 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
3064 chandransh 2093 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
3064 chandransh 2100 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
3431 rajveer 2103 
    if result.ex is not None:
3064 chandransh 2104 
      raise result.ex
2105 
    return
1627 ankur.sing 2106 
 
3064 chandransh 2107 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2108 
    """
3064 chandransh 2109 
    Returns the list of orders whose delivery time has passed but have not been
2110 
    delivered yet for the given provider and warehouse. To get a complete list of
2111 
    undelivered orders, pass them as -1.
2112 
    Returns an empty list if no such orders exist.
3431 rajveer 2113 
 
1886 ankur.sing 2114 
    Parameters:
3064 chandransh 2115 
     - providerId
2116 
     - warehouseId
1886 ankur.sing 2117 
    """
3064 chandransh 2118 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2119 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2120 
 
3064 chandransh 2121 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2122 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2123 
    args = getUndeliveredOrders_args()
2124 
    args.providerId = providerId
2125 
    args.warehouseId = warehouseId
1886 ankur.sing 2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
3064 chandransh 2130 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
3064 chandransh 2137 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
3431 rajveer 2140 
    if result.success is not None:
1886 ankur.sing 2141 
      return result.success
3064 chandransh 2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2143 
 
2536 chandransh 2144 
  def toggleDOAFlag(self, orderId):
2145 
    """
2146 
    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.
2147 
    Returns the final flag status.
2148 
    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 2149 
 
2536 chandransh 2150 
    Parameters:
2151 
     - orderId
2152 
    """
2153 
    self.send_toggleDOAFlag(orderId)
2154 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2155 
 
2536 chandransh 2156 
  def send_toggleDOAFlag(self, orderId):
2157 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2158 
    args = toggleDOAFlag_args()
2159 
    args.orderId = orderId
2160 
    args.write(self._oprot)
2161 
    self._oprot.writeMessageEnd()
2162 
    self._oprot.trans.flush()
2163 
 
2164 
  def recv_toggleDOAFlag(self, ):
2165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2166 
    if mtype == TMessageType.EXCEPTION:
2167 
      x = TApplicationException()
2168 
      x.read(self._iprot)
2169 
      self._iprot.readMessageEnd()
2170 
      raise x
2171 
    result = toggleDOAFlag_result()
2172 
    result.read(self._iprot)
2173 
    self._iprot.readMessageEnd()
3431 rajveer 2174 
    if result.success is not None:
2536 chandransh 2175 
      return result.success
3431 rajveer 2176 
    if result.ex is not None:
2536 chandransh 2177 
      raise result.ex
2178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2179 
 
2180 
  def requestPickupNumber(self, orderId):
2181 
    """
2182 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2183 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2184 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2185 
    For any other status, it returns false.
2186 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2187 
 
2536 chandransh 2188 
    Parameters:
2189 
     - orderId
2190 
    """
2191 
    self.send_requestPickupNumber(orderId)
2192 
    return self.recv_requestPickupNumber()
2193 
 
2194 
  def send_requestPickupNumber(self, orderId):
2195 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2196 
    args = requestPickupNumber_args()
2197 
    args.orderId = orderId
2198 
    args.write(self._oprot)
2199 
    self._oprot.writeMessageEnd()
2200 
    self._oprot.trans.flush()
2201 
 
2202 
  def recv_requestPickupNumber(self, ):
2203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2204 
    if mtype == TMessageType.EXCEPTION:
2205 
      x = TApplicationException()
2206 
      x.read(self._iprot)
2207 
      self._iprot.readMessageEnd()
2208 
      raise x
2209 
    result = requestPickupNumber_result()
2210 
    result.read(self._iprot)
2211 
    self._iprot.readMessageEnd()
3431 rajveer 2212 
    if result.success is not None:
2536 chandransh 2213 
      return result.success
3431 rajveer 2214 
    if result.ex is not None:
2536 chandransh 2215 
      raise result.ex
2216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2217 
 
2218 
  def authorizePickup(self, orderId, pickupNumber):
2219 
    """
2220 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2221 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2222 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2223 
    	3. Returns true
2591 chandransh 2224 
    If the order is in any other status, it returns false.
2536 chandransh 2225 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2226 
 
2536 chandransh 2227 
    Parameters:
2228 
     - orderId
2229 
     - pickupNumber
2230 
    """
2231 
    self.send_authorizePickup(orderId, pickupNumber)
2232 
    return self.recv_authorizePickup()
2233 
 
2234 
  def send_authorizePickup(self, orderId, pickupNumber):
2235 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2236 
    args = authorizePickup_args()
2237 
    args.orderId = orderId
2238 
    args.pickupNumber = pickupNumber
2239 
    args.write(self._oprot)
2240 
    self._oprot.writeMessageEnd()
2241 
    self._oprot.trans.flush()
2242 
 
2243 
  def recv_authorizePickup(self, ):
2244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2245 
    if mtype == TMessageType.EXCEPTION:
2246 
      x = TApplicationException()
2247 
      x.read(self._iprot)
2248 
      self._iprot.readMessageEnd()
2249 
      raise x
2250 
    result = authorizePickup_result()
2251 
    result.read(self._iprot)
2252 
    self._iprot.readMessageEnd()
3431 rajveer 2253 
    if result.success is not None:
2536 chandransh 2254 
      return result.success
3431 rajveer 2255 
    if result.ex is not None:
2536 chandransh 2256 
      raise result.ex
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2258 
 
2764 chandransh 2259 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2260 
    """
2261 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2262 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2263 
 
2764 chandransh 2264 
    Parameters:
2265 
     - providerId
2266 
     - pickupDetails
2267 
    """
2268 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2269 
    return self.recv_markDoasAsPickedUp()
2270 
 
2271 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2272 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2273 
    args = markDoasAsPickedUp_args()
2274 
    args.providerId = providerId
2275 
    args.pickupDetails = pickupDetails
2276 
    args.write(self._oprot)
2277 
    self._oprot.writeMessageEnd()
2278 
    self._oprot.trans.flush()
2279 
 
2280 
  def recv_markDoasAsPickedUp(self, ):
2281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2282 
    if mtype == TMessageType.EXCEPTION:
2283 
      x = TApplicationException()
2284 
      x.read(self._iprot)
2285 
      self._iprot.readMessageEnd()
2286 
      raise x
2287 
    result = markDoasAsPickedUp_result()
2288 
    result.read(self._iprot)
2289 
    self._iprot.readMessageEnd()
3431 rajveer 2290 
    if result.success is not None:
2764 chandransh 2291 
      return result.success
2292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2293 
 
2616 chandransh 2294 
  def receiveReturn(self, orderId):
2591 chandransh 2295 
    """
2599 chandransh 2296 
    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 2297 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2298 
    If the order is in any other state, it returns false.
2299 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2300 
 
2591 chandransh 2301 
    Parameters:
2302 
     - orderId
2303 
    """
2616 chandransh 2304 
    self.send_receiveReturn(orderId)
2305 
    return self.recv_receiveReturn()
2536 chandransh 2306 
 
2616 chandransh 2307 
  def send_receiveReturn(self, orderId):
2308 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2309 
    args = receiveReturn_args()
2591 chandransh 2310 
    args.orderId = orderId
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2616 chandransh 2315 
  def recv_receiveReturn(self, ):
2591 chandransh 2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2616 chandransh 2322 
    result = receiveReturn_result()
2591 chandransh 2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.success is not None:
2591 chandransh 2326 
      return result.success
3431 rajveer 2327 
    if result.ex is not None:
2591 chandransh 2328 
      raise result.ex
2616 chandransh 2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2330 
 
2331 
  def validateDoa(self, orderId, isValid):
2332 
    """
2599 chandransh 2333 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2334 
    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 2335 
    If the order is in any other state, it returns false.
2336 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2337 
 
2591 chandransh 2338 
    Parameters:
2339 
     - orderId
2340 
     - isValid
2341 
    """
2342 
    self.send_validateDoa(orderId, isValid)
2343 
    return self.recv_validateDoa()
2344 
 
2345 
  def send_validateDoa(self, orderId, isValid):
2346 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2347 
    args = validateDoa_args()
2348 
    args.orderId = orderId
2349 
    args.isValid = isValid
2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_validateDoa(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = validateDoa_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
3431 rajveer 2364 
    if result.success is not None:
2591 chandransh 2365 
      return result.success
3431 rajveer 2366 
    if result.ex is not None:
2591 chandransh 2367 
      raise result.ex
2368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2369 
 
2616 chandransh 2370 
  def reshipOrder(self, orderId):
2371 
    """
2372 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2373 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2374 
    	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.
2375 
 
2376 
    If the order is in DOA_CERT_VALID state, it does the following:
2377 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2378 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2379 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2380 
 
2616 chandransh 2381 
    Returns the id of the newly created order.
3431 rajveer 2382 
 
2616 chandransh 2383 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2384 
 
2616 chandransh 2385 
    Parameters:
2386 
     - orderId
2387 
    """
2388 
    self.send_reshipOrder(orderId)
2389 
    return self.recv_reshipOrder()
2591 chandransh 2390 
 
2616 chandransh 2391 
  def send_reshipOrder(self, orderId):
2392 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2393 
    args = reshipOrder_args()
2394 
    args.orderId = orderId
2395 
    args.write(self._oprot)
2396 
    self._oprot.writeMessageEnd()
2397 
    self._oprot.trans.flush()
2398 
 
2399 
  def recv_reshipOrder(self, ):
2400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2401 
    if mtype == TMessageType.EXCEPTION:
2402 
      x = TApplicationException()
2403 
      x.read(self._iprot)
2404 
      self._iprot.readMessageEnd()
2405 
      raise x
2406 
    result = reshipOrder_result()
2407 
    result.read(self._iprot)
2408 
    self._iprot.readMessageEnd()
3431 rajveer 2409 
    if result.success is not None:
2616 chandransh 2410 
      return result.success
3431 rajveer 2411 
    if result.ex is not None:
2616 chandransh 2412 
      raise result.ex
2413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2414 
 
3226 chandransh 2415 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2416 
    """
2417 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2418 
    	1. Creates a refund request for batch processing.
2419 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2420 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2421 
 
2616 chandransh 2422 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2423 
    	1. Creates a refund request for batch processing.
3226 chandransh 2424 
    	2. Cancels the reservation of the item in the warehouse.
2425 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2426 
 
3226 chandransh 2427 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2428 
    	1. Cancels the reservation of the item in the warehouse.
2429 
    	2. Marks the current order as CANCELED.
2430 
 
2431 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2432 
 
2616 chandransh 2433 
    Returns True if it is successful, False otherwise.
3431 rajveer 2434 
 
2616 chandransh 2435 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2436 
 
2616 chandransh 2437 
    Parameters:
2438 
     - orderId
3226 chandransh 2439 
     - refundedBy
2440 
     - reason
2616 chandransh 2441 
    """
3226 chandransh 2442 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2443 
    return self.recv_refundOrder()
2444 
 
3226 chandransh 2445 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2446 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2447 
    args = refundOrder_args()
2448 
    args.orderId = orderId
3226 chandransh 2449 
    args.refundedBy = refundedBy
2450 
    args.reason = reason
2616 chandransh 2451 
    args.write(self._oprot)
2452 
    self._oprot.writeMessageEnd()
2453 
    self._oprot.trans.flush()
2454 
 
2455 
  def recv_refundOrder(self, ):
2456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2457 
    if mtype == TMessageType.EXCEPTION:
2458 
      x = TApplicationException()
2459 
      x.read(self._iprot)
2460 
      self._iprot.readMessageEnd()
2461 
      raise x
2462 
    result = refundOrder_result()
2463 
    result.read(self._iprot)
2464 
    self._iprot.readMessageEnd()
3431 rajveer 2465 
    if result.success is not None:
2616 chandransh 2466 
      return result.success
3431 rajveer 2467 
    if result.ex is not None:
2616 chandransh 2468 
      raise result.ex
2469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2470 
 
2690 chandransh 2471 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2472 
    """
2473 
    Get all return orders created between the from and to dates for the given warehouse.
2474 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2475 
 
2690 chandransh 2476 
    Parameters:
2477 
     - warehouseId
2478 
     - fromDate
2479 
     - toDate
2480 
    """
2481 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2482 
    return self.recv_getReturnOrders()
2616 chandransh 2483 
 
2690 chandransh 2484 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2485 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2486 
    args = getReturnOrders_args()
2487 
    args.warehouseId = warehouseId
2488 
    args.fromDate = fromDate
2489 
    args.toDate = toDate
2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
2494 
  def recv_getReturnOrders(self, ):
2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
2501 
    result = getReturnOrders_result()
2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
3431 rajveer 2504 
    if result.success is not None:
2690 chandransh 2505 
      return result.success
2506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2507 
 
2700 chandransh 2508 
  def getReturnOrder(self, id):
2509 
    """
2510 
    Returns the ReturnOrder corresponding to the given id.
2511 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2512 
 
2700 chandransh 2513 
    Parameters:
2514 
     - id
2515 
    """
2516 
    self.send_getReturnOrder(id)
2517 
    return self.recv_getReturnOrder()
2518 
 
2519 
  def send_getReturnOrder(self, id):
2520 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2521 
    args = getReturnOrder_args()
2522 
    args.id = id
2523 
    args.write(self._oprot)
2524 
    self._oprot.writeMessageEnd()
2525 
    self._oprot.trans.flush()
2526 
 
2527 
  def recv_getReturnOrder(self, ):
2528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2529 
    if mtype == TMessageType.EXCEPTION:
2530 
      x = TApplicationException()
2531 
      x.read(self._iprot)
2532 
      self._iprot.readMessageEnd()
2533 
      raise x
2534 
    result = getReturnOrder_result()
2535 
    result.read(self._iprot)
2536 
    self._iprot.readMessageEnd()
3431 rajveer 2537 
    if result.success is not None:
2700 chandransh 2538 
      return result.success
3431 rajveer 2539 
    if result.ex is not None:
2700 chandransh 2540 
      raise result.ex
2541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2542 
 
2690 chandransh 2543 
  def processReturn(self, returnOrderId):
2544 
    """
2545 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2546 
 
2690 chandransh 2547 
    Parameters:
2548 
     - returnOrderId
2549 
    """
2550 
    self.send_processReturn(returnOrderId)
2551 
    self.recv_processReturn()
2552 
 
2553 
  def send_processReturn(self, returnOrderId):
2554 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2555 
    args = processReturn_args()
2556 
    args.returnOrderId = returnOrderId
2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
2561 
  def recv_processReturn(self, ):
2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
2568 
    result = processReturn_result()
2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
3431 rajveer 2571 
    if result.ex is not None:
2690 chandransh 2572 
      raise result.ex
2573 
    return
2574 
 
2819 chandransh 2575 
  def createPurchaseOrder(self, warehouseId):
2576 
    """
2577 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2578 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2579 
 
2819 chandransh 2580 
    Parameters:
2581 
     - warehouseId
2582 
    """
2583 
    self.send_createPurchaseOrder(warehouseId)
2584 
    return self.recv_createPurchaseOrder()
2690 chandransh 2585 
 
2819 chandransh 2586 
  def send_createPurchaseOrder(self, warehouseId):
2587 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2588 
    args = createPurchaseOrder_args()
2589 
    args.warehouseId = warehouseId
2590 
    args.write(self._oprot)
2591 
    self._oprot.writeMessageEnd()
2592 
    self._oprot.trans.flush()
2593 
 
2594 
  def recv_createPurchaseOrder(self, ):
2595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2596 
    if mtype == TMessageType.EXCEPTION:
2597 
      x = TApplicationException()
2598 
      x.read(self._iprot)
2599 
      self._iprot.readMessageEnd()
2600 
      raise x
2601 
    result = createPurchaseOrder_result()
2602 
    result.read(self._iprot)
2603 
    self._iprot.readMessageEnd()
3431 rajveer 2604 
    if result.success is not None:
2819 chandransh 2605 
      return result.success
3431 rajveer 2606 
    if result.ex is not None:
2819 chandransh 2607 
      raise result.ex
2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2609 
 
3451 chandransh 2610 
  def updateWeight(self, orderId, weight):
2611 
    """
2612 
    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 2613 
 
3451 chandransh 2614 
    Parameters:
2615 
     - orderId
2616 
     - weight
2617 
    """
2618 
    self.send_updateWeight(orderId, weight)
2619 
    return self.recv_updateWeight()
2620 
 
2621 
  def send_updateWeight(self, orderId, weight):
2622 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2623 
    args = updateWeight_args()
2624 
    args.orderId = orderId
2625 
    args.weight = weight
2626 
    args.write(self._oprot)
2627 
    self._oprot.writeMessageEnd()
2628 
    self._oprot.trans.flush()
2629 
 
2630 
  def recv_updateWeight(self, ):
2631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2632 
    if mtype == TMessageType.EXCEPTION:
2633 
      x = TApplicationException()
2634 
      x.read(self._iprot)
2635 
      self._iprot.readMessageEnd()
2636 
      raise x
2637 
    result = updateWeight_result()
2638 
    result.read(self._iprot)
2639 
    self._iprot.readMessageEnd()
2640 
    if result.success is not None:
2641 
      return result.success
2642 
    if result.ex is not None:
2643 
      raise result.ex
2644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2645 
 
3469 chandransh 2646 
  def changeItem(self, orderId, itemId):
2647 
    """
2648 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2649 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2650 
 
3469 chandransh 2651 
    Parameters:
2652 
     - orderId
2653 
     - itemId
2654 
    """
2655 
    self.send_changeItem(orderId, itemId)
2656 
    return self.recv_changeItem()
2657 
 
2658 
  def send_changeItem(self, orderId, itemId):
2659 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2660 
    args = changeItem_args()
2661 
    args.orderId = orderId
2662 
    args.itemId = itemId
2663 
    args.write(self._oprot)
2664 
    self._oprot.writeMessageEnd()
2665 
    self._oprot.trans.flush()
2666 
 
2667 
  def recv_changeItem(self, ):
2668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2669 
    if mtype == TMessageType.EXCEPTION:
2670 
      x = TApplicationException()
2671 
      x.read(self._iprot)
2672 
      self._iprot.readMessageEnd()
2673 
      raise x
2674 
    result = changeItem_result()
2675 
    result.read(self._iprot)
2676 
    self._iprot.readMessageEnd()
2677 
    if result.success is not None:
2678 
      return result.success
2679 
    if result.ex is not None:
2680 
      raise result.ex
2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2682 
 
2683 
  def shiftToWarehouse(self, orderId, warehouseId):
2684 
    """
2685 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2686 
 
2687 
    Parameters:
2688 
     - orderId
2689 
     - warehouseId
2690 
    """
2691 
    self.send_shiftToWarehouse(orderId, warehouseId)
2692 
    return self.recv_shiftToWarehouse()
2693 
 
2694 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2695 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2696 
    args = shiftToWarehouse_args()
2697 
    args.orderId = orderId
2698 
    args.warehouseId = warehouseId
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_shiftToWarehouse(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = shiftToWarehouse_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    if result.success is not None:
2714 
      return result.success
2715 
    if result.ex is not None:
2716 
      raise result.ex
2717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2718 
 
3986 chandransh 2719 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2720 
    """
2721 
    Adds the given delay reason to the given order.
3986 chandransh 2722 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2723 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2724 
 
3553 chandransh 2725 
    Parameters:
2726 
     - orderId
2727 
     - delayReason
3986 chandransh 2728 
     - furtherDelay
3553 chandransh 2729 
    """
3986 chandransh 2730 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2731 
    return self.recv_addDelayReason()
2732 
 
3986 chandransh 2733 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2734 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2735 
    args = addDelayReason_args()
2736 
    args.orderId = orderId
2737 
    args.delayReason = delayReason
3986 chandransh 2738 
    args.furtherDelay = furtherDelay
3553 chandransh 2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
2743 
  def recv_addDelayReason(self, ):
2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
2750 
    result = addDelayReason_result()
2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
2753 
    if result.success is not None:
2754 
      return result.success
2755 
    if result.ex is not None:
2756 
      raise result.ex
2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2758 
 
3956 chandransh 2759 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2760 
    """
2761 
    Marks the COD orders with given AWB nos. as having been processed.
2762 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2763 
 
3956 chandransh 2764 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2765 
    1. There is no order corresponding to an AWB number.
2766 
    2. The captured amount for a payment exceeds the total payment.
2767 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2768 
 
2769 
    Parameters:
2770 
     - collectedAmountMap
2771 
     - xferBy
2772 
     - xferTxnId
2773 
     - xferDate
2774 
    """
2775 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2776 
    return self.recv_reconcileCodCollection()
2777 
 
2778 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2779 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2780 
    args = reconcileCodCollection_args()
2781 
    args.collectedAmountMap = collectedAmountMap
2782 
    args.xferBy = xferBy
2783 
    args.xferTxnId = xferTxnId
2784 
    args.xferDate = xferDate
2785 
    args.write(self._oprot)
2786 
    self._oprot.writeMessageEnd()
2787 
    self._oprot.trans.flush()
2788 
 
2789 
  def recv_reconcileCodCollection(self, ):
2790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2791 
    if mtype == TMessageType.EXCEPTION:
2792 
      x = TApplicationException()
2793 
      x.read(self._iprot)
2794 
      self._iprot.readMessageEnd()
2795 
      raise x
2796 
    result = reconcileCodCollection_result()
2797 
    result.read(self._iprot)
2798 
    self._iprot.readMessageEnd()
2799 
    if result.success is not None:
2800 
      return result.success
2801 
    if result.ex is not None:
2802 
      raise result.ex
2803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2804 
 
4008 mandeep.dh 2805 
  def getTransactionsRequiringExtraProcessing(self, category):
2806 
    """
4065 mandeep.dh 2807 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2808 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2809 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2810 
 
4008 mandeep.dh 2811 
    Parameters:
2812 
     - category
2813 
    """
2814 
    self.send_getTransactionsRequiringExtraProcessing(category)
2815 
    return self.recv_getTransactionsRequiringExtraProcessing()
2816 
 
2817 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2818 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2819 
    args = getTransactionsRequiringExtraProcessing_args()
2820 
    args.category = category
2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getTransactionsRequiringExtraProcessing_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success is not None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2838 
 
2839 
  def markTransactionAsProcessed(self, transactionId, category):
2840 
    """
2841 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2842 
    It essentially deletes the transaction id record for a particular
2843 
    processing type category (if present) from DB.
2844 
    This is currently used by CRM application.
4008 mandeep.dh 2845 
 
2846 
    Parameters:
2847 
     - transactionId
2848 
     - category
2849 
    """
2850 
    self.send_markTransactionAsProcessed(transactionId, category)
2851 
    self.recv_markTransactionAsProcessed()
2852 
 
2853 
  def send_markTransactionAsProcessed(self, transactionId, category):
2854 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2855 
    args = markTransactionAsProcessed_args()
2856 
    args.transactionId = transactionId
2857 
    args.category = category
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_markTransactionAsProcessed(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = markTransactionAsProcessed_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
2872 
    return
2873 
 
4018 chandransh 2874 
  def getItemWiseRiskyOrdersCount(self, ):
2875 
    """
2876 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2877 
    is defined as one whose shipping date is about to expire.
2878 
    """
2879 
    self.send_getItemWiseRiskyOrdersCount()
2880 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2881 
 
4018 chandransh 2882 
  def send_getItemWiseRiskyOrdersCount(self, ):
2883 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2884 
    args = getItemWiseRiskyOrdersCount_args()
2885 
    args.write(self._oprot)
2886 
    self._oprot.writeMessageEnd()
2887 
    self._oprot.trans.flush()
2888 
 
2889 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2891 
    if mtype == TMessageType.EXCEPTION:
2892 
      x = TApplicationException()
2893 
      x.read(self._iprot)
2894 
      self._iprot.readMessageEnd()
2895 
      raise x
2896 
    result = getItemWiseRiskyOrdersCount_result()
2897 
    result.read(self._iprot)
2898 
    self._iprot.readMessageEnd()
2899 
    if result.success is not None:
2900 
      return result.success
2901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2902 
 
4295 varun.gupt 2903 
  def getOrdersForItemIds(self, itemIds):
2904 
    """
2905 
    Returns a list of all orders which have items with given id
2906 
 
2907 
    Parameters:
2908 
     - itemIds
2909 
    """
2910 
    self.send_getOrdersForItemIds(itemIds)
2911 
    return self.recv_getOrdersForItemIds()
2912 
 
2913 
  def send_getOrdersForItemIds(self, itemIds):
2914 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2915 
    args = getOrdersForItemIds_args()
2916 
    args.itemIds = itemIds
2917 
    args.write(self._oprot)
2918 
    self._oprot.writeMessageEnd()
2919 
    self._oprot.trans.flush()
2920 
 
2921 
  def recv_getOrdersForItemIds(self, ):
2922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2923 
    if mtype == TMessageType.EXCEPTION:
2924 
      x = TApplicationException()
2925 
      x.read(self._iprot)
2926 
      self._iprot.readMessageEnd()
2927 
      raise x
2928 
    result = getOrdersForItemIds_result()
2929 
    result.read(self._iprot)
2930 
    self._iprot.readMessageEnd()
2931 
    if result.success is not None:
2932 
      return result.success
2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2934 
 
4247 rajveer 2935 
  def markOrderCancellationRequestReceived(self, orderId):
2936 
    """
2937 
    Mark order as cancellation request received. If customer sends request of cancellation of
2938 
    a particular order, this method will be called. It will just change status of the order
2939 
    depending on its current status. It also records the previous status, so that we can move
2940 
    back to that status if cancellation request is denied.
4018 chandransh 2941 
 
4247 rajveer 2942 
    Parameters:
2943 
     - orderId
2944 
    """
2945 
    self.send_markOrderCancellationRequestReceived(orderId)
2946 
    self.recv_markOrderCancellationRequestReceived()
2947 
 
2948 
  def send_markOrderCancellationRequestReceived(self, orderId):
2949 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2950 
    args = markOrderCancellationRequestReceived_args()
2951 
    args.orderId = orderId
2952 
    args.write(self._oprot)
2953 
    self._oprot.writeMessageEnd()
2954 
    self._oprot.trans.flush()
2955 
 
2956 
  def recv_markOrderCancellationRequestReceived(self, ):
2957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2958 
    if mtype == TMessageType.EXCEPTION:
2959 
      x = TApplicationException()
2960 
      x.read(self._iprot)
2961 
      self._iprot.readMessageEnd()
2962 
      raise x
2963 
    result = markOrderCancellationRequestReceived_result()
2964 
    result.read(self._iprot)
2965 
    self._iprot.readMessageEnd()
2966 
    if result.ex is not None:
2967 
      raise result.ex
2968 
    return
2969 
 
2970 
  def markOrderCancellationRequestConfirmed(self, orderId):
2971 
    """
2972 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2973 
    cancellation request confirmed. After this OM will be able to cancel the order.
2974 
 
2975 
    Parameters:
2976 
     - orderId
2977 
    """
2978 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2979 
    self.recv_markOrderCancellationRequestConfirmed()
2980 
 
2981 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2982 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2983 
    args = markOrderCancellationRequestConfirmed_args()
2984 
    args.orderId = orderId
2985 
    args.write(self._oprot)
2986 
    self._oprot.writeMessageEnd()
2987 
    self._oprot.trans.flush()
2988 
 
2989 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2991 
    if mtype == TMessageType.EXCEPTION:
2992 
      x = TApplicationException()
2993 
      x.read(self._iprot)
2994 
      self._iprot.readMessageEnd()
2995 
      raise x
2996 
    result = markOrderCancellationRequestConfirmed_result()
2997 
    result.read(self._iprot)
2998 
    self._iprot.readMessageEnd()
2999 
    if result.ex is not None:
3000 
      raise result.ex
3001 
    return
3002 
 
3003 
  def markOrderCancellationRequestDenied(self, orderId):
3004 
    """
3005 
    If we decide to not to cancel order, we will move the order ro previous status.
3006 
 
3007 
    Parameters:
3008 
     - orderId
3009 
    """
3010 
    self.send_markOrderCancellationRequestDenied(orderId)
3011 
    self.recv_markOrderCancellationRequestDenied()
3012 
 
3013 
  def send_markOrderCancellationRequestDenied(self, orderId):
3014 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3015 
    args = markOrderCancellationRequestDenied_args()
3016 
    args.orderId = orderId
3017 
    args.write(self._oprot)
3018 
    self._oprot.writeMessageEnd()
3019 
    self._oprot.trans.flush()
3020 
 
3021 
  def recv_markOrderCancellationRequestDenied(self, ):
3022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3023 
    if mtype == TMessageType.EXCEPTION:
3024 
      x = TApplicationException()
3025 
      x.read(self._iprot)
3026 
      self._iprot.readMessageEnd()
3027 
      raise x
3028 
    result = markOrderCancellationRequestDenied_result()
3029 
    result.read(self._iprot)
3030 
    self._iprot.readMessageEnd()
3031 
    if result.ex is not None:
3032 
      raise result.ex
3033 
    return
3034 
 
4258 rajveer 3035 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3036 
    """
4258 rajveer 3037 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3038 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3039 
 
3040 
    Parameters:
4258 rajveer 3041 
     - transactionId
4247 rajveer 3042 
    """
4258 rajveer 3043 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3044 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3045 
 
4258 rajveer 3046 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3047 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3048 
    args = markTransactionAsPaymentFlagRemoved_args()
3049 
    args.transactionId = transactionId
4247 rajveer 3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
4258 rajveer 3054 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
4258 rajveer 3061 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.ex is not None:
3065 
      raise result.ex
3066 
    return
3067 
 
4259 anupam.sin 3068 
  def refundTransaction(self, transactionId, refundedBy, reason):
3069 
    """
3070 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3071 
    need to be cancelled
4247 rajveer 3072 
 
4259 anupam.sin 3073 
    Parameters:
3074 
     - transactionId
3075 
     - refundedBy
3076 
     - reason
3077 
    """
3078 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3079 
    self.recv_refundTransaction()
3080 
 
3081 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3082 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3083 
    args = refundTransaction_args()
3084 
    args.transactionId = transactionId
3085 
    args.refundedBy = refundedBy
3086 
    args.reason = reason
3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_refundTransaction(self, ):
3092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3093 
    if mtype == TMessageType.EXCEPTION:
3094 
      x = TApplicationException()
3095 
      x.read(self._iprot)
3096 
      self._iprot.readMessageEnd()
3097 
      raise x
3098 
    result = refundTransaction_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.ex is not None:
3102 
      raise result.ex
3103 
    return
3104 
 
4324 mandeep.dh 3105 
  def updateShipmentAddress(self, orderId, addressId):
3106 
    """
3107 
    Updates shipment address of an order. Delivery and shipping date estimates
3108 
    etc. are also updated here.
3109 
 
3110 
    Throws TransactionServiceException in case address change is not
3111 
    possible due to certain reasons such as new pincode in address is
3112 
    not serviceable etc.
3113 
 
3114 
    Parameters:
3115 
     - orderId
3116 
     - addressId
3117 
    """
3118 
    self.send_updateShipmentAddress(orderId, addressId)
3119 
    self.recv_updateShipmentAddress()
3120 
 
3121 
  def send_updateShipmentAddress(self, orderId, addressId):
3122 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3123 
    args = updateShipmentAddress_args()
3124 
    args.orderId = orderId
3125 
    args.addressId = addressId
3126 
    args.write(self._oprot)
3127 
    self._oprot.writeMessageEnd()
3128 
    self._oprot.trans.flush()
3129 
 
3130 
  def recv_updateShipmentAddress(self, ):
3131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3132 
    if mtype == TMessageType.EXCEPTION:
3133 
      x = TApplicationException()
3134 
      x.read(self._iprot)
3135 
      self._iprot.readMessageEnd()
3136 
      raise x
3137 
    result = updateShipmentAddress_result()
3138 
    result.read(self._iprot)
3139 
    self._iprot.readMessageEnd()
3140 
    if result.ex is not None:
3141 
      raise result.ex
3142 
    return
3143 
 
4285 rajveer 3144 
  def acceptOrdersForItemId(self, itemId, inventory):
3145 
    """
3146 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3147 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3148 
 
4285 rajveer 3149 
    Parameters:
3150 
     - itemId
3151 
     - inventory
3152 
    """
3153 
    self.send_acceptOrdersForItemId(itemId, inventory)
3154 
    return self.recv_acceptOrdersForItemId()
3155 
 
3156 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3157 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3158 
    args = acceptOrdersForItemId_args()
3159 
    args.itemId = itemId
3160 
    args.inventory = inventory
3161 
    args.write(self._oprot)
3162 
    self._oprot.writeMessageEnd()
3163 
    self._oprot.trans.flush()
3164 
 
3165 
  def recv_acceptOrdersForItemId(self, ):
3166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3167 
    if mtype == TMessageType.EXCEPTION:
3168 
      x = TApplicationException()
3169 
      x.read(self._iprot)
3170 
      self._iprot.readMessageEnd()
3171 
      raise x
3172 
    result = acceptOrdersForItemId_result()
3173 
    result.read(self._iprot)
3174 
    self._iprot.readMessageEnd()
3175 
    if result.success is not None:
3176 
      return result.success
3177 
    if result.ex is not None:
3178 
      raise result.ex
3179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3180 
 
4369 rajveer 3181 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3182 
    """
3183 
    Parameters:
3184 
     - vendorId
3185 
     - itemId
3186 
     - quantity
3187 
     - estimate
4369 rajveer 3188 
     - isReminder
4303 rajveer 3189 
    """
4369 rajveer 3190 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3191 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3192 
 
4369 rajveer 3193 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3194 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3195 
    args = markOrdersAsPORaised_args()
3196 
    args.vendorId = vendorId
3197 
    args.itemId = itemId
3198 
    args.quantity = quantity
3199 
    args.estimate = estimate
4369 rajveer 3200 
    args.isReminder = isReminder
4303 rajveer 3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_markOrdersAsPORaised(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = markOrdersAsPORaised_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.ex is not None:
3216 
      raise result.ex
3217 
    return
3218 
 
4369 rajveer 3219 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3220 
    """
3221 
    Parameters:
3222 
     - vendorId
3223 
     - itemId
3224 
     - quantity
3225 
     - estimate
4369 rajveer 3226 
     - isReminder
4303 rajveer 3227 
    """
4369 rajveer 3228 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3229 
    self.recv_markOrdersAsReversalInitiated()
3230 
 
4369 rajveer 3231 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3232 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3233 
    args = markOrdersAsReversalInitiated_args()
3234 
    args.vendorId = vendorId
3235 
    args.itemId = itemId
3236 
    args.quantity = quantity
3237 
    args.estimate = estimate
4369 rajveer 3238 
    args.isReminder = isReminder
4303 rajveer 3239 
    args.write(self._oprot)
3240 
    self._oprot.writeMessageEnd()
3241 
    self._oprot.trans.flush()
3242 
 
3243 
  def recv_markOrdersAsReversalInitiated(self, ):
3244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3245 
    if mtype == TMessageType.EXCEPTION:
3246 
      x = TApplicationException()
3247 
      x.read(self._iprot)
3248 
      self._iprot.readMessageEnd()
3249 
      raise x
3250 
    result = markOrdersAsReversalInitiated_result()
3251 
    result.read(self._iprot)
3252 
    self._iprot.readMessageEnd()
3253 
    if result.ex is not None:
3254 
      raise result.ex
3255 
    return
3256 
 
4369 rajveer 3257 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3258 
    """
3259 
    Parameters:
3260 
     - vendorId
3261 
     - itemId
3262 
     - quantity
3263 
     - estimate
4369 rajveer 3264 
     - isReminder
4303 rajveer 3265 
    """
4369 rajveer 3266 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3267 
    self.recv_markOrdersAsNotAvailabke()
3268 
 
4369 rajveer 3269 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3270 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3271 
    args = markOrdersAsNotAvailabke_args()
3272 
    args.vendorId = vendorId
3273 
    args.itemId = itemId
3274 
    args.quantity = quantity
3275 
    args.estimate = estimate
4369 rajveer 3276 
    args.isReminder = isReminder
4303 rajveer 3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_markOrdersAsNotAvailabke(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = markOrdersAsNotAvailabke_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
3291 
    if result.ex is not None:
3292 
      raise result.ex
3293 
    return
3294 
 
4369 rajveer 3295 
  def markOrdersAsTimeout(self, vendorId):
3296 
    """
3297 
    Parameters:
3298 
     - vendorId
3299 
    """
3300 
    self.send_markOrdersAsTimeout(vendorId)
3301 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3302 
 
4369 rajveer 3303 
  def send_markOrdersAsTimeout(self, vendorId):
3304 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3305 
    args = markOrdersAsTimeout_args()
3306 
    args.vendorId = vendorId
3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_markOrdersAsTimeout(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = markOrdersAsTimeout_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
3321 
    if result.success is not None:
3322 
      return result.success
3323 
    if result.ex is not None:
3324 
      raise result.ex
3325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3326 
 
3327 
 
3376 rajveer 3328 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3329 
  def __init__(self, handler):
3376 rajveer 3330 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3331 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3332 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3333 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3334 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3335 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3336 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3337 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3338 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3339 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3340 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3341 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3342 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3343 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3344 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3345 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3346 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3347 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3348 
    self._processMap["createOrder"] = Processor.process_createOrder
3349 
    self._processMap["getOrder"] = Processor.process_getOrder
3350 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3351 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3352 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3353 
    self._processMap["setAlert"] = Processor.process_setAlert
3354 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3355 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3356 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3357 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3358 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3359 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3360 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3361 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3362 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3363 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3364 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3365 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3366 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3367 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3368 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3369 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3370 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3371 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3372 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3373 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3374 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3375 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3376 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3377 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3378 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3379 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3380 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3381 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3382 
    self._processMap["changeItem"] = Processor.process_changeItem
3383 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3384 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3385 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3386 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3387 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3388 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3389 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3390 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3391 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3392 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3393 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3394 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3395 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3396 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3397 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3398 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3399 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3400 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
94 ashish 3401 
 
3402 
  def process(self, iprot, oprot):
3403 
    (name, type, seqid) = iprot.readMessageBegin()
3404 
    if name not in self._processMap:
3405 
      iprot.skip(TType.STRUCT)
3406 
      iprot.readMessageEnd()
3407 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3408 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3409 
      x.write(oprot)
3410 
      oprot.writeMessageEnd()
3411 
      oprot.trans.flush()
3412 
      return
3413 
    else:
3414 
      self._processMap[name](self, seqid, iprot, oprot)
3415 
    return True
3416 
 
3417 
  def process_createTransaction(self, seqid, iprot, oprot):
3418 
    args = createTransaction_args()
3419 
    args.read(iprot)
3420 
    iprot.readMessageEnd()
3421 
    result = createTransaction_result()
3422 
    try:
132 ashish 3423 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3424 
    except TransactionServiceException, ex:
3425 
      result.ex = ex
3426 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3427 
    result.write(oprot)
3428 
    oprot.writeMessageEnd()
3429 
    oprot.trans.flush()
3430 
 
3431 
  def process_getTransaction(self, seqid, iprot, oprot):
3432 
    args = getTransaction_args()
3433 
    args.read(iprot)
3434 
    iprot.readMessageEnd()
3435 
    result = getTransaction_result()
3436 
    try:
3437 
      result.success = self._handler.getTransaction(args.id)
3438 
    except TransactionServiceException, ex:
3439 
      result.ex = ex
3440 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3441 
    result.write(oprot)
3442 
    oprot.writeMessageEnd()
3443 
    oprot.trans.flush()
3444 
 
3445 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3446 
    args = getTransactionsForCustomer_args()
3447 
    args.read(iprot)
3448 
    iprot.readMessageEnd()
3449 
    result = getTransactionsForCustomer_result()
3450 
    try:
3451 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3452 
    except TransactionServiceException, ex:
3453 
      result.ex = ex
3454 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3455 
    result.write(oprot)
3456 
    oprot.writeMessageEnd()
3457 
    oprot.trans.flush()
3458 
 
132 ashish 3459 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3460 
    args = getTransactionsForShoppingCartId_args()
3461 
    args.read(iprot)
3462 
    iprot.readMessageEnd()
3463 
    result = getTransactionsForShoppingCartId_result()
3464 
    try:
3465 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3466 
    except TransactionServiceException, ex:
3467 
      result.ex = ex
3468 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3469 
    result.write(oprot)
3470 
    oprot.writeMessageEnd()
3471 
    oprot.trans.flush()
3472 
 
94 ashish 3473 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3474 
    args = getTransactionStatus_args()
3475 
    args.read(iprot)
3476 
    iprot.readMessageEnd()
3477 
    result = getTransactionStatus_result()
3478 
    try:
3479 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3480 
    except TransactionServiceException, ex:
3481 
      result.ex = ex
3482 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3483 
    result.write(oprot)
3484 
    oprot.writeMessageEnd()
3485 
    oprot.trans.flush()
3486 
 
3487 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3488 
    args = changeTransactionStatus_args()
3489 
    args.read(iprot)
3490 
    iprot.readMessageEnd()
3491 
    result = changeTransactionStatus_result()
3492 
    try:
3493 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3494 
    except TransactionServiceException, ex:
3495 
      result.ex = ex
3496 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3497 
    result.write(oprot)
3498 
    oprot.writeMessageEnd()
3499 
    oprot.trans.flush()
3500 
 
1398 varun.gupt 3501 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3502 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3503 
    args.read(iprot)
3504 
    iprot.readMessageEnd()
1398 varun.gupt 3505 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3506 
    try:
1398 varun.gupt 3507 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3508 
    except TransactionServiceException, ex:
3509 
      result.ex = ex
1398 varun.gupt 3510 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3511 
    result.write(oprot)
3512 
    oprot.writeMessageEnd()
3513 
    oprot.trans.flush()
3514 
 
483 rajveer 3515 
  def process_getAllOrders(self, seqid, iprot, oprot):
3516 
    args = getAllOrders_args()
94 ashish 3517 
    args.read(iprot)
3518 
    iprot.readMessageEnd()
483 rajveer 3519 
    result = getAllOrders_result()
94 ashish 3520 
    try:
483 rajveer 3521 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3522 
    except TransactionServiceException, ex:
3523 
      result.ex = ex
483 rajveer 3524 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3525 
    result.write(oprot)
3526 
    oprot.writeMessageEnd()
3527 
    oprot.trans.flush()
3528 
 
4133 chandransh 3529 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3530 
    args = getOrdersInBatch_args()
3531 
    args.read(iprot)
3532 
    iprot.readMessageEnd()
3533 
    result = getOrdersInBatch_result()
3534 
    try:
3535 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3536 
    except TransactionServiceException, ex:
3537 
      result.ex = ex
3538 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3539 
    result.write(oprot)
3540 
    oprot.writeMessageEnd()
3541 
    oprot.trans.flush()
3542 
 
3543 
  def process_getOrderCount(self, seqid, iprot, oprot):
3544 
    args = getOrderCount_args()
3545 
    args.read(iprot)
3546 
    iprot.readMessageEnd()
3547 
    result = getOrderCount_result()
3548 
    try:
3549 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3550 
    except TransactionServiceException, ex:
3551 
      result.ex = ex
3552 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3553 
    result.write(oprot)
3554 
    oprot.writeMessageEnd()
3555 
    oprot.trans.flush()
3556 
 
999 varun.gupt 3557 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3558 
    args = getOrdersByBillingDate_args()
3559 
    args.read(iprot)
3560 
    iprot.readMessageEnd()
3561 
    result = getOrdersByBillingDate_result()
3562 
    try:
3563 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3564 
    except TransactionServiceException, ex:
3565 
      result.ex = ex
3566 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3567 
    result.write(oprot)
3568 
    oprot.writeMessageEnd()
3569 
    oprot.trans.flush()
3570 
 
3427 chandransh 3571 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3572 
    args = getOrdersByShippingDate_args()
3573 
    args.read(iprot)
3574 
    iprot.readMessageEnd()
3575 
    result = getOrdersByShippingDate_result()
3576 
    try:
3451 chandransh 3577 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3578 
    except TransactionServiceException, ex:
3579 
      result.ex = ex
3580 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3581 
    result.write(oprot)
3582 
    oprot.writeMessageEnd()
3583 
    oprot.trans.flush()
3584 
 
1382 varun.gupt 3585 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3586 
    args = getReturnableOrdersForCustomer_args()
3587 
    args.read(iprot)
3588 
    iprot.readMessageEnd()
3589 
    result = getReturnableOrdersForCustomer_result()
3590 
    try:
3591 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3592 
    except TransactionServiceException, ex:
3593 
      result.ex = ex
3594 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3595 
    result.write(oprot)
3596 
    oprot.writeMessageEnd()
3597 
    oprot.trans.flush()
3598 
 
3599 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3600 
    args = getCancellableOrdersForCustomer_args()
3601 
    args.read(iprot)
3602 
    iprot.readMessageEnd()
3603 
    result = getCancellableOrdersForCustomer_result()
3604 
    try:
3605 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3606 
    except TransactionServiceException, ex:
3607 
      result.ex = ex
3608 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3609 
    result.write(oprot)
3610 
    oprot.writeMessageEnd()
3611 
    oprot.trans.flush()
3612 
 
483 rajveer 3613 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3614 
    args = changeOrderStatus_args()
94 ashish 3615 
    args.read(iprot)
3616 
    iprot.readMessageEnd()
483 rajveer 3617 
    result = changeOrderStatus_result()
94 ashish 3618 
    try:
483 rajveer 3619 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3620 
    except TransactionServiceException, ex:
3621 
      result.ex = ex
483 rajveer 3622 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3623 
    result.write(oprot)
3624 
    oprot.writeMessageEnd()
3625 
    oprot.trans.flush()
3626 
 
483 rajveer 3627 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3628 
    args = getOrdersForTransaction_args()
94 ashish 3629 
    args.read(iprot)
3630 
    iprot.readMessageEnd()
483 rajveer 3631 
    result = getOrdersForTransaction_result()
94 ashish 3632 
    try:
1528 ankur.sing 3633 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3634 
    except TransactionServiceException, ex:
3635 
      result.ex = ex
483 rajveer 3636 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3637 
    result.write(oprot)
3638 
    oprot.writeMessageEnd()
3639 
    oprot.trans.flush()
3640 
 
483 rajveer 3641 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3642 
    args = getOrdersForCustomer_args()
94 ashish 3643 
    args.read(iprot)
3644 
    iprot.readMessageEnd()
483 rajveer 3645 
    result = getOrdersForCustomer_result()
94 ashish 3646 
    try:
3014 chandransh 3647 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3648 
    except TransactionServiceException, ex:
3649 
      result.ex = ex
483 rajveer 3650 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3651 
    result.write(oprot)
3652 
    oprot.writeMessageEnd()
3653 
    oprot.trans.flush()
3654 
 
483 rajveer 3655 
  def process_createOrder(self, seqid, iprot, oprot):
3656 
    args = createOrder_args()
94 ashish 3657 
    args.read(iprot)
3658 
    iprot.readMessageEnd()
483 rajveer 3659 
    result = createOrder_result()
94 ashish 3660 
    try:
483 rajveer 3661 
      result.success = self._handler.createOrder(args.order)
94 ashish 3662 
    except TransactionServiceException, ex:
3663 
      result.ex = ex
483 rajveer 3664 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3665 
    result.write(oprot)
3666 
    oprot.writeMessageEnd()
3667 
    oprot.trans.flush()
3668 
 
483 rajveer 3669 
  def process_getOrder(self, seqid, iprot, oprot):
3670 
    args = getOrder_args()
94 ashish 3671 
    args.read(iprot)
3672 
    iprot.readMessageEnd()
483 rajveer 3673 
    result = getOrder_result()
94 ashish 3674 
    try:
483 rajveer 3675 
      result.success = self._handler.getOrder(args.id)
94 ashish 3676 
    except TransactionServiceException, ex:
3677 
      result.ex = ex
483 rajveer 3678 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3679 
    result.write(oprot)
3680 
    oprot.writeMessageEnd()
3681 
    oprot.trans.flush()
3682 
 
483 rajveer 3683 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3684 
    args = getLineItemsForOrder_args()
94 ashish 3685 
    args.read(iprot)
3686 
    iprot.readMessageEnd()
483 rajveer 3687 
    result = getLineItemsForOrder_result()
94 ashish 3688 
    try:
483 rajveer 3689 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3690 
    except TransactionServiceException, ex:
3691 
      result.ex = ex
483 rajveer 3692 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3693 
    result.write(oprot)
3694 
    oprot.writeMessageEnd()
3695 
    oprot.trans.flush()
3696 
 
1528 ankur.sing 3697 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3698 
    args = getOrderForCustomer_args()
3699 
    args.read(iprot)
3700 
    iprot.readMessageEnd()
3701 
    result = getOrderForCustomer_result()
3702 
    try:
3703 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3704 
    except TransactionServiceException, ex:
3705 
      result.ex = ex
3706 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3707 
    result.write(oprot)
3708 
    oprot.writeMessageEnd()
3709 
    oprot.trans.flush()
3710 
 
3064 chandransh 3711 
  def process_getAlerts(self, seqid, iprot, oprot):
3712 
    args = getAlerts_args()
3713 
    args.read(iprot)
3714 
    iprot.readMessageEnd()
3715 
    result = getAlerts_result()
3716 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3717 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3718 
    result.write(oprot)
3719 
    oprot.writeMessageEnd()
3720 
    oprot.trans.flush()
3721 
 
3722 
  def process_setAlert(self, seqid, iprot, oprot):
3723 
    args = setAlert_args()
3724 
    args.read(iprot)
3725 
    iprot.readMessageEnd()
3726 
    result = setAlert_result()
3727 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3728 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3729 
    result.write(oprot)
3730 
    oprot.writeMessageEnd()
3731 
    oprot.trans.flush()
3732 
 
3733 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3734 
    args = getValidOrderCount_args()
3735 
    args.read(iprot)
3736 
    iprot.readMessageEnd()
3737 
    result = getValidOrderCount_result()
3738 
    result.success = self._handler.getValidOrderCount()
3739 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3740 
    result.write(oprot)
3741 
    oprot.writeMessageEnd()
3742 
    oprot.trans.flush()
3743 
 
3744 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3745 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3746 
    args.read(iprot)
3747 
    iprot.readMessageEnd()
3748 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3749 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3750 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
3754 
 
3755 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3756 
    args = getValidOrdersAmountRange_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = getValidOrdersAmountRange_result()
3760 
    result.success = self._handler.getValidOrdersAmountRange()
3761 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3762 
    result.write(oprot)
3763 
    oprot.writeMessageEnd()
3764 
    oprot.trans.flush()
3765 
 
3766 
  def process_getValidOrders(self, seqid, iprot, oprot):
3767 
    args = getValidOrders_args()
3768 
    args.read(iprot)
3769 
    iprot.readMessageEnd()
3770 
    result = getValidOrders_result()
3771 
    result.success = self._handler.getValidOrders(args.limit)
3772 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3773 
    result.write(oprot)
3774 
    oprot.writeMessageEnd()
3775 
    oprot.trans.flush()
3776 
 
1220 chandransh 3777 
  def process_batchOrders(self, seqid, iprot, oprot):
3778 
    args = batchOrders_args()
3779 
    args.read(iprot)
3780 
    iprot.readMessageEnd()
3781 
    result = batchOrders_result()
3782 
    try:
3783 
      result.success = self._handler.batchOrders(args.warehouseId)
3784 
    except TransactionServiceException, ex:
3785 
      result.ex = ex
3786 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3787 
    result.write(oprot)
3788 
    oprot.writeMessageEnd()
3789 
    oprot.trans.flush()
3790 
 
1208 chandransh 3791 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3792 
    args = markOrderAsOutOfStock_args()
3793 
    args.read(iprot)
3794 
    iprot.readMessageEnd()
3795 
    result = markOrderAsOutOfStock_result()
3796 
    try:
3797 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3798 
    except TransactionServiceException, ex:
3799 
      result.ex = ex
3800 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
3804 
 
3064 chandransh 3805 
  def process_verifyOrder(self, seqid, iprot, oprot):
3806 
    args = verifyOrder_args()
759 chandransh 3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
3064 chandransh 3809 
    result = verifyOrder_result()
759 chandransh 3810 
    try:
3064 chandransh 3811 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3812 
    except TransactionServiceException, ex:
3813 
      result.ex = ex
3064 chandransh 3814 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
3818 
 
3064 chandransh 3819 
  def process_acceptOrder(self, seqid, iprot, oprot):
3820 
    args = acceptOrder_args()
1113 chandransh 3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
3064 chandransh 3823 
    result = acceptOrder_result()
1113 chandransh 3824 
    try:
3064 chandransh 3825 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3826 
    except TransactionServiceException, ex:
3827 
      result.ex = ex
3064 chandransh 3828 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3829 
    result.write(oprot)
3830 
    oprot.writeMessageEnd()
3831 
    oprot.trans.flush()
3832 
 
3064 chandransh 3833 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3834 
    args = addBillingDetails_args()
1135 chandransh 3835 
    args.read(iprot)
3836 
    iprot.readMessageEnd()
3064 chandransh 3837 
    result = addBillingDetails_result()
1135 chandransh 3838 
    try:
4283 anupam.sin 3839 
      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 3840 
    except TransactionServiceException, ex:
3841 
      result.ex = ex
3064 chandransh 3842 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3843 
    result.write(oprot)
3844 
    oprot.writeMessageEnd()
3845 
    oprot.trans.flush()
3846 
 
3064 chandransh 3847 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3848 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3849 
    args.read(iprot)
3850 
    iprot.readMessageEnd()
3064 chandransh 3851 
    result = markOrdersAsManifested_result()
3852 
    try:
3853 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3854 
    except TransactionServiceException, ex:
3855 
      result.ex = ex
3856 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3857 
    result.write(oprot)
3858 
    oprot.writeMessageEnd()
3859 
    oprot.trans.flush()
3860 
 
3064 chandransh 3861 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3862 
    args = markOrdersAsPickedUp_args()
304 ashish 3863 
    args.read(iprot)
3864 
    iprot.readMessageEnd()
3064 chandransh 3865 
    result = markOrdersAsPickedUp_result()
3866 
    try:
3867 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3868 
    except TransactionServiceException, ex:
3869 
      result.ex = ex
3870 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3871 
    result.write(oprot)
3872 
    oprot.writeMessageEnd()
3873 
    oprot.trans.flush()
94 ashish 3874 
 
3064 chandransh 3875 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3876 
    args = markOrdersAsDelivered_args()
304 ashish 3877 
    args.read(iprot)
3878 
    iprot.readMessageEnd()
3064 chandransh 3879 
    result = markOrdersAsDelivered_result()
3880 
    try:
3881 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3882 
    except TransactionServiceException, ex:
3883 
      result.ex = ex
3884 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3885 
    result.write(oprot)
3886 
    oprot.writeMessageEnd()
3887 
    oprot.trans.flush()
3888 
 
3064 chandransh 3889 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3890 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3891 
    args.read(iprot)
3892 
    iprot.readMessageEnd()
3064 chandransh 3893 
    result = markOrdersAsFailed_result()
3894 
    try:
3895 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3896 
    except TransactionServiceException, ex:
3897 
      result.ex = ex
3898 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3899 
    result.write(oprot)
3900 
    oprot.writeMessageEnd()
3901 
    oprot.trans.flush()
304 ashish 3902 
 
3064 chandransh 3903 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3904 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3905 
    args.read(iprot)
3906 
    iprot.readMessageEnd()
3064 chandransh 3907 
    result = updateNonDeliveryReason_result()
3908 
    try:
3909 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3910 
    except TransactionServiceException, ex:
3911 
      result.ex = ex
3912 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3913 
    result.write(oprot)
3914 
    oprot.writeMessageEnd()
3915 
    oprot.trans.flush()
1596 ankur.sing 3916 
 
3064 chandransh 3917 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3918 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3919 
    args.read(iprot)
3920 
    iprot.readMessageEnd()
3064 chandransh 3921 
    result = getUndeliveredOrders_result()
3922 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3923 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3924 
    result.write(oprot)
3925 
    oprot.writeMessageEnd()
3926 
    oprot.trans.flush()
3927 
 
2536 chandransh 3928 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3929 
    args = toggleDOAFlag_args()
3930 
    args.read(iprot)
3931 
    iprot.readMessageEnd()
3932 
    result = toggleDOAFlag_result()
3933 
    try:
3934 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3935 
    except TransactionServiceException, ex:
3936 
      result.ex = ex
3937 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3938 
    result.write(oprot)
3939 
    oprot.writeMessageEnd()
3940 
    oprot.trans.flush()
1886 ankur.sing 3941 
 
2536 chandransh 3942 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3943 
    args = requestPickupNumber_args()
3944 
    args.read(iprot)
3945 
    iprot.readMessageEnd()
3946 
    result = requestPickupNumber_result()
3947 
    try:
3948 
      result.success = self._handler.requestPickupNumber(args.orderId)
3949 
    except TransactionServiceException, ex:
3950 
      result.ex = ex
3951 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3952 
    result.write(oprot)
3953 
    oprot.writeMessageEnd()
3954 
    oprot.trans.flush()
3955 
 
3956 
  def process_authorizePickup(self, seqid, iprot, oprot):
3957 
    args = authorizePickup_args()
3958 
    args.read(iprot)
3959 
    iprot.readMessageEnd()
3960 
    result = authorizePickup_result()
3961 
    try:
3962 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3963 
    except TransactionServiceException, ex:
3964 
      result.ex = ex
3965 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3966 
    result.write(oprot)
3967 
    oprot.writeMessageEnd()
3968 
    oprot.trans.flush()
3969 
 
2764 chandransh 3970 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3971 
    args = markDoasAsPickedUp_args()
3972 
    args.read(iprot)
3973 
    iprot.readMessageEnd()
3974 
    result = markDoasAsPickedUp_result()
3975 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3976 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
2616 chandransh 3981 
  def process_receiveReturn(self, seqid, iprot, oprot):
3982 
    args = receiveReturn_args()
2591 chandransh 3983 
    args.read(iprot)
3984 
    iprot.readMessageEnd()
2616 chandransh 3985 
    result = receiveReturn_result()
2591 chandransh 3986 
    try:
2616 chandransh 3987 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3988 
    except TransactionServiceException, ex:
3989 
      result.ex = ex
2616 chandransh 3990 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3991 
    result.write(oprot)
3992 
    oprot.writeMessageEnd()
3993 
    oprot.trans.flush()
2536 chandransh 3994 
 
2591 chandransh 3995 
  def process_validateDoa(self, seqid, iprot, oprot):
3996 
    args = validateDoa_args()
3997 
    args.read(iprot)
3998 
    iprot.readMessageEnd()
3999 
    result = validateDoa_result()
4000 
    try:
4001 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4002 
    except TransactionServiceException, ex:
4003 
      result.ex = ex
4004 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4005 
    result.write(oprot)
4006 
    oprot.writeMessageEnd()
4007 
    oprot.trans.flush()
4008 
 
2616 chandransh 4009 
  def process_reshipOrder(self, seqid, iprot, oprot):
4010 
    args = reshipOrder_args()
4011 
    args.read(iprot)
4012 
    iprot.readMessageEnd()
4013 
    result = reshipOrder_result()
4014 
    try:
4015 
      result.success = self._handler.reshipOrder(args.orderId)
4016 
    except TransactionServiceException, ex:
4017 
      result.ex = ex
4018 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4019 
    result.write(oprot)
4020 
    oprot.writeMessageEnd()
4021 
    oprot.trans.flush()
2591 chandransh 4022 
 
2616 chandransh 4023 
  def process_refundOrder(self, seqid, iprot, oprot):
4024 
    args = refundOrder_args()
4025 
    args.read(iprot)
4026 
    iprot.readMessageEnd()
4027 
    result = refundOrder_result()
4028 
    try:
3226 chandransh 4029 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4030 
    except TransactionServiceException, ex:
4031 
      result.ex = ex
4032 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4033 
    result.write(oprot)
4034 
    oprot.writeMessageEnd()
4035 
    oprot.trans.flush()
4036 
 
2690 chandransh 4037 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4038 
    args = getReturnOrders_args()
4039 
    args.read(iprot)
4040 
    iprot.readMessageEnd()
4041 
    result = getReturnOrders_result()
4042 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4043 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4044 
    result.write(oprot)
4045 
    oprot.writeMessageEnd()
4046 
    oprot.trans.flush()
2616 chandransh 4047 
 
2700 chandransh 4048 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4049 
    args = getReturnOrder_args()
4050 
    args.read(iprot)
4051 
    iprot.readMessageEnd()
4052 
    result = getReturnOrder_result()
4053 
    try:
4054 
      result.success = self._handler.getReturnOrder(args.id)
4055 
    except TransactionServiceException, ex:
4056 
      result.ex = ex
4057 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4058 
    result.write(oprot)
4059 
    oprot.writeMessageEnd()
4060 
    oprot.trans.flush()
4061 
 
2690 chandransh 4062 
  def process_processReturn(self, seqid, iprot, oprot):
4063 
    args = processReturn_args()
4064 
    args.read(iprot)
4065 
    iprot.readMessageEnd()
4066 
    result = processReturn_result()
4067 
    try:
4068 
      self._handler.processReturn(args.returnOrderId)
4069 
    except TransactionServiceException, ex:
4070 
      result.ex = ex
4071 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4072 
    result.write(oprot)
4073 
    oprot.writeMessageEnd()
4074 
    oprot.trans.flush()
4075 
 
2819 chandransh 4076 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4077 
    args = createPurchaseOrder_args()
4078 
    args.read(iprot)
4079 
    iprot.readMessageEnd()
4080 
    result = createPurchaseOrder_result()
4081 
    try:
4082 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4083 
    except TransactionServiceException, ex:
4084 
      result.ex = ex
4085 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4086 
    result.write(oprot)
4087 
    oprot.writeMessageEnd()
4088 
    oprot.trans.flush()
2690 chandransh 4089 
 
3451 chandransh 4090 
  def process_updateWeight(self, seqid, iprot, oprot):
4091 
    args = updateWeight_args()
4092 
    args.read(iprot)
4093 
    iprot.readMessageEnd()
4094 
    result = updateWeight_result()
4095 
    try:
4096 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4097 
    except TransactionServiceException, ex:
4098 
      result.ex = ex
4099 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4100 
    result.write(oprot)
4101 
    oprot.writeMessageEnd()
4102 
    oprot.trans.flush()
2819 chandransh 4103 
 
3469 chandransh 4104 
  def process_changeItem(self, seqid, iprot, oprot):
4105 
    args = changeItem_args()
4106 
    args.read(iprot)
4107 
    iprot.readMessageEnd()
4108 
    result = changeItem_result()
4109 
    try:
4110 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4111 
    except TransactionServiceException, ex:
4112 
      result.ex = ex
4113 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4114 
    result.write(oprot)
4115 
    oprot.writeMessageEnd()
4116 
    oprot.trans.flush()
3451 chandransh 4117 
 
3469 chandransh 4118 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4119 
    args = shiftToWarehouse_args()
4120 
    args.read(iprot)
4121 
    iprot.readMessageEnd()
4122 
    result = shiftToWarehouse_result()
4123 
    try:
4124 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4125 
    except TransactionServiceException, ex:
4126 
      result.ex = ex
4127 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4128 
    result.write(oprot)
4129 
    oprot.writeMessageEnd()
4130 
    oprot.trans.flush()
4131 
 
3553 chandransh 4132 
  def process_addDelayReason(self, seqid, iprot, oprot):
4133 
    args = addDelayReason_args()
4134 
    args.read(iprot)
4135 
    iprot.readMessageEnd()
4136 
    result = addDelayReason_result()
4137 
    try:
3986 chandransh 4138 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4139 
    except TransactionServiceException, ex:
4140 
      result.ex = ex
4141 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4142 
    result.write(oprot)
4143 
    oprot.writeMessageEnd()
4144 
    oprot.trans.flush()
3469 chandransh 4145 
 
3956 chandransh 4146 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4147 
    args = reconcileCodCollection_args()
4148 
    args.read(iprot)
4149 
    iprot.readMessageEnd()
4150 
    result = reconcileCodCollection_result()
4151 
    try:
4152 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4153 
    except TransactionServiceException, ex:
4154 
      result.ex = ex
4155 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4156 
    result.write(oprot)
4157 
    oprot.writeMessageEnd()
4158 
    oprot.trans.flush()
3553 chandransh 4159 
 
4008 mandeep.dh 4160 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4161 
    args = getTransactionsRequiringExtraProcessing_args()
4162 
    args.read(iprot)
4163 
    iprot.readMessageEnd()
4164 
    result = getTransactionsRequiringExtraProcessing_result()
4165 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4166 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4167 
    result.write(oprot)
4168 
    oprot.writeMessageEnd()
4169 
    oprot.trans.flush()
3956 chandransh 4170 
 
4008 mandeep.dh 4171 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4172 
    args = markTransactionAsProcessed_args()
4173 
    args.read(iprot)
4174 
    iprot.readMessageEnd()
4175 
    result = markTransactionAsProcessed_result()
4176 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4177 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4178 
    result.write(oprot)
4179 
    oprot.writeMessageEnd()
4180 
    oprot.trans.flush()
4181 
 
4018 chandransh 4182 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4183 
    args = getItemWiseRiskyOrdersCount_args()
4184 
    args.read(iprot)
4185 
    iprot.readMessageEnd()
4186 
    result = getItemWiseRiskyOrdersCount_result()
4187 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4188 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
4008 mandeep.dh 4192 
 
4295 varun.gupt 4193 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4194 
    args = getOrdersForItemIds_args()
4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
4197 
    result = getOrdersForItemIds_result()
4198 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4199 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
4203 
 
4247 rajveer 4204 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4205 
    args = markOrderCancellationRequestReceived_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = markOrderCancellationRequestReceived_result()
4209 
    try:
4210 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4211 
    except TransactionServiceException, ex:
4212 
      result.ex = ex
4213 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4214 
    result.write(oprot)
4215 
    oprot.writeMessageEnd()
4216 
    oprot.trans.flush()
4018 chandransh 4217 
 
4247 rajveer 4218 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4219 
    args = markOrderCancellationRequestConfirmed_args()
4220 
    args.read(iprot)
4221 
    iprot.readMessageEnd()
4222 
    result = markOrderCancellationRequestConfirmed_result()
4223 
    try:
4224 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4225 
    except TransactionServiceException, ex:
4226 
      result.ex = ex
4227 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4228 
    result.write(oprot)
4229 
    oprot.writeMessageEnd()
4230 
    oprot.trans.flush()
4231 
 
4232 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4233 
    args = markOrderCancellationRequestDenied_args()
4234 
    args.read(iprot)
4235 
    iprot.readMessageEnd()
4236 
    result = markOrderCancellationRequestDenied_result()
4237 
    try:
4238 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4239 
    except TransactionServiceException, ex:
4240 
      result.ex = ex
4241 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4242 
    result.write(oprot)
4243 
    oprot.writeMessageEnd()
4244 
    oprot.trans.flush()
4245 
 
4258 rajveer 4246 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4247 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4248 
    args.read(iprot)
4249 
    iprot.readMessageEnd()
4258 rajveer 4250 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4251 
    try:
4258 rajveer 4252 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4253 
    except TransactionServiceException, ex:
4254 
      result.ex = ex
4258 rajveer 4255 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4256 
    result.write(oprot)
4257 
    oprot.writeMessageEnd()
4258 
    oprot.trans.flush()
4259 
 
4259 anupam.sin 4260 
  def process_refundTransaction(self, seqid, iprot, oprot):
4261 
    args = refundTransaction_args()
4262 
    args.read(iprot)
4263 
    iprot.readMessageEnd()
4264 
    result = refundTransaction_result()
4265 
    try:
4266 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4267 
    except TransactionServiceException, ex:
4268 
      result.ex = ex
4269 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4270 
    result.write(oprot)
4271 
    oprot.writeMessageEnd()
4272 
    oprot.trans.flush()
4247 rajveer 4273 
 
4324 mandeep.dh 4274 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4275 
    args = updateShipmentAddress_args()
4276 
    args.read(iprot)
4277 
    iprot.readMessageEnd()
4278 
    result = updateShipmentAddress_result()
4279 
    try:
4280 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4281 
    except TransactionServiceException, ex:
4282 
      result.ex = ex
4283 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4284 
    result.write(oprot)
4285 
    oprot.writeMessageEnd()
4286 
    oprot.trans.flush()
4287 
 
4285 rajveer 4288 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4289 
    args = acceptOrdersForItemId_args()
4290 
    args.read(iprot)
4291 
    iprot.readMessageEnd()
4292 
    result = acceptOrdersForItemId_result()
4293 
    try:
4294 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4295 
    except TransactionServiceException, ex:
4296 
      result.ex = ex
4297 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4298 
    result.write(oprot)
4299 
    oprot.writeMessageEnd()
4300 
    oprot.trans.flush()
4259 anupam.sin 4301 
 
4303 rajveer 4302 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4303 
    args = markOrdersAsPORaised_args()
4304 
    args.read(iprot)
4305 
    iprot.readMessageEnd()
4306 
    result = markOrdersAsPORaised_result()
4307 
    try:
4369 rajveer 4308 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4309 
    except TransactionServiceException, ex:
4310 
      result.ex = ex
4311 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4312 
    result.write(oprot)
4313 
    oprot.writeMessageEnd()
4314 
    oprot.trans.flush()
4285 rajveer 4315 
 
4303 rajveer 4316 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4317 
    args = markOrdersAsReversalInitiated_args()
4318 
    args.read(iprot)
4319 
    iprot.readMessageEnd()
4320 
    result = markOrdersAsReversalInitiated_result()
4321 
    try:
4369 rajveer 4322 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4323 
    except TransactionServiceException, ex:
4324 
      result.ex = ex
4325 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4326 
    result.write(oprot)
4327 
    oprot.writeMessageEnd()
4328 
    oprot.trans.flush()
4329 
 
4330 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4331 
    args = markOrdersAsNotAvailabke_args()
4332 
    args.read(iprot)
4333 
    iprot.readMessageEnd()
4334 
    result = markOrdersAsNotAvailabke_result()
4335 
    try:
4369 rajveer 4336 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4337 
    except TransactionServiceException, ex:
4338 
      result.ex = ex
4339 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4340 
    result.write(oprot)
4341 
    oprot.writeMessageEnd()
4342 
    oprot.trans.flush()
4343 
 
4369 rajveer 4344 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4345 
    args = markOrdersAsTimeout_args()
4346 
    args.read(iprot)
4347 
    iprot.readMessageEnd()
4348 
    result = markOrdersAsTimeout_result()
4349 
    try:
4350 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4351 
    except TransactionServiceException, ex:
4352 
      result.ex = ex
4353 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4354 
    result.write(oprot)
4355 
    oprot.writeMessageEnd()
4356 
    oprot.trans.flush()
4303 rajveer 4357 
 
4369 rajveer 4358 
 
94 ashish 4359 
# HELPER FUNCTIONS AND STRUCTURES
4360 
 
4361 
class createTransaction_args:
4362 
  """
4363 
  Attributes:
4364 
   - transaction
4365 
  """
4366 
 
4367 
  thrift_spec = (
4368 
    None, # 0
4369 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4370 
  )
4371 
 
4372 
  def __init__(self, transaction=None,):
4373 
    self.transaction = transaction
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
4384 
      if fid == 1:
4385 
        if ftype == TType.STRUCT:
4386 
          self.transaction = Transaction()
4387 
          self.transaction.read(iprot)
4388 
        else:
4389 
          iprot.skip(ftype)
4390 
      else:
4391 
        iprot.skip(ftype)
4392 
      iprot.readFieldEnd()
4393 
    iprot.readStructEnd()
4394 
 
4395 
  def write(self, oprot):
4396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4398 
      return
4399 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4400 
    if self.transaction is not None:
94 ashish 4401 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4402 
      self.transaction.write(oprot)
4403 
      oprot.writeFieldEnd()
4404 
    oprot.writeFieldStop()
4405 
    oprot.writeStructEnd()
4406 
 
3431 rajveer 4407 
  def validate(self):
4408 
    return
4409 
 
4410 
 
94 ashish 4411 
  def __repr__(self):
4412 
    L = ['%s=%r' % (key, value)
4413 
      for key, value in self.__dict__.iteritems()]
4414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4415 
 
4416 
  def __eq__(self, other):
4417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4418 
 
4419 
  def __ne__(self, other):
4420 
    return not (self == other)
4421 
 
4422 
class createTransaction_result:
4423 
  """
4424 
  Attributes:
132 ashish 4425 
   - success
94 ashish 4426 
   - ex
4427 
  """
4428 
 
4429 
  thrift_spec = (
132 ashish 4430 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4432 
  )
4433 
 
132 ashish 4434 
  def __init__(self, success=None, ex=None,):
4435 
    self.success = success
94 ashish 4436 
    self.ex = ex
4437 
 
4438 
  def read(self, iprot):
4439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4441 
      return
4442 
    iprot.readStructBegin()
4443 
    while True:
4444 
      (fname, ftype, fid) = iprot.readFieldBegin()
4445 
      if ftype == TType.STOP:
4446 
        break
132 ashish 4447 
      if fid == 0:
4448 
        if ftype == TType.I64:
4449 
          self.success = iprot.readI64();
4450 
        else:
4451 
          iprot.skip(ftype)
4452 
      elif fid == 1:
94 ashish 4453 
        if ftype == TType.STRUCT:
4454 
          self.ex = TransactionServiceException()
4455 
          self.ex.read(iprot)
4456 
        else:
4457 
          iprot.skip(ftype)
4458 
      else:
4459 
        iprot.skip(ftype)
4460 
      iprot.readFieldEnd()
4461 
    iprot.readStructEnd()
4462 
 
4463 
  def write(self, oprot):
4464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4466 
      return
4467 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4468 
    if self.success is not None:
132 ashish 4469 
      oprot.writeFieldBegin('success', TType.I64, 0)
4470 
      oprot.writeI64(self.success)
4471 
      oprot.writeFieldEnd()
3431 rajveer 4472 
    if self.ex is not None:
94 ashish 4473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4474 
      self.ex.write(oprot)
4475 
      oprot.writeFieldEnd()
4476 
    oprot.writeFieldStop()
4477 
    oprot.writeStructEnd()
4478 
 
3431 rajveer 4479 
  def validate(self):
4480 
    return
4481 
 
4482 
 
94 ashish 4483 
  def __repr__(self):
4484 
    L = ['%s=%r' % (key, value)
4485 
      for key, value in self.__dict__.iteritems()]
4486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4487 
 
4488 
  def __eq__(self, other):
4489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4490 
 
4491 
  def __ne__(self, other):
4492 
    return not (self == other)
4493 
 
4494 
class getTransaction_args:
4495 
  """
4496 
  Attributes:
4497 
   - id
4498 
  """
4499 
 
4500 
  thrift_spec = (
4501 
    None, # 0
4502 
    (1, TType.I64, 'id', None, None, ), # 1
4503 
  )
4504 
 
4505 
  def __init__(self, id=None,):
4506 
    self.id = id
4507 
 
4508 
  def read(self, iprot):
4509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4511 
      return
4512 
    iprot.readStructBegin()
4513 
    while True:
4514 
      (fname, ftype, fid) = iprot.readFieldBegin()
4515 
      if ftype == TType.STOP:
4516 
        break
4517 
      if fid == 1:
4518 
        if ftype == TType.I64:
4519 
          self.id = iprot.readI64();
4520 
        else:
4521 
          iprot.skip(ftype)
4522 
      else:
4523 
        iprot.skip(ftype)
4524 
      iprot.readFieldEnd()
4525 
    iprot.readStructEnd()
4526 
 
4527 
  def write(self, oprot):
4528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4530 
      return
4531 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4532 
    if self.id is not None:
94 ashish 4533 
      oprot.writeFieldBegin('id', TType.I64, 1)
4534 
      oprot.writeI64(self.id)
4535 
      oprot.writeFieldEnd()
4536 
    oprot.writeFieldStop()
4537 
    oprot.writeStructEnd()
4538 
 
3431 rajveer 4539 
  def validate(self):
4540 
    return
4541 
 
4542 
 
94 ashish 4543 
  def __repr__(self):
4544 
    L = ['%s=%r' % (key, value)
4545 
      for key, value in self.__dict__.iteritems()]
4546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4547 
 
4548 
  def __eq__(self, other):
4549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4550 
 
4551 
  def __ne__(self, other):
4552 
    return not (self == other)
4553 
 
4554 
class getTransaction_result:
4555 
  """
4556 
  Attributes:
4557 
   - success
4558 
   - ex
4559 
  """
4560 
 
4561 
  thrift_spec = (
4562 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4564 
  )
4565 
 
4566 
  def __init__(self, success=None, ex=None,):
4567 
    self.success = success
4568 
    self.ex = ex
4569 
 
4570 
  def read(self, iprot):
4571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4573 
      return
4574 
    iprot.readStructBegin()
4575 
    while True:
4576 
      (fname, ftype, fid) = iprot.readFieldBegin()
4577 
      if ftype == TType.STOP:
4578 
        break
4579 
      if fid == 0:
4580 
        if ftype == TType.STRUCT:
4581 
          self.success = Transaction()
4582 
          self.success.read(iprot)
4583 
        else:
4584 
          iprot.skip(ftype)
4585 
      elif fid == 1:
4586 
        if ftype == TType.STRUCT:
4587 
          self.ex = TransactionServiceException()
4588 
          self.ex.read(iprot)
4589 
        else:
4590 
          iprot.skip(ftype)
4591 
      else:
4592 
        iprot.skip(ftype)
4593 
      iprot.readFieldEnd()
4594 
    iprot.readStructEnd()
4595 
 
4596 
  def write(self, oprot):
4597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4599 
      return
4600 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4601 
    if self.success is not None:
94 ashish 4602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4603 
      self.success.write(oprot)
4604 
      oprot.writeFieldEnd()
3431 rajveer 4605 
    if self.ex is not None:
94 ashish 4606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4607 
      self.ex.write(oprot)
4608 
      oprot.writeFieldEnd()
4609 
    oprot.writeFieldStop()
4610 
    oprot.writeStructEnd()
4611 
 
3431 rajveer 4612 
  def validate(self):
4613 
    return
4614 
 
4615 
 
94 ashish 4616 
  def __repr__(self):
4617 
    L = ['%s=%r' % (key, value)
4618 
      for key, value in self.__dict__.iteritems()]
4619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4620 
 
4621 
  def __eq__(self, other):
4622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4623 
 
4624 
  def __ne__(self, other):
4625 
    return not (self == other)
4626 
 
4627 
class getTransactionsForCustomer_args:
4628 
  """
4629 
  Attributes:
4630 
   - customerId
4631 
   - from_date
4632 
   - to_date
4633 
   - status
4634 
  """
4635 
 
4636 
  thrift_spec = (
4637 
    None, # 0
4638 
    (1, TType.I64, 'customerId', None, None, ), # 1
4639 
    (2, TType.I64, 'from_date', None, None, ), # 2
4640 
    (3, TType.I64, 'to_date', None, None, ), # 3
4641 
    (4, TType.I32, 'status', None, None, ), # 4
4642 
  )
4643 
 
4644 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4645 
    self.customerId = customerId
4646 
    self.from_date = from_date
4647 
    self.to_date = to_date
4648 
    self.status = status
4649 
 
4650 
  def read(self, iprot):
4651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4653 
      return
4654 
    iprot.readStructBegin()
4655 
    while True:
4656 
      (fname, ftype, fid) = iprot.readFieldBegin()
4657 
      if ftype == TType.STOP:
4658 
        break
4659 
      if fid == 1:
4660 
        if ftype == TType.I64:
4661 
          self.customerId = iprot.readI64();
4662 
        else:
4663 
          iprot.skip(ftype)
4664 
      elif fid == 2:
4665 
        if ftype == TType.I64:
4666 
          self.from_date = iprot.readI64();
4667 
        else:
4668 
          iprot.skip(ftype)
4669 
      elif fid == 3:
4670 
        if ftype == TType.I64:
4671 
          self.to_date = iprot.readI64();
4672 
        else:
4673 
          iprot.skip(ftype)
4674 
      elif fid == 4:
4675 
        if ftype == TType.I32:
4676 
          self.status = iprot.readI32();
4677 
        else:
4678 
          iprot.skip(ftype)
4679 
      else:
4680 
        iprot.skip(ftype)
4681 
      iprot.readFieldEnd()
4682 
    iprot.readStructEnd()
4683 
 
4684 
  def write(self, oprot):
4685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4687 
      return
4688 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4689 
    if self.customerId is not None:
94 ashish 4690 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4691 
      oprot.writeI64(self.customerId)
4692 
      oprot.writeFieldEnd()
3431 rajveer 4693 
    if self.from_date is not None:
94 ashish 4694 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4695 
      oprot.writeI64(self.from_date)
4696 
      oprot.writeFieldEnd()
3431 rajveer 4697 
    if self.to_date is not None:
94 ashish 4698 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4699 
      oprot.writeI64(self.to_date)
4700 
      oprot.writeFieldEnd()
3431 rajveer 4701 
    if self.status is not None:
94 ashish 4702 
      oprot.writeFieldBegin('status', TType.I32, 4)
4703 
      oprot.writeI32(self.status)
4704 
      oprot.writeFieldEnd()
4705 
    oprot.writeFieldStop()
4706 
    oprot.writeStructEnd()
4707 
 
3431 rajveer 4708 
  def validate(self):
4709 
    return
4710 
 
4711 
 
94 ashish 4712 
  def __repr__(self):
4713 
    L = ['%s=%r' % (key, value)
4714 
      for key, value in self.__dict__.iteritems()]
4715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4716 
 
4717 
  def __eq__(self, other):
4718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4719 
 
4720 
  def __ne__(self, other):
4721 
    return not (self == other)
4722 
 
4723 
class getTransactionsForCustomer_result:
4724 
  """
4725 
  Attributes:
4726 
   - success
4727 
   - ex
4728 
  """
4729 
 
4730 
  thrift_spec = (
4731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4733 
  )
4734 
 
4735 
  def __init__(self, success=None, ex=None,):
4736 
    self.success = success
4737 
    self.ex = ex
4738 
 
4739 
  def read(self, iprot):
4740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4742 
      return
4743 
    iprot.readStructBegin()
4744 
    while True:
4745 
      (fname, ftype, fid) = iprot.readFieldBegin()
4746 
      if ftype == TType.STOP:
4747 
        break
4748 
      if fid == 0:
4749 
        if ftype == TType.LIST:
4750 
          self.success = []
685 chandransh 4751 
          (_etype17, _size14) = iprot.readListBegin()
4752 
          for _i18 in xrange(_size14):
4753 
            _elem19 = Transaction()
4754 
            _elem19.read(iprot)
4755 
            self.success.append(_elem19)
94 ashish 4756 
          iprot.readListEnd()
4757 
        else:
4758 
          iprot.skip(ftype)
4759 
      elif fid == 1:
4760 
        if ftype == TType.STRUCT:
4761 
          self.ex = TransactionServiceException()
4762 
          self.ex.read(iprot)
4763 
        else:
4764 
          iprot.skip(ftype)
4765 
      else:
4766 
        iprot.skip(ftype)
4767 
      iprot.readFieldEnd()
4768 
    iprot.readStructEnd()
4769 
 
4770 
  def write(self, oprot):
4771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4773 
      return
4774 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4775 
    if self.success is not None:
94 ashish 4776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4778 
      for iter20 in self.success:
4779 
        iter20.write(oprot)
94 ashish 4780 
      oprot.writeListEnd()
4781 
      oprot.writeFieldEnd()
3431 rajveer 4782 
    if self.ex is not None:
94 ashish 4783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4784 
      self.ex.write(oprot)
4785 
      oprot.writeFieldEnd()
4786 
    oprot.writeFieldStop()
4787 
    oprot.writeStructEnd()
4788 
 
3431 rajveer 4789 
  def validate(self):
4790 
    return
4791 
 
4792 
 
94 ashish 4793 
  def __repr__(self):
4794 
    L = ['%s=%r' % (key, value)
4795 
      for key, value in self.__dict__.iteritems()]
4796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4797 
 
4798 
  def __eq__(self, other):
4799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4800 
 
4801 
  def __ne__(self, other):
4802 
    return not (self == other)
4803 
 
132 ashish 4804 
class getTransactionsForShoppingCartId_args:
4805 
  """
4806 
  Attributes:
4807 
   - shoppingCartId
4808 
  """
4809 
 
4810 
  thrift_spec = (
4811 
    None, # 0
4812 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4813 
  )
4814 
 
4815 
  def __init__(self, shoppingCartId=None,):
4816 
    self.shoppingCartId = shoppingCartId
4817 
 
4818 
  def read(self, iprot):
4819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4821 
      return
4822 
    iprot.readStructBegin()
4823 
    while True:
4824 
      (fname, ftype, fid) = iprot.readFieldBegin()
4825 
      if ftype == TType.STOP:
4826 
        break
4827 
      if fid == 1:
4828 
        if ftype == TType.I64:
4829 
          self.shoppingCartId = iprot.readI64();
4830 
        else:
4831 
          iprot.skip(ftype)
4832 
      else:
4833 
        iprot.skip(ftype)
4834 
      iprot.readFieldEnd()
4835 
    iprot.readStructEnd()
4836 
 
4837 
  def write(self, oprot):
4838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4840 
      return
4841 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4842 
    if self.shoppingCartId is not None:
132 ashish 4843 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4844 
      oprot.writeI64(self.shoppingCartId)
4845 
      oprot.writeFieldEnd()
4846 
    oprot.writeFieldStop()
4847 
    oprot.writeStructEnd()
4848 
 
3431 rajveer 4849 
  def validate(self):
4850 
    return
4851 
 
4852 
 
132 ashish 4853 
  def __repr__(self):
4854 
    L = ['%s=%r' % (key, value)
4855 
      for key, value in self.__dict__.iteritems()]
4856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4857 
 
4858 
  def __eq__(self, other):
4859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4860 
 
4861 
  def __ne__(self, other):
4862 
    return not (self == other)
4863 
 
4864 
class getTransactionsForShoppingCartId_result:
4865 
  """
4866 
  Attributes:
4867 
   - success
4868 
   - ex
4869 
  """
4870 
 
4871 
  thrift_spec = (
4872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4874 
  )
4875 
 
4876 
  def __init__(self, success=None, ex=None,):
4877 
    self.success = success
4878 
    self.ex = ex
4879 
 
4880 
  def read(self, iprot):
4881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4883 
      return
4884 
    iprot.readStructBegin()
4885 
    while True:
4886 
      (fname, ftype, fid) = iprot.readFieldBegin()
4887 
      if ftype == TType.STOP:
4888 
        break
4889 
      if fid == 0:
4890 
        if ftype == TType.LIST:
4891 
          self.success = []
685 chandransh 4892 
          (_etype24, _size21) = iprot.readListBegin()
4893 
          for _i25 in xrange(_size21):
4894 
            _elem26 = Transaction()
4895 
            _elem26.read(iprot)
4896 
            self.success.append(_elem26)
132 ashish 4897 
          iprot.readListEnd()
4898 
        else:
4899 
          iprot.skip(ftype)
4900 
      elif fid == 1:
4901 
        if ftype == TType.STRUCT:
4902 
          self.ex = TransactionServiceException()
4903 
          self.ex.read(iprot)
4904 
        else:
4905 
          iprot.skip(ftype)
4906 
      else:
4907 
        iprot.skip(ftype)
4908 
      iprot.readFieldEnd()
4909 
    iprot.readStructEnd()
4910 
 
4911 
  def write(self, oprot):
4912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4914 
      return
4915 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4916 
    if self.success is not None:
132 ashish 4917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4919 
      for iter27 in self.success:
4920 
        iter27.write(oprot)
132 ashish 4921 
      oprot.writeListEnd()
4922 
      oprot.writeFieldEnd()
3431 rajveer 4923 
    if self.ex is not None:
132 ashish 4924 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4925 
      self.ex.write(oprot)
4926 
      oprot.writeFieldEnd()
4927 
    oprot.writeFieldStop()
4928 
    oprot.writeStructEnd()
4929 
 
3431 rajveer 4930 
  def validate(self):
4931 
    return
4932 
 
4933 
 
132 ashish 4934 
  def __repr__(self):
4935 
    L = ['%s=%r' % (key, value)
4936 
      for key, value in self.__dict__.iteritems()]
4937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4938 
 
4939 
  def __eq__(self, other):
4940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4941 
 
4942 
  def __ne__(self, other):
4943 
    return not (self == other)
4944 
 
94 ashish 4945 
class getTransactionStatus_args:
4946 
  """
4947 
  Attributes:
4948 
   - transactionId
4949 
  """
4950 
 
4951 
  thrift_spec = (
4952 
    None, # 0
4953 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4954 
  )
4955 
 
4956 
  def __init__(self, transactionId=None,):
4957 
    self.transactionId = transactionId
4958 
 
4959 
  def read(self, iprot):
4960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4962 
      return
4963 
    iprot.readStructBegin()
4964 
    while True:
4965 
      (fname, ftype, fid) = iprot.readFieldBegin()
4966 
      if ftype == TType.STOP:
4967 
        break
4968 
      if fid == 1:
4969 
        if ftype == TType.I64:
4970 
          self.transactionId = iprot.readI64();
4971 
        else:
4972 
          iprot.skip(ftype)
4973 
      else:
4974 
        iprot.skip(ftype)
4975 
      iprot.readFieldEnd()
4976 
    iprot.readStructEnd()
4977 
 
4978 
  def write(self, oprot):
4979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4981 
      return
4982 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4983 
    if self.transactionId is not None:
94 ashish 4984 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4985 
      oprot.writeI64(self.transactionId)
4986 
      oprot.writeFieldEnd()
4987 
    oprot.writeFieldStop()
4988 
    oprot.writeStructEnd()
4989 
 
3431 rajveer 4990 
  def validate(self):
4991 
    return
4992 
 
4993 
 
94 ashish 4994 
  def __repr__(self):
4995 
    L = ['%s=%r' % (key, value)
4996 
      for key, value in self.__dict__.iteritems()]
4997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4998 
 
4999 
  def __eq__(self, other):
5000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5001 
 
5002 
  def __ne__(self, other):
5003 
    return not (self == other)
5004 
 
5005 
class getTransactionStatus_result:
5006 
  """
5007 
  Attributes:
5008 
   - success
5009 
   - ex
5010 
  """
5011 
 
5012 
  thrift_spec = (
5013 
    (0, TType.I32, 'success', None, None, ), # 0
5014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5015 
  )
5016 
 
5017 
  def __init__(self, success=None, ex=None,):
5018 
    self.success = success
5019 
    self.ex = ex
5020 
 
5021 
  def read(self, iprot):
5022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5024 
      return
5025 
    iprot.readStructBegin()
5026 
    while True:
5027 
      (fname, ftype, fid) = iprot.readFieldBegin()
5028 
      if ftype == TType.STOP:
5029 
        break
5030 
      if fid == 0:
5031 
        if ftype == TType.I32:
5032 
          self.success = iprot.readI32();
5033 
        else:
5034 
          iprot.skip(ftype)
5035 
      elif fid == 1:
5036 
        if ftype == TType.STRUCT:
5037 
          self.ex = TransactionServiceException()
5038 
          self.ex.read(iprot)
5039 
        else:
5040 
          iprot.skip(ftype)
5041 
      else:
5042 
        iprot.skip(ftype)
5043 
      iprot.readFieldEnd()
5044 
    iprot.readStructEnd()
5045 
 
5046 
  def write(self, oprot):
5047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5049 
      return
5050 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5051 
    if self.success is not None:
94 ashish 5052 
      oprot.writeFieldBegin('success', TType.I32, 0)
5053 
      oprot.writeI32(self.success)
5054 
      oprot.writeFieldEnd()
3431 rajveer 5055 
    if self.ex is not None:
94 ashish 5056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5057 
      self.ex.write(oprot)
5058 
      oprot.writeFieldEnd()
5059 
    oprot.writeFieldStop()
5060 
    oprot.writeStructEnd()
5061 
 
3431 rajveer 5062 
  def validate(self):
5063 
    return
5064 
 
5065 
 
94 ashish 5066 
  def __repr__(self):
5067 
    L = ['%s=%r' % (key, value)
5068 
      for key, value in self.__dict__.iteritems()]
5069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5070 
 
5071 
  def __eq__(self, other):
5072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5073 
 
5074 
  def __ne__(self, other):
5075 
    return not (self == other)
5076 
 
5077 
class changeTransactionStatus_args:
5078 
  """
5079 
  Attributes:
5080 
   - transactionId
5081 
   - status
5082 
   - description
5083 
  """
5084 
 
5085 
  thrift_spec = (
5086 
    None, # 0
5087 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5088 
    (2, TType.I32, 'status', None, None, ), # 2
5089 
    (3, TType.STRING, 'description', None, None, ), # 3
5090 
  )
5091 
 
5092 
  def __init__(self, transactionId=None, status=None, description=None,):
5093 
    self.transactionId = transactionId
5094 
    self.status = status
5095 
    self.description = description
5096 
 
5097 
  def read(self, iprot):
5098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5100 
      return
5101 
    iprot.readStructBegin()
5102 
    while True:
5103 
      (fname, ftype, fid) = iprot.readFieldBegin()
5104 
      if ftype == TType.STOP:
5105 
        break
5106 
      if fid == 1:
5107 
        if ftype == TType.I64:
5108 
          self.transactionId = iprot.readI64();
5109 
        else:
5110 
          iprot.skip(ftype)
5111 
      elif fid == 2:
5112 
        if ftype == TType.I32:
5113 
          self.status = iprot.readI32();
5114 
        else:
5115 
          iprot.skip(ftype)
5116 
      elif fid == 3:
5117 
        if ftype == TType.STRING:
5118 
          self.description = iprot.readString();
5119 
        else:
5120 
          iprot.skip(ftype)
5121 
      else:
5122 
        iprot.skip(ftype)
5123 
      iprot.readFieldEnd()
5124 
    iprot.readStructEnd()
5125 
 
5126 
  def write(self, oprot):
5127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5129 
      return
5130 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5131 
    if self.transactionId is not None:
94 ashish 5132 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5133 
      oprot.writeI64(self.transactionId)
5134 
      oprot.writeFieldEnd()
3431 rajveer 5135 
    if self.status is not None:
94 ashish 5136 
      oprot.writeFieldBegin('status', TType.I32, 2)
5137 
      oprot.writeI32(self.status)
5138 
      oprot.writeFieldEnd()
3431 rajveer 5139 
    if self.description is not None:
94 ashish 5140 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5141 
      oprot.writeString(self.description)
5142 
      oprot.writeFieldEnd()
5143 
    oprot.writeFieldStop()
5144 
    oprot.writeStructEnd()
5145 
 
3431 rajveer 5146 
  def validate(self):
5147 
    return
5148 
 
5149 
 
94 ashish 5150 
  def __repr__(self):
5151 
    L = ['%s=%r' % (key, value)
5152 
      for key, value in self.__dict__.iteritems()]
5153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5154 
 
5155 
  def __eq__(self, other):
5156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5157 
 
5158 
  def __ne__(self, other):
5159 
    return not (self == other)
5160 
 
5161 
class changeTransactionStatus_result:
5162 
  """
5163 
  Attributes:
5164 
   - success
5165 
   - ex
5166 
  """
5167 
 
5168 
  thrift_spec = (
5169 
    (0, TType.BOOL, 'success', None, None, ), # 0
5170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5171 
  )
5172 
 
5173 
  def __init__(self, success=None, ex=None,):
5174 
    self.success = success
5175 
    self.ex = ex
5176 
 
5177 
  def read(self, iprot):
5178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5180 
      return
5181 
    iprot.readStructBegin()
5182 
    while True:
5183 
      (fname, ftype, fid) = iprot.readFieldBegin()
5184 
      if ftype == TType.STOP:
5185 
        break
5186 
      if fid == 0:
5187 
        if ftype == TType.BOOL:
5188 
          self.success = iprot.readBool();
5189 
        else:
5190 
          iprot.skip(ftype)
5191 
      elif fid == 1:
5192 
        if ftype == TType.STRUCT:
5193 
          self.ex = TransactionServiceException()
5194 
          self.ex.read(iprot)
5195 
        else:
5196 
          iprot.skip(ftype)
5197 
      else:
5198 
        iprot.skip(ftype)
5199 
      iprot.readFieldEnd()
5200 
    iprot.readStructEnd()
5201 
 
5202 
  def write(self, oprot):
5203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5205 
      return
5206 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5207 
    if self.success is not None:
94 ashish 5208 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5209 
      oprot.writeBool(self.success)
5210 
      oprot.writeFieldEnd()
3431 rajveer 5211 
    if self.ex is not None:
94 ashish 5212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5213 
      self.ex.write(oprot)
5214 
      oprot.writeFieldEnd()
5215 
    oprot.writeFieldStop()
5216 
    oprot.writeStructEnd()
5217 
 
3431 rajveer 5218 
  def validate(self):
5219 
    return
5220 
 
5221 
 
94 ashish 5222 
  def __repr__(self):
5223 
    L = ['%s=%r' % (key, value)
5224 
      for key, value in self.__dict__.iteritems()]
5225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5226 
 
5227 
  def __eq__(self, other):
5228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5229 
 
5230 
  def __ne__(self, other):
5231 
    return not (self == other)
5232 
 
1398 varun.gupt 5233 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5234 
  """
5235 
  Attributes:
5236 
   - transactionId
5237 
  """
5238 
 
5239 
  thrift_spec = (
5240 
    None, # 0
5241 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5242 
  )
5243 
 
5244 
  def __init__(self, transactionId=None,):
5245 
    self.transactionId = transactionId
5246 
 
5247 
  def read(self, iprot):
5248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5250 
      return
5251 
    iprot.readStructBegin()
5252 
    while True:
5253 
      (fname, ftype, fid) = iprot.readFieldBegin()
5254 
      if ftype == TType.STOP:
5255 
        break
5256 
      if fid == 1:
5257 
        if ftype == TType.I64:
5258 
          self.transactionId = iprot.readI64();
5259 
        else:
5260 
          iprot.skip(ftype)
5261 
      else:
5262 
        iprot.skip(ftype)
5263 
      iprot.readFieldEnd()
5264 
    iprot.readStructEnd()
5265 
 
5266 
  def write(self, oprot):
5267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5269 
      return
1398 varun.gupt 5270 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5271 
    if self.transactionId is not None:
1382 varun.gupt 5272 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5273 
      oprot.writeI64(self.transactionId)
5274 
      oprot.writeFieldEnd()
5275 
    oprot.writeFieldStop()
5276 
    oprot.writeStructEnd()
5277 
 
3431 rajveer 5278 
  def validate(self):
5279 
    return
5280 
 
5281 
 
1382 varun.gupt 5282 
  def __repr__(self):
5283 
    L = ['%s=%r' % (key, value)
5284 
      for key, value in self.__dict__.iteritems()]
5285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5286 
 
5287 
  def __eq__(self, other):
5288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5289 
 
5290 
  def __ne__(self, other):
5291 
    return not (self == other)
5292 
 
1398 varun.gupt 5293 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5294 
  """
5295 
  Attributes:
5296 
   - success
5297 
   - ex
5298 
  """
5299 
 
5300 
  thrift_spec = (
5301 
    (0, TType.BOOL, 'success', None, None, ), # 0
5302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5303 
  )
5304 
 
5305 
  def __init__(self, success=None, ex=None,):
5306 
    self.success = success
5307 
    self.ex = ex
5308 
 
5309 
  def read(self, iprot):
5310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5312 
      return
5313 
    iprot.readStructBegin()
5314 
    while True:
5315 
      (fname, ftype, fid) = iprot.readFieldBegin()
5316 
      if ftype == TType.STOP:
5317 
        break
5318 
      if fid == 0:
5319 
        if ftype == TType.BOOL:
5320 
          self.success = iprot.readBool();
5321 
        else:
5322 
          iprot.skip(ftype)
5323 
      elif fid == 1:
5324 
        if ftype == TType.STRUCT:
5325 
          self.ex = TransactionServiceException()
5326 
          self.ex.read(iprot)
5327 
        else:
5328 
          iprot.skip(ftype)
5329 
      else:
5330 
        iprot.skip(ftype)
5331 
      iprot.readFieldEnd()
5332 
    iprot.readStructEnd()
5333 
 
5334 
  def write(self, oprot):
5335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5337 
      return
1398 varun.gupt 5338 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5339 
    if self.success is not None:
1382 varun.gupt 5340 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5341 
      oprot.writeBool(self.success)
5342 
      oprot.writeFieldEnd()
3431 rajveer 5343 
    if self.ex is not None:
1382 varun.gupt 5344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5345 
      self.ex.write(oprot)
5346 
      oprot.writeFieldEnd()
5347 
    oprot.writeFieldStop()
5348 
    oprot.writeStructEnd()
5349 
 
3431 rajveer 5350 
  def validate(self):
5351 
    return
5352 
 
5353 
 
1382 varun.gupt 5354 
  def __repr__(self):
5355 
    L = ['%s=%r' % (key, value)
5356 
      for key, value in self.__dict__.iteritems()]
5357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5358 
 
5359 
  def __eq__(self, other):
5360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5361 
 
5362 
  def __ne__(self, other):
5363 
    return not (self == other)
5364 
 
483 rajveer 5365 
class getAllOrders_args:
94 ashish 5366 
  """
5367 
  Attributes:
483 rajveer 5368 
   - status
5369 
   - from_date
5370 
   - to_date
5371 
   - warehouse_id
94 ashish 5372 
  """
5373 
 
5374 
  thrift_spec = (
5375 
    None, # 0
483 rajveer 5376 
    (1, TType.I32, 'status', None, None, ), # 1
5377 
    (2, TType.I64, 'from_date', None, None, ), # 2
5378 
    (3, TType.I64, 'to_date', None, None, ), # 3
5379 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5380 
  )
5381 
 
483 rajveer 5382 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5383 
    self.status = status
5384 
    self.from_date = from_date
5385 
    self.to_date = to_date
5386 
    self.warehouse_id = warehouse_id
94 ashish 5387 
 
5388 
  def read(self, iprot):
5389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5391 
      return
5392 
    iprot.readStructBegin()
5393 
    while True:
5394 
      (fname, ftype, fid) = iprot.readFieldBegin()
5395 
      if ftype == TType.STOP:
5396 
        break
5397 
      if fid == 1:
483 rajveer 5398 
        if ftype == TType.I32:
5399 
          self.status = iprot.readI32();
94 ashish 5400 
        else:
5401 
          iprot.skip(ftype)
483 rajveer 5402 
      elif fid == 2:
5403 
        if ftype == TType.I64:
5404 
          self.from_date = iprot.readI64();
94 ashish 5405 
        else:
5406 
          iprot.skip(ftype)
483 rajveer 5407 
      elif fid == 3:
5408 
        if ftype == TType.I64:
5409 
          self.to_date = iprot.readI64();
94 ashish 5410 
        else:
5411 
          iprot.skip(ftype)
483 rajveer 5412 
      elif fid == 4:
94 ashish 5413 
        if ftype == TType.I64:
483 rajveer 5414 
          self.warehouse_id = iprot.readI64();
94 ashish 5415 
        else:
5416 
          iprot.skip(ftype)
5417 
      else:
5418 
        iprot.skip(ftype)
5419 
      iprot.readFieldEnd()
5420 
    iprot.readStructEnd()
5421 
 
5422 
  def write(self, oprot):
5423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5425 
      return
483 rajveer 5426 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5427 
    if self.status is not None:
483 rajveer 5428 
      oprot.writeFieldBegin('status', TType.I32, 1)
5429 
      oprot.writeI32(self.status)
94 ashish 5430 
      oprot.writeFieldEnd()
3431 rajveer 5431 
    if self.from_date is not None:
483 rajveer 5432 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5433 
      oprot.writeI64(self.from_date)
94 ashish 5434 
      oprot.writeFieldEnd()
3431 rajveer 5435 
    if self.to_date is not None:
483 rajveer 5436 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5437 
      oprot.writeI64(self.to_date)
94 ashish 5438 
      oprot.writeFieldEnd()
3431 rajveer 5439 
    if self.warehouse_id is not None:
483 rajveer 5440 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5441 
      oprot.writeI64(self.warehouse_id)
94 ashish 5442 
      oprot.writeFieldEnd()
5443 
    oprot.writeFieldStop()
5444 
    oprot.writeStructEnd()
5445 
 
3431 rajveer 5446 
  def validate(self):
5447 
    return
5448 
 
5449 
 
94 ashish 5450 
  def __repr__(self):
5451 
    L = ['%s=%r' % (key, value)
5452 
      for key, value in self.__dict__.iteritems()]
5453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5454 
 
5455 
  def __eq__(self, other):
5456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5457 
 
5458 
  def __ne__(self, other):
5459 
    return not (self == other)
5460 
 
483 rajveer 5461 
class getAllOrders_result:
94 ashish 5462 
  """
5463 
  Attributes:
5464 
   - success
5465 
   - ex
5466 
  """
5467 
 
5468 
  thrift_spec = (
483 rajveer 5469 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5471 
  )
5472 
 
5473 
  def __init__(self, success=None, ex=None,):
5474 
    self.success = success
5475 
    self.ex = ex
5476 
 
5477 
  def read(self, iprot):
5478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5480 
      return
5481 
    iprot.readStructBegin()
5482 
    while True:
5483 
      (fname, ftype, fid) = iprot.readFieldBegin()
5484 
      if ftype == TType.STOP:
5485 
        break
5486 
      if fid == 0:
483 rajveer 5487 
        if ftype == TType.LIST:
5488 
          self.success = []
685 chandransh 5489 
          (_etype31, _size28) = iprot.readListBegin()
5490 
          for _i32 in xrange(_size28):
5491 
            _elem33 = Order()
5492 
            _elem33.read(iprot)
5493 
            self.success.append(_elem33)
483 rajveer 5494 
          iprot.readListEnd()
94 ashish 5495 
        else:
5496 
          iprot.skip(ftype)
5497 
      elif fid == 1:
5498 
        if ftype == TType.STRUCT:
5499 
          self.ex = TransactionServiceException()
5500 
          self.ex.read(iprot)
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      else:
5504 
        iprot.skip(ftype)
5505 
      iprot.readFieldEnd()
5506 
    iprot.readStructEnd()
5507 
 
5508 
  def write(self, oprot):
5509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5511 
      return
483 rajveer 5512 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5513 
    if self.success is not None:
483 rajveer 5514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5516 
      for iter34 in self.success:
5517 
        iter34.write(oprot)
483 rajveer 5518 
      oprot.writeListEnd()
94 ashish 5519 
      oprot.writeFieldEnd()
3431 rajveer 5520 
    if self.ex is not None:
94 ashish 5521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5522 
      self.ex.write(oprot)
5523 
      oprot.writeFieldEnd()
5524 
    oprot.writeFieldStop()
5525 
    oprot.writeStructEnd()
5526 
 
3431 rajveer 5527 
  def validate(self):
5528 
    return
5529 
 
5530 
 
94 ashish 5531 
  def __repr__(self):
5532 
    L = ['%s=%r' % (key, value)
5533 
      for key, value in self.__dict__.iteritems()]
5534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5535 
 
5536 
  def __eq__(self, other):
5537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5538 
 
5539 
  def __ne__(self, other):
5540 
    return not (self == other)
5541 
 
4133 chandransh 5542 
class getOrdersInBatch_args:
5543 
  """
5544 
  Attributes:
5545 
   - statuses
5546 
   - offset
5547 
   - limit
5548 
   - warehouse_id
5549 
  """
5550 
 
5551 
  thrift_spec = (
5552 
    None, # 0
5553 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5554 
    (2, TType.I64, 'offset', None, None, ), # 2
5555 
    (3, TType.I64, 'limit', None, None, ), # 3
5556 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5557 
  )
5558 
 
5559 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5560 
    self.statuses = statuses
5561 
    self.offset = offset
5562 
    self.limit = limit
5563 
    self.warehouse_id = warehouse_id
5564 
 
5565 
  def read(self, iprot):
5566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5568 
      return
5569 
    iprot.readStructBegin()
5570 
    while True:
5571 
      (fname, ftype, fid) = iprot.readFieldBegin()
5572 
      if ftype == TType.STOP:
5573 
        break
5574 
      if fid == 1:
5575 
        if ftype == TType.LIST:
5576 
          self.statuses = []
5577 
          (_etype38, _size35) = iprot.readListBegin()
5578 
          for _i39 in xrange(_size35):
5579 
            _elem40 = iprot.readI32();
5580 
            self.statuses.append(_elem40)
5581 
          iprot.readListEnd()
5582 
        else:
5583 
          iprot.skip(ftype)
5584 
      elif fid == 2:
5585 
        if ftype == TType.I64:
5586 
          self.offset = iprot.readI64();
5587 
        else:
5588 
          iprot.skip(ftype)
5589 
      elif fid == 3:
5590 
        if ftype == TType.I64:
5591 
          self.limit = iprot.readI64();
5592 
        else:
5593 
          iprot.skip(ftype)
5594 
      elif fid == 4:
5595 
        if ftype == TType.I64:
5596 
          self.warehouse_id = iprot.readI64();
5597 
        else:
5598 
          iprot.skip(ftype)
5599 
      else:
5600 
        iprot.skip(ftype)
5601 
      iprot.readFieldEnd()
5602 
    iprot.readStructEnd()
5603 
 
5604 
  def write(self, oprot):
5605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5607 
      return
5608 
    oprot.writeStructBegin('getOrdersInBatch_args')
5609 
    if self.statuses is not None:
5610 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5611 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5612 
      for iter41 in self.statuses:
5613 
        oprot.writeI32(iter41)
5614 
      oprot.writeListEnd()
5615 
      oprot.writeFieldEnd()
5616 
    if self.offset is not None:
5617 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5618 
      oprot.writeI64(self.offset)
5619 
      oprot.writeFieldEnd()
5620 
    if self.limit is not None:
5621 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5622 
      oprot.writeI64(self.limit)
5623 
      oprot.writeFieldEnd()
5624 
    if self.warehouse_id is not None:
5625 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5626 
      oprot.writeI64(self.warehouse_id)
5627 
      oprot.writeFieldEnd()
5628 
    oprot.writeFieldStop()
5629 
    oprot.writeStructEnd()
5630 
 
5631 
  def validate(self):
5632 
    return
5633 
 
5634 
 
5635 
  def __repr__(self):
5636 
    L = ['%s=%r' % (key, value)
5637 
      for key, value in self.__dict__.iteritems()]
5638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5639 
 
5640 
  def __eq__(self, other):
5641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5642 
 
5643 
  def __ne__(self, other):
5644 
    return not (self == other)
5645 
 
5646 
class getOrdersInBatch_result:
5647 
  """
5648 
  Attributes:
5649 
   - success
5650 
   - ex
5651 
  """
5652 
 
5653 
  thrift_spec = (
5654 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5656 
  )
5657 
 
5658 
  def __init__(self, success=None, ex=None,):
5659 
    self.success = success
5660 
    self.ex = ex
5661 
 
5662 
  def read(self, iprot):
5663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5665 
      return
5666 
    iprot.readStructBegin()
5667 
    while True:
5668 
      (fname, ftype, fid) = iprot.readFieldBegin()
5669 
      if ftype == TType.STOP:
5670 
        break
5671 
      if fid == 0:
5672 
        if ftype == TType.LIST:
5673 
          self.success = []
5674 
          (_etype45, _size42) = iprot.readListBegin()
5675 
          for _i46 in xrange(_size42):
5676 
            _elem47 = Order()
5677 
            _elem47.read(iprot)
5678 
            self.success.append(_elem47)
5679 
          iprot.readListEnd()
5680 
        else:
5681 
          iprot.skip(ftype)
5682 
      elif fid == 1:
5683 
        if ftype == TType.STRUCT:
5684 
          self.ex = TransactionServiceException()
5685 
          self.ex.read(iprot)
5686 
        else:
5687 
          iprot.skip(ftype)
5688 
      else:
5689 
        iprot.skip(ftype)
5690 
      iprot.readFieldEnd()
5691 
    iprot.readStructEnd()
5692 
 
5693 
  def write(self, oprot):
5694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5696 
      return
5697 
    oprot.writeStructBegin('getOrdersInBatch_result')
5698 
    if self.success is not None:
5699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5701 
      for iter48 in self.success:
5702 
        iter48.write(oprot)
5703 
      oprot.writeListEnd()
5704 
      oprot.writeFieldEnd()
5705 
    if self.ex is not None:
5706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5707 
      self.ex.write(oprot)
5708 
      oprot.writeFieldEnd()
5709 
    oprot.writeFieldStop()
5710 
    oprot.writeStructEnd()
5711 
 
5712 
  def validate(self):
5713 
    return
5714 
 
5715 
 
5716 
  def __repr__(self):
5717 
    L = ['%s=%r' % (key, value)
5718 
      for key, value in self.__dict__.iteritems()]
5719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5720 
 
5721 
  def __eq__(self, other):
5722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5723 
 
5724 
  def __ne__(self, other):
5725 
    return not (self == other)
5726 
 
5727 
class getOrderCount_args:
5728 
  """
5729 
  Attributes:
5730 
   - statuses
5731 
   - warehouseId
5732 
  """
5733 
 
5734 
  thrift_spec = (
5735 
    None, # 0
5736 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5737 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5738 
  )
5739 
 
5740 
  def __init__(self, statuses=None, warehouseId=None,):
5741 
    self.statuses = statuses
5742 
    self.warehouseId = warehouseId
5743 
 
5744 
  def read(self, iprot):
5745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5747 
      return
5748 
    iprot.readStructBegin()
5749 
    while True:
5750 
      (fname, ftype, fid) = iprot.readFieldBegin()
5751 
      if ftype == TType.STOP:
5752 
        break
5753 
      if fid == 1:
5754 
        if ftype == TType.LIST:
5755 
          self.statuses = []
5756 
          (_etype52, _size49) = iprot.readListBegin()
5757 
          for _i53 in xrange(_size49):
5758 
            _elem54 = iprot.readI32();
5759 
            self.statuses.append(_elem54)
5760 
          iprot.readListEnd()
5761 
        else:
5762 
          iprot.skip(ftype)
5763 
      elif fid == 2:
5764 
        if ftype == TType.I64:
5765 
          self.warehouseId = iprot.readI64();
5766 
        else:
5767 
          iprot.skip(ftype)
5768 
      else:
5769 
        iprot.skip(ftype)
5770 
      iprot.readFieldEnd()
5771 
    iprot.readStructEnd()
5772 
 
5773 
  def write(self, oprot):
5774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5776 
      return
5777 
    oprot.writeStructBegin('getOrderCount_args')
5778 
    if self.statuses is not None:
5779 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5780 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5781 
      for iter55 in self.statuses:
5782 
        oprot.writeI32(iter55)
5783 
      oprot.writeListEnd()
5784 
      oprot.writeFieldEnd()
5785 
    if self.warehouseId is not None:
5786 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5787 
      oprot.writeI64(self.warehouseId)
5788 
      oprot.writeFieldEnd()
5789 
    oprot.writeFieldStop()
5790 
    oprot.writeStructEnd()
5791 
 
5792 
  def validate(self):
5793 
    return
5794 
 
5795 
 
5796 
  def __repr__(self):
5797 
    L = ['%s=%r' % (key, value)
5798 
      for key, value in self.__dict__.iteritems()]
5799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5800 
 
5801 
  def __eq__(self, other):
5802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5803 
 
5804 
  def __ne__(self, other):
5805 
    return not (self == other)
5806 
 
5807 
class getOrderCount_result:
5808 
  """
5809 
  Attributes:
5810 
   - success
5811 
   - ex
5812 
  """
5813 
 
5814 
  thrift_spec = (
5815 
    (0, TType.I32, 'success', None, None, ), # 0
5816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5817 
  )
5818 
 
5819 
  def __init__(self, success=None, ex=None,):
5820 
    self.success = success
5821 
    self.ex = ex
5822 
 
5823 
  def read(self, iprot):
5824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5826 
      return
5827 
    iprot.readStructBegin()
5828 
    while True:
5829 
      (fname, ftype, fid) = iprot.readFieldBegin()
5830 
      if ftype == TType.STOP:
5831 
        break
5832 
      if fid == 0:
5833 
        if ftype == TType.I32:
5834 
          self.success = iprot.readI32();
5835 
        else:
5836 
          iprot.skip(ftype)
5837 
      elif fid == 1:
5838 
        if ftype == TType.STRUCT:
5839 
          self.ex = TransactionServiceException()
5840 
          self.ex.read(iprot)
5841 
        else:
5842 
          iprot.skip(ftype)
5843 
      else:
5844 
        iprot.skip(ftype)
5845 
      iprot.readFieldEnd()
5846 
    iprot.readStructEnd()
5847 
 
5848 
  def write(self, oprot):
5849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5851 
      return
5852 
    oprot.writeStructBegin('getOrderCount_result')
5853 
    if self.success is not None:
5854 
      oprot.writeFieldBegin('success', TType.I32, 0)
5855 
      oprot.writeI32(self.success)
5856 
      oprot.writeFieldEnd()
5857 
    if self.ex is not None:
5858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5859 
      self.ex.write(oprot)
5860 
      oprot.writeFieldEnd()
5861 
    oprot.writeFieldStop()
5862 
    oprot.writeStructEnd()
5863 
 
5864 
  def validate(self):
5865 
    return
5866 
 
5867 
 
5868 
  def __repr__(self):
5869 
    L = ['%s=%r' % (key, value)
5870 
      for key, value in self.__dict__.iteritems()]
5871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5872 
 
5873 
  def __eq__(self, other):
5874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5875 
 
5876 
  def __ne__(self, other):
5877 
    return not (self == other)
5878 
 
999 varun.gupt 5879 
class getOrdersByBillingDate_args:
5880 
  """
5881 
  Attributes:
5882 
   - status
5883 
   - start_billing_date
5884 
   - end_billing_date
5885 
   - warehouse_id
5886 
  """
5887 
 
5888 
  thrift_spec = (
5889 
    None, # 0
5890 
    (1, TType.I32, 'status', None, None, ), # 1
5891 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5892 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5893 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5894 
  )
5895 
 
5896 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5897 
    self.status = status
5898 
    self.start_billing_date = start_billing_date
5899 
    self.end_billing_date = end_billing_date
5900 
    self.warehouse_id = warehouse_id
5901 
 
5902 
  def read(self, iprot):
5903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5905 
      return
5906 
    iprot.readStructBegin()
5907 
    while True:
5908 
      (fname, ftype, fid) = iprot.readFieldBegin()
5909 
      if ftype == TType.STOP:
5910 
        break
5911 
      if fid == 1:
5912 
        if ftype == TType.I32:
5913 
          self.status = iprot.readI32();
5914 
        else:
5915 
          iprot.skip(ftype)
5916 
      elif fid == 2:
5917 
        if ftype == TType.I64:
5918 
          self.start_billing_date = iprot.readI64();
5919 
        else:
5920 
          iprot.skip(ftype)
5921 
      elif fid == 3:
5922 
        if ftype == TType.I64:
5923 
          self.end_billing_date = iprot.readI64();
5924 
        else:
5925 
          iprot.skip(ftype)
5926 
      elif fid == 4:
5927 
        if ftype == TType.I64:
5928 
          self.warehouse_id = iprot.readI64();
5929 
        else:
5930 
          iprot.skip(ftype)
5931 
      else:
5932 
        iprot.skip(ftype)
5933 
      iprot.readFieldEnd()
5934 
    iprot.readStructEnd()
5935 
 
5936 
  def write(self, oprot):
5937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5939 
      return
5940 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5941 
    if self.status is not None:
999 varun.gupt 5942 
      oprot.writeFieldBegin('status', TType.I32, 1)
5943 
      oprot.writeI32(self.status)
5944 
      oprot.writeFieldEnd()
3431 rajveer 5945 
    if self.start_billing_date is not None:
999 varun.gupt 5946 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5947 
      oprot.writeI64(self.start_billing_date)
5948 
      oprot.writeFieldEnd()
3431 rajveer 5949 
    if self.end_billing_date is not None:
999 varun.gupt 5950 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5951 
      oprot.writeI64(self.end_billing_date)
5952 
      oprot.writeFieldEnd()
3431 rajveer 5953 
    if self.warehouse_id is not None:
999 varun.gupt 5954 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5955 
      oprot.writeI64(self.warehouse_id)
5956 
      oprot.writeFieldEnd()
5957 
    oprot.writeFieldStop()
5958 
    oprot.writeStructEnd()
5959 
 
3431 rajveer 5960 
  def validate(self):
5961 
    return
5962 
 
5963 
 
999 varun.gupt 5964 
  def __repr__(self):
5965 
    L = ['%s=%r' % (key, value)
5966 
      for key, value in self.__dict__.iteritems()]
5967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5968 
 
5969 
  def __eq__(self, other):
5970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5971 
 
5972 
  def __ne__(self, other):
5973 
    return not (self == other)
5974 
 
5975 
class getOrdersByBillingDate_result:
5976 
  """
5977 
  Attributes:
5978 
   - success
5979 
   - ex
5980 
  """
5981 
 
5982 
  thrift_spec = (
5983 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5985 
  )
5986 
 
5987 
  def __init__(self, success=None, ex=None,):
5988 
    self.success = success
5989 
    self.ex = ex
5990 
 
5991 
  def read(self, iprot):
5992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5994 
      return
5995 
    iprot.readStructBegin()
5996 
    while True:
5997 
      (fname, ftype, fid) = iprot.readFieldBegin()
5998 
      if ftype == TType.STOP:
5999 
        break
6000 
      if fid == 0:
6001 
        if ftype == TType.LIST:
6002 
          self.success = []
4133 chandransh 6003 
          (_etype59, _size56) = iprot.readListBegin()
6004 
          for _i60 in xrange(_size56):
6005 
            _elem61 = Order()
6006 
            _elem61.read(iprot)
6007 
            self.success.append(_elem61)
999 varun.gupt 6008 
          iprot.readListEnd()
6009 
        else:
6010 
          iprot.skip(ftype)
6011 
      elif fid == 1:
6012 
        if ftype == TType.STRUCT:
6013 
          self.ex = TransactionServiceException()
6014 
          self.ex.read(iprot)
6015 
        else:
6016 
          iprot.skip(ftype)
6017 
      else:
6018 
        iprot.skip(ftype)
6019 
      iprot.readFieldEnd()
6020 
    iprot.readStructEnd()
6021 
 
6022 
  def write(self, oprot):
6023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6025 
      return
6026 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6027 
    if self.success is not None:
999 varun.gupt 6028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6029 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6030 
      for iter62 in self.success:
6031 
        iter62.write(oprot)
999 varun.gupt 6032 
      oprot.writeListEnd()
6033 
      oprot.writeFieldEnd()
3431 rajveer 6034 
    if self.ex is not None:
999 varun.gupt 6035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6036 
      self.ex.write(oprot)
6037 
      oprot.writeFieldEnd()
6038 
    oprot.writeFieldStop()
6039 
    oprot.writeStructEnd()
6040 
 
3431 rajveer 6041 
  def validate(self):
6042 
    return
6043 
 
6044 
 
999 varun.gupt 6045 
  def __repr__(self):
6046 
    L = ['%s=%r' % (key, value)
6047 
      for key, value in self.__dict__.iteritems()]
6048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6049 
 
6050 
  def __eq__(self, other):
6051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6052 
 
6053 
  def __ne__(self, other):
6054 
    return not (self == other)
6055 
 
3427 chandransh 6056 
class getOrdersByShippingDate_args:
6057 
  """
6058 
  Attributes:
6059 
   - fromShippingDate
6060 
   - toShippingDate
6061 
   - providerId
6062 
   - warehouseId
3451 chandransh 6063 
   - cod
3427 chandransh 6064 
  """
6065 
 
6066 
  thrift_spec = (
6067 
    None, # 0
6068 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6069 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6070 
    (3, TType.I64, 'providerId', None, None, ), # 3
6071 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6072 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6073 
  )
6074 
 
3451 chandransh 6075 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6076 
    self.fromShippingDate = fromShippingDate
6077 
    self.toShippingDate = toShippingDate
6078 
    self.providerId = providerId
6079 
    self.warehouseId = warehouseId
3451 chandransh 6080 
    self.cod = cod
3427 chandransh 6081 
 
6082 
  def read(self, iprot):
6083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6085 
      return
6086 
    iprot.readStructBegin()
6087 
    while True:
6088 
      (fname, ftype, fid) = iprot.readFieldBegin()
6089 
      if ftype == TType.STOP:
6090 
        break
6091 
      if fid == 1:
6092 
        if ftype == TType.I64:
6093 
          self.fromShippingDate = iprot.readI64();
6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      elif fid == 2:
6097 
        if ftype == TType.I64:
6098 
          self.toShippingDate = iprot.readI64();
6099 
        else:
6100 
          iprot.skip(ftype)
6101 
      elif fid == 3:
6102 
        if ftype == TType.I64:
6103 
          self.providerId = iprot.readI64();
6104 
        else:
6105 
          iprot.skip(ftype)
6106 
      elif fid == 4:
6107 
        if ftype == TType.I64:
6108 
          self.warehouseId = iprot.readI64();
6109 
        else:
6110 
          iprot.skip(ftype)
3451 chandransh 6111 
      elif fid == 5:
6112 
        if ftype == TType.BOOL:
6113 
          self.cod = iprot.readBool();
6114 
        else:
6115 
          iprot.skip(ftype)
3427 chandransh 6116 
      else:
6117 
        iprot.skip(ftype)
6118 
      iprot.readFieldEnd()
6119 
    iprot.readStructEnd()
6120 
 
6121 
  def write(self, oprot):
6122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6124 
      return
6125 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6126 
    if self.fromShippingDate is not None:
3427 chandransh 6127 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6128 
      oprot.writeI64(self.fromShippingDate)
6129 
      oprot.writeFieldEnd()
3431 rajveer 6130 
    if self.toShippingDate is not None:
3427 chandransh 6131 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6132 
      oprot.writeI64(self.toShippingDate)
6133 
      oprot.writeFieldEnd()
3431 rajveer 6134 
    if self.providerId is not None:
3427 chandransh 6135 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6136 
      oprot.writeI64(self.providerId)
6137 
      oprot.writeFieldEnd()
3431 rajveer 6138 
    if self.warehouseId is not None:
3427 chandransh 6139 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6140 
      oprot.writeI64(self.warehouseId)
6141 
      oprot.writeFieldEnd()
3451 chandransh 6142 
    if self.cod is not None:
6143 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6144 
      oprot.writeBool(self.cod)
6145 
      oprot.writeFieldEnd()
3427 chandransh 6146 
    oprot.writeFieldStop()
6147 
    oprot.writeStructEnd()
6148 
 
3431 rajveer 6149 
  def validate(self):
6150 
    return
6151 
 
6152 
 
3427 chandransh 6153 
  def __repr__(self):
6154 
    L = ['%s=%r' % (key, value)
6155 
      for key, value in self.__dict__.iteritems()]
6156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6157 
 
6158 
  def __eq__(self, other):
6159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6160 
 
6161 
  def __ne__(self, other):
6162 
    return not (self == other)
6163 
 
6164 
class getOrdersByShippingDate_result:
6165 
  """
6166 
  Attributes:
6167 
   - success
6168 
   - ex
6169 
  """
6170 
 
6171 
  thrift_spec = (
6172 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6174 
  )
6175 
 
6176 
  def __init__(self, success=None, ex=None,):
6177 
    self.success = success
6178 
    self.ex = ex
6179 
 
6180 
  def read(self, iprot):
6181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6183 
      return
6184 
    iprot.readStructBegin()
6185 
    while True:
6186 
      (fname, ftype, fid) = iprot.readFieldBegin()
6187 
      if ftype == TType.STOP:
6188 
        break
6189 
      if fid == 0:
6190 
        if ftype == TType.LIST:
6191 
          self.success = []
4133 chandransh 6192 
          (_etype66, _size63) = iprot.readListBegin()
6193 
          for _i67 in xrange(_size63):
6194 
            _elem68 = Order()
6195 
            _elem68.read(iprot)
6196 
            self.success.append(_elem68)
3427 chandransh 6197 
          iprot.readListEnd()
6198 
        else:
6199 
          iprot.skip(ftype)
6200 
      elif fid == 1:
6201 
        if ftype == TType.STRUCT:
6202 
          self.ex = TransactionServiceException()
6203 
          self.ex.read(iprot)
6204 
        else:
6205 
          iprot.skip(ftype)
6206 
      else:
6207 
        iprot.skip(ftype)
6208 
      iprot.readFieldEnd()
6209 
    iprot.readStructEnd()
6210 
 
6211 
  def write(self, oprot):
6212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6214 
      return
6215 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6216 
    if self.success is not None:
3427 chandransh 6217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6218 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6219 
      for iter69 in self.success:
6220 
        iter69.write(oprot)
3427 chandransh 6221 
      oprot.writeListEnd()
6222 
      oprot.writeFieldEnd()
3431 rajveer 6223 
    if self.ex is not None:
3427 chandransh 6224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6225 
      self.ex.write(oprot)
6226 
      oprot.writeFieldEnd()
6227 
    oprot.writeFieldStop()
6228 
    oprot.writeStructEnd()
6229 
 
3431 rajveer 6230 
  def validate(self):
6231 
    return
6232 
 
6233 
 
3427 chandransh 6234 
  def __repr__(self):
6235 
    L = ['%s=%r' % (key, value)
6236 
      for key, value in self.__dict__.iteritems()]
6237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6238 
 
6239 
  def __eq__(self, other):
6240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6241 
 
6242 
  def __ne__(self, other):
6243 
    return not (self == other)
6244 
 
1382 varun.gupt 6245 
class getReturnableOrdersForCustomer_args:
6246 
  """
6247 
  Attributes:
6248 
   - customer_id
6249 
   - limit
6250 
  """
6251 
 
6252 
  thrift_spec = (
6253 
    None, # 0
6254 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6255 
    (2, TType.I64, 'limit', None, None, ), # 2
6256 
  )
6257 
 
6258 
  def __init__(self, customer_id=None, limit=None,):
6259 
    self.customer_id = customer_id
6260 
    self.limit = limit
6261 
 
6262 
  def read(self, iprot):
6263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6265 
      return
6266 
    iprot.readStructBegin()
6267 
    while True:
6268 
      (fname, ftype, fid) = iprot.readFieldBegin()
6269 
      if ftype == TType.STOP:
6270 
        break
6271 
      if fid == 1:
6272 
        if ftype == TType.I64:
6273 
          self.customer_id = iprot.readI64();
6274 
        else:
6275 
          iprot.skip(ftype)
6276 
      elif fid == 2:
6277 
        if ftype == TType.I64:
6278 
          self.limit = iprot.readI64();
6279 
        else:
6280 
          iprot.skip(ftype)
6281 
      else:
6282 
        iprot.skip(ftype)
6283 
      iprot.readFieldEnd()
6284 
    iprot.readStructEnd()
6285 
 
6286 
  def write(self, oprot):
6287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6289 
      return
6290 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6291 
    if self.customer_id is not None:
1382 varun.gupt 6292 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6293 
      oprot.writeI64(self.customer_id)
6294 
      oprot.writeFieldEnd()
3431 rajveer 6295 
    if self.limit is not None:
1382 varun.gupt 6296 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6297 
      oprot.writeI64(self.limit)
6298 
      oprot.writeFieldEnd()
6299 
    oprot.writeFieldStop()
6300 
    oprot.writeStructEnd()
6301 
 
3431 rajveer 6302 
  def validate(self):
6303 
    return
6304 
 
6305 
 
1382 varun.gupt 6306 
  def __repr__(self):
6307 
    L = ['%s=%r' % (key, value)
6308 
      for key, value in self.__dict__.iteritems()]
6309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6310 
 
6311 
  def __eq__(self, other):
6312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6313 
 
6314 
  def __ne__(self, other):
6315 
    return not (self == other)
6316 
 
6317 
class getReturnableOrdersForCustomer_result:
6318 
  """
6319 
  Attributes:
6320 
   - success
6321 
   - ex
6322 
  """
6323 
 
6324 
  thrift_spec = (
6325 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6327 
  )
6328 
 
6329 
  def __init__(self, success=None, ex=None,):
6330 
    self.success = success
6331 
    self.ex = ex
6332 
 
6333 
  def read(self, iprot):
6334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6336 
      return
6337 
    iprot.readStructBegin()
6338 
    while True:
6339 
      (fname, ftype, fid) = iprot.readFieldBegin()
6340 
      if ftype == TType.STOP:
6341 
        break
6342 
      if fid == 0:
6343 
        if ftype == TType.LIST:
6344 
          self.success = []
4133 chandransh 6345 
          (_etype73, _size70) = iprot.readListBegin()
6346 
          for _i74 in xrange(_size70):
6347 
            _elem75 = iprot.readI64();
6348 
            self.success.append(_elem75)
1382 varun.gupt 6349 
          iprot.readListEnd()
6350 
        else:
6351 
          iprot.skip(ftype)
6352 
      elif fid == 1:
6353 
        if ftype == TType.STRUCT:
6354 
          self.ex = TransactionServiceException()
6355 
          self.ex.read(iprot)
6356 
        else:
6357 
          iprot.skip(ftype)
6358 
      else:
6359 
        iprot.skip(ftype)
6360 
      iprot.readFieldEnd()
6361 
    iprot.readStructEnd()
6362 
 
6363 
  def write(self, oprot):
6364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6366 
      return
6367 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6368 
    if self.success is not None:
1382 varun.gupt 6369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6370 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6371 
      for iter76 in self.success:
6372 
        oprot.writeI64(iter76)
1382 varun.gupt 6373 
      oprot.writeListEnd()
6374 
      oprot.writeFieldEnd()
3431 rajveer 6375 
    if self.ex is not None:
1382 varun.gupt 6376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6377 
      self.ex.write(oprot)
6378 
      oprot.writeFieldEnd()
6379 
    oprot.writeFieldStop()
6380 
    oprot.writeStructEnd()
6381 
 
3431 rajveer 6382 
  def validate(self):
6383 
    return
6384 
 
6385 
 
1382 varun.gupt 6386 
  def __repr__(self):
6387 
    L = ['%s=%r' % (key, value)
6388 
      for key, value in self.__dict__.iteritems()]
6389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6390 
 
6391 
  def __eq__(self, other):
6392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6393 
 
6394 
  def __ne__(self, other):
6395 
    return not (self == other)
6396 
 
6397 
class getCancellableOrdersForCustomer_args:
6398 
  """
6399 
  Attributes:
6400 
   - customer_id
6401 
   - limit
6402 
  """
6403 
 
6404 
  thrift_spec = (
6405 
    None, # 0
6406 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6407 
    (2, TType.I64, 'limit', None, None, ), # 2
6408 
  )
6409 
 
6410 
  def __init__(self, customer_id=None, limit=None,):
6411 
    self.customer_id = customer_id
6412 
    self.limit = limit
6413 
 
6414 
  def read(self, iprot):
6415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6417 
      return
6418 
    iprot.readStructBegin()
6419 
    while True:
6420 
      (fname, ftype, fid) = iprot.readFieldBegin()
6421 
      if ftype == TType.STOP:
6422 
        break
6423 
      if fid == 1:
6424 
        if ftype == TType.I64:
6425 
          self.customer_id = iprot.readI64();
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      elif fid == 2:
6429 
        if ftype == TType.I64:
6430 
          self.limit = iprot.readI64();
6431 
        else:
6432 
          iprot.skip(ftype)
6433 
      else:
6434 
        iprot.skip(ftype)
6435 
      iprot.readFieldEnd()
6436 
    iprot.readStructEnd()
6437 
 
6438 
  def write(self, oprot):
6439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6441 
      return
6442 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6443 
    if self.customer_id is not None:
1382 varun.gupt 6444 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6445 
      oprot.writeI64(self.customer_id)
6446 
      oprot.writeFieldEnd()
3431 rajveer 6447 
    if self.limit is not None:
1382 varun.gupt 6448 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6449 
      oprot.writeI64(self.limit)
6450 
      oprot.writeFieldEnd()
6451 
    oprot.writeFieldStop()
6452 
    oprot.writeStructEnd()
6453 
 
3431 rajveer 6454 
  def validate(self):
6455 
    return
6456 
 
6457 
 
1382 varun.gupt 6458 
  def __repr__(self):
6459 
    L = ['%s=%r' % (key, value)
6460 
      for key, value in self.__dict__.iteritems()]
6461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6462 
 
6463 
  def __eq__(self, other):
6464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6465 
 
6466 
  def __ne__(self, other):
6467 
    return not (self == other)
6468 
 
6469 
class getCancellableOrdersForCustomer_result:
6470 
  """
6471 
  Attributes:
6472 
   - success
6473 
   - ex
6474 
  """
6475 
 
6476 
  thrift_spec = (
6477 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6479 
  )
6480 
 
6481 
  def __init__(self, success=None, ex=None,):
6482 
    self.success = success
6483 
    self.ex = ex
6484 
 
6485 
  def read(self, iprot):
6486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6488 
      return
6489 
    iprot.readStructBegin()
6490 
    while True:
6491 
      (fname, ftype, fid) = iprot.readFieldBegin()
6492 
      if ftype == TType.STOP:
6493 
        break
6494 
      if fid == 0:
6495 
        if ftype == TType.LIST:
6496 
          self.success = []
4133 chandransh 6497 
          (_etype80, _size77) = iprot.readListBegin()
6498 
          for _i81 in xrange(_size77):
6499 
            _elem82 = iprot.readI64();
6500 
            self.success.append(_elem82)
1382 varun.gupt 6501 
          iprot.readListEnd()
6502 
        else:
6503 
          iprot.skip(ftype)
6504 
      elif fid == 1:
6505 
        if ftype == TType.STRUCT:
6506 
          self.ex = TransactionServiceException()
6507 
          self.ex.read(iprot)
6508 
        else:
6509 
          iprot.skip(ftype)
6510 
      else:
6511 
        iprot.skip(ftype)
6512 
      iprot.readFieldEnd()
6513 
    iprot.readStructEnd()
6514 
 
6515 
  def write(self, oprot):
6516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6518 
      return
6519 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6520 
    if self.success is not None:
1382 varun.gupt 6521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6522 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6523 
      for iter83 in self.success:
6524 
        oprot.writeI64(iter83)
1382 varun.gupt 6525 
      oprot.writeListEnd()
6526 
      oprot.writeFieldEnd()
3431 rajveer 6527 
    if self.ex is not None:
1382 varun.gupt 6528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6529 
      self.ex.write(oprot)
6530 
      oprot.writeFieldEnd()
6531 
    oprot.writeFieldStop()
6532 
    oprot.writeStructEnd()
6533 
 
3431 rajveer 6534 
  def validate(self):
6535 
    return
6536 
 
6537 
 
1382 varun.gupt 6538 
  def __repr__(self):
6539 
    L = ['%s=%r' % (key, value)
6540 
      for key, value in self.__dict__.iteritems()]
6541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6542 
 
6543 
  def __eq__(self, other):
6544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6545 
 
6546 
  def __ne__(self, other):
6547 
    return not (self == other)
6548 
 
483 rajveer 6549 
class changeOrderStatus_args:
94 ashish 6550 
  """
6551 
  Attributes:
483 rajveer 6552 
   - orderId
6553 
   - status
6554 
   - description
94 ashish 6555 
  """
6556 
 
6557 
  thrift_spec = (
6558 
    None, # 0
483 rajveer 6559 
    (1, TType.I64, 'orderId', None, None, ), # 1
6560 
    (2, TType.I32, 'status', None, None, ), # 2
6561 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6562 
  )
6563 
 
483 rajveer 6564 
  def __init__(self, orderId=None, status=None, description=None,):
6565 
    self.orderId = orderId
6566 
    self.status = status
6567 
    self.description = description
94 ashish 6568 
 
6569 
  def read(self, iprot):
6570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6572 
      return
6573 
    iprot.readStructBegin()
6574 
    while True:
6575 
      (fname, ftype, fid) = iprot.readFieldBegin()
6576 
      if ftype == TType.STOP:
6577 
        break
6578 
      if fid == 1:
6579 
        if ftype == TType.I64:
483 rajveer 6580 
          self.orderId = iprot.readI64();
94 ashish 6581 
        else:
6582 
          iprot.skip(ftype)
6583 
      elif fid == 2:
483 rajveer 6584 
        if ftype == TType.I32:
6585 
          self.status = iprot.readI32();
94 ashish 6586 
        else:
6587 
          iprot.skip(ftype)
483 rajveer 6588 
      elif fid == 3:
6589 
        if ftype == TType.STRING:
6590 
          self.description = iprot.readString();
6591 
        else:
6592 
          iprot.skip(ftype)
94 ashish 6593 
      else:
6594 
        iprot.skip(ftype)
6595 
      iprot.readFieldEnd()
6596 
    iprot.readStructEnd()
6597 
 
6598 
  def write(self, oprot):
6599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6601 
      return
483 rajveer 6602 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6603 
    if self.orderId is not None:
483 rajveer 6604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6605 
      oprot.writeI64(self.orderId)
94 ashish 6606 
      oprot.writeFieldEnd()
3431 rajveer 6607 
    if self.status is not None:
483 rajveer 6608 
      oprot.writeFieldBegin('status', TType.I32, 2)
6609 
      oprot.writeI32(self.status)
94 ashish 6610 
      oprot.writeFieldEnd()
3431 rajveer 6611 
    if self.description is not None:
483 rajveer 6612 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6613 
      oprot.writeString(self.description)
6614 
      oprot.writeFieldEnd()
94 ashish 6615 
    oprot.writeFieldStop()
6616 
    oprot.writeStructEnd()
6617 
 
3431 rajveer 6618 
  def validate(self):
6619 
    return
6620 
 
6621 
 
94 ashish 6622 
  def __repr__(self):
6623 
    L = ['%s=%r' % (key, value)
6624 
      for key, value in self.__dict__.iteritems()]
6625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6626 
 
6627 
  def __eq__(self, other):
6628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6629 
 
6630 
  def __ne__(self, other):
6631 
    return not (self == other)
6632 
 
483 rajveer 6633 
class changeOrderStatus_result:
94 ashish 6634 
  """
6635 
  Attributes:
6636 
   - success
6637 
   - ex
6638 
  """
6639 
 
6640 
  thrift_spec = (
6641 
    (0, TType.BOOL, 'success', None, None, ), # 0
6642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6643 
  )
6644 
 
6645 
  def __init__(self, success=None, ex=None,):
6646 
    self.success = success
6647 
    self.ex = ex
6648 
 
6649 
  def read(self, iprot):
6650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6652 
      return
6653 
    iprot.readStructBegin()
6654 
    while True:
6655 
      (fname, ftype, fid) = iprot.readFieldBegin()
6656 
      if ftype == TType.STOP:
6657 
        break
6658 
      if fid == 0:
6659 
        if ftype == TType.BOOL:
6660 
          self.success = iprot.readBool();
6661 
        else:
6662 
          iprot.skip(ftype)
6663 
      elif fid == 1:
6664 
        if ftype == TType.STRUCT:
6665 
          self.ex = TransactionServiceException()
6666 
          self.ex.read(iprot)
6667 
        else:
6668 
          iprot.skip(ftype)
6669 
      else:
6670 
        iprot.skip(ftype)
6671 
      iprot.readFieldEnd()
6672 
    iprot.readStructEnd()
6673 
 
6674 
  def write(self, oprot):
6675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6677 
      return
483 rajveer 6678 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6679 
    if self.success is not None:
94 ashish 6680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6681 
      oprot.writeBool(self.success)
6682 
      oprot.writeFieldEnd()
3431 rajveer 6683 
    if self.ex is not None:
94 ashish 6684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6685 
      self.ex.write(oprot)
6686 
      oprot.writeFieldEnd()
6687 
    oprot.writeFieldStop()
6688 
    oprot.writeStructEnd()
6689 
 
3431 rajveer 6690 
  def validate(self):
6691 
    return
6692 
 
6693 
 
94 ashish 6694 
  def __repr__(self):
6695 
    L = ['%s=%r' % (key, value)
6696 
      for key, value in self.__dict__.iteritems()]
6697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6698 
 
6699 
  def __eq__(self, other):
6700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6701 
 
6702 
  def __ne__(self, other):
6703 
    return not (self == other)
6704 
 
3064 chandransh 6705 
class getOrdersForTransaction_args:
494 rajveer 6706 
  """
6707 
  Attributes:
3064 chandransh 6708 
   - transactionId
6709 
   - customerId
494 rajveer 6710 
  """
6711 
 
6712 
  thrift_spec = (
6713 
    None, # 0
3064 chandransh 6714 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6715 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6716 
  )
6717 
 
3064 chandransh 6718 
  def __init__(self, transactionId=None, customerId=None,):
6719 
    self.transactionId = transactionId
6720 
    self.customerId = customerId
494 rajveer 6721 
 
6722 
  def read(self, iprot):
6723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6725 
      return
6726 
    iprot.readStructBegin()
6727 
    while True:
6728 
      (fname, ftype, fid) = iprot.readFieldBegin()
6729 
      if ftype == TType.STOP:
6730 
        break
6731 
      if fid == 1:
6732 
        if ftype == TType.I64:
3064 chandransh 6733 
          self.transactionId = iprot.readI64();
494 rajveer 6734 
        else:
6735 
          iprot.skip(ftype)
6736 
      elif fid == 2:
3064 chandransh 6737 
        if ftype == TType.I64:
6738 
          self.customerId = iprot.readI64();
494 rajveer 6739 
        else:
6740 
          iprot.skip(ftype)
6741 
      else:
6742 
        iprot.skip(ftype)
6743 
      iprot.readFieldEnd()
6744 
    iprot.readStructEnd()
6745 
 
6746 
  def write(self, oprot):
6747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6749 
      return
3064 chandransh 6750 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6751 
    if self.transactionId is not None:
3064 chandransh 6752 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6753 
      oprot.writeI64(self.transactionId)
494 rajveer 6754 
      oprot.writeFieldEnd()
3431 rajveer 6755 
    if self.customerId is not None:
3064 chandransh 6756 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6757 
      oprot.writeI64(self.customerId)
494 rajveer 6758 
      oprot.writeFieldEnd()
6759 
    oprot.writeFieldStop()
6760 
    oprot.writeStructEnd()
6761 
 
3431 rajveer 6762 
  def validate(self):
6763 
    return
6764 
 
6765 
 
494 rajveer 6766 
  def __repr__(self):
6767 
    L = ['%s=%r' % (key, value)
6768 
      for key, value in self.__dict__.iteritems()]
6769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6770 
 
6771 
  def __eq__(self, other):
6772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6773 
 
6774 
  def __ne__(self, other):
6775 
    return not (self == other)
6776 
 
3064 chandransh 6777 
class getOrdersForTransaction_result:
494 rajveer 6778 
  """
6779 
  Attributes:
6780 
   - success
6781 
   - ex
6782 
  """
6783 
 
6784 
  thrift_spec = (
3064 chandransh 6785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6787 
  )
6788 
 
6789 
  def __init__(self, success=None, ex=None,):
6790 
    self.success = success
6791 
    self.ex = ex
6792 
 
6793 
  def read(self, iprot):
6794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6796 
      return
6797 
    iprot.readStructBegin()
6798 
    while True:
6799 
      (fname, ftype, fid) = iprot.readFieldBegin()
6800 
      if ftype == TType.STOP:
6801 
        break
6802 
      if fid == 0:
3064 chandransh 6803 
        if ftype == TType.LIST:
6804 
          self.success = []
4133 chandransh 6805 
          (_etype87, _size84) = iprot.readListBegin()
6806 
          for _i88 in xrange(_size84):
6807 
            _elem89 = Order()
6808 
            _elem89.read(iprot)
6809 
            self.success.append(_elem89)
3064 chandransh 6810 
          iprot.readListEnd()
494 rajveer 6811 
        else:
6812 
          iprot.skip(ftype)
6813 
      elif fid == 1:
6814 
        if ftype == TType.STRUCT:
6815 
          self.ex = TransactionServiceException()
6816 
          self.ex.read(iprot)
6817 
        else:
6818 
          iprot.skip(ftype)
6819 
      else:
6820 
        iprot.skip(ftype)
6821 
      iprot.readFieldEnd()
6822 
    iprot.readStructEnd()
6823 
 
6824 
  def write(self, oprot):
6825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6827 
      return
3064 chandransh 6828 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6829 
    if self.success is not None:
3064 chandransh 6830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6832 
      for iter90 in self.success:
6833 
        iter90.write(oprot)
3064 chandransh 6834 
      oprot.writeListEnd()
494 rajveer 6835 
      oprot.writeFieldEnd()
3431 rajveer 6836 
    if self.ex is not None:
494 rajveer 6837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6838 
      self.ex.write(oprot)
6839 
      oprot.writeFieldEnd()
6840 
    oprot.writeFieldStop()
6841 
    oprot.writeStructEnd()
6842 
 
3431 rajveer 6843 
  def validate(self):
6844 
    return
6845 
 
6846 
 
494 rajveer 6847 
  def __repr__(self):
6848 
    L = ['%s=%r' % (key, value)
6849 
      for key, value in self.__dict__.iteritems()]
6850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6851 
 
6852 
  def __eq__(self, other):
6853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6854 
 
6855 
  def __ne__(self, other):
6856 
    return not (self == other)
6857 
 
3064 chandransh 6858 
class getOrdersForCustomer_args:
1149 chandransh 6859 
  """
6860 
  Attributes:
3064 chandransh 6861 
   - customerId
6862 
   - from_date
6863 
   - to_date
6864 
   - statuses
1149 chandransh 6865 
  """
6866 
 
6867 
  thrift_spec = (
6868 
    None, # 0
3064 chandransh 6869 
    (1, TType.I64, 'customerId', None, None, ), # 1
6870 
    (2, TType.I64, 'from_date', None, None, ), # 2
6871 
    (3, TType.I64, 'to_date', None, None, ), # 3
6872 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6873 
  )
6874 
 
3064 chandransh 6875 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6876 
    self.customerId = customerId
6877 
    self.from_date = from_date
6878 
    self.to_date = to_date
6879 
    self.statuses = statuses
1149 chandransh 6880 
 
6881 
  def read(self, iprot):
6882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6884 
      return
6885 
    iprot.readStructBegin()
6886 
    while True:
6887 
      (fname, ftype, fid) = iprot.readFieldBegin()
6888 
      if ftype == TType.STOP:
6889 
        break
6890 
      if fid == 1:
6891 
        if ftype == TType.I64:
3064 chandransh 6892 
          self.customerId = iprot.readI64();
1149 chandransh 6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      elif fid == 2:
6896 
        if ftype == TType.I64:
3064 chandransh 6897 
          self.from_date = iprot.readI64();
1149 chandransh 6898 
        else:
6899 
          iprot.skip(ftype)
2783 chandransh 6900 
      elif fid == 3:
6901 
        if ftype == TType.I64:
3064 chandransh 6902 
          self.to_date = iprot.readI64();
2783 chandransh 6903 
        else:
6904 
          iprot.skip(ftype)
6905 
      elif fid == 4:
3064 chandransh 6906 
        if ftype == TType.LIST:
6907 
          self.statuses = []
4133 chandransh 6908 
          (_etype94, _size91) = iprot.readListBegin()
6909 
          for _i95 in xrange(_size91):
6910 
            _elem96 = iprot.readI32();
6911 
            self.statuses.append(_elem96)
3064 chandransh 6912 
          iprot.readListEnd()
2783 chandransh 6913 
        else:
6914 
          iprot.skip(ftype)
1149 chandransh 6915 
      else:
6916 
        iprot.skip(ftype)
6917 
      iprot.readFieldEnd()
6918 
    iprot.readStructEnd()
6919 
 
6920 
  def write(self, oprot):
6921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6923 
      return
3064 chandransh 6924 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6925 
    if self.customerId is not None:
3064 chandransh 6926 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6927 
      oprot.writeI64(self.customerId)
1149 chandransh 6928 
      oprot.writeFieldEnd()
3431 rajveer 6929 
    if self.from_date is not None:
3064 chandransh 6930 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6931 
      oprot.writeI64(self.from_date)
1149 chandransh 6932 
      oprot.writeFieldEnd()
3431 rajveer 6933 
    if self.to_date is not None:
3064 chandransh 6934 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6935 
      oprot.writeI64(self.to_date)
2783 chandransh 6936 
      oprot.writeFieldEnd()
3431 rajveer 6937 
    if self.statuses is not None:
3064 chandransh 6938 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6939 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6940 
      for iter97 in self.statuses:
6941 
        oprot.writeI32(iter97)
3064 chandransh 6942 
      oprot.writeListEnd()
2783 chandransh 6943 
      oprot.writeFieldEnd()
1149 chandransh 6944 
    oprot.writeFieldStop()
6945 
    oprot.writeStructEnd()
6946 
 
3431 rajveer 6947 
  def validate(self):
6948 
    return
6949 
 
6950 
 
1149 chandransh 6951 
  def __repr__(self):
6952 
    L = ['%s=%r' % (key, value)
6953 
      for key, value in self.__dict__.iteritems()]
6954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6955 
 
6956 
  def __eq__(self, other):
6957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6958 
 
6959 
  def __ne__(self, other):
6960 
    return not (self == other)
6961 
 
3064 chandransh 6962 
class getOrdersForCustomer_result:
1149 chandransh 6963 
  """
6964 
  Attributes:
6965 
   - success
6966 
   - ex
6967 
  """
6968 
 
6969 
  thrift_spec = (
3064 chandransh 6970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6971 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6972 
  )
6973 
 
6974 
  def __init__(self, success=None, ex=None,):
6975 
    self.success = success
6976 
    self.ex = ex
6977 
 
6978 
  def read(self, iprot):
6979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6981 
      return
6982 
    iprot.readStructBegin()
6983 
    while True:
6984 
      (fname, ftype, fid) = iprot.readFieldBegin()
6985 
      if ftype == TType.STOP:
6986 
        break
6987 
      if fid == 0:
3064 chandransh 6988 
        if ftype == TType.LIST:
6989 
          self.success = []
4133 chandransh 6990 
          (_etype101, _size98) = iprot.readListBegin()
6991 
          for _i102 in xrange(_size98):
6992 
            _elem103 = Order()
6993 
            _elem103.read(iprot)
6994 
            self.success.append(_elem103)
3064 chandransh 6995 
          iprot.readListEnd()
1149 chandransh 6996 
        else:
6997 
          iprot.skip(ftype)
6998 
      elif fid == 1:
6999 
        if ftype == TType.STRUCT:
7000 
          self.ex = TransactionServiceException()
7001 
          self.ex.read(iprot)
7002 
        else:
7003 
          iprot.skip(ftype)
7004 
      else:
7005 
        iprot.skip(ftype)
7006 
      iprot.readFieldEnd()
7007 
    iprot.readStructEnd()
7008 
 
7009 
  def write(self, oprot):
7010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7012 
      return
3064 chandransh 7013 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7014 
    if self.success is not None:
3064 chandransh 7015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7017 
      for iter104 in self.success:
7018 
        iter104.write(oprot)
3064 chandransh 7019 
      oprot.writeListEnd()
1149 chandransh 7020 
      oprot.writeFieldEnd()
3431 rajveer 7021 
    if self.ex is not None:
1149 chandransh 7022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7023 
      self.ex.write(oprot)
7024 
      oprot.writeFieldEnd()
7025 
    oprot.writeFieldStop()
7026 
    oprot.writeStructEnd()
7027 
 
3431 rajveer 7028 
  def validate(self):
7029 
    return
7030 
 
7031 
 
1149 chandransh 7032 
  def __repr__(self):
7033 
    L = ['%s=%r' % (key, value)
7034 
      for key, value in self.__dict__.iteritems()]
7035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7036 
 
7037 
  def __eq__(self, other):
7038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7039 
 
7040 
  def __ne__(self, other):
7041 
    return not (self == other)
7042 
 
3064 chandransh 7043 
class createOrder_args:
921 rajveer 7044 
  """
7045 
  Attributes:
3064 chandransh 7046 
   - order
921 rajveer 7047 
  """
7048 
 
7049 
  thrift_spec = (
7050 
    None, # 0
3064 chandransh 7051 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7052 
  )
7053 
 
3064 chandransh 7054 
  def __init__(self, order=None,):
7055 
    self.order = order
921 rajveer 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 == 1:
3064 chandransh 7067 
        if ftype == TType.STRUCT:
7068 
          self.order = Order()
7069 
          self.order.read(iprot)
921 rajveer 7070 
        else:
7071 
          iprot.skip(ftype)
7072 
      else:
7073 
        iprot.skip(ftype)
7074 
      iprot.readFieldEnd()
7075 
    iprot.readStructEnd()
7076 
 
7077 
  def write(self, oprot):
7078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7080 
      return
3064 chandransh 7081 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7082 
    if self.order is not None:
3064 chandransh 7083 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7084 
      self.order.write(oprot)
921 rajveer 7085 
      oprot.writeFieldEnd()
7086 
    oprot.writeFieldStop()
7087 
    oprot.writeStructEnd()
7088 
 
3431 rajveer 7089 
  def validate(self):
7090 
    return
7091 
 
7092 
 
921 rajveer 7093 
  def __repr__(self):
7094 
    L = ['%s=%r' % (key, value)
7095 
      for key, value in self.__dict__.iteritems()]
7096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7097 
 
7098 
  def __eq__(self, other):
7099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7100 
 
7101 
  def __ne__(self, other):
7102 
    return not (self == other)
7103 
 
3064 chandransh 7104 
class createOrder_result:
921 rajveer 7105 
  """
7106 
  Attributes:
7107 
   - success
7108 
   - ex
7109 
  """
7110 
 
7111 
  thrift_spec = (
3064 chandransh 7112 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7114 
  )
7115 
 
7116 
  def __init__(self, success=None, ex=None,):
7117 
    self.success = success
7118 
    self.ex = ex
7119 
 
7120 
  def read(self, iprot):
7121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7123 
      return
7124 
    iprot.readStructBegin()
7125 
    while True:
7126 
      (fname, ftype, fid) = iprot.readFieldBegin()
7127 
      if ftype == TType.STOP:
7128 
        break
7129 
      if fid == 0:
3064 chandransh 7130 
        if ftype == TType.I64:
7131 
          self.success = iprot.readI64();
921 rajveer 7132 
        else:
7133 
          iprot.skip(ftype)
7134 
      elif fid == 1:
7135 
        if ftype == TType.STRUCT:
7136 
          self.ex = TransactionServiceException()
7137 
          self.ex.read(iprot)
7138 
        else:
7139 
          iprot.skip(ftype)
7140 
      else:
7141 
        iprot.skip(ftype)
7142 
      iprot.readFieldEnd()
7143 
    iprot.readStructEnd()
7144 
 
7145 
  def write(self, oprot):
7146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7148 
      return
3064 chandransh 7149 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7150 
    if self.success is not None:
3064 chandransh 7151 
      oprot.writeFieldBegin('success', TType.I64, 0)
7152 
      oprot.writeI64(self.success)
921 rajveer 7153 
      oprot.writeFieldEnd()
3431 rajveer 7154 
    if self.ex is not None:
921 rajveer 7155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7156 
      self.ex.write(oprot)
7157 
      oprot.writeFieldEnd()
7158 
    oprot.writeFieldStop()
7159 
    oprot.writeStructEnd()
7160 
 
3431 rajveer 7161 
  def validate(self):
7162 
    return
7163 
 
7164 
 
921 rajveer 7165 
  def __repr__(self):
7166 
    L = ['%s=%r' % (key, value)
7167 
      for key, value in self.__dict__.iteritems()]
7168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7169 
 
7170 
  def __eq__(self, other):
7171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7172 
 
7173 
  def __ne__(self, other):
7174 
    return not (self == other)
7175 
 
3064 chandransh 7176 
class getOrder_args:
921 rajveer 7177 
  """
7178 
  Attributes:
3064 chandransh 7179 
   - id
921 rajveer 7180 
  """
7181 
 
7182 
  thrift_spec = (
7183 
    None, # 0
3064 chandransh 7184 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7185 
  )
7186 
 
3064 chandransh 7187 
  def __init__(self, id=None,):
7188 
    self.id = id
921 rajveer 7189 
 
7190 
  def read(self, iprot):
7191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7193 
      return
7194 
    iprot.readStructBegin()
7195 
    while True:
7196 
      (fname, ftype, fid) = iprot.readFieldBegin()
7197 
      if ftype == TType.STOP:
7198 
        break
7199 
      if fid == 1:
7200 
        if ftype == TType.I64:
3064 chandransh 7201 
          self.id = iprot.readI64();
921 rajveer 7202 
        else:
7203 
          iprot.skip(ftype)
7204 
      else:
7205 
        iprot.skip(ftype)
7206 
      iprot.readFieldEnd()
7207 
    iprot.readStructEnd()
7208 
 
7209 
  def write(self, oprot):
7210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7212 
      return
3064 chandransh 7213 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7214 
    if self.id is not None:
3064 chandransh 7215 
      oprot.writeFieldBegin('id', TType.I64, 1)
7216 
      oprot.writeI64(self.id)
921 rajveer 7217 
      oprot.writeFieldEnd()
7218 
    oprot.writeFieldStop()
7219 
    oprot.writeStructEnd()
7220 
 
3431 rajveer 7221 
  def validate(self):
7222 
    return
7223 
 
7224 
 
921 rajveer 7225 
  def __repr__(self):
7226 
    L = ['%s=%r' % (key, value)
7227 
      for key, value in self.__dict__.iteritems()]
7228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7229 
 
7230 
  def __eq__(self, other):
7231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7232 
 
7233 
  def __ne__(self, other):
7234 
    return not (self == other)
7235 
 
3064 chandransh 7236 
class getOrder_result:
921 rajveer 7237 
  """
7238 
  Attributes:
7239 
   - success
7240 
   - ex
7241 
  """
7242 
 
7243 
  thrift_spec = (
3064 chandransh 7244 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7246 
  )
7247 
 
7248 
  def __init__(self, success=None, ex=None,):
7249 
    self.success = success
7250 
    self.ex = ex
7251 
 
7252 
  def read(self, iprot):
7253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7255 
      return
7256 
    iprot.readStructBegin()
7257 
    while True:
7258 
      (fname, ftype, fid) = iprot.readFieldBegin()
7259 
      if ftype == TType.STOP:
7260 
        break
7261 
      if fid == 0:
3064 chandransh 7262 
        if ftype == TType.STRUCT:
7263 
          self.success = Order()
7264 
          self.success.read(iprot)
921 rajveer 7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 1:
7268 
        if ftype == TType.STRUCT:
7269 
          self.ex = TransactionServiceException()
7270 
          self.ex.read(iprot)
7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      else:
7274 
        iprot.skip(ftype)
7275 
      iprot.readFieldEnd()
7276 
    iprot.readStructEnd()
7277 
 
7278 
  def write(self, oprot):
7279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7281 
      return
3064 chandransh 7282 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7283 
    if self.success is not None:
3064 chandransh 7284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7285 
      self.success.write(oprot)
921 rajveer 7286 
      oprot.writeFieldEnd()
3431 rajveer 7287 
    if self.ex is not None:
921 rajveer 7288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7289 
      self.ex.write(oprot)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
3431 rajveer 7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
921 rajveer 7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
3064 chandransh 7309 
class getLineItemsForOrder_args:
94 ashish 7310 
  """
7311 
  Attributes:
3064 chandransh 7312 
   - orderId
94 ashish 7313 
  """
7314 
 
7315 
  thrift_spec = (
7316 
    None, # 0
3064 chandransh 7317 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7318 
  )
7319 
 
3064 chandransh 7320 
  def __init__(self, orderId=None,):
7321 
    self.orderId = orderId
94 ashish 7322 
 
7323 
  def read(self, iprot):
7324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7326 
      return
7327 
    iprot.readStructBegin()
7328 
    while True:
7329 
      (fname, ftype, fid) = iprot.readFieldBegin()
7330 
      if ftype == TType.STOP:
7331 
        break
7332 
      if fid == 1:
7333 
        if ftype == TType.I64:
3064 chandransh 7334 
          self.orderId = iprot.readI64();
94 ashish 7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      else:
7338 
        iprot.skip(ftype)
7339 
      iprot.readFieldEnd()
7340 
    iprot.readStructEnd()
7341 
 
7342 
  def write(self, oprot):
7343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7345 
      return
3064 chandransh 7346 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7347 
    if self.orderId is not None:
3064 chandransh 7348 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7349 
      oprot.writeI64(self.orderId)
94 ashish 7350 
      oprot.writeFieldEnd()
7351 
    oprot.writeFieldStop()
7352 
    oprot.writeStructEnd()
7353 
 
3431 rajveer 7354 
  def validate(self):
7355 
    return
7356 
 
7357 
 
94 ashish 7358 
  def __repr__(self):
7359 
    L = ['%s=%r' % (key, value)
7360 
      for key, value in self.__dict__.iteritems()]
7361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7362 
 
7363 
  def __eq__(self, other):
7364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7365 
 
7366 
  def __ne__(self, other):
7367 
    return not (self == other)
7368 
 
3064 chandransh 7369 
class getLineItemsForOrder_result:
94 ashish 7370 
  """
7371 
  Attributes:
7372 
   - success
7373 
   - ex
7374 
  """
7375 
 
7376 
  thrift_spec = (
3064 chandransh 7377 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7379 
  )
7380 
 
7381 
  def __init__(self, success=None, ex=None,):
7382 
    self.success = success
7383 
    self.ex = ex
7384 
 
7385 
  def read(self, iprot):
7386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7388 
      return
7389 
    iprot.readStructBegin()
7390 
    while True:
7391 
      (fname, ftype, fid) = iprot.readFieldBegin()
7392 
      if ftype == TType.STOP:
7393 
        break
7394 
      if fid == 0:
483 rajveer 7395 
        if ftype == TType.LIST:
7396 
          self.success = []
4133 chandransh 7397 
          (_etype108, _size105) = iprot.readListBegin()
7398 
          for _i109 in xrange(_size105):
7399 
            _elem110 = LineItem()
7400 
            _elem110.read(iprot)
7401 
            self.success.append(_elem110)
483 rajveer 7402 
          iprot.readListEnd()
94 ashish 7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      elif fid == 1:
7406 
        if ftype == TType.STRUCT:
7407 
          self.ex = TransactionServiceException()
7408 
          self.ex.read(iprot)
7409 
        else:
7410 
          iprot.skip(ftype)
7411 
      else:
7412 
        iprot.skip(ftype)
7413 
      iprot.readFieldEnd()
7414 
    iprot.readStructEnd()
7415 
 
7416 
  def write(self, oprot):
7417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7419 
      return
3064 chandransh 7420 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7421 
    if self.success is not None:
483 rajveer 7422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7424 
      for iter111 in self.success:
7425 
        iter111.write(oprot)
483 rajveer 7426 
      oprot.writeListEnd()
94 ashish 7427 
      oprot.writeFieldEnd()
3431 rajveer 7428 
    if self.ex is not None:
94 ashish 7429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7430 
      self.ex.write(oprot)
7431 
      oprot.writeFieldEnd()
7432 
    oprot.writeFieldStop()
7433 
    oprot.writeStructEnd()
7434 
 
3431 rajveer 7435 
  def validate(self):
7436 
    return
7437 
 
7438 
 
94 ashish 7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
3064 chandransh 7450 
class getOrderForCustomer_args:
94 ashish 7451 
  """
7452 
  Attributes:
3064 chandransh 7453 
   - orderId
483 rajveer 7454 
   - customerId
94 ashish 7455 
  """
7456 
 
7457 
  thrift_spec = (
7458 
    None, # 0
3064 chandransh 7459 
    (1, TType.I64, 'orderId', None, None, ), # 1
7460 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7461 
  )
7462 
 
3064 chandransh 7463 
  def __init__(self, orderId=None, customerId=None,):
7464 
    self.orderId = orderId
483 rajveer 7465 
    self.customerId = customerId
94 ashish 7466 
 
7467 
  def read(self, iprot):
7468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7470 
      return
7471 
    iprot.readStructBegin()
7472 
    while True:
7473 
      (fname, ftype, fid) = iprot.readFieldBegin()
7474 
      if ftype == TType.STOP:
7475 
        break
7476 
      if fid == 1:
7477 
        if ftype == TType.I64:
3064 chandransh 7478 
          self.orderId = iprot.readI64();
94 ashish 7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 2:
7482 
        if ftype == TType.I64:
3064 chandransh 7483 
          self.customerId = iprot.readI64();
94 ashish 7484 
        else:
7485 
          iprot.skip(ftype)
7486 
      else:
7487 
        iprot.skip(ftype)
7488 
      iprot.readFieldEnd()
7489 
    iprot.readStructEnd()
7490 
 
7491 
  def write(self, oprot):
7492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7494 
      return
3064 chandransh 7495 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7496 
    if self.orderId is not None:
3064 chandransh 7497 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7498 
      oprot.writeI64(self.orderId)
7499 
      oprot.writeFieldEnd()
3431 rajveer 7500 
    if self.customerId is not None:
3064 chandransh 7501 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7502 
      oprot.writeI64(self.customerId)
94 ashish 7503 
      oprot.writeFieldEnd()
7504 
    oprot.writeFieldStop()
7505 
    oprot.writeStructEnd()
7506 
 
3431 rajveer 7507 
  def validate(self):
7508 
    return
7509 
 
7510 
 
94 ashish 7511 
  def __repr__(self):
7512 
    L = ['%s=%r' % (key, value)
7513 
      for key, value in self.__dict__.iteritems()]
7514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7515 
 
7516 
  def __eq__(self, other):
7517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7518 
 
7519 
  def __ne__(self, other):
7520 
    return not (self == other)
7521 
 
3064 chandransh 7522 
class getOrderForCustomer_result:
94 ashish 7523 
  """
7524 
  Attributes:
7525 
   - success
7526 
   - ex
7527 
  """
7528 
 
7529 
  thrift_spec = (
3064 chandransh 7530 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7532 
  )
7533 
 
7534 
  def __init__(self, success=None, ex=None,):
7535 
    self.success = success
7536 
    self.ex = ex
7537 
 
7538 
  def read(self, iprot):
7539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7541 
      return
7542 
    iprot.readStructBegin()
7543 
    while True:
7544 
      (fname, ftype, fid) = iprot.readFieldBegin()
7545 
      if ftype == TType.STOP:
7546 
        break
7547 
      if fid == 0:
3064 chandransh 7548 
        if ftype == TType.STRUCT:
7549 
          self.success = Order()
7550 
          self.success.read(iprot)
94 ashish 7551 
        else:
7552 
          iprot.skip(ftype)
7553 
      elif fid == 1:
7554 
        if ftype == TType.STRUCT:
7555 
          self.ex = TransactionServiceException()
7556 
          self.ex.read(iprot)
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      else:
7560 
        iprot.skip(ftype)
7561 
      iprot.readFieldEnd()
7562 
    iprot.readStructEnd()
7563 
 
7564 
  def write(self, oprot):
7565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7567 
      return
3064 chandransh 7568 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7569 
    if self.success is not None:
3064 chandransh 7570 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7571 
      self.success.write(oprot)
94 ashish 7572 
      oprot.writeFieldEnd()
3431 rajveer 7573 
    if self.ex is not None:
94 ashish 7574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7575 
      self.ex.write(oprot)
7576 
      oprot.writeFieldEnd()
7577 
    oprot.writeFieldStop()
7578 
    oprot.writeStructEnd()
7579 
 
3431 rajveer 7580 
  def validate(self):
7581 
    return
7582 
 
7583 
 
94 ashish 7584 
  def __repr__(self):
7585 
    L = ['%s=%r' % (key, value)
7586 
      for key, value in self.__dict__.iteritems()]
7587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7588 
 
7589 
  def __eq__(self, other):
7590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7591 
 
7592 
  def __ne__(self, other):
7593 
    return not (self == other)
7594 
 
3064 chandransh 7595 
class getAlerts_args:
94 ashish 7596 
  """
7597 
  Attributes:
3064 chandransh 7598 
   - orderId
7599 
   - valid
94 ashish 7600 
  """
7601 
 
7602 
  thrift_spec = (
7603 
    None, # 0
3064 chandransh 7604 
    (1, TType.I64, 'orderId', None, None, ), # 1
7605 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7606 
  )
7607 
 
3064 chandransh 7608 
  def __init__(self, orderId=None, valid=None,):
7609 
    self.orderId = orderId
7610 
    self.valid = valid
94 ashish 7611 
 
7612 
  def read(self, iprot):
7613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7615 
      return
7616 
    iprot.readStructBegin()
7617 
    while True:
7618 
      (fname, ftype, fid) = iprot.readFieldBegin()
7619 
      if ftype == TType.STOP:
7620 
        break
7621 
      if fid == 1:
3064 chandransh 7622 
        if ftype == TType.I64:
7623 
          self.orderId = iprot.readI64();
94 ashish 7624 
        else:
7625 
          iprot.skip(ftype)
3064 chandransh 7626 
      elif fid == 2:
7627 
        if ftype == TType.BOOL:
7628 
          self.valid = iprot.readBool();
7629 
        else:
7630 
          iprot.skip(ftype)
94 ashish 7631 
      else:
7632 
        iprot.skip(ftype)
7633 
      iprot.readFieldEnd()
7634 
    iprot.readStructEnd()
7635 
 
7636 
  def write(self, oprot):
7637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7639 
      return
3064 chandransh 7640 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7641 
    if self.orderId is not None:
3064 chandransh 7642 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7643 
      oprot.writeI64(self.orderId)
94 ashish 7644 
      oprot.writeFieldEnd()
3431 rajveer 7645 
    if self.valid is not None:
3064 chandransh 7646 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7647 
      oprot.writeBool(self.valid)
7648 
      oprot.writeFieldEnd()
94 ashish 7649 
    oprot.writeFieldStop()
7650 
    oprot.writeStructEnd()
7651 
 
3431 rajveer 7652 
  def validate(self):
7653 
    return
7654 
 
7655 
 
94 ashish 7656 
  def __repr__(self):
7657 
    L = ['%s=%r' % (key, value)
7658 
      for key, value in self.__dict__.iteritems()]
7659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7660 
 
7661 
  def __eq__(self, other):
7662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7663 
 
7664 
  def __ne__(self, other):
7665 
    return not (self == other)
7666 
 
3064 chandransh 7667 
class getAlerts_result:
94 ashish 7668 
  """
7669 
  Attributes:
7670 
   - success
7671 
  """
7672 
 
7673 
  thrift_spec = (
3064 chandransh 7674 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7675 
  )
7676 
 
3064 chandransh 7677 
  def __init__(self, success=None,):
94 ashish 7678 
    self.success = success
7679 
 
7680 
  def read(self, iprot):
7681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7683 
      return
7684 
    iprot.readStructBegin()
7685 
    while True:
7686 
      (fname, ftype, fid) = iprot.readFieldBegin()
7687 
      if ftype == TType.STOP:
7688 
        break
7689 
      if fid == 0:
3064 chandransh 7690 
        if ftype == TType.LIST:
7691 
          self.success = []
4133 chandransh 7692 
          (_etype115, _size112) = iprot.readListBegin()
7693 
          for _i116 in xrange(_size112):
7694 
            _elem117 = Alert()
7695 
            _elem117.read(iprot)
7696 
            self.success.append(_elem117)
3064 chandransh 7697 
          iprot.readListEnd()
94 ashish 7698 
        else:
7699 
          iprot.skip(ftype)
7700 
      else:
7701 
        iprot.skip(ftype)
7702 
      iprot.readFieldEnd()
7703 
    iprot.readStructEnd()
7704 
 
7705 
  def write(self, oprot):
7706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7708 
      return
3064 chandransh 7709 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7710 
    if self.success is not None:
3064 chandransh 7711 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7712 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7713 
      for iter118 in self.success:
7714 
        iter118.write(oprot)
3064 chandransh 7715 
      oprot.writeListEnd()
94 ashish 7716 
      oprot.writeFieldEnd()
7717 
    oprot.writeFieldStop()
7718 
    oprot.writeStructEnd()
7719 
 
3431 rajveer 7720 
  def validate(self):
7721 
    return
7722 
 
7723 
 
94 ashish 7724 
  def __repr__(self):
7725 
    L = ['%s=%r' % (key, value)
7726 
      for key, value in self.__dict__.iteritems()]
7727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7728 
 
7729 
  def __eq__(self, other):
7730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7731 
 
7732 
  def __ne__(self, other):
7733 
    return not (self == other)
7734 
 
3064 chandransh 7735 
class setAlert_args:
94 ashish 7736 
  """
7737 
  Attributes:
3064 chandransh 7738 
   - orderId
7739 
   - unset
7740 
   - type
7741 
   - comment
94 ashish 7742 
  """
7743 
 
7744 
  thrift_spec = (
7745 
    None, # 0
3064 chandransh 7746 
    (1, TType.I64, 'orderId', None, None, ), # 1
7747 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7748 
    (3, TType.I64, 'type', None, None, ), # 3
7749 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7750 
  )
7751 
 
3064 chandransh 7752 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7753 
    self.orderId = orderId
7754 
    self.unset = unset
7755 
    self.type = type
7756 
    self.comment = comment
94 ashish 7757 
 
7758 
  def read(self, iprot):
7759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7761 
      return
7762 
    iprot.readStructBegin()
7763 
    while True:
7764 
      (fname, ftype, fid) = iprot.readFieldBegin()
7765 
      if ftype == TType.STOP:
7766 
        break
7767 
      if fid == 1:
7768 
        if ftype == TType.I64:
3064 chandransh 7769 
          self.orderId = iprot.readI64();
94 ashish 7770 
        else:
7771 
          iprot.skip(ftype)
3064 chandransh 7772 
      elif fid == 2:
7773 
        if ftype == TType.BOOL:
7774 
          self.unset = iprot.readBool();
7775 
        else:
7776 
          iprot.skip(ftype)
7777 
      elif fid == 3:
7778 
        if ftype == TType.I64:
7779 
          self.type = iprot.readI64();
7780 
        else:
7781 
          iprot.skip(ftype)
7782 
      elif fid == 4:
7783 
        if ftype == TType.STRING:
7784 
          self.comment = iprot.readString();
7785 
        else:
7786 
          iprot.skip(ftype)
94 ashish 7787 
      else:
7788 
        iprot.skip(ftype)
7789 
      iprot.readFieldEnd()
7790 
    iprot.readStructEnd()
7791 
 
7792 
  def write(self, oprot):
7793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7795 
      return
3064 chandransh 7796 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7797 
    if self.orderId is not None:
3064 chandransh 7798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7799 
      oprot.writeI64(self.orderId)
94 ashish 7800 
      oprot.writeFieldEnd()
3431 rajveer 7801 
    if self.unset is not None:
3064 chandransh 7802 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7803 
      oprot.writeBool(self.unset)
7804 
      oprot.writeFieldEnd()
3431 rajveer 7805 
    if self.type is not None:
3064 chandransh 7806 
      oprot.writeFieldBegin('type', TType.I64, 3)
7807 
      oprot.writeI64(self.type)
7808 
      oprot.writeFieldEnd()
3431 rajveer 7809 
    if self.comment is not None:
3064 chandransh 7810 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7811 
      oprot.writeString(self.comment)
7812 
      oprot.writeFieldEnd()
94 ashish 7813 
    oprot.writeFieldStop()
7814 
    oprot.writeStructEnd()
7815 
 
3431 rajveer 7816 
  def validate(self):
7817 
    return
7818 
 
7819 
 
94 ashish 7820 
  def __repr__(self):
7821 
    L = ['%s=%r' % (key, value)
7822 
      for key, value in self.__dict__.iteritems()]
7823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7824 
 
7825 
  def __eq__(self, other):
7826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7827 
 
7828 
  def __ne__(self, other):
7829 
    return not (self == other)
7830 
 
3064 chandransh 7831 
class setAlert_result:
7832 
 
7833 
  thrift_spec = (
7834 
  )
7835 
 
7836 
  def read(self, iprot):
7837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7839 
      return
7840 
    iprot.readStructBegin()
7841 
    while True:
7842 
      (fname, ftype, fid) = iprot.readFieldBegin()
7843 
      if ftype == TType.STOP:
7844 
        break
7845 
      else:
7846 
        iprot.skip(ftype)
7847 
      iprot.readFieldEnd()
7848 
    iprot.readStructEnd()
7849 
 
7850 
  def write(self, oprot):
7851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7853 
      return
7854 
    oprot.writeStructBegin('setAlert_result')
7855 
    oprot.writeFieldStop()
7856 
    oprot.writeStructEnd()
7857 
 
3431 rajveer 7858 
  def validate(self):
7859 
    return
7860 
 
7861 
 
3064 chandransh 7862 
  def __repr__(self):
7863 
    L = ['%s=%r' % (key, value)
7864 
      for key, value in self.__dict__.iteritems()]
7865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7866 
 
7867 
  def __eq__(self, other):
7868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7869 
 
7870 
  def __ne__(self, other):
7871 
    return not (self == other)
7872 
 
7873 
class getValidOrderCount_args:
7874 
 
7875 
  thrift_spec = (
7876 
  )
7877 
 
7878 
  def read(self, iprot):
7879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7881 
      return
7882 
    iprot.readStructBegin()
7883 
    while True:
7884 
      (fname, ftype, fid) = iprot.readFieldBegin()
7885 
      if ftype == TType.STOP:
7886 
        break
7887 
      else:
7888 
        iprot.skip(ftype)
7889 
      iprot.readFieldEnd()
7890 
    iprot.readStructEnd()
7891 
 
7892 
  def write(self, oprot):
7893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7895 
      return
7896 
    oprot.writeStructBegin('getValidOrderCount_args')
7897 
    oprot.writeFieldStop()
7898 
    oprot.writeStructEnd()
7899 
 
3431 rajveer 7900 
  def validate(self):
7901 
    return
7902 
 
7903 
 
3064 chandransh 7904 
  def __repr__(self):
7905 
    L = ['%s=%r' % (key, value)
7906 
      for key, value in self.__dict__.iteritems()]
7907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7908 
 
7909 
  def __eq__(self, other):
7910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7911 
 
7912 
  def __ne__(self, other):
7913 
    return not (self == other)
7914 
 
7915 
class getValidOrderCount_result:
94 ashish 7916 
  """
7917 
  Attributes:
7918 
   - success
7919 
  """
7920 
 
7921 
  thrift_spec = (
3064 chandransh 7922 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7923 
  )
7924 
 
3064 chandransh 7925 
  def __init__(self, success=None,):
94 ashish 7926 
    self.success = success
7927 
 
7928 
  def read(self, iprot):
7929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7931 
      return
7932 
    iprot.readStructBegin()
7933 
    while True:
7934 
      (fname, ftype, fid) = iprot.readFieldBegin()
7935 
      if ftype == TType.STOP:
7936 
        break
7937 
      if fid == 0:
3064 chandransh 7938 
        if ftype == TType.I64:
7939 
          self.success = iprot.readI64();
94 ashish 7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
3064 chandransh 7951 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7952 
    if self.success is not None:
3064 chandransh 7953 
      oprot.writeFieldBegin('success', TType.I64, 0)
7954 
      oprot.writeI64(self.success)
94 ashish 7955 
      oprot.writeFieldEnd()
7956 
    oprot.writeFieldStop()
7957 
    oprot.writeStructEnd()
7958 
 
3431 rajveer 7959 
  def validate(self):
7960 
    return
7961 
 
7962 
 
94 ashish 7963 
  def __repr__(self):
7964 
    L = ['%s=%r' % (key, value)
7965 
      for key, value in self.__dict__.iteritems()]
7966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7967 
 
7968 
  def __eq__(self, other):
7969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7970 
 
7971 
  def __ne__(self, other):
7972 
    return not (self == other)
7973 
 
3064 chandransh 7974 
class getNoOfCustomersWithSuccessfulTransaction_args:
7975 
 
7976 
  thrift_spec = (
7977 
  )
7978 
 
7979 
  def read(self, iprot):
7980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7982 
      return
7983 
    iprot.readStructBegin()
7984 
    while True:
7985 
      (fname, ftype, fid) = iprot.readFieldBegin()
7986 
      if ftype == TType.STOP:
7987 
        break
7988 
      else:
7989 
        iprot.skip(ftype)
7990 
      iprot.readFieldEnd()
7991 
    iprot.readStructEnd()
7992 
 
7993 
  def write(self, oprot):
7994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7996 
      return
7997 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7998 
    oprot.writeFieldStop()
7999 
    oprot.writeStructEnd()
8000 
 
3431 rajveer 8001 
  def validate(self):
8002 
    return
8003 
 
8004 
 
3064 chandransh 8005 
  def __repr__(self):
8006 
    L = ['%s=%r' % (key, value)
8007 
      for key, value in self.__dict__.iteritems()]
8008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8009 
 
8010 
  def __eq__(self, other):
8011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8012 
 
8013 
  def __ne__(self, other):
8014 
    return not (self == other)
8015 
 
8016 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8017 
  """
8018 
  Attributes:
3064 chandransh 8019 
   - success
94 ashish 8020 
  """
8021 
 
8022 
  thrift_spec = (
3064 chandransh 8023 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8024 
  )
8025 
 
3064 chandransh 8026 
  def __init__(self, success=None,):
8027 
    self.success = success
94 ashish 8028 
 
8029 
  def read(self, iprot):
8030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8032 
      return
8033 
    iprot.readStructBegin()
8034 
    while True:
8035 
      (fname, ftype, fid) = iprot.readFieldBegin()
8036 
      if ftype == TType.STOP:
8037 
        break
3064 chandransh 8038 
      if fid == 0:
94 ashish 8039 
        if ftype == TType.I64:
3064 chandransh 8040 
          self.success = iprot.readI64();
94 ashish 8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      else:
8044 
        iprot.skip(ftype)
8045 
      iprot.readFieldEnd()
8046 
    iprot.readStructEnd()
8047 
 
8048 
  def write(self, oprot):
8049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8051 
      return
3064 chandransh 8052 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8053 
    if self.success is not None:
3064 chandransh 8054 
      oprot.writeFieldBegin('success', TType.I64, 0)
8055 
      oprot.writeI64(self.success)
94 ashish 8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
3431 rajveer 8060 
  def validate(self):
8061 
    return
8062 
 
8063 
 
94 ashish 8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
3064 chandransh 8075 
class getValidOrdersAmountRange_args:
8076 
 
8077 
  thrift_spec = (
8078 
  )
8079 
 
8080 
  def read(self, iprot):
8081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8083 
      return
8084 
    iprot.readStructBegin()
8085 
    while True:
8086 
      (fname, ftype, fid) = iprot.readFieldBegin()
8087 
      if ftype == TType.STOP:
8088 
        break
8089 
      else:
8090 
        iprot.skip(ftype)
8091 
      iprot.readFieldEnd()
8092 
    iprot.readStructEnd()
8093 
 
8094 
  def write(self, oprot):
8095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8097 
      return
8098 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8099 
    oprot.writeFieldStop()
8100 
    oprot.writeStructEnd()
8101 
 
3431 rajveer 8102 
  def validate(self):
8103 
    return
8104 
 
8105 
 
3064 chandransh 8106 
  def __repr__(self):
8107 
    L = ['%s=%r' % (key, value)
8108 
      for key, value in self.__dict__.iteritems()]
8109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8110 
 
8111 
  def __eq__(self, other):
8112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8113 
 
8114 
  def __ne__(self, other):
8115 
    return not (self == other)
8116 
 
8117 
class getValidOrdersAmountRange_result:
94 ashish 8118 
  """
8119 
  Attributes:
8120 
   - success
8121 
  """
8122 
 
8123 
  thrift_spec = (
3064 chandransh 8124 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8125 
  )
8126 
 
3064 chandransh 8127 
  def __init__(self, success=None,):
94 ashish 8128 
    self.success = success
8129 
 
8130 
  def read(self, iprot):
8131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8133 
      return
8134 
    iprot.readStructBegin()
8135 
    while True:
8136 
      (fname, ftype, fid) = iprot.readFieldBegin()
8137 
      if ftype == TType.STOP:
8138 
        break
8139 
      if fid == 0:
483 rajveer 8140 
        if ftype == TType.LIST:
8141 
          self.success = []
4133 chandransh 8142 
          (_etype122, _size119) = iprot.readListBegin()
8143 
          for _i123 in xrange(_size119):
8144 
            _elem124 = iprot.readDouble();
8145 
            self.success.append(_elem124)
483 rajveer 8146 
          iprot.readListEnd()
94 ashish 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('getValidOrdersAmountRange_result')
3431 rajveer 8159 
    if self.success is not None:
483 rajveer 8160 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8161 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8162 
      for iter125 in self.success:
8163 
        oprot.writeDouble(iter125)
483 rajveer 8164 
      oprot.writeListEnd()
94 ashish 8165 
      oprot.writeFieldEnd()
8166 
    oprot.writeFieldStop()
8167 
    oprot.writeStructEnd()
8168 
 
3431 rajveer 8169 
  def validate(self):
8170 
    return
8171 
 
8172 
 
94 ashish 8173 
  def __repr__(self):
8174 
    L = ['%s=%r' % (key, value)
8175 
      for key, value in self.__dict__.iteritems()]
8176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8177 
 
8178 
  def __eq__(self, other):
8179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8180 
 
8181 
  def __ne__(self, other):
8182 
    return not (self == other)
8183 
 
3064 chandransh 8184 
class getValidOrders_args:
1528 ankur.sing 8185 
  """
8186 
  Attributes:
3064 chandransh 8187 
   - limit
1528 ankur.sing 8188 
  """
8189 
 
8190 
  thrift_spec = (
8191 
    None, # 0
3064 chandransh 8192 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8193 
  )
8194 
 
3064 chandransh 8195 
  def __init__(self, limit=None,):
8196 
    self.limit = limit
1528 ankur.sing 8197 
 
8198 
  def read(self, iprot):
8199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8201 
      return
8202 
    iprot.readStructBegin()
8203 
    while True:
8204 
      (fname, ftype, fid) = iprot.readFieldBegin()
8205 
      if ftype == TType.STOP:
8206 
        break
8207 
      if fid == 1:
8208 
        if ftype == TType.I64:
3064 chandransh 8209 
          self.limit = iprot.readI64();
1528 ankur.sing 8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      else:
8213 
        iprot.skip(ftype)
8214 
      iprot.readFieldEnd()
8215 
    iprot.readStructEnd()
8216 
 
8217 
  def write(self, oprot):
8218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8220 
      return
3064 chandransh 8221 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8222 
    if self.limit is not None:
3064 chandransh 8223 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8224 
      oprot.writeI64(self.limit)
1528 ankur.sing 8225 
      oprot.writeFieldEnd()
8226 
    oprot.writeFieldStop()
8227 
    oprot.writeStructEnd()
8228 
 
3431 rajveer 8229 
  def validate(self):
8230 
    return
8231 
 
8232 
 
1528 ankur.sing 8233 
  def __repr__(self):
8234 
    L = ['%s=%r' % (key, value)
8235 
      for key, value in self.__dict__.iteritems()]
8236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8237 
 
8238 
  def __eq__(self, other):
8239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8240 
 
8241 
  def __ne__(self, other):
8242 
    return not (self == other)
8243 
 
3064 chandransh 8244 
class getValidOrders_result:
1528 ankur.sing 8245 
  """
8246 
  Attributes:
8247 
   - success
8248 
  """
8249 
 
8250 
  thrift_spec = (
3064 chandransh 8251 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8252 
  )
8253 
 
3064 chandransh 8254 
  def __init__(self, success=None,):
1528 ankur.sing 8255 
    self.success = success
8256 
 
8257 
  def read(self, iprot):
8258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8260 
      return
8261 
    iprot.readStructBegin()
8262 
    while True:
8263 
      (fname, ftype, fid) = iprot.readFieldBegin()
8264 
      if ftype == TType.STOP:
8265 
        break
8266 
      if fid == 0:
3064 chandransh 8267 
        if ftype == TType.LIST:
8268 
          self.success = []
4133 chandransh 8269 
          (_etype129, _size126) = iprot.readListBegin()
8270 
          for _i130 in xrange(_size126):
8271 
            _elem131 = Order()
8272 
            _elem131.read(iprot)
8273 
            self.success.append(_elem131)
3064 chandransh 8274 
          iprot.readListEnd()
1528 ankur.sing 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
3064 chandransh 8286 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8287 
    if self.success is not None:
3064 chandransh 8288 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8289 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8290 
      for iter132 in self.success:
8291 
        iter132.write(oprot)
3064 chandransh 8292 
      oprot.writeListEnd()
1528 ankur.sing 8293 
      oprot.writeFieldEnd()
8294 
    oprot.writeFieldStop()
8295 
    oprot.writeStructEnd()
8296 
 
3431 rajveer 8297 
  def validate(self):
8298 
    return
8299 
 
8300 
 
1528 ankur.sing 8301 
  def __repr__(self):
8302 
    L = ['%s=%r' % (key, value)
8303 
      for key, value in self.__dict__.iteritems()]
8304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8305 
 
8306 
  def __eq__(self, other):
8307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8308 
 
8309 
  def __ne__(self, other):
8310 
    return not (self == other)
8311 
 
1220 chandransh 8312 
class batchOrders_args:
8313 
  """
8314 
  Attributes:
8315 
   - warehouseId
8316 
  """
8317 
 
8318 
  thrift_spec = (
8319 
    None, # 0
8320 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8321 
  )
8322 
 
8323 
  def __init__(self, warehouseId=None,):
8324 
    self.warehouseId = warehouseId
8325 
 
8326 
  def read(self, iprot):
8327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8329 
      return
8330 
    iprot.readStructBegin()
8331 
    while True:
8332 
      (fname, ftype, fid) = iprot.readFieldBegin()
8333 
      if ftype == TType.STOP:
8334 
        break
8335 
      if fid == 1:
8336 
        if ftype == TType.I64:
8337 
          self.warehouseId = iprot.readI64();
8338 
        else:
8339 
          iprot.skip(ftype)
8340 
      else:
8341 
        iprot.skip(ftype)
8342 
      iprot.readFieldEnd()
8343 
    iprot.readStructEnd()
8344 
 
8345 
  def write(self, oprot):
8346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8348 
      return
8349 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8350 
    if self.warehouseId is not None:
1220 chandransh 8351 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8352 
      oprot.writeI64(self.warehouseId)
8353 
      oprot.writeFieldEnd()
8354 
    oprot.writeFieldStop()
8355 
    oprot.writeStructEnd()
8356 
 
3431 rajveer 8357 
  def validate(self):
8358 
    return
8359 
 
8360 
 
1220 chandransh 8361 
  def __repr__(self):
8362 
    L = ['%s=%r' % (key, value)
8363 
      for key, value in self.__dict__.iteritems()]
8364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8365 
 
8366 
  def __eq__(self, other):
8367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8368 
 
8369 
  def __ne__(self, other):
8370 
    return not (self == other)
8371 
 
8372 
class batchOrders_result:
8373 
  """
8374 
  Attributes:
8375 
   - success
8376 
   - ex
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8381 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, success=None, ex=None,):
8385 
    self.success = success
8386 
    self.ex = ex
8387 
 
8388 
  def read(self, iprot):
8389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8391 
      return
8392 
    iprot.readStructBegin()
8393 
    while True:
8394 
      (fname, ftype, fid) = iprot.readFieldBegin()
8395 
      if ftype == TType.STOP:
8396 
        break
8397 
      if fid == 0:
8398 
        if ftype == TType.LIST:
8399 
          self.success = []
4133 chandransh 8400 
          (_etype136, _size133) = iprot.readListBegin()
8401 
          for _i137 in xrange(_size133):
8402 
            _elem138 = Order()
8403 
            _elem138.read(iprot)
8404 
            self.success.append(_elem138)
1220 chandransh 8405 
          iprot.readListEnd()
8406 
        else:
8407 
          iprot.skip(ftype)
8408 
      elif fid == 1:
8409 
        if ftype == TType.STRUCT:
8410 
          self.ex = TransactionServiceException()
8411 
          self.ex.read(iprot)
8412 
        else:
8413 
          iprot.skip(ftype)
8414 
      else:
8415 
        iprot.skip(ftype)
8416 
      iprot.readFieldEnd()
8417 
    iprot.readStructEnd()
8418 
 
8419 
  def write(self, oprot):
8420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8422 
      return
8423 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8424 
    if self.success is not None:
1220 chandransh 8425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8427 
      for iter139 in self.success:
8428 
        iter139.write(oprot)
1220 chandransh 8429 
      oprot.writeListEnd()
8430 
      oprot.writeFieldEnd()
3431 rajveer 8431 
    if self.ex is not None:
1220 chandransh 8432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8433 
      self.ex.write(oprot)
8434 
      oprot.writeFieldEnd()
8435 
    oprot.writeFieldStop()
8436 
    oprot.writeStructEnd()
8437 
 
3431 rajveer 8438 
  def validate(self):
8439 
    return
8440 
 
8441 
 
1220 chandransh 8442 
  def __repr__(self):
8443 
    L = ['%s=%r' % (key, value)
8444 
      for key, value in self.__dict__.iteritems()]
8445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8446 
 
8447 
  def __eq__(self, other):
8448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8449 
 
8450 
  def __ne__(self, other):
8451 
    return not (self == other)
8452 
 
1208 chandransh 8453 
class markOrderAsOutOfStock_args:
8454 
  """
8455 
  Attributes:
8456 
   - orderId
8457 
  """
8458 
 
8459 
  thrift_spec = (
8460 
    None, # 0
8461 
    (1, TType.I64, 'orderId', None, None, ), # 1
8462 
  )
8463 
 
8464 
  def __init__(self, orderId=None,):
8465 
    self.orderId = orderId
8466 
 
8467 
  def read(self, iprot):
8468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8470 
      return
8471 
    iprot.readStructBegin()
8472 
    while True:
8473 
      (fname, ftype, fid) = iprot.readFieldBegin()
8474 
      if ftype == TType.STOP:
8475 
        break
8476 
      if fid == 1:
8477 
        if ftype == TType.I64:
8478 
          self.orderId = iprot.readI64();
8479 
        else:
8480 
          iprot.skip(ftype)
8481 
      else:
8482 
        iprot.skip(ftype)
8483 
      iprot.readFieldEnd()
8484 
    iprot.readStructEnd()
8485 
 
8486 
  def write(self, oprot):
8487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8489 
      return
8490 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8491 
    if self.orderId is not None:
1208 chandransh 8492 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8493 
      oprot.writeI64(self.orderId)
8494 
      oprot.writeFieldEnd()
8495 
    oprot.writeFieldStop()
8496 
    oprot.writeStructEnd()
8497 
 
3431 rajveer 8498 
  def validate(self):
8499 
    return
8500 
 
8501 
 
1208 chandransh 8502 
  def __repr__(self):
8503 
    L = ['%s=%r' % (key, value)
8504 
      for key, value in self.__dict__.iteritems()]
8505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8506 
 
8507 
  def __eq__(self, other):
8508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8509 
 
8510 
  def __ne__(self, other):
8511 
    return not (self == other)
8512 
 
8513 
class markOrderAsOutOfStock_result:
8514 
  """
8515 
  Attributes:
8516 
   - success
8517 
   - ex
8518 
  """
8519 
 
8520 
  thrift_spec = (
8521 
    (0, TType.BOOL, 'success', None, None, ), # 0
8522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8523 
  )
8524 
 
8525 
  def __init__(self, success=None, ex=None,):
8526 
    self.success = success
8527 
    self.ex = ex
8528 
 
8529 
  def read(self, iprot):
8530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8532 
      return
8533 
    iprot.readStructBegin()
8534 
    while True:
8535 
      (fname, ftype, fid) = iprot.readFieldBegin()
8536 
      if ftype == TType.STOP:
8537 
        break
8538 
      if fid == 0:
8539 
        if ftype == TType.BOOL:
8540 
          self.success = iprot.readBool();
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 1:
8544 
        if ftype == TType.STRUCT:
8545 
          self.ex = TransactionServiceException()
8546 
          self.ex.read(iprot)
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      else:
8550 
        iprot.skip(ftype)
8551 
      iprot.readFieldEnd()
8552 
    iprot.readStructEnd()
8553 
 
8554 
  def write(self, oprot):
8555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8557 
      return
8558 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8559 
    if self.success is not None:
1208 chandransh 8560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8561 
      oprot.writeBool(self.success)
8562 
      oprot.writeFieldEnd()
3431 rajveer 8563 
    if self.ex is not None:
1208 chandransh 8564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8565 
      self.ex.write(oprot)
8566 
      oprot.writeFieldEnd()
8567 
    oprot.writeFieldStop()
8568 
    oprot.writeStructEnd()
8569 
 
3431 rajveer 8570 
  def validate(self):
8571 
    return
8572 
 
8573 
 
1208 chandransh 8574 
  def __repr__(self):
8575 
    L = ['%s=%r' % (key, value)
8576 
      for key, value in self.__dict__.iteritems()]
8577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8578 
 
8579 
  def __eq__(self, other):
8580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8581 
 
8582 
  def __ne__(self, other):
8583 
    return not (self == other)
8584 
 
3064 chandransh 8585 
class verifyOrder_args:
759 chandransh 8586 
  """
8587 
  Attributes:
3064 chandransh 8588 
   - orderId
759 chandransh 8589 
  """
8590 
 
8591 
  thrift_spec = (
8592 
    None, # 0
3064 chandransh 8593 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8594 
  )
8595 
 
3064 chandransh 8596 
  def __init__(self, orderId=None,):
8597 
    self.orderId = orderId
759 chandransh 8598 
 
8599 
  def read(self, iprot):
8600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8602 
      return
8603 
    iprot.readStructBegin()
8604 
    while True:
8605 
      (fname, ftype, fid) = iprot.readFieldBegin()
8606 
      if ftype == TType.STOP:
8607 
        break
8608 
      if fid == 1:
8609 
        if ftype == TType.I64:
3064 chandransh 8610 
          self.orderId = iprot.readI64();
759 chandransh 8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      else:
8614 
        iprot.skip(ftype)
8615 
      iprot.readFieldEnd()
8616 
    iprot.readStructEnd()
8617 
 
8618 
  def write(self, oprot):
8619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8621 
      return
3064 chandransh 8622 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8623 
    if self.orderId is not None:
3064 chandransh 8624 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8625 
      oprot.writeI64(self.orderId)
759 chandransh 8626 
      oprot.writeFieldEnd()
8627 
    oprot.writeFieldStop()
8628 
    oprot.writeStructEnd()
8629 
 
3431 rajveer 8630 
  def validate(self):
8631 
    return
8632 
 
8633 
 
759 chandransh 8634 
  def __repr__(self):
8635 
    L = ['%s=%r' % (key, value)
8636 
      for key, value in self.__dict__.iteritems()]
8637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8638 
 
8639 
  def __eq__(self, other):
8640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8641 
 
8642 
  def __ne__(self, other):
8643 
    return not (self == other)
8644 
 
3064 chandransh 8645 
class verifyOrder_result:
759 chandransh 8646 
  """
8647 
  Attributes:
8648 
   - success
8649 
   - ex
8650 
  """
8651 
 
8652 
  thrift_spec = (
8653 
    (0, TType.BOOL, 'success', None, None, ), # 0
8654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8655 
  )
8656 
 
8657 
  def __init__(self, success=None, ex=None,):
8658 
    self.success = success
8659 
    self.ex = ex
8660 
 
8661 
  def read(self, iprot):
8662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8664 
      return
8665 
    iprot.readStructBegin()
8666 
    while True:
8667 
      (fname, ftype, fid) = iprot.readFieldBegin()
8668 
      if ftype == TType.STOP:
8669 
        break
8670 
      if fid == 0:
8671 
        if ftype == TType.BOOL:
8672 
          self.success = iprot.readBool();
8673 
        else:
8674 
          iprot.skip(ftype)
8675 
      elif fid == 1:
8676 
        if ftype == TType.STRUCT:
8677 
          self.ex = TransactionServiceException()
8678 
          self.ex.read(iprot)
8679 
        else:
8680 
          iprot.skip(ftype)
8681 
      else:
8682 
        iprot.skip(ftype)
8683 
      iprot.readFieldEnd()
8684 
    iprot.readStructEnd()
8685 
 
8686 
  def write(self, oprot):
8687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8689 
      return
3064 chandransh 8690 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8691 
    if self.success is not None:
759 chandransh 8692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8693 
      oprot.writeBool(self.success)
8694 
      oprot.writeFieldEnd()
3431 rajveer 8695 
    if self.ex is not None:
759 chandransh 8696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8697 
      self.ex.write(oprot)
8698 
      oprot.writeFieldEnd()
8699 
    oprot.writeFieldStop()
8700 
    oprot.writeStructEnd()
8701 
 
3431 rajveer 8702 
  def validate(self):
8703 
    return
8704 
 
8705 
 
759 chandransh 8706 
  def __repr__(self):
8707 
    L = ['%s=%r' % (key, value)
8708 
      for key, value in self.__dict__.iteritems()]
8709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8710 
 
8711 
  def __eq__(self, other):
8712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8713 
 
8714 
  def __ne__(self, other):
8715 
    return not (self == other)
8716 
 
3064 chandransh 8717 
class acceptOrder_args:
1113 chandransh 8718 
  """
8719 
  Attributes:
3064 chandransh 8720 
   - orderId
1113 chandransh 8721 
  """
8722 
 
8723 
  thrift_spec = (
8724 
    None, # 0
3064 chandransh 8725 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8726 
  )
8727 
 
3064 chandransh 8728 
  def __init__(self, orderId=None,):
8729 
    self.orderId = orderId
1113 chandransh 8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      if fid == 1:
8741 
        if ftype == TType.I64:
3064 chandransh 8742 
          self.orderId = iprot.readI64();
1113 chandransh 8743 
        else:
8744 
          iprot.skip(ftype)
8745 
      else:
8746 
        iprot.skip(ftype)
8747 
      iprot.readFieldEnd()
8748 
    iprot.readStructEnd()
8749 
 
8750 
  def write(self, oprot):
8751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8753 
      return
3064 chandransh 8754 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8755 
    if self.orderId is not None:
3064 chandransh 8756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8757 
      oprot.writeI64(self.orderId)
1113 chandransh 8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
3431 rajveer 8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
1113 chandransh 8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
3064 chandransh 8777 
class acceptOrder_result:
1113 chandransh 8778 
  """
8779 
  Attributes:
8780 
   - success
8781 
   - ex
8782 
  """
8783 
 
8784 
  thrift_spec = (
3064 chandransh 8785 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8787 
  )
8788 
 
8789 
  def __init__(self, success=None, ex=None,):
8790 
    self.success = success
8791 
    self.ex = ex
8792 
 
8793 
  def read(self, iprot):
8794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8796 
      return
8797 
    iprot.readStructBegin()
8798 
    while True:
8799 
      (fname, ftype, fid) = iprot.readFieldBegin()
8800 
      if ftype == TType.STOP:
8801 
        break
8802 
      if fid == 0:
3064 chandransh 8803 
        if ftype == TType.BOOL:
8804 
          self.success = iprot.readBool();
1113 chandransh 8805 
        else:
8806 
          iprot.skip(ftype)
8807 
      elif fid == 1:
8808 
        if ftype == TType.STRUCT:
8809 
          self.ex = TransactionServiceException()
8810 
          self.ex.read(iprot)
8811 
        else:
8812 
          iprot.skip(ftype)
8813 
      else:
8814 
        iprot.skip(ftype)
8815 
      iprot.readFieldEnd()
8816 
    iprot.readStructEnd()
8817 
 
8818 
  def write(self, oprot):
8819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8821 
      return
3064 chandransh 8822 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8823 
    if self.success is not None:
3064 chandransh 8824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8825 
      oprot.writeBool(self.success)
1113 chandransh 8826 
      oprot.writeFieldEnd()
3431 rajveer 8827 
    if self.ex is not None:
1113 chandransh 8828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8829 
      self.ex.write(oprot)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
3431 rajveer 8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
1113 chandransh 8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
3064 chandransh 8849 
class addBillingDetails_args:
1135 chandransh 8850 
  """
8851 
  Attributes:
3064 chandransh 8852 
   - orderId
8853 
   - invoice_number
4283 anupam.sin 8854 
   - imeiNumber
8855 
   - itemNumber
3064 chandransh 8856 
   - billed_by
4264 rajveer 8857 
   - jacketNumber
4283 anupam.sin 8858 
   - billingType
8859 
   - vendorId
1135 chandransh 8860 
  """
8861 
 
8862 
  thrift_spec = (
8863 
    None, # 0
3064 chandransh 8864 
    (1, TType.I64, 'orderId', None, None, ), # 1
8865 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8866 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8867 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8868 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8869 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8870 
    (7, TType.I64, 'billingType', None, None, ), # 7
8871 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8872 
  )
8873 
 
4283 anupam.sin 8874 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8875 
    self.orderId = orderId
8876 
    self.invoice_number = invoice_number
4283 anupam.sin 8877 
    self.imeiNumber = imeiNumber
8878 
    self.itemNumber = itemNumber
3064 chandransh 8879 
    self.billed_by = billed_by
4264 rajveer 8880 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8881 
    self.billingType = billingType
8882 
    self.vendorId = vendorId
1135 chandransh 8883 
 
8884 
  def read(self, iprot):
8885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8887 
      return
8888 
    iprot.readStructBegin()
8889 
    while True:
8890 
      (fname, ftype, fid) = iprot.readFieldBegin()
8891 
      if ftype == TType.STOP:
8892 
        break
8893 
      if fid == 1:
8894 
        if ftype == TType.I64:
3064 chandransh 8895 
          self.orderId = iprot.readI64();
1135 chandransh 8896 
        else:
8897 
          iprot.skip(ftype)
8898 
      elif fid == 2:
3064 chandransh 8899 
        if ftype == TType.STRING:
8900 
          self.invoice_number = iprot.readString();
1135 chandransh 8901 
        else:
8902 
          iprot.skip(ftype)
3064 chandransh 8903 
      elif fid == 3:
4264 rajveer 8904 
        if ftype == TType.I64:
3064 chandransh 8905 
          self.imeiNumber = iprot.readI64();
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      elif fid == 4:
8909 
        if ftype == TType.STRING:
8910 
          self.itemNumber = iprot.readString();
8911 
        else:
8912 
          iprot.skip(ftype)
8913 
      elif fid == 5:
8914 
        if ftype == TType.STRING:
4283 anupam.sin 8915 
          self.billed_by = iprot.readString();
3064 chandransh 8916 
        else:
8917 
          iprot.skip(ftype)
8918 
      elif fid == 6:
8919 
        if ftype == TType.I64:
4283 anupam.sin 8920 
          self.jacketNumber = iprot.readI64();
8921 
        else:
8922 
          iprot.skip(ftype)
8923 
      elif fid == 7:
8924 
        if ftype == TType.I64:
3064 chandransh 8925 
          self.billingType = iprot.readI64();
8926 
        else:
8927 
          iprot.skip(ftype)
4283 anupam.sin 8928 
      elif fid == 8:
8929 
        if ftype == TType.I64:
8930 
          self.vendorId = iprot.readI64();
8931 
        else:
8932 
          iprot.skip(ftype)
1246 chandransh 8933 
      else:
8934 
        iprot.skip(ftype)
8935 
      iprot.readFieldEnd()
8936 
    iprot.readStructEnd()
8937 
 
8938 
  def write(self, oprot):
8939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8941 
      return
4283 anupam.sin 8942 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8943 
    if self.orderId is not None:
3064 chandransh 8944 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8945 
      oprot.writeI64(self.orderId)
1246 chandransh 8946 
      oprot.writeFieldEnd()
4283 anupam.sin 8947 
    if self.invoice_number is not None:
8948 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8949 
      oprot.writeString(self.invoice_number)
1246 chandransh 8950 
      oprot.writeFieldEnd()
3431 rajveer 8951 
    if self.imeiNumber is not None:
3064 chandransh 8952 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8953 
      oprot.writeI64(self.imeiNumber)
8954 
      oprot.writeFieldEnd()
3431 rajveer 8955 
    if self.itemNumber is not None:
3064 chandransh 8956 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8957 
      oprot.writeString(self.itemNumber)
8958 
      oprot.writeFieldEnd()
4283 anupam.sin 8959 
    if self.billed_by is not None:
8960 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8961 
      oprot.writeString(self.billed_by)
3064 chandransh 8962 
      oprot.writeFieldEnd()
4283 anupam.sin 8963 
    if self.jacketNumber is not None:
8964 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8965 
      oprot.writeI64(self.jacketNumber)
8966 
      oprot.writeFieldEnd()
3431 rajveer 8967 
    if self.billingType is not None:
4283 anupam.sin 8968 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8969 
      oprot.writeI64(self.billingType)
8970 
      oprot.writeFieldEnd()
4283 anupam.sin 8971 
    if self.vendorId is not None:
8972 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8973 
      oprot.writeI64(self.vendorId)
8974 
      oprot.writeFieldEnd()
1246 chandransh 8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
3431 rajveer 8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
1246 chandransh 8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
4283 anupam.sin 8993 
class addBillingDetails_result:
1246 chandransh 8994 
  """
8995 
  Attributes:
3064 chandransh 8996 
   - success
1246 chandransh 8997 
   - ex
8998 
  """
8999 
 
9000 
  thrift_spec = (
3064 chandransh 9001 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9002 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9003 
  )
9004 
 
3064 chandransh 9005 
  def __init__(self, success=None, ex=None,):
9006 
    self.success = success
1246 chandransh 9007 
    self.ex = ex
9008 
 
9009 
  def read(self, iprot):
9010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9012 
      return
9013 
    iprot.readStructBegin()
9014 
    while True:
9015 
      (fname, ftype, fid) = iprot.readFieldBegin()
9016 
      if ftype == TType.STOP:
9017 
        break
3064 chandransh 9018 
      if fid == 0:
9019 
        if ftype == TType.BOOL:
9020 
          self.success = iprot.readBool();
9021 
        else:
9022 
          iprot.skip(ftype)
9023 
      elif fid == 1:
1246 chandransh 9024 
        if ftype == TType.STRUCT:
9025 
          self.ex = TransactionServiceException()
9026 
          self.ex.read(iprot)
9027 
        else:
9028 
          iprot.skip(ftype)
9029 
      else:
9030 
        iprot.skip(ftype)
9031 
      iprot.readFieldEnd()
9032 
    iprot.readStructEnd()
9033 
 
9034 
  def write(self, oprot):
9035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9037 
      return
4283 anupam.sin 9038 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9039 
    if self.success is not None:
3064 chandransh 9040 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9041 
      oprot.writeBool(self.success)
9042 
      oprot.writeFieldEnd()
3431 rajveer 9043 
    if self.ex is not None:
1246 chandransh 9044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9045 
      self.ex.write(oprot)
9046 
      oprot.writeFieldEnd()
9047 
    oprot.writeFieldStop()
9048 
    oprot.writeStructEnd()
9049 
 
3431 rajveer 9050 
  def validate(self):
9051 
    return
9052 
 
9053 
 
1246 chandransh 9054 
  def __repr__(self):
9055 
    L = ['%s=%r' % (key, value)
9056 
      for key, value in self.__dict__.iteritems()]
9057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9058 
 
9059 
  def __eq__(self, other):
9060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9061 
 
9062 
  def __ne__(self, other):
9063 
    return not (self == other)
9064 
 
3064 chandransh 9065 
class markOrdersAsManifested_args:
1408 ankur.sing 9066 
  """
9067 
  Attributes:
3064 chandransh 9068 
   - warehouseId
1408 ankur.sing 9069 
   - providerId
3064 chandransh 9070 
   - cod
1408 ankur.sing 9071 
  """
9072 
 
9073 
  thrift_spec = (
9074 
    None, # 0
3064 chandransh 9075 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9076 
    (2, TType.I64, 'providerId', None, None, ), # 2
9077 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9078 
  )
9079 
 
3064 chandransh 9080 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9081 
    self.warehouseId = warehouseId
1408 ankur.sing 9082 
    self.providerId = providerId
3064 chandransh 9083 
    self.cod = cod
1408 ankur.sing 9084 
 
9085 
  def read(self, iprot):
9086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9088 
      return
9089 
    iprot.readStructBegin()
9090 
    while True:
9091 
      (fname, ftype, fid) = iprot.readFieldBegin()
9092 
      if ftype == TType.STOP:
9093 
        break
9094 
      if fid == 1:
9095 
        if ftype == TType.I64:
3064 chandransh 9096 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      elif fid == 2:
9100 
        if ftype == TType.I64:
3064 chandransh 9101 
          self.providerId = iprot.readI64();
1408 ankur.sing 9102 
        else:
9103 
          iprot.skip(ftype)
3064 chandransh 9104 
      elif fid == 3:
9105 
        if ftype == TType.BOOL:
9106 
          self.cod = iprot.readBool();
9107 
        else:
9108 
          iprot.skip(ftype)
1408 ankur.sing 9109 
      else:
9110 
        iprot.skip(ftype)
9111 
      iprot.readFieldEnd()
9112 
    iprot.readStructEnd()
9113 
 
9114 
  def write(self, oprot):
9115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9117 
      return
3064 chandransh 9118 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9119 
    if self.warehouseId is not None:
3064 chandransh 9120 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9121 
      oprot.writeI64(self.warehouseId)
9122 
      oprot.writeFieldEnd()
3431 rajveer 9123 
    if self.providerId is not None:
3064 chandransh 9124 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9125 
      oprot.writeI64(self.providerId)
9126 
      oprot.writeFieldEnd()
3431 rajveer 9127 
    if self.cod is not None:
3064 chandransh 9128 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9129 
      oprot.writeBool(self.cod)
1408 ankur.sing 9130 
      oprot.writeFieldEnd()
9131 
    oprot.writeFieldStop()
9132 
    oprot.writeStructEnd()
9133 
 
3431 rajveer 9134 
  def validate(self):
9135 
    return
9136 
 
9137 
 
1408 ankur.sing 9138 
  def __repr__(self):
9139 
    L = ['%s=%r' % (key, value)
9140 
      for key, value in self.__dict__.iteritems()]
9141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9142 
 
9143 
  def __eq__(self, other):
9144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9145 
 
9146 
  def __ne__(self, other):
9147 
    return not (self == other)
9148 
 
3064 chandransh 9149 
class markOrdersAsManifested_result:
1408 ankur.sing 9150 
  """
9151 
  Attributes:
9152 
   - success
3064 chandransh 9153 
   - ex
1408 ankur.sing 9154 
  """
9155 
 
9156 
  thrift_spec = (
3064 chandransh 9157 
    (0, TType.BOOL, 'success', None, None, ), # 0
9158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9159 
  )
9160 
 
3064 chandransh 9161 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9162 
    self.success = success
3064 chandransh 9163 
    self.ex = ex
1408 ankur.sing 9164 
 
9165 
  def read(self, iprot):
9166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9168 
      return
9169 
    iprot.readStructBegin()
9170 
    while True:
9171 
      (fname, ftype, fid) = iprot.readFieldBegin()
9172 
      if ftype == TType.STOP:
9173 
        break
9174 
      if fid == 0:
3064 chandransh 9175 
        if ftype == TType.BOOL:
9176 
          self.success = iprot.readBool();
1408 ankur.sing 9177 
        else:
9178 
          iprot.skip(ftype)
3064 chandransh 9179 
      elif fid == 1:
9180 
        if ftype == TType.STRUCT:
9181 
          self.ex = TransactionServiceException()
9182 
          self.ex.read(iprot)
9183 
        else:
9184 
          iprot.skip(ftype)
1408 ankur.sing 9185 
      else:
9186 
        iprot.skip(ftype)
9187 
      iprot.readFieldEnd()
9188 
    iprot.readStructEnd()
9189 
 
9190 
  def write(self, oprot):
9191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9193 
      return
3064 chandransh 9194 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9195 
    if self.success is not None:
3064 chandransh 9196 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9197 
      oprot.writeBool(self.success)
1408 ankur.sing 9198 
      oprot.writeFieldEnd()
3431 rajveer 9199 
    if self.ex is not None:
3064 chandransh 9200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9201 
      self.ex.write(oprot)
9202 
      oprot.writeFieldEnd()
1408 ankur.sing 9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
3431 rajveer 9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
1408 ankur.sing 9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
3064 chandransh 9221 
class markOrdersAsPickedUp_args:
304 ashish 9222 
  """
9223 
  Attributes:
3064 chandransh 9224 
   - providerId
9225 
   - pickupDetails
304 ashish 9226 
  """
94 ashish 9227 
 
304 ashish 9228 
  thrift_spec = (
9229 
    None, # 0
3064 chandransh 9230 
    (1, TType.I64, 'providerId', None, None, ), # 1
9231 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9232 
  )
9233 
 
3064 chandransh 9234 
  def __init__(self, providerId=None, pickupDetails=None,):
9235 
    self.providerId = providerId
9236 
    self.pickupDetails = pickupDetails
304 ashish 9237 
 
9238 
  def read(self, iprot):
9239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9241 
      return
9242 
    iprot.readStructBegin()
9243 
    while True:
9244 
      (fname, ftype, fid) = iprot.readFieldBegin()
9245 
      if ftype == TType.STOP:
9246 
        break
9247 
      if fid == 1:
9248 
        if ftype == TType.I64:
3064 chandransh 9249 
          self.providerId = iprot.readI64();
304 ashish 9250 
        else:
9251 
          iprot.skip(ftype)
9252 
      elif fid == 2:
3064 chandransh 9253 
        if ftype == TType.MAP:
9254 
          self.pickupDetails = {}
4133 chandransh 9255 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9256 
          for _i144 in xrange(_size140):
9257 
            _key145 = iprot.readString();
9258 
            _val146 = iprot.readString();
9259 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9260 
          iprot.readMapEnd()
304 ashish 9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
3064 chandransh 9272 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9273 
    if self.providerId is not None:
3064 chandransh 9274 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9275 
      oprot.writeI64(self.providerId)
304 ashish 9276 
      oprot.writeFieldEnd()
3431 rajveer 9277 
    if self.pickupDetails is not None:
3064 chandransh 9278 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9279 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9280 
      for kiter147,viter148 in self.pickupDetails.items():
9281 
        oprot.writeString(kiter147)
9282 
        oprot.writeString(viter148)
3064 chandransh 9283 
      oprot.writeMapEnd()
304 ashish 9284 
      oprot.writeFieldEnd()
9285 
    oprot.writeFieldStop()
9286 
    oprot.writeStructEnd()
9287 
 
3431 rajveer 9288 
  def validate(self):
9289 
    return
9290 
 
9291 
 
304 ashish 9292 
  def __repr__(self):
9293 
    L = ['%s=%r' % (key, value)
9294 
      for key, value in self.__dict__.iteritems()]
9295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9296 
 
9297 
  def __eq__(self, other):
9298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9299 
 
9300 
  def __ne__(self, other):
9301 
    return not (self == other)
9302 
 
3064 chandransh 9303 
class markOrdersAsPickedUp_result:
304 ashish 9304 
  """
9305 
  Attributes:
9306 
   - success
3064 chandransh 9307 
   - ex
304 ashish 9308 
  """
9309 
 
9310 
  thrift_spec = (
3064 chandransh 9311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9313 
  )
9314 
 
3064 chandransh 9315 
  def __init__(self, success=None, ex=None,):
304 ashish 9316 
    self.success = success
3064 chandransh 9317 
    self.ex = ex
304 ashish 9318 
 
9319 
  def read(self, iprot):
9320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9322 
      return
9323 
    iprot.readStructBegin()
9324 
    while True:
9325 
      (fname, ftype, fid) = iprot.readFieldBegin()
9326 
      if ftype == TType.STOP:
9327 
        break
9328 
      if fid == 0:
9329 
        if ftype == TType.LIST:
9330 
          self.success = []
4133 chandransh 9331 
          (_etype152, _size149) = iprot.readListBegin()
9332 
          for _i153 in xrange(_size149):
9333 
            _elem154 = Order()
9334 
            _elem154.read(iprot)
9335 
            self.success.append(_elem154)
304 ashish 9336 
          iprot.readListEnd()
9337 
        else:
9338 
          iprot.skip(ftype)
3064 chandransh 9339 
      elif fid == 1:
9340 
        if ftype == TType.STRUCT:
9341 
          self.ex = TransactionServiceException()
9342 
          self.ex.read(iprot)
9343 
        else:
9344 
          iprot.skip(ftype)
304 ashish 9345 
      else:
9346 
        iprot.skip(ftype)
9347 
      iprot.readFieldEnd()
9348 
    iprot.readStructEnd()
9349 
 
9350 
  def write(self, oprot):
9351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9353 
      return
3064 chandransh 9354 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9355 
    if self.success is not None:
304 ashish 9356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9358 
      for iter155 in self.success:
9359 
        iter155.write(oprot)
304 ashish 9360 
      oprot.writeListEnd()
9361 
      oprot.writeFieldEnd()
3431 rajveer 9362 
    if self.ex is not None:
3064 chandransh 9363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9364 
      self.ex.write(oprot)
9365 
      oprot.writeFieldEnd()
304 ashish 9366 
    oprot.writeFieldStop()
9367 
    oprot.writeStructEnd()
9368 
 
3431 rajveer 9369 
  def validate(self):
9370 
    return
9371 
 
9372 
 
304 ashish 9373 
  def __repr__(self):
9374 
    L = ['%s=%r' % (key, value)
9375 
      for key, value in self.__dict__.iteritems()]
9376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9377 
 
9378 
  def __eq__(self, other):
9379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9380 
 
9381 
  def __ne__(self, other):
9382 
    return not (self == other)
9383 
 
3064 chandransh 9384 
class markOrdersAsDelivered_args:
304 ashish 9385 
  """
9386 
  Attributes:
3064 chandransh 9387 
   - providerId
9388 
   - deliveredOrders
304 ashish 9389 
  """
9390 
 
9391 
  thrift_spec = (
9392 
    None, # 0
3064 chandransh 9393 
    (1, TType.I64, 'providerId', None, None, ), # 1
9394 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9395 
  )
9396 
 
3064 chandransh 9397 
  def __init__(self, providerId=None, deliveredOrders=None,):
9398 
    self.providerId = providerId
9399 
    self.deliveredOrders = deliveredOrders
304 ashish 9400 
 
9401 
  def read(self, iprot):
9402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9404 
      return
9405 
    iprot.readStructBegin()
9406 
    while True:
9407 
      (fname, ftype, fid) = iprot.readFieldBegin()
9408 
      if ftype == TType.STOP:
9409 
        break
9410 
      if fid == 1:
9411 
        if ftype == TType.I64:
3064 chandransh 9412 
          self.providerId = iprot.readI64();
304 ashish 9413 
        else:
9414 
          iprot.skip(ftype)
9415 
      elif fid == 2:
3064 chandransh 9416 
        if ftype == TType.MAP:
9417 
          self.deliveredOrders = {}
4133 chandransh 9418 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9419 
          for _i160 in xrange(_size156):
9420 
            _key161 = iprot.readString();
9421 
            _val162 = iprot.readString();
9422 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9423 
          iprot.readMapEnd()
304 ashish 9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      else:
9427 
        iprot.skip(ftype)
9428 
      iprot.readFieldEnd()
9429 
    iprot.readStructEnd()
9430 
 
9431 
  def write(self, oprot):
9432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9434 
      return
3064 chandransh 9435 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9436 
    if self.providerId is not None:
3064 chandransh 9437 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9438 
      oprot.writeI64(self.providerId)
304 ashish 9439 
      oprot.writeFieldEnd()
3431 rajveer 9440 
    if self.deliveredOrders is not None:
3064 chandransh 9441 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9442 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9443 
      for kiter163,viter164 in self.deliveredOrders.items():
9444 
        oprot.writeString(kiter163)
9445 
        oprot.writeString(viter164)
3064 chandransh 9446 
      oprot.writeMapEnd()
304 ashish 9447 
      oprot.writeFieldEnd()
9448 
    oprot.writeFieldStop()
9449 
    oprot.writeStructEnd()
9450 
 
3431 rajveer 9451 
  def validate(self):
9452 
    return
9453 
 
9454 
 
304 ashish 9455 
  def __repr__(self):
9456 
    L = ['%s=%r' % (key, value)
9457 
      for key, value in self.__dict__.iteritems()]
9458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9459 
 
9460 
  def __eq__(self, other):
9461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9462 
 
9463 
  def __ne__(self, other):
9464 
    return not (self == other)
9465 
 
3064 chandransh 9466 
class markOrdersAsDelivered_result:
9467 
  """
9468 
  Attributes:
9469 
   - ex
9470 
  """
304 ashish 9471 
 
9472 
  thrift_spec = (
3064 chandransh 9473 
    None, # 0
9474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9475 
  )
9476 
 
3064 chandransh 9477 
  def __init__(self, ex=None,):
9478 
    self.ex = ex
304 ashish 9479 
 
1596 ankur.sing 9480 
  def read(self, iprot):
9481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9483 
      return
9484 
    iprot.readStructBegin()
9485 
    while True:
9486 
      (fname, ftype, fid) = iprot.readFieldBegin()
9487 
      if ftype == TType.STOP:
9488 
        break
3064 chandransh 9489 
      if fid == 1:
9490 
        if ftype == TType.STRUCT:
9491 
          self.ex = TransactionServiceException()
9492 
          self.ex.read(iprot)
9493 
        else:
9494 
          iprot.skip(ftype)
1596 ankur.sing 9495 
      else:
9496 
        iprot.skip(ftype)
9497 
      iprot.readFieldEnd()
9498 
    iprot.readStructEnd()
9499 
 
9500 
  def write(self, oprot):
9501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9503 
      return
3064 chandransh 9504 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9505 
    if self.ex is not None:
3064 chandransh 9506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9507 
      self.ex.write(oprot)
9508 
      oprot.writeFieldEnd()
1596 ankur.sing 9509 
    oprot.writeFieldStop()
9510 
    oprot.writeStructEnd()
9511 
 
3431 rajveer 9512 
  def validate(self):
9513 
    return
9514 
 
9515 
 
1596 ankur.sing 9516 
  def __repr__(self):
9517 
    L = ['%s=%r' % (key, value)
9518 
      for key, value in self.__dict__.iteritems()]
9519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9520 
 
9521 
  def __eq__(self, other):
9522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9523 
 
9524 
  def __ne__(self, other):
9525 
    return not (self == other)
9526 
 
3064 chandransh 9527 
class markOrdersAsFailed_args:
1596 ankur.sing 9528 
  """
9529 
  Attributes:
3064 chandransh 9530 
   - providerId
9531 
   - returnedOrders
1596 ankur.sing 9532 
  """
9533 
 
9534 
  thrift_spec = (
3064 chandransh 9535 
    None, # 0
9536 
    (1, TType.I64, 'providerId', None, None, ), # 1
9537 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9538 
  )
9539 
 
3064 chandransh 9540 
  def __init__(self, providerId=None, returnedOrders=None,):
9541 
    self.providerId = providerId
9542 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9543 
 
9544 
  def read(self, iprot):
9545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9547 
      return
9548 
    iprot.readStructBegin()
9549 
    while True:
9550 
      (fname, ftype, fid) = iprot.readFieldBegin()
9551 
      if ftype == TType.STOP:
9552 
        break
3064 chandransh 9553 
      if fid == 1:
1596 ankur.sing 9554 
        if ftype == TType.I64:
3064 chandransh 9555 
          self.providerId = iprot.readI64();
1596 ankur.sing 9556 
        else:
9557 
          iprot.skip(ftype)
3064 chandransh 9558 
      elif fid == 2:
9559 
        if ftype == TType.MAP:
9560 
          self.returnedOrders = {}
4133 chandransh 9561 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9562 
          for _i169 in xrange(_size165):
9563 
            _key170 = iprot.readString();
9564 
            _val171 = iprot.readString();
9565 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9566 
          iprot.readMapEnd()
9567 
        else:
9568 
          iprot.skip(ftype)
1596 ankur.sing 9569 
      else:
9570 
        iprot.skip(ftype)
9571 
      iprot.readFieldEnd()
9572 
    iprot.readStructEnd()
9573 
 
9574 
  def write(self, oprot):
9575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9577 
      return
3064 chandransh 9578 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9579 
    if self.providerId is not None:
3064 chandransh 9580 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9581 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9582 
      oprot.writeFieldEnd()
3431 rajveer 9583 
    if self.returnedOrders is not None:
3064 chandransh 9584 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9585 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9586 
      for kiter172,viter173 in self.returnedOrders.items():
9587 
        oprot.writeString(kiter172)
9588 
        oprot.writeString(viter173)
3064 chandransh 9589 
      oprot.writeMapEnd()
9590 
      oprot.writeFieldEnd()
1596 ankur.sing 9591 
    oprot.writeFieldStop()
9592 
    oprot.writeStructEnd()
9593 
 
3431 rajveer 9594 
  def validate(self):
9595 
    return
9596 
 
9597 
 
1596 ankur.sing 9598 
  def __repr__(self):
9599 
    L = ['%s=%r' % (key, value)
9600 
      for key, value in self.__dict__.iteritems()]
9601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9602 
 
9603 
  def __eq__(self, other):
9604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9605 
 
9606 
  def __ne__(self, other):
9607 
    return not (self == other)
9608 
 
3064 chandransh 9609 
class markOrdersAsFailed_result:
9610 
  """
9611 
  Attributes:
9612 
   - ex
9613 
  """
1596 ankur.sing 9614 
 
1627 ankur.sing 9615 
  thrift_spec = (
3064 chandransh 9616 
    None, # 0
9617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9618 
  )
9619 
 
3064 chandransh 9620 
  def __init__(self, ex=None,):
9621 
    self.ex = ex
9622 
 
1627 ankur.sing 9623 
  def read(self, iprot):
9624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9626 
      return
9627 
    iprot.readStructBegin()
9628 
    while True:
9629 
      (fname, ftype, fid) = iprot.readFieldBegin()
9630 
      if ftype == TType.STOP:
9631 
        break
3064 chandransh 9632 
      if fid == 1:
9633 
        if ftype == TType.STRUCT:
9634 
          self.ex = TransactionServiceException()
9635 
          self.ex.read(iprot)
9636 
        else:
9637 
          iprot.skip(ftype)
1627 ankur.sing 9638 
      else:
9639 
        iprot.skip(ftype)
9640 
      iprot.readFieldEnd()
9641 
    iprot.readStructEnd()
9642 
 
9643 
  def write(self, oprot):
9644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9646 
      return
3064 chandransh 9647 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9648 
    if self.ex is not None:
3064 chandransh 9649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9650 
      self.ex.write(oprot)
9651 
      oprot.writeFieldEnd()
1627 ankur.sing 9652 
    oprot.writeFieldStop()
9653 
    oprot.writeStructEnd()
9654 
 
3431 rajveer 9655 
  def validate(self):
9656 
    return
9657 
 
9658 
 
1627 ankur.sing 9659 
  def __repr__(self):
9660 
    L = ['%s=%r' % (key, value)
9661 
      for key, value in self.__dict__.iteritems()]
9662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9663 
 
9664 
  def __eq__(self, other):
9665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9666 
 
9667 
  def __ne__(self, other):
9668 
    return not (self == other)
9669 
 
3064 chandransh 9670 
class updateNonDeliveryReason_args:
1627 ankur.sing 9671 
  """
9672 
  Attributes:
3064 chandransh 9673 
   - providerId
9674 
   - undeliveredOrders
1627 ankur.sing 9675 
  """
9676 
 
9677 
  thrift_spec = (
3064 chandransh 9678 
    None, # 0
9679 
    (1, TType.I64, 'providerId', None, None, ), # 1
9680 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9681 
  )
9682 
 
3064 chandransh 9683 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9684 
    self.providerId = providerId
9685 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9686 
 
9687 
  def read(self, iprot):
9688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9690 
      return
9691 
    iprot.readStructBegin()
9692 
    while True:
9693 
      (fname, ftype, fid) = iprot.readFieldBegin()
9694 
      if ftype == TType.STOP:
9695 
        break
3064 chandransh 9696 
      if fid == 1:
1627 ankur.sing 9697 
        if ftype == TType.I64:
3064 chandransh 9698 
          self.providerId = iprot.readI64();
1627 ankur.sing 9699 
        else:
9700 
          iprot.skip(ftype)
3064 chandransh 9701 
      elif fid == 2:
9702 
        if ftype == TType.MAP:
9703 
          self.undeliveredOrders = {}
4133 chandransh 9704 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9705 
          for _i178 in xrange(_size174):
9706 
            _key179 = iprot.readString();
9707 
            _val180 = iprot.readString();
9708 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9709 
          iprot.readMapEnd()
9710 
        else:
9711 
          iprot.skip(ftype)
1627 ankur.sing 9712 
      else:
9713 
        iprot.skip(ftype)
9714 
      iprot.readFieldEnd()
9715 
    iprot.readStructEnd()
9716 
 
9717 
  def write(self, oprot):
9718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9720 
      return
3064 chandransh 9721 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9722 
    if self.providerId is not None:
3064 chandransh 9723 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9724 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9725 
      oprot.writeFieldEnd()
3431 rajveer 9726 
    if self.undeliveredOrders is not None:
3064 chandransh 9727 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9728 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9729 
      for kiter181,viter182 in self.undeliveredOrders.items():
9730 
        oprot.writeString(kiter181)
9731 
        oprot.writeString(viter182)
3064 chandransh 9732 
      oprot.writeMapEnd()
9733 
      oprot.writeFieldEnd()
1627 ankur.sing 9734 
    oprot.writeFieldStop()
9735 
    oprot.writeStructEnd()
9736 
 
3431 rajveer 9737 
  def validate(self):
9738 
    return
9739 
 
9740 
 
1627 ankur.sing 9741 
  def __repr__(self):
9742 
    L = ['%s=%r' % (key, value)
9743 
      for key, value in self.__dict__.iteritems()]
9744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9745 
 
9746 
  def __eq__(self, other):
9747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9748 
 
9749 
  def __ne__(self, other):
9750 
    return not (self == other)
9751 
 
3064 chandransh 9752 
class updateNonDeliveryReason_result:
1627 ankur.sing 9753 
  """
9754 
  Attributes:
3064 chandransh 9755 
   - ex
1627 ankur.sing 9756 
  """
9757 
 
9758 
  thrift_spec = (
3064 chandransh 9759 
    None, # 0
9760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9761 
  )
9762 
 
3064 chandransh 9763 
  def __init__(self, ex=None,):
9764 
    self.ex = ex
1627 ankur.sing 9765 
 
9766 
  def read(self, iprot):
9767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9769 
      return
9770 
    iprot.readStructBegin()
9771 
    while True:
9772 
      (fname, ftype, fid) = iprot.readFieldBegin()
9773 
      if ftype == TType.STOP:
9774 
        break
3064 chandransh 9775 
      if fid == 1:
9776 
        if ftype == TType.STRUCT:
9777 
          self.ex = TransactionServiceException()
9778 
          self.ex.read(iprot)
1627 ankur.sing 9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      else:
9782 
        iprot.skip(ftype)
9783 
      iprot.readFieldEnd()
9784 
    iprot.readStructEnd()
9785 
 
9786 
  def write(self, oprot):
9787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9789 
      return
3064 chandransh 9790 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9791 
    if self.ex is not None:
3064 chandransh 9792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9793 
      self.ex.write(oprot)
1627 ankur.sing 9794 
      oprot.writeFieldEnd()
9795 
    oprot.writeFieldStop()
9796 
    oprot.writeStructEnd()
9797 
 
3431 rajveer 9798 
  def validate(self):
9799 
    return
9800 
 
9801 
 
1627 ankur.sing 9802 
  def __repr__(self):
9803 
    L = ['%s=%r' % (key, value)
9804 
      for key, value in self.__dict__.iteritems()]
9805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9806 
 
9807 
  def __eq__(self, other):
9808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9809 
 
9810 
  def __ne__(self, other):
9811 
    return not (self == other)
9812 
 
3064 chandransh 9813 
class getUndeliveredOrders_args:
1886 ankur.sing 9814 
  """
9815 
  Attributes:
3064 chandransh 9816 
   - providerId
9817 
   - warehouseId
1886 ankur.sing 9818 
  """
1627 ankur.sing 9819 
 
1886 ankur.sing 9820 
  thrift_spec = (
9821 
    None, # 0
3064 chandransh 9822 
    (1, TType.I64, 'providerId', None, None, ), # 1
9823 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9824 
  )
9825 
 
3064 chandransh 9826 
  def __init__(self, providerId=None, warehouseId=None,):
9827 
    self.providerId = providerId
9828 
    self.warehouseId = warehouseId
1886 ankur.sing 9829 
 
9830 
  def read(self, iprot):
9831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9833 
      return
9834 
    iprot.readStructBegin()
9835 
    while True:
9836 
      (fname, ftype, fid) = iprot.readFieldBegin()
9837 
      if ftype == TType.STOP:
9838 
        break
9839 
      if fid == 1:
9840 
        if ftype == TType.I64:
3064 chandransh 9841 
          self.providerId = iprot.readI64();
1886 ankur.sing 9842 
        else:
9843 
          iprot.skip(ftype)
3064 chandransh 9844 
      elif fid == 2:
9845 
        if ftype == TType.I64:
9846 
          self.warehouseId = iprot.readI64();
9847 
        else:
9848 
          iprot.skip(ftype)
1886 ankur.sing 9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
3064 chandransh 9858 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9859 
    if self.providerId is not None:
3064 chandransh 9860 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9861 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9862 
      oprot.writeFieldEnd()
3431 rajveer 9863 
    if self.warehouseId is not None:
3064 chandransh 9864 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9865 
      oprot.writeI64(self.warehouseId)
9866 
      oprot.writeFieldEnd()
1886 ankur.sing 9867 
    oprot.writeFieldStop()
9868 
    oprot.writeStructEnd()
9869 
 
3431 rajveer 9870 
  def validate(self):
9871 
    return
9872 
 
9873 
 
1886 ankur.sing 9874 
  def __repr__(self):
9875 
    L = ['%s=%r' % (key, value)
9876 
      for key, value in self.__dict__.iteritems()]
9877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9878 
 
9879 
  def __eq__(self, other):
9880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9881 
 
9882 
  def __ne__(self, other):
9883 
    return not (self == other)
9884 
 
3064 chandransh 9885 
class getUndeliveredOrders_result:
1886 ankur.sing 9886 
  """
9887 
  Attributes:
9888 
   - success
9889 
  """
9890 
 
9891 
  thrift_spec = (
9892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9893 
  )
9894 
 
9895 
  def __init__(self, success=None,):
9896 
    self.success = success
9897 
 
9898 
  def read(self, iprot):
9899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9901 
      return
9902 
    iprot.readStructBegin()
9903 
    while True:
9904 
      (fname, ftype, fid) = iprot.readFieldBegin()
9905 
      if ftype == TType.STOP:
9906 
        break
9907 
      if fid == 0:
9908 
        if ftype == TType.LIST:
9909 
          self.success = []
4133 chandransh 9910 
          (_etype186, _size183) = iprot.readListBegin()
9911 
          for _i187 in xrange(_size183):
9912 
            _elem188 = Order()
9913 
            _elem188.read(iprot)
9914 
            self.success.append(_elem188)
1886 ankur.sing 9915 
          iprot.readListEnd()
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
3064 chandransh 9927 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9928 
    if self.success is not None:
1886 ankur.sing 9929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9931 
      for iter189 in self.success:
9932 
        iter189.write(oprot)
1886 ankur.sing 9933 
      oprot.writeListEnd()
9934 
      oprot.writeFieldEnd()
9935 
    oprot.writeFieldStop()
9936 
    oprot.writeStructEnd()
9937 
 
3431 rajveer 9938 
  def validate(self):
9939 
    return
9940 
 
9941 
 
1886 ankur.sing 9942 
  def __repr__(self):
9943 
    L = ['%s=%r' % (key, value)
9944 
      for key, value in self.__dict__.iteritems()]
9945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9946 
 
9947 
  def __eq__(self, other):
9948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9949 
 
9950 
  def __ne__(self, other):
9951 
    return not (self == other)
9952 
 
2536 chandransh 9953 
class toggleDOAFlag_args:
9954 
  """
9955 
  Attributes:
9956 
   - orderId
9957 
  """
1886 ankur.sing 9958 
 
2536 chandransh 9959 
  thrift_spec = (
9960 
    None, # 0
9961 
    (1, TType.I64, 'orderId', None, None, ), # 1
9962 
  )
9963 
 
9964 
  def __init__(self, orderId=None,):
9965 
    self.orderId = orderId
9966 
 
9967 
  def read(self, iprot):
9968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9970 
      return
9971 
    iprot.readStructBegin()
9972 
    while True:
9973 
      (fname, ftype, fid) = iprot.readFieldBegin()
9974 
      if ftype == TType.STOP:
9975 
        break
9976 
      if fid == 1:
9977 
        if ftype == TType.I64:
9978 
          self.orderId = iprot.readI64();
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      else:
9982 
        iprot.skip(ftype)
9983 
      iprot.readFieldEnd()
9984 
    iprot.readStructEnd()
9985 
 
9986 
  def write(self, oprot):
9987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9989 
      return
9990 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9991 
    if self.orderId is not None:
2536 chandransh 9992 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9993 
      oprot.writeI64(self.orderId)
9994 
      oprot.writeFieldEnd()
9995 
    oprot.writeFieldStop()
9996 
    oprot.writeStructEnd()
9997 
 
3431 rajveer 9998 
  def validate(self):
9999 
    return
10000 
 
10001 
 
2536 chandransh 10002 
  def __repr__(self):
10003 
    L = ['%s=%r' % (key, value)
10004 
      for key, value in self.__dict__.iteritems()]
10005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10006 
 
10007 
  def __eq__(self, other):
10008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10009 
 
10010 
  def __ne__(self, other):
10011 
    return not (self == other)
10012 
 
10013 
class toggleDOAFlag_result:
10014 
  """
10015 
  Attributes:
10016 
   - success
10017 
   - ex
10018 
  """
10019 
 
10020 
  thrift_spec = (
10021 
    (0, TType.BOOL, 'success', None, None, ), # 0
10022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10023 
  )
10024 
 
10025 
  def __init__(self, success=None, ex=None,):
10026 
    self.success = success
10027 
    self.ex = ex
10028 
 
10029 
  def read(self, iprot):
10030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10032 
      return
10033 
    iprot.readStructBegin()
10034 
    while True:
10035 
      (fname, ftype, fid) = iprot.readFieldBegin()
10036 
      if ftype == TType.STOP:
10037 
        break
10038 
      if fid == 0:
10039 
        if ftype == TType.BOOL:
10040 
          self.success = iprot.readBool();
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      elif fid == 1:
10044 
        if ftype == TType.STRUCT:
10045 
          self.ex = TransactionServiceException()
10046 
          self.ex.read(iprot)
10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      else:
10050 
        iprot.skip(ftype)
10051 
      iprot.readFieldEnd()
10052 
    iprot.readStructEnd()
10053 
 
10054 
  def write(self, oprot):
10055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10057 
      return
10058 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10059 
    if self.success is not None:
2536 chandransh 10060 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10061 
      oprot.writeBool(self.success)
10062 
      oprot.writeFieldEnd()
3431 rajveer 10063 
    if self.ex is not None:
2536 chandransh 10064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10065 
      self.ex.write(oprot)
10066 
      oprot.writeFieldEnd()
10067 
    oprot.writeFieldStop()
10068 
    oprot.writeStructEnd()
10069 
 
3431 rajveer 10070 
  def validate(self):
10071 
    return
10072 
 
10073 
 
2536 chandransh 10074 
  def __repr__(self):
10075 
    L = ['%s=%r' % (key, value)
10076 
      for key, value in self.__dict__.iteritems()]
10077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10078 
 
10079 
  def __eq__(self, other):
10080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10081 
 
10082 
  def __ne__(self, other):
10083 
    return not (self == other)
10084 
 
10085 
class requestPickupNumber_args:
10086 
  """
10087 
  Attributes:
10088 
   - orderId
10089 
  """
10090 
 
10091 
  thrift_spec = (
10092 
    None, # 0
10093 
    (1, TType.I64, 'orderId', None, None, ), # 1
10094 
  )
10095 
 
10096 
  def __init__(self, orderId=None,):
10097 
    self.orderId = orderId
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 1:
10109 
        if ftype == TType.I64:
10110 
          self.orderId = iprot.readI64();
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10123 
    if self.orderId is not None:
2536 chandransh 10124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10125 
      oprot.writeI64(self.orderId)
10126 
      oprot.writeFieldEnd()
10127 
    oprot.writeFieldStop()
10128 
    oprot.writeStructEnd()
10129 
 
3431 rajveer 10130 
  def validate(self):
10131 
    return
10132 
 
10133 
 
2536 chandransh 10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
10145 
class requestPickupNumber_result:
10146 
  """
10147 
  Attributes:
10148 
   - success
10149 
   - ex
10150 
  """
10151 
 
10152 
  thrift_spec = (
10153 
    (0, TType.BOOL, 'success', None, None, ), # 0
10154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10155 
  )
10156 
 
10157 
  def __init__(self, success=None, ex=None,):
10158 
    self.success = success
10159 
    self.ex = ex
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 0:
10171 
        if ftype == TType.BOOL:
10172 
          self.success = iprot.readBool();
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      elif fid == 1:
10176 
        if ftype == TType.STRUCT:
10177 
          self.ex = TransactionServiceException()
10178 
          self.ex.read(iprot)
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10191 
    if self.success is not None:
2536 chandransh 10192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10193 
      oprot.writeBool(self.success)
10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.ex is not None:
2536 chandransh 10196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10197 
      self.ex.write(oprot)
10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
3431 rajveer 10202 
  def validate(self):
10203 
    return
10204 
 
10205 
 
2536 chandransh 10206 
  def __repr__(self):
10207 
    L = ['%s=%r' % (key, value)
10208 
      for key, value in self.__dict__.iteritems()]
10209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10210 
 
10211 
  def __eq__(self, other):
10212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10213 
 
10214 
  def __ne__(self, other):
10215 
    return not (self == other)
10216 
 
10217 
class authorizePickup_args:
10218 
  """
10219 
  Attributes:
10220 
   - orderId
10221 
   - pickupNumber
10222 
  """
10223 
 
10224 
  thrift_spec = (
10225 
    None, # 0
10226 
    (1, TType.I64, 'orderId', None, None, ), # 1
10227 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10228 
  )
10229 
 
10230 
  def __init__(self, orderId=None, pickupNumber=None,):
10231 
    self.orderId = orderId
10232 
    self.pickupNumber = pickupNumber
10233 
 
10234 
  def read(self, iprot):
10235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10237 
      return
10238 
    iprot.readStructBegin()
10239 
    while True:
10240 
      (fname, ftype, fid) = iprot.readFieldBegin()
10241 
      if ftype == TType.STOP:
10242 
        break
10243 
      if fid == 1:
10244 
        if ftype == TType.I64:
10245 
          self.orderId = iprot.readI64();
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      elif fid == 2:
10249 
        if ftype == TType.STRING:
10250 
          self.pickupNumber = iprot.readString();
10251 
        else:
10252 
          iprot.skip(ftype)
10253 
      else:
10254 
        iprot.skip(ftype)
10255 
      iprot.readFieldEnd()
10256 
    iprot.readStructEnd()
10257 
 
10258 
  def write(self, oprot):
10259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10261 
      return
10262 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10263 
    if self.orderId is not None:
2536 chandransh 10264 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10265 
      oprot.writeI64(self.orderId)
10266 
      oprot.writeFieldEnd()
3431 rajveer 10267 
    if self.pickupNumber is not None:
2536 chandransh 10268 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10269 
      oprot.writeString(self.pickupNumber)
10270 
      oprot.writeFieldEnd()
10271 
    oprot.writeFieldStop()
10272 
    oprot.writeStructEnd()
10273 
 
3431 rajveer 10274 
  def validate(self):
10275 
    return
10276 
 
10277 
 
2536 chandransh 10278 
  def __repr__(self):
10279 
    L = ['%s=%r' % (key, value)
10280 
      for key, value in self.__dict__.iteritems()]
10281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10282 
 
10283 
  def __eq__(self, other):
10284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10285 
 
10286 
  def __ne__(self, other):
10287 
    return not (self == other)
10288 
 
10289 
class authorizePickup_result:
10290 
  """
10291 
  Attributes:
10292 
   - success
10293 
   - ex
10294 
  """
10295 
 
10296 
  thrift_spec = (
10297 
    (0, TType.BOOL, 'success', None, None, ), # 0
10298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10299 
  )
10300 
 
10301 
  def __init__(self, success=None, ex=None,):
10302 
    self.success = success
10303 
    self.ex = ex
10304 
 
10305 
  def read(self, iprot):
10306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10308 
      return
10309 
    iprot.readStructBegin()
10310 
    while True:
10311 
      (fname, ftype, fid) = iprot.readFieldBegin()
10312 
      if ftype == TType.STOP:
10313 
        break
10314 
      if fid == 0:
10315 
        if ftype == TType.BOOL:
10316 
          self.success = iprot.readBool();
10317 
        else:
10318 
          iprot.skip(ftype)
10319 
      elif fid == 1:
10320 
        if ftype == TType.STRUCT:
10321 
          self.ex = TransactionServiceException()
10322 
          self.ex.read(iprot)
10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      else:
10326 
        iprot.skip(ftype)
10327 
      iprot.readFieldEnd()
10328 
    iprot.readStructEnd()
10329 
 
10330 
  def write(self, oprot):
10331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10333 
      return
10334 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10335 
    if self.success is not None:
2536 chandransh 10336 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10337 
      oprot.writeBool(self.success)
10338 
      oprot.writeFieldEnd()
3431 rajveer 10339 
    if self.ex is not None:
2536 chandransh 10340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10341 
      self.ex.write(oprot)
10342 
      oprot.writeFieldEnd()
10343 
    oprot.writeFieldStop()
10344 
    oprot.writeStructEnd()
10345 
 
3431 rajveer 10346 
  def validate(self):
10347 
    return
10348 
 
10349 
 
2536 chandransh 10350 
  def __repr__(self):
10351 
    L = ['%s=%r' % (key, value)
10352 
      for key, value in self.__dict__.iteritems()]
10353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10354 
 
10355 
  def __eq__(self, other):
10356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10357 
 
10358 
  def __ne__(self, other):
10359 
    return not (self == other)
10360 
 
2764 chandransh 10361 
class markDoasAsPickedUp_args:
10362 
  """
10363 
  Attributes:
10364 
   - providerId
10365 
   - pickupDetails
10366 
  """
10367 
 
10368 
  thrift_spec = (
10369 
    None, # 0
10370 
    (1, TType.I64, 'providerId', None, None, ), # 1
10371 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10372 
  )
10373 
 
10374 
  def __init__(self, providerId=None, pickupDetails=None,):
10375 
    self.providerId = providerId
10376 
    self.pickupDetails = pickupDetails
10377 
 
10378 
  def read(self, iprot):
10379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10381 
      return
10382 
    iprot.readStructBegin()
10383 
    while True:
10384 
      (fname, ftype, fid) = iprot.readFieldBegin()
10385 
      if ftype == TType.STOP:
10386 
        break
10387 
      if fid == 1:
10388 
        if ftype == TType.I64:
10389 
          self.providerId = iprot.readI64();
10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      elif fid == 2:
10393 
        if ftype == TType.MAP:
10394 
          self.pickupDetails = {}
4133 chandransh 10395 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10396 
          for _i194 in xrange(_size190):
10397 
            _key195 = iprot.readString();
10398 
            _val196 = iprot.readString();
10399 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10400 
          iprot.readMapEnd()
10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
10412 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10413 
    if self.providerId is not None:
2764 chandransh 10414 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10415 
      oprot.writeI64(self.providerId)
10416 
      oprot.writeFieldEnd()
3431 rajveer 10417 
    if self.pickupDetails is not None:
2764 chandransh 10418 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10419 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10420 
      for kiter197,viter198 in self.pickupDetails.items():
10421 
        oprot.writeString(kiter197)
10422 
        oprot.writeString(viter198)
2764 chandransh 10423 
      oprot.writeMapEnd()
10424 
      oprot.writeFieldEnd()
10425 
    oprot.writeFieldStop()
10426 
    oprot.writeStructEnd()
10427 
 
3431 rajveer 10428 
  def validate(self):
10429 
    return
10430 
 
10431 
 
2764 chandransh 10432 
  def __repr__(self):
10433 
    L = ['%s=%r' % (key, value)
10434 
      for key, value in self.__dict__.iteritems()]
10435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10436 
 
10437 
  def __eq__(self, other):
10438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10439 
 
10440 
  def __ne__(self, other):
10441 
    return not (self == other)
10442 
 
10443 
class markDoasAsPickedUp_result:
10444 
  """
10445 
  Attributes:
10446 
   - success
10447 
  """
10448 
 
10449 
  thrift_spec = (
10450 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10451 
  )
10452 
 
10453 
  def __init__(self, success=None,):
10454 
    self.success = success
10455 
 
10456 
  def read(self, iprot):
10457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10459 
      return
10460 
    iprot.readStructBegin()
10461 
    while True:
10462 
      (fname, ftype, fid) = iprot.readFieldBegin()
10463 
      if ftype == TType.STOP:
10464 
        break
10465 
      if fid == 0:
10466 
        if ftype == TType.LIST:
10467 
          self.success = []
4133 chandransh 10468 
          (_etype202, _size199) = iprot.readListBegin()
10469 
          for _i203 in xrange(_size199):
10470 
            _elem204 = Order()
10471 
            _elem204.read(iprot)
10472 
            self.success.append(_elem204)
2764 chandransh 10473 
          iprot.readListEnd()
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
10485 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10486 
    if self.success is not None:
2764 chandransh 10487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10489 
      for iter205 in self.success:
10490 
        iter205.write(oprot)
2764 chandransh 10491 
      oprot.writeListEnd()
10492 
      oprot.writeFieldEnd()
10493 
    oprot.writeFieldStop()
10494 
    oprot.writeStructEnd()
10495 
 
3431 rajveer 10496 
  def validate(self):
10497 
    return
10498 
 
10499 
 
2764 chandransh 10500 
  def __repr__(self):
10501 
    L = ['%s=%r' % (key, value)
10502 
      for key, value in self.__dict__.iteritems()]
10503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10504 
 
10505 
  def __eq__(self, other):
10506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10507 
 
10508 
  def __ne__(self, other):
10509 
    return not (self == other)
10510 
 
2616 chandransh 10511 
class receiveReturn_args:
2591 chandransh 10512 
  """
10513 
  Attributes:
10514 
   - orderId
10515 
  """
2536 chandransh 10516 
 
2591 chandransh 10517 
  thrift_spec = (
10518 
    None, # 0
10519 
    (1, TType.I64, 'orderId', None, None, ), # 1
10520 
  )
10521 
 
10522 
  def __init__(self, orderId=None,):
10523 
    self.orderId = orderId
10524 
 
10525 
  def read(self, iprot):
10526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10528 
      return
10529 
    iprot.readStructBegin()
10530 
    while True:
10531 
      (fname, ftype, fid) = iprot.readFieldBegin()
10532 
      if ftype == TType.STOP:
10533 
        break
10534 
      if fid == 1:
10535 
        if ftype == TType.I64:
10536 
          self.orderId = iprot.readI64();
10537 
        else:
10538 
          iprot.skip(ftype)
10539 
      else:
10540 
        iprot.skip(ftype)
10541 
      iprot.readFieldEnd()
10542 
    iprot.readStructEnd()
10543 
 
10544 
  def write(self, oprot):
10545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10547 
      return
2616 chandransh 10548 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10549 
    if self.orderId is not None:
2591 chandransh 10550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10551 
      oprot.writeI64(self.orderId)
10552 
      oprot.writeFieldEnd()
10553 
    oprot.writeFieldStop()
10554 
    oprot.writeStructEnd()
10555 
 
3431 rajveer 10556 
  def validate(self):
10557 
    return
10558 
 
10559 
 
2591 chandransh 10560 
  def __repr__(self):
10561 
    L = ['%s=%r' % (key, value)
10562 
      for key, value in self.__dict__.iteritems()]
10563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10564 
 
10565 
  def __eq__(self, other):
10566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10567 
 
10568 
  def __ne__(self, other):
10569 
    return not (self == other)
10570 
 
2616 chandransh 10571 
class receiveReturn_result:
2591 chandransh 10572 
  """
10573 
  Attributes:
10574 
   - success
10575 
   - ex
10576 
  """
10577 
 
10578 
  thrift_spec = (
10579 
    (0, TType.BOOL, 'success', None, None, ), # 0
10580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10581 
  )
10582 
 
10583 
  def __init__(self, success=None, ex=None,):
10584 
    self.success = success
10585 
    self.ex = ex
10586 
 
10587 
  def read(self, iprot):
10588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10590 
      return
10591 
    iprot.readStructBegin()
10592 
    while True:
10593 
      (fname, ftype, fid) = iprot.readFieldBegin()
10594 
      if ftype == TType.STOP:
10595 
        break
10596 
      if fid == 0:
10597 
        if ftype == TType.BOOL:
10598 
          self.success = iprot.readBool();
10599 
        else:
10600 
          iprot.skip(ftype)
10601 
      elif fid == 1:
10602 
        if ftype == TType.STRUCT:
10603 
          self.ex = TransactionServiceException()
10604 
          self.ex.read(iprot)
10605 
        else:
10606 
          iprot.skip(ftype)
10607 
      else:
10608 
        iprot.skip(ftype)
10609 
      iprot.readFieldEnd()
10610 
    iprot.readStructEnd()
10611 
 
10612 
  def write(self, oprot):
10613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10615 
      return
2616 chandransh 10616 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10617 
    if self.success is not None:
2591 chandransh 10618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10619 
      oprot.writeBool(self.success)
10620 
      oprot.writeFieldEnd()
3431 rajveer 10621 
    if self.ex is not None:
2591 chandransh 10622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10623 
      self.ex.write(oprot)
10624 
      oprot.writeFieldEnd()
10625 
    oprot.writeFieldStop()
10626 
    oprot.writeStructEnd()
10627 
 
3431 rajveer 10628 
  def validate(self):
10629 
    return
10630 
 
10631 
 
2591 chandransh 10632 
  def __repr__(self):
10633 
    L = ['%s=%r' % (key, value)
10634 
      for key, value in self.__dict__.iteritems()]
10635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10636 
 
10637 
  def __eq__(self, other):
10638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10639 
 
10640 
  def __ne__(self, other):
10641 
    return not (self == other)
10642 
 
10643 
class validateDoa_args:
10644 
  """
10645 
  Attributes:
10646 
   - orderId
10647 
   - isValid
10648 
  """
10649 
 
10650 
  thrift_spec = (
10651 
    None, # 0
10652 
    (1, TType.I64, 'orderId', None, None, ), # 1
10653 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10654 
  )
10655 
 
10656 
  def __init__(self, orderId=None, isValid=None,):
10657 
    self.orderId = orderId
10658 
    self.isValid = isValid
10659 
 
10660 
  def read(self, iprot):
10661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10663 
      return
10664 
    iprot.readStructBegin()
10665 
    while True:
10666 
      (fname, ftype, fid) = iprot.readFieldBegin()
10667 
      if ftype == TType.STOP:
10668 
        break
10669 
      if fid == 1:
10670 
        if ftype == TType.I64:
10671 
          self.orderId = iprot.readI64();
10672 
        else:
10673 
          iprot.skip(ftype)
10674 
      elif fid == 2:
10675 
        if ftype == TType.BOOL:
10676 
          self.isValid = iprot.readBool();
10677 
        else:
10678 
          iprot.skip(ftype)
10679 
      else:
10680 
        iprot.skip(ftype)
10681 
      iprot.readFieldEnd()
10682 
    iprot.readStructEnd()
10683 
 
10684 
  def write(self, oprot):
10685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10687 
      return
10688 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10689 
    if self.orderId is not None:
2591 chandransh 10690 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10691 
      oprot.writeI64(self.orderId)
10692 
      oprot.writeFieldEnd()
3431 rajveer 10693 
    if self.isValid is not None:
2591 chandransh 10694 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10695 
      oprot.writeBool(self.isValid)
10696 
      oprot.writeFieldEnd()
10697 
    oprot.writeFieldStop()
10698 
    oprot.writeStructEnd()
10699 
 
3431 rajveer 10700 
  def validate(self):
10701 
    return
10702 
 
10703 
 
2591 chandransh 10704 
  def __repr__(self):
10705 
    L = ['%s=%r' % (key, value)
10706 
      for key, value in self.__dict__.iteritems()]
10707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10708 
 
10709 
  def __eq__(self, other):
10710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10711 
 
10712 
  def __ne__(self, other):
10713 
    return not (self == other)
10714 
 
10715 
class validateDoa_result:
10716 
  """
10717 
  Attributes:
10718 
   - success
10719 
   - ex
10720 
  """
10721 
 
10722 
  thrift_spec = (
10723 
    (0, TType.BOOL, 'success', None, None, ), # 0
10724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10725 
  )
10726 
 
10727 
  def __init__(self, success=None, ex=None,):
10728 
    self.success = success
10729 
    self.ex = ex
10730 
 
10731 
  def read(self, iprot):
10732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10734 
      return
10735 
    iprot.readStructBegin()
10736 
    while True:
10737 
      (fname, ftype, fid) = iprot.readFieldBegin()
10738 
      if ftype == TType.STOP:
10739 
        break
10740 
      if fid == 0:
10741 
        if ftype == TType.BOOL:
10742 
          self.success = iprot.readBool();
10743 
        else:
10744 
          iprot.skip(ftype)
10745 
      elif fid == 1:
10746 
        if ftype == TType.STRUCT:
10747 
          self.ex = TransactionServiceException()
10748 
          self.ex.read(iprot)
10749 
        else:
10750 
          iprot.skip(ftype)
10751 
      else:
10752 
        iprot.skip(ftype)
10753 
      iprot.readFieldEnd()
10754 
    iprot.readStructEnd()
10755 
 
10756 
  def write(self, oprot):
10757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10759 
      return
10760 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10761 
    if self.success is not None:
2591 chandransh 10762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10763 
      oprot.writeBool(self.success)
10764 
      oprot.writeFieldEnd()
3431 rajveer 10765 
    if self.ex is not None:
2591 chandransh 10766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10767 
      self.ex.write(oprot)
10768 
      oprot.writeFieldEnd()
10769 
    oprot.writeFieldStop()
10770 
    oprot.writeStructEnd()
10771 
 
3431 rajveer 10772 
  def validate(self):
10773 
    return
10774 
 
10775 
 
2591 chandransh 10776 
  def __repr__(self):
10777 
    L = ['%s=%r' % (key, value)
10778 
      for key, value in self.__dict__.iteritems()]
10779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10780 
 
10781 
  def __eq__(self, other):
10782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10783 
 
10784 
  def __ne__(self, other):
10785 
    return not (self == other)
10786 
 
2616 chandransh 10787 
class reshipOrder_args:
10788 
  """
10789 
  Attributes:
10790 
   - orderId
10791 
  """
2591 chandransh 10792 
 
2616 chandransh 10793 
  thrift_spec = (
10794 
    None, # 0
10795 
    (1, TType.I64, 'orderId', None, None, ), # 1
10796 
  )
10797 
 
10798 
  def __init__(self, orderId=None,):
10799 
    self.orderId = orderId
10800 
 
10801 
  def read(self, iprot):
10802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10804 
      return
10805 
    iprot.readStructBegin()
10806 
    while True:
10807 
      (fname, ftype, fid) = iprot.readFieldBegin()
10808 
      if ftype == TType.STOP:
10809 
        break
10810 
      if fid == 1:
10811 
        if ftype == TType.I64:
10812 
          self.orderId = iprot.readI64();
10813 
        else:
10814 
          iprot.skip(ftype)
10815 
      else:
10816 
        iprot.skip(ftype)
10817 
      iprot.readFieldEnd()
10818 
    iprot.readStructEnd()
10819 
 
10820 
  def write(self, oprot):
10821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10823 
      return
10824 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10825 
    if self.orderId is not None:
2616 chandransh 10826 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10827 
      oprot.writeI64(self.orderId)
10828 
      oprot.writeFieldEnd()
10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
3431 rajveer 10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
2616 chandransh 10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
10847 
class reshipOrder_result:
10848 
  """
10849 
  Attributes:
10850 
   - success
10851 
   - ex
10852 
  """
10853 
 
10854 
  thrift_spec = (
10855 
    (0, TType.I64, 'success', None, None, ), # 0
10856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10857 
  )
10858 
 
10859 
  def __init__(self, success=None, ex=None,):
10860 
    self.success = success
10861 
    self.ex = ex
10862 
 
10863 
  def read(self, iprot):
10864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10866 
      return
10867 
    iprot.readStructBegin()
10868 
    while True:
10869 
      (fname, ftype, fid) = iprot.readFieldBegin()
10870 
      if ftype == TType.STOP:
10871 
        break
10872 
      if fid == 0:
10873 
        if ftype == TType.I64:
10874 
          self.success = iprot.readI64();
10875 
        else:
10876 
          iprot.skip(ftype)
10877 
      elif fid == 1:
10878 
        if ftype == TType.STRUCT:
10879 
          self.ex = TransactionServiceException()
10880 
          self.ex.read(iprot)
10881 
        else:
10882 
          iprot.skip(ftype)
10883 
      else:
10884 
        iprot.skip(ftype)
10885 
      iprot.readFieldEnd()
10886 
    iprot.readStructEnd()
10887 
 
10888 
  def write(self, oprot):
10889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10891 
      return
10892 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10893 
    if self.success is not None:
2616 chandransh 10894 
      oprot.writeFieldBegin('success', TType.I64, 0)
10895 
      oprot.writeI64(self.success)
10896 
      oprot.writeFieldEnd()
3431 rajveer 10897 
    if self.ex is not None:
2616 chandransh 10898 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10899 
      self.ex.write(oprot)
10900 
      oprot.writeFieldEnd()
10901 
    oprot.writeFieldStop()
10902 
    oprot.writeStructEnd()
10903 
 
3431 rajveer 10904 
  def validate(self):
10905 
    return
10906 
 
10907 
 
2616 chandransh 10908 
  def __repr__(self):
10909 
    L = ['%s=%r' % (key, value)
10910 
      for key, value in self.__dict__.iteritems()]
10911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10912 
 
10913 
  def __eq__(self, other):
10914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10915 
 
10916 
  def __ne__(self, other):
10917 
    return not (self == other)
10918 
 
10919 
class refundOrder_args:
10920 
  """
10921 
  Attributes:
10922 
   - orderId
3226 chandransh 10923 
   - refundedBy
10924 
   - reason
2616 chandransh 10925 
  """
10926 
 
10927 
  thrift_spec = (
10928 
    None, # 0
10929 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10930 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10931 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10932 
  )
10933 
 
3226 chandransh 10934 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10935 
    self.orderId = orderId
3226 chandransh 10936 
    self.refundedBy = refundedBy
10937 
    self.reason = reason
2616 chandransh 10938 
 
10939 
  def read(self, iprot):
10940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10942 
      return
10943 
    iprot.readStructBegin()
10944 
    while True:
10945 
      (fname, ftype, fid) = iprot.readFieldBegin()
10946 
      if ftype == TType.STOP:
10947 
        break
10948 
      if fid == 1:
10949 
        if ftype == TType.I64:
10950 
          self.orderId = iprot.readI64();
10951 
        else:
10952 
          iprot.skip(ftype)
3226 chandransh 10953 
      elif fid == 2:
10954 
        if ftype == TType.STRING:
10955 
          self.refundedBy = iprot.readString();
10956 
        else:
10957 
          iprot.skip(ftype)
10958 
      elif fid == 3:
10959 
        if ftype == TType.STRING:
10960 
          self.reason = iprot.readString();
10961 
        else:
10962 
          iprot.skip(ftype)
2616 chandransh 10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
10972 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10973 
    if self.orderId is not None:
2616 chandransh 10974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10975 
      oprot.writeI64(self.orderId)
10976 
      oprot.writeFieldEnd()
3431 rajveer 10977 
    if self.refundedBy is not None:
3226 chandransh 10978 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10979 
      oprot.writeString(self.refundedBy)
10980 
      oprot.writeFieldEnd()
3431 rajveer 10981 
    if self.reason is not None:
3226 chandransh 10982 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10983 
      oprot.writeString(self.reason)
10984 
      oprot.writeFieldEnd()
2616 chandransh 10985 
    oprot.writeFieldStop()
10986 
    oprot.writeStructEnd()
10987 
 
3431 rajveer 10988 
  def validate(self):
10989 
    return
10990 
 
10991 
 
2616 chandransh 10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
11003 
class refundOrder_result:
11004 
  """
11005 
  Attributes:
11006 
   - success
11007 
   - ex
11008 
  """
11009 
 
11010 
  thrift_spec = (
11011 
    (0, TType.BOOL, 'success', None, None, ), # 0
11012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11013 
  )
11014 
 
11015 
  def __init__(self, success=None, ex=None,):
11016 
    self.success = success
11017 
    self.ex = ex
11018 
 
11019 
  def read(self, iprot):
11020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11022 
      return
11023 
    iprot.readStructBegin()
11024 
    while True:
11025 
      (fname, ftype, fid) = iprot.readFieldBegin()
11026 
      if ftype == TType.STOP:
11027 
        break
11028 
      if fid == 0:
11029 
        if ftype == TType.BOOL:
11030 
          self.success = iprot.readBool();
11031 
        else:
11032 
          iprot.skip(ftype)
11033 
      elif fid == 1:
11034 
        if ftype == TType.STRUCT:
11035 
          self.ex = TransactionServiceException()
11036 
          self.ex.read(iprot)
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      else:
11040 
        iprot.skip(ftype)
11041 
      iprot.readFieldEnd()
11042 
    iprot.readStructEnd()
11043 
 
11044 
  def write(self, oprot):
11045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11047 
      return
11048 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11049 
    if self.success is not None:
2616 chandransh 11050 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11051 
      oprot.writeBool(self.success)
11052 
      oprot.writeFieldEnd()
3431 rajveer 11053 
    if self.ex is not None:
2616 chandransh 11054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11055 
      self.ex.write(oprot)
11056 
      oprot.writeFieldEnd()
11057 
    oprot.writeFieldStop()
11058 
    oprot.writeStructEnd()
11059 
 
3431 rajveer 11060 
  def validate(self):
11061 
    return
11062 
 
11063 
 
2616 chandransh 11064 
  def __repr__(self):
11065 
    L = ['%s=%r' % (key, value)
11066 
      for key, value in self.__dict__.iteritems()]
11067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11068 
 
11069 
  def __eq__(self, other):
11070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11071 
 
11072 
  def __ne__(self, other):
11073 
    return not (self == other)
11074 
 
2690 chandransh 11075 
class getReturnOrders_args:
11076 
  """
11077 
  Attributes:
11078 
   - warehouseId
11079 
   - fromDate
11080 
   - toDate
11081 
  """
2616 chandransh 11082 
 
2690 chandransh 11083 
  thrift_spec = (
11084 
    None, # 0
11085 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11086 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11087 
    (3, TType.I64, 'toDate', None, None, ), # 3
11088 
  )
11089 
 
11090 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11091 
    self.warehouseId = warehouseId
11092 
    self.fromDate = fromDate
11093 
    self.toDate = toDate
11094 
 
11095 
  def read(self, iprot):
11096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11098 
      return
11099 
    iprot.readStructBegin()
11100 
    while True:
11101 
      (fname, ftype, fid) = iprot.readFieldBegin()
11102 
      if ftype == TType.STOP:
11103 
        break
11104 
      if fid == 1:
11105 
        if ftype == TType.I64:
11106 
          self.warehouseId = iprot.readI64();
11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      elif fid == 2:
11110 
        if ftype == TType.I64:
11111 
          self.fromDate = iprot.readI64();
11112 
        else:
11113 
          iprot.skip(ftype)
11114 
      elif fid == 3:
11115 
        if ftype == TType.I64:
11116 
          self.toDate = iprot.readI64();
11117 
        else:
11118 
          iprot.skip(ftype)
11119 
      else:
11120 
        iprot.skip(ftype)
11121 
      iprot.readFieldEnd()
11122 
    iprot.readStructEnd()
11123 
 
11124 
  def write(self, oprot):
11125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11127 
      return
11128 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11129 
    if self.warehouseId is not None:
2690 chandransh 11130 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11131 
      oprot.writeI64(self.warehouseId)
11132 
      oprot.writeFieldEnd()
3431 rajveer 11133 
    if self.fromDate is not None:
2690 chandransh 11134 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11135 
      oprot.writeI64(self.fromDate)
11136 
      oprot.writeFieldEnd()
3431 rajveer 11137 
    if self.toDate is not None:
2690 chandransh 11138 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11139 
      oprot.writeI64(self.toDate)
11140 
      oprot.writeFieldEnd()
11141 
    oprot.writeFieldStop()
11142 
    oprot.writeStructEnd()
11143 
 
3431 rajveer 11144 
  def validate(self):
11145 
    return
11146 
 
11147 
 
2690 chandransh 11148 
  def __repr__(self):
11149 
    L = ['%s=%r' % (key, value)
11150 
      for key, value in self.__dict__.iteritems()]
11151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11152 
 
11153 
  def __eq__(self, other):
11154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11155 
 
11156 
  def __ne__(self, other):
11157 
    return not (self == other)
11158 
 
11159 
class getReturnOrders_result:
11160 
  """
11161 
  Attributes:
11162 
   - success
11163 
  """
11164 
 
11165 
  thrift_spec = (
11166 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11167 
  )
11168 
 
11169 
  def __init__(self, success=None,):
11170 
    self.success = success
11171 
 
11172 
  def read(self, iprot):
11173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11175 
      return
11176 
    iprot.readStructBegin()
11177 
    while True:
11178 
      (fname, ftype, fid) = iprot.readFieldBegin()
11179 
      if ftype == TType.STOP:
11180 
        break
11181 
      if fid == 0:
11182 
        if ftype == TType.LIST:
11183 
          self.success = []
4133 chandransh 11184 
          (_etype209, _size206) = iprot.readListBegin()
11185 
          for _i210 in xrange(_size206):
11186 
            _elem211 = ReturnOrder()
11187 
            _elem211.read(iprot)
11188 
            self.success.append(_elem211)
2690 chandransh 11189 
          iprot.readListEnd()
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('getReturnOrders_result')
3431 rajveer 11202 
    if self.success is not None:
2690 chandransh 11203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11204 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11205 
      for iter212 in self.success:
11206 
        iter212.write(oprot)
2690 chandransh 11207 
      oprot.writeListEnd()
11208 
      oprot.writeFieldEnd()
11209 
    oprot.writeFieldStop()
11210 
    oprot.writeStructEnd()
11211 
 
3431 rajveer 11212 
  def validate(self):
11213 
    return
11214 
 
11215 
 
2690 chandransh 11216 
  def __repr__(self):
11217 
    L = ['%s=%r' % (key, value)
11218 
      for key, value in self.__dict__.iteritems()]
11219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11220 
 
11221 
  def __eq__(self, other):
11222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11223 
 
11224 
  def __ne__(self, other):
11225 
    return not (self == other)
11226 
 
2700 chandransh 11227 
class getReturnOrder_args:
11228 
  """
11229 
  Attributes:
11230 
   - id
11231 
  """
11232 
 
11233 
  thrift_spec = (
11234 
    None, # 0
11235 
    (1, TType.I64, 'id', None, None, ), # 1
11236 
  )
11237 
 
11238 
  def __init__(self, id=None,):
11239 
    self.id = id
11240 
 
11241 
  def read(self, iprot):
11242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11244 
      return
11245 
    iprot.readStructBegin()
11246 
    while True:
11247 
      (fname, ftype, fid) = iprot.readFieldBegin()
11248 
      if ftype == TType.STOP:
11249 
        break
11250 
      if fid == 1:
11251 
        if ftype == TType.I64:
11252 
          self.id = iprot.readI64();
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
11264 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11265 
    if self.id is not None:
2700 chandransh 11266 
      oprot.writeFieldBegin('id', TType.I64, 1)
11267 
      oprot.writeI64(self.id)
11268 
      oprot.writeFieldEnd()
11269 
    oprot.writeFieldStop()
11270 
    oprot.writeStructEnd()
11271 
 
3431 rajveer 11272 
  def validate(self):
11273 
    return
11274 
 
11275 
 
2700 chandransh 11276 
  def __repr__(self):
11277 
    L = ['%s=%r' % (key, value)
11278 
      for key, value in self.__dict__.iteritems()]
11279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11280 
 
11281 
  def __eq__(self, other):
11282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11283 
 
11284 
  def __ne__(self, other):
11285 
    return not (self == other)
11286 
 
11287 
class getReturnOrder_result:
11288 
  """
11289 
  Attributes:
11290 
   - success
11291 
   - ex
11292 
  """
11293 
 
11294 
  thrift_spec = (
11295 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11297 
  )
11298 
 
11299 
  def __init__(self, success=None, ex=None,):
11300 
    self.success = success
11301 
    self.ex = ex
11302 
 
11303 
  def read(self, iprot):
11304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11306 
      return
11307 
    iprot.readStructBegin()
11308 
    while True:
11309 
      (fname, ftype, fid) = iprot.readFieldBegin()
11310 
      if ftype == TType.STOP:
11311 
        break
11312 
      if fid == 0:
11313 
        if ftype == TType.STRUCT:
11314 
          self.success = ReturnOrder()
11315 
          self.success.read(iprot)
11316 
        else:
11317 
          iprot.skip(ftype)
11318 
      elif fid == 1:
11319 
        if ftype == TType.STRUCT:
11320 
          self.ex = TransactionServiceException()
11321 
          self.ex.read(iprot)
11322 
        else:
11323 
          iprot.skip(ftype)
11324 
      else:
11325 
        iprot.skip(ftype)
11326 
      iprot.readFieldEnd()
11327 
    iprot.readStructEnd()
11328 
 
11329 
  def write(self, oprot):
11330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11332 
      return
11333 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11334 
    if self.success is not None:
2700 chandransh 11335 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11336 
      self.success.write(oprot)
11337 
      oprot.writeFieldEnd()
3431 rajveer 11338 
    if self.ex is not None:
2700 chandransh 11339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11340 
      self.ex.write(oprot)
11341 
      oprot.writeFieldEnd()
11342 
    oprot.writeFieldStop()
11343 
    oprot.writeStructEnd()
11344 
 
3431 rajveer 11345 
  def validate(self):
11346 
    return
11347 
 
11348 
 
2700 chandransh 11349 
  def __repr__(self):
11350 
    L = ['%s=%r' % (key, value)
11351 
      for key, value in self.__dict__.iteritems()]
11352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11353 
 
11354 
  def __eq__(self, other):
11355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11356 
 
11357 
  def __ne__(self, other):
11358 
    return not (self == other)
11359 
 
2690 chandransh 11360 
class processReturn_args:
11361 
  """
11362 
  Attributes:
11363 
   - returnOrderId
11364 
  """
11365 
 
11366 
  thrift_spec = (
11367 
    None, # 0
11368 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11369 
  )
11370 
 
11371 
  def __init__(self, returnOrderId=None,):
11372 
    self.returnOrderId = returnOrderId
11373 
 
11374 
  def read(self, iprot):
11375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11377 
      return
11378 
    iprot.readStructBegin()
11379 
    while True:
11380 
      (fname, ftype, fid) = iprot.readFieldBegin()
11381 
      if ftype == TType.STOP:
11382 
        break
11383 
      if fid == 1:
11384 
        if ftype == TType.I64:
11385 
          self.returnOrderId = iprot.readI64();
11386 
        else:
11387 
          iprot.skip(ftype)
11388 
      else:
11389 
        iprot.skip(ftype)
11390 
      iprot.readFieldEnd()
11391 
    iprot.readStructEnd()
11392 
 
11393 
  def write(self, oprot):
11394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11396 
      return
11397 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11398 
    if self.returnOrderId is not None:
2690 chandransh 11399 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11400 
      oprot.writeI64(self.returnOrderId)
11401 
      oprot.writeFieldEnd()
11402 
    oprot.writeFieldStop()
11403 
    oprot.writeStructEnd()
11404 
 
3431 rajveer 11405 
  def validate(self):
11406 
    return
11407 
 
11408 
 
2690 chandransh 11409 
  def __repr__(self):
11410 
    L = ['%s=%r' % (key, value)
11411 
      for key, value in self.__dict__.iteritems()]
11412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11413 
 
11414 
  def __eq__(self, other):
11415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11416 
 
11417 
  def __ne__(self, other):
11418 
    return not (self == other)
11419 
 
11420 
class processReturn_result:
11421 
  """
11422 
  Attributes:
11423 
   - ex
11424 
  """
11425 
 
11426 
  thrift_spec = (
11427 
    None, # 0
11428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11429 
  )
11430 
 
11431 
  def __init__(self, ex=None,):
11432 
    self.ex = ex
11433 
 
11434 
  def read(self, iprot):
11435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11437 
      return
11438 
    iprot.readStructBegin()
11439 
    while True:
11440 
      (fname, ftype, fid) = iprot.readFieldBegin()
11441 
      if ftype == TType.STOP:
11442 
        break
11443 
      if fid == 1:
11444 
        if ftype == TType.STRUCT:
11445 
          self.ex = TransactionServiceException()
11446 
          self.ex.read(iprot)
11447 
        else:
11448 
          iprot.skip(ftype)
11449 
      else:
11450 
        iprot.skip(ftype)
11451 
      iprot.readFieldEnd()
11452 
    iprot.readStructEnd()
11453 
 
11454 
  def write(self, oprot):
11455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11457 
      return
11458 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11459 
    if self.ex is not None:
2690 chandransh 11460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11461 
      self.ex.write(oprot)
11462 
      oprot.writeFieldEnd()
11463 
    oprot.writeFieldStop()
11464 
    oprot.writeStructEnd()
11465 
 
3431 rajveer 11466 
  def validate(self):
11467 
    return
11468 
 
11469 
 
2690 chandransh 11470 
  def __repr__(self):
11471 
    L = ['%s=%r' % (key, value)
11472 
      for key, value in self.__dict__.iteritems()]
11473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11474 
 
11475 
  def __eq__(self, other):
11476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11477 
 
11478 
  def __ne__(self, other):
11479 
    return not (self == other)
11480 
 
2819 chandransh 11481 
class createPurchaseOrder_args:
11482 
  """
11483 
  Attributes:
11484 
   - warehouseId
11485 
  """
2690 chandransh 11486 
 
2819 chandransh 11487 
  thrift_spec = (
11488 
    None, # 0
11489 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11490 
  )
11491 
 
11492 
  def __init__(self, warehouseId=None,):
11493 
    self.warehouseId = warehouseId
11494 
 
11495 
  def read(self, iprot):
11496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11498 
      return
11499 
    iprot.readStructBegin()
11500 
    while True:
11501 
      (fname, ftype, fid) = iprot.readFieldBegin()
11502 
      if ftype == TType.STOP:
11503 
        break
11504 
      if fid == 1:
11505 
        if ftype == TType.I64:
11506 
          self.warehouseId = iprot.readI64();
11507 
        else:
11508 
          iprot.skip(ftype)
11509 
      else:
11510 
        iprot.skip(ftype)
11511 
      iprot.readFieldEnd()
11512 
    iprot.readStructEnd()
11513 
 
11514 
  def write(self, oprot):
11515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11517 
      return
11518 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11519 
    if self.warehouseId is not None:
2819 chandransh 11520 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11521 
      oprot.writeI64(self.warehouseId)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
2819 chandransh 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
11541 
class createPurchaseOrder_result:
11542 
  """
11543 
  Attributes:
11544 
   - success
11545 
   - ex
11546 
  """
11547 
 
11548 
  thrift_spec = (
11549 
    (0, TType.I64, 'success', None, None, ), # 0
11550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, success=None, ex=None,):
11554 
    self.success = success
11555 
    self.ex = ex
11556 
 
11557 
  def read(self, iprot):
11558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11560 
      return
11561 
    iprot.readStructBegin()
11562 
    while True:
11563 
      (fname, ftype, fid) = iprot.readFieldBegin()
11564 
      if ftype == TType.STOP:
11565 
        break
11566 
      if fid == 0:
11567 
        if ftype == TType.I64:
11568 
          self.success = iprot.readI64();
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      elif fid == 1:
11572 
        if ftype == TType.STRUCT:
11573 
          self.ex = TransactionServiceException()
11574 
          self.ex.read(iprot)
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
11586 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11587 
    if self.success is not None:
2819 chandransh 11588 
      oprot.writeFieldBegin('success', TType.I64, 0)
11589 
      oprot.writeI64(self.success)
11590 
      oprot.writeFieldEnd()
3431 rajveer 11591 
    if self.ex is not None:
2819 chandransh 11592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11593 
      self.ex.write(oprot)
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
3431 rajveer 11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
2819 chandransh 11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
3451 chandransh 11612 
 
11613 
class updateWeight_args:
11614 
  """
11615 
  Attributes:
11616 
   - orderId
11617 
   - weight
11618 
  """
11619 
 
11620 
  thrift_spec = (
11621 
    None, # 0
11622 
    (1, TType.I64, 'orderId', None, None, ), # 1
11623 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11624 
  )
11625 
 
11626 
  def __init__(self, orderId=None, weight=None,):
11627 
    self.orderId = orderId
11628 
    self.weight = weight
11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
11639 
      if fid == 1:
11640 
        if ftype == TType.I64:
11641 
          self.orderId = iprot.readI64();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      elif fid == 2:
11645 
        if ftype == TType.DOUBLE:
11646 
          self.weight = iprot.readDouble();
11647 
        else:
11648 
          iprot.skip(ftype)
11649 
      else:
11650 
        iprot.skip(ftype)
11651 
      iprot.readFieldEnd()
11652 
    iprot.readStructEnd()
11653 
 
11654 
  def write(self, oprot):
11655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11657 
      return
11658 
    oprot.writeStructBegin('updateWeight_args')
11659 
    if self.orderId is not None:
11660 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11661 
      oprot.writeI64(self.orderId)
11662 
      oprot.writeFieldEnd()
11663 
    if self.weight is not None:
11664 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11665 
      oprot.writeDouble(self.weight)
11666 
      oprot.writeFieldEnd()
11667 
    oprot.writeFieldStop()
11668 
    oprot.writeStructEnd()
11669 
 
11670 
  def validate(self):
11671 
    return
11672 
 
11673 
 
11674 
  def __repr__(self):
11675 
    L = ['%s=%r' % (key, value)
11676 
      for key, value in self.__dict__.iteritems()]
11677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11678 
 
11679 
  def __eq__(self, other):
11680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11681 
 
11682 
  def __ne__(self, other):
11683 
    return not (self == other)
11684 
 
11685 
class updateWeight_result:
11686 
  """
11687 
  Attributes:
11688 
   - success
11689 
   - ex
11690 
  """
11691 
 
11692 
  thrift_spec = (
11693 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11695 
  )
11696 
 
11697 
  def __init__(self, success=None, ex=None,):
11698 
    self.success = success
11699 
    self.ex = ex
11700 
 
11701 
  def read(self, iprot):
11702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11704 
      return
11705 
    iprot.readStructBegin()
11706 
    while True:
11707 
      (fname, ftype, fid) = iprot.readFieldBegin()
11708 
      if ftype == TType.STOP:
11709 
        break
11710 
      if fid == 0:
11711 
        if ftype == TType.STRUCT:
11712 
          self.success = Order()
11713 
          self.success.read(iprot)
11714 
        else:
11715 
          iprot.skip(ftype)
11716 
      elif fid == 1:
11717 
        if ftype == TType.STRUCT:
11718 
          self.ex = TransactionServiceException()
11719 
          self.ex.read(iprot)
11720 
        else:
11721 
          iprot.skip(ftype)
11722 
      else:
11723 
        iprot.skip(ftype)
11724 
      iprot.readFieldEnd()
11725 
    iprot.readStructEnd()
11726 
 
11727 
  def write(self, oprot):
11728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11730 
      return
11731 
    oprot.writeStructBegin('updateWeight_result')
11732 
    if self.success is not None:
11733 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11734 
      self.success.write(oprot)
11735 
      oprot.writeFieldEnd()
11736 
    if self.ex is not None:
11737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11738 
      self.ex.write(oprot)
11739 
      oprot.writeFieldEnd()
11740 
    oprot.writeFieldStop()
11741 
    oprot.writeStructEnd()
11742 
 
11743 
  def validate(self):
11744 
    return
11745 
 
11746 
 
11747 
  def __repr__(self):
11748 
    L = ['%s=%r' % (key, value)
11749 
      for key, value in self.__dict__.iteritems()]
11750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11751 
 
11752 
  def __eq__(self, other):
11753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11754 
 
11755 
  def __ne__(self, other):
11756 
    return not (self == other)
3469 chandransh 11757 
 
11758 
class changeItem_args:
11759 
  """
11760 
  Attributes:
11761 
   - orderId
11762 
   - itemId
11763 
  """
11764 
 
11765 
  thrift_spec = (
11766 
    None, # 0
11767 
    (1, TType.I64, 'orderId', None, None, ), # 1
11768 
    (2, TType.I64, 'itemId', None, None, ), # 2
11769 
  )
11770 
 
11771 
  def __init__(self, orderId=None, itemId=None,):
11772 
    self.orderId = orderId
11773 
    self.itemId = itemId
11774 
 
11775 
  def read(self, iprot):
11776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11778 
      return
11779 
    iprot.readStructBegin()
11780 
    while True:
11781 
      (fname, ftype, fid) = iprot.readFieldBegin()
11782 
      if ftype == TType.STOP:
11783 
        break
11784 
      if fid == 1:
11785 
        if ftype == TType.I64:
11786 
          self.orderId = iprot.readI64();
11787 
        else:
11788 
          iprot.skip(ftype)
11789 
      elif fid == 2:
11790 
        if ftype == TType.I64:
11791 
          self.itemId = iprot.readI64();
11792 
        else:
11793 
          iprot.skip(ftype)
11794 
      else:
11795 
        iprot.skip(ftype)
11796 
      iprot.readFieldEnd()
11797 
    iprot.readStructEnd()
11798 
 
11799 
  def write(self, oprot):
11800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11802 
      return
11803 
    oprot.writeStructBegin('changeItem_args')
11804 
    if self.orderId is not None:
11805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11806 
      oprot.writeI64(self.orderId)
11807 
      oprot.writeFieldEnd()
11808 
    if self.itemId is not None:
11809 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11810 
      oprot.writeI64(self.itemId)
11811 
      oprot.writeFieldEnd()
11812 
    oprot.writeFieldStop()
11813 
    oprot.writeStructEnd()
11814 
 
11815 
  def validate(self):
11816 
    return
11817 
 
11818 
 
11819 
  def __repr__(self):
11820 
    L = ['%s=%r' % (key, value)
11821 
      for key, value in self.__dict__.iteritems()]
11822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11823 
 
11824 
  def __eq__(self, other):
11825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11826 
 
11827 
  def __ne__(self, other):
11828 
    return not (self == other)
11829 
 
11830 
class changeItem_result:
11831 
  """
11832 
  Attributes:
11833 
   - success
11834 
   - ex
11835 
  """
11836 
 
11837 
  thrift_spec = (
11838 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11840 
  )
11841 
 
11842 
  def __init__(self, success=None, ex=None,):
11843 
    self.success = success
11844 
    self.ex = ex
11845 
 
11846 
  def read(self, iprot):
11847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11849 
      return
11850 
    iprot.readStructBegin()
11851 
    while True:
11852 
      (fname, ftype, fid) = iprot.readFieldBegin()
11853 
      if ftype == TType.STOP:
11854 
        break
11855 
      if fid == 0:
11856 
        if ftype == TType.STRUCT:
11857 
          self.success = Order()
11858 
          self.success.read(iprot)
11859 
        else:
11860 
          iprot.skip(ftype)
11861 
      elif fid == 1:
11862 
        if ftype == TType.STRUCT:
11863 
          self.ex = TransactionServiceException()
11864 
          self.ex.read(iprot)
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      else:
11868 
        iprot.skip(ftype)
11869 
      iprot.readFieldEnd()
11870 
    iprot.readStructEnd()
11871 
 
11872 
  def write(self, oprot):
11873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11875 
      return
11876 
    oprot.writeStructBegin('changeItem_result')
11877 
    if self.success is not None:
11878 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11879 
      self.success.write(oprot)
11880 
      oprot.writeFieldEnd()
11881 
    if self.ex is not None:
11882 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11883 
      self.ex.write(oprot)
11884 
      oprot.writeFieldEnd()
11885 
    oprot.writeFieldStop()
11886 
    oprot.writeStructEnd()
11887 
 
11888 
  def validate(self):
11889 
    return
11890 
 
11891 
 
11892 
  def __repr__(self):
11893 
    L = ['%s=%r' % (key, value)
11894 
      for key, value in self.__dict__.iteritems()]
11895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11896 
 
11897 
  def __eq__(self, other):
11898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11899 
 
11900 
  def __ne__(self, other):
11901 
    return not (self == other)
11902 
 
11903 
class shiftToWarehouse_args:
11904 
  """
11905 
  Attributes:
11906 
   - orderId
11907 
   - warehouseId
11908 
  """
11909 
 
11910 
  thrift_spec = (
11911 
    None, # 0
11912 
    (1, TType.I64, 'orderId', None, None, ), # 1
11913 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11914 
  )
11915 
 
11916 
  def __init__(self, orderId=None, warehouseId=None,):
11917 
    self.orderId = orderId
11918 
    self.warehouseId = warehouseId
11919 
 
11920 
  def read(self, iprot):
11921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11923 
      return
11924 
    iprot.readStructBegin()
11925 
    while True:
11926 
      (fname, ftype, fid) = iprot.readFieldBegin()
11927 
      if ftype == TType.STOP:
11928 
        break
11929 
      if fid == 1:
11930 
        if ftype == TType.I64:
11931 
          self.orderId = iprot.readI64();
11932 
        else:
11933 
          iprot.skip(ftype)
11934 
      elif fid == 2:
11935 
        if ftype == TType.I64:
11936 
          self.warehouseId = iprot.readI64();
11937 
        else:
11938 
          iprot.skip(ftype)
11939 
      else:
11940 
        iprot.skip(ftype)
11941 
      iprot.readFieldEnd()
11942 
    iprot.readStructEnd()
11943 
 
11944 
  def write(self, oprot):
11945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11947 
      return
11948 
    oprot.writeStructBegin('shiftToWarehouse_args')
11949 
    if self.orderId is not None:
11950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11951 
      oprot.writeI64(self.orderId)
11952 
      oprot.writeFieldEnd()
11953 
    if self.warehouseId is not None:
11954 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11955 
      oprot.writeI64(self.warehouseId)
11956 
      oprot.writeFieldEnd()
11957 
    oprot.writeFieldStop()
11958 
    oprot.writeStructEnd()
11959 
 
11960 
  def validate(self):
11961 
    return
11962 
 
11963 
 
11964 
  def __repr__(self):
11965 
    L = ['%s=%r' % (key, value)
11966 
      for key, value in self.__dict__.iteritems()]
11967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11968 
 
11969 
  def __eq__(self, other):
11970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11971 
 
11972 
  def __ne__(self, other):
11973 
    return not (self == other)
11974 
 
11975 
class shiftToWarehouse_result:
11976 
  """
11977 
  Attributes:
11978 
   - success
11979 
   - ex
11980 
  """
11981 
 
11982 
  thrift_spec = (
11983 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11985 
  )
11986 
 
11987 
  def __init__(self, success=None, ex=None,):
11988 
    self.success = success
11989 
    self.ex = ex
11990 
 
11991 
  def read(self, iprot):
11992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11994 
      return
11995 
    iprot.readStructBegin()
11996 
    while True:
11997 
      (fname, ftype, fid) = iprot.readFieldBegin()
11998 
      if ftype == TType.STOP:
11999 
        break
12000 
      if fid == 0:
12001 
        if ftype == TType.STRUCT:
12002 
          self.success = Order()
12003 
          self.success.read(iprot)
12004 
        else:
12005 
          iprot.skip(ftype)
12006 
      elif fid == 1:
12007 
        if ftype == TType.STRUCT:
12008 
          self.ex = TransactionServiceException()
12009 
          self.ex.read(iprot)
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      else:
12013 
        iprot.skip(ftype)
12014 
      iprot.readFieldEnd()
12015 
    iprot.readStructEnd()
12016 
 
12017 
  def write(self, oprot):
12018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12020 
      return
12021 
    oprot.writeStructBegin('shiftToWarehouse_result')
12022 
    if self.success is not None:
12023 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12024 
      self.success.write(oprot)
12025 
      oprot.writeFieldEnd()
12026 
    if self.ex is not None:
12027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12028 
      self.ex.write(oprot)
12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
3553 chandransh 12047 
 
12048 
class addDelayReason_args:
12049 
  """
12050 
  Attributes:
12051 
   - orderId
12052 
   - delayReason
3986 chandransh 12053 
   - furtherDelay
3553 chandransh 12054 
  """
12055 
 
12056 
  thrift_spec = (
12057 
    None, # 0
12058 
    (1, TType.I64, 'orderId', None, None, ), # 1
12059 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12060 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12061 
  )
12062 
 
3986 chandransh 12063 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12064 
    self.orderId = orderId
12065 
    self.delayReason = delayReason
3986 chandransh 12066 
    self.furtherDelay = furtherDelay
3553 chandransh 12067 
 
12068 
  def read(self, iprot):
12069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12071 
      return
12072 
    iprot.readStructBegin()
12073 
    while True:
12074 
      (fname, ftype, fid) = iprot.readFieldBegin()
12075 
      if ftype == TType.STOP:
12076 
        break
12077 
      if fid == 1:
12078 
        if ftype == TType.I64:
12079 
          self.orderId = iprot.readI64();
12080 
        else:
12081 
          iprot.skip(ftype)
12082 
      elif fid == 2:
12083 
        if ftype == TType.I32:
12084 
          self.delayReason = iprot.readI32();
12085 
        else:
12086 
          iprot.skip(ftype)
3986 chandransh 12087 
      elif fid == 3:
12088 
        if ftype == TType.I64:
12089 
          self.furtherDelay = iprot.readI64();
12090 
        else:
12091 
          iprot.skip(ftype)
3553 chandransh 12092 
      else:
12093 
        iprot.skip(ftype)
12094 
      iprot.readFieldEnd()
12095 
    iprot.readStructEnd()
12096 
 
12097 
  def write(self, oprot):
12098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12100 
      return
12101 
    oprot.writeStructBegin('addDelayReason_args')
12102 
    if self.orderId is not None:
12103 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12104 
      oprot.writeI64(self.orderId)
12105 
      oprot.writeFieldEnd()
12106 
    if self.delayReason is not None:
12107 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12108 
      oprot.writeI32(self.delayReason)
12109 
      oprot.writeFieldEnd()
3986 chandransh 12110 
    if self.furtherDelay is not None:
12111 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12112 
      oprot.writeI64(self.furtherDelay)
12113 
      oprot.writeFieldEnd()
3553 chandransh 12114 
    oprot.writeFieldStop()
12115 
    oprot.writeStructEnd()
12116 
 
12117 
  def validate(self):
12118 
    return
12119 
 
12120 
 
12121 
  def __repr__(self):
12122 
    L = ['%s=%r' % (key, value)
12123 
      for key, value in self.__dict__.iteritems()]
12124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12125 
 
12126 
  def __eq__(self, other):
12127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12128 
 
12129 
  def __ne__(self, other):
12130 
    return not (self == other)
12131 
 
12132 
class addDelayReason_result:
12133 
  """
12134 
  Attributes:
12135 
   - success
12136 
   - ex
12137 
  """
12138 
 
12139 
  thrift_spec = (
12140 
    (0, TType.BOOL, 'success', None, None, ), # 0
12141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12142 
  )
12143 
 
12144 
  def __init__(self, success=None, ex=None,):
12145 
    self.success = success
12146 
    self.ex = ex
12147 
 
12148 
  def read(self, iprot):
12149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12151 
      return
12152 
    iprot.readStructBegin()
12153 
    while True:
12154 
      (fname, ftype, fid) = iprot.readFieldBegin()
12155 
      if ftype == TType.STOP:
12156 
        break
12157 
      if fid == 0:
12158 
        if ftype == TType.BOOL:
12159 
          self.success = iprot.readBool();
12160 
        else:
12161 
          iprot.skip(ftype)
12162 
      elif fid == 1:
12163 
        if ftype == TType.STRUCT:
12164 
          self.ex = TransactionServiceException()
12165 
          self.ex.read(iprot)
12166 
        else:
12167 
          iprot.skip(ftype)
12168 
      else:
12169 
        iprot.skip(ftype)
12170 
      iprot.readFieldEnd()
12171 
    iprot.readStructEnd()
12172 
 
12173 
  def write(self, oprot):
12174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12176 
      return
12177 
    oprot.writeStructBegin('addDelayReason_result')
12178 
    if self.success is not None:
12179 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12180 
      oprot.writeBool(self.success)
12181 
      oprot.writeFieldEnd()
12182 
    if self.ex is not None:
12183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12184 
      self.ex.write(oprot)
12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
3956 chandransh 12203 
 
12204 
class reconcileCodCollection_args:
12205 
  """
12206 
  Attributes:
12207 
   - collectedAmountMap
12208 
   - xferBy
12209 
   - xferTxnId
12210 
   - xferDate
12211 
  """
12212 
 
12213 
  thrift_spec = (
12214 
    None, # 0
12215 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12216 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12217 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12218 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12219 
  )
12220 
 
12221 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12222 
    self.collectedAmountMap = collectedAmountMap
12223 
    self.xferBy = xferBy
12224 
    self.xferTxnId = xferTxnId
12225 
    self.xferDate = xferDate
12226 
 
12227 
  def read(self, iprot):
12228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12230 
      return
12231 
    iprot.readStructBegin()
12232 
    while True:
12233 
      (fname, ftype, fid) = iprot.readFieldBegin()
12234 
      if ftype == TType.STOP:
12235 
        break
12236 
      if fid == 1:
12237 
        if ftype == TType.MAP:
12238 
          self.collectedAmountMap = {}
4133 chandransh 12239 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12240 
          for _i217 in xrange(_size213):
12241 
            _key218 = iprot.readString();
12242 
            _val219 = iprot.readDouble();
12243 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12244 
          iprot.readMapEnd()
12245 
        else:
12246 
          iprot.skip(ftype)
12247 
      elif fid == 2:
12248 
        if ftype == TType.STRING:
12249 
          self.xferBy = iprot.readString();
12250 
        else:
12251 
          iprot.skip(ftype)
12252 
      elif fid == 3:
12253 
        if ftype == TType.STRING:
12254 
          self.xferTxnId = iprot.readString();
12255 
        else:
12256 
          iprot.skip(ftype)
12257 
      elif fid == 4:
12258 
        if ftype == TType.I64:
12259 
          self.xferDate = iprot.readI64();
12260 
        else:
12261 
          iprot.skip(ftype)
12262 
      else:
12263 
        iprot.skip(ftype)
12264 
      iprot.readFieldEnd()
12265 
    iprot.readStructEnd()
12266 
 
12267 
  def write(self, oprot):
12268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12270 
      return
12271 
    oprot.writeStructBegin('reconcileCodCollection_args')
12272 
    if self.collectedAmountMap is not None:
12273 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12274 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12275 
      for kiter220,viter221 in self.collectedAmountMap.items():
12276 
        oprot.writeString(kiter220)
12277 
        oprot.writeDouble(viter221)
3956 chandransh 12278 
      oprot.writeMapEnd()
12279 
      oprot.writeFieldEnd()
12280 
    if self.xferBy is not None:
12281 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12282 
      oprot.writeString(self.xferBy)
12283 
      oprot.writeFieldEnd()
12284 
    if self.xferTxnId is not None:
12285 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12286 
      oprot.writeString(self.xferTxnId)
12287 
      oprot.writeFieldEnd()
12288 
    if self.xferDate is not None:
12289 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12290 
      oprot.writeI64(self.xferDate)
12291 
      oprot.writeFieldEnd()
12292 
    oprot.writeFieldStop()
12293 
    oprot.writeStructEnd()
12294 
 
12295 
  def validate(self):
12296 
    return
12297 
 
12298 
 
12299 
  def __repr__(self):
12300 
    L = ['%s=%r' % (key, value)
12301 
      for key, value in self.__dict__.iteritems()]
12302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12303 
 
12304 
  def __eq__(self, other):
12305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12306 
 
12307 
  def __ne__(self, other):
12308 
    return not (self == other)
12309 
 
12310 
class reconcileCodCollection_result:
12311 
  """
12312 
  Attributes:
12313 
   - success
12314 
   - ex
12315 
  """
12316 
 
12317 
  thrift_spec = (
12318 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12320 
  )
12321 
 
12322 
  def __init__(self, success=None, ex=None,):
12323 
    self.success = success
12324 
    self.ex = ex
12325 
 
12326 
  def read(self, iprot):
12327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12329 
      return
12330 
    iprot.readStructBegin()
12331 
    while True:
12332 
      (fname, ftype, fid) = iprot.readFieldBegin()
12333 
      if ftype == TType.STOP:
12334 
        break
12335 
      if fid == 0:
12336 
        if ftype == TType.MAP:
12337 
          self.success = {}
4133 chandransh 12338 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12339 
          for _i226 in xrange(_size222):
12340 
            _key227 = iprot.readString();
12341 
            _val228 = iprot.readString();
12342 
            self.success[_key227] = _val228
3956 chandransh 12343 
          iprot.readMapEnd()
12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      elif fid == 1:
12347 
        if ftype == TType.STRUCT:
12348 
          self.ex = TransactionServiceException()
12349 
          self.ex.read(iprot)
12350 
        else:
12351 
          iprot.skip(ftype)
12352 
      else:
12353 
        iprot.skip(ftype)
12354 
      iprot.readFieldEnd()
12355 
    iprot.readStructEnd()
12356 
 
12357 
  def write(self, oprot):
12358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12360 
      return
12361 
    oprot.writeStructBegin('reconcileCodCollection_result')
12362 
    if self.success is not None:
12363 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12364 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12365 
      for kiter229,viter230 in self.success.items():
12366 
        oprot.writeString(kiter229)
12367 
        oprot.writeString(viter230)
3956 chandransh 12368 
      oprot.writeMapEnd()
12369 
      oprot.writeFieldEnd()
12370 
    if self.ex is not None:
12371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12372 
      self.ex.write(oprot)
12373 
      oprot.writeFieldEnd()
12374 
    oprot.writeFieldStop()
12375 
    oprot.writeStructEnd()
12376 
 
12377 
  def validate(self):
12378 
    return
12379 
 
12380 
 
12381 
  def __repr__(self):
12382 
    L = ['%s=%r' % (key, value)
12383 
      for key, value in self.__dict__.iteritems()]
12384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12385 
 
12386 
  def __eq__(self, other):
12387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12388 
 
12389 
  def __ne__(self, other):
12390 
    return not (self == other)
4008 mandeep.dh 12391 
 
12392 
class getTransactionsRequiringExtraProcessing_args:
12393 
  """
12394 
  Attributes:
12395 
   - category
12396 
  """
12397 
 
12398 
  thrift_spec = (
12399 
    None, # 0
12400 
    (1, TType.I32, 'category', None, None, ), # 1
12401 
  )
12402 
 
12403 
  def __init__(self, category=None,):
12404 
    self.category = category
12405 
 
12406 
  def read(self, iprot):
12407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12409 
      return
12410 
    iprot.readStructBegin()
12411 
    while True:
12412 
      (fname, ftype, fid) = iprot.readFieldBegin()
12413 
      if ftype == TType.STOP:
12414 
        break
12415 
      if fid == 1:
12416 
        if ftype == TType.I32:
12417 
          self.category = iprot.readI32();
12418 
        else:
12419 
          iprot.skip(ftype)
12420 
      else:
12421 
        iprot.skip(ftype)
12422 
      iprot.readFieldEnd()
12423 
    iprot.readStructEnd()
12424 
 
12425 
  def write(self, oprot):
12426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12428 
      return
12429 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12430 
    if self.category is not None:
12431 
      oprot.writeFieldBegin('category', TType.I32, 1)
12432 
      oprot.writeI32(self.category)
12433 
      oprot.writeFieldEnd()
12434 
    oprot.writeFieldStop()
12435 
    oprot.writeStructEnd()
12436 
 
12437 
  def validate(self):
12438 
    return
12439 
 
12440 
 
12441 
  def __repr__(self):
12442 
    L = ['%s=%r' % (key, value)
12443 
      for key, value in self.__dict__.iteritems()]
12444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12445 
 
12446 
  def __eq__(self, other):
12447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12448 
 
12449 
  def __ne__(self, other):
12450 
    return not (self == other)
12451 
 
12452 
class getTransactionsRequiringExtraProcessing_result:
12453 
  """
12454 
  Attributes:
12455 
   - success
12456 
  """
12457 
 
12458 
  thrift_spec = (
12459 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12460 
  )
12461 
 
12462 
  def __init__(self, success=None,):
12463 
    self.success = success
12464 
 
12465 
  def read(self, iprot):
12466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12468 
      return
12469 
    iprot.readStructBegin()
12470 
    while True:
12471 
      (fname, ftype, fid) = iprot.readFieldBegin()
12472 
      if ftype == TType.STOP:
12473 
        break
12474 
      if fid == 0:
12475 
        if ftype == TType.LIST:
12476 
          self.success = []
4133 chandransh 12477 
          (_etype234, _size231) = iprot.readListBegin()
12478 
          for _i235 in xrange(_size231):
12479 
            _elem236 = iprot.readI64();
12480 
            self.success.append(_elem236)
4008 mandeep.dh 12481 
          iprot.readListEnd()
12482 
        else:
12483 
          iprot.skip(ftype)
12484 
      else:
12485 
        iprot.skip(ftype)
12486 
      iprot.readFieldEnd()
12487 
    iprot.readStructEnd()
12488 
 
12489 
  def write(self, oprot):
12490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12492 
      return
12493 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12494 
    if self.success is not None:
12495 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12496 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12497 
      for iter237 in self.success:
12498 
        oprot.writeI64(iter237)
4008 mandeep.dh 12499 
      oprot.writeListEnd()
12500 
      oprot.writeFieldEnd()
12501 
    oprot.writeFieldStop()
12502 
    oprot.writeStructEnd()
12503 
 
12504 
  def validate(self):
12505 
    return
12506 
 
12507 
 
12508 
  def __repr__(self):
12509 
    L = ['%s=%r' % (key, value)
12510 
      for key, value in self.__dict__.iteritems()]
12511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12512 
 
12513 
  def __eq__(self, other):
12514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12515 
 
12516 
  def __ne__(self, other):
12517 
    return not (self == other)
12518 
 
12519 
class markTransactionAsProcessed_args:
12520 
  """
12521 
  Attributes:
12522 
   - transactionId
12523 
   - category
12524 
  """
12525 
 
12526 
  thrift_spec = (
12527 
    None, # 0
12528 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12529 
    (2, TType.I32, 'category', None, None, ), # 2
12530 
  )
12531 
 
12532 
  def __init__(self, transactionId=None, category=None,):
12533 
    self.transactionId = transactionId
12534 
    self.category = category
12535 
 
12536 
  def read(self, iprot):
12537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12539 
      return
12540 
    iprot.readStructBegin()
12541 
    while True:
12542 
      (fname, ftype, fid) = iprot.readFieldBegin()
12543 
      if ftype == TType.STOP:
12544 
        break
12545 
      if fid == 1:
12546 
        if ftype == TType.I64:
12547 
          self.transactionId = iprot.readI64();
12548 
        else:
12549 
          iprot.skip(ftype)
12550 
      elif fid == 2:
12551 
        if ftype == TType.I32:
12552 
          self.category = iprot.readI32();
12553 
        else:
12554 
          iprot.skip(ftype)
12555 
      else:
12556 
        iprot.skip(ftype)
12557 
      iprot.readFieldEnd()
12558 
    iprot.readStructEnd()
12559 
 
12560 
  def write(self, oprot):
12561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12563 
      return
12564 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12565 
    if self.transactionId is not None:
12566 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12567 
      oprot.writeI64(self.transactionId)
12568 
      oprot.writeFieldEnd()
12569 
    if self.category is not None:
12570 
      oprot.writeFieldBegin('category', TType.I32, 2)
12571 
      oprot.writeI32(self.category)
12572 
      oprot.writeFieldEnd()
12573 
    oprot.writeFieldStop()
12574 
    oprot.writeStructEnd()
12575 
 
12576 
  def validate(self):
12577 
    return
12578 
 
12579 
 
12580 
  def __repr__(self):
12581 
    L = ['%s=%r' % (key, value)
12582 
      for key, value in self.__dict__.iteritems()]
12583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12584 
 
12585 
  def __eq__(self, other):
12586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12587 
 
12588 
  def __ne__(self, other):
12589 
    return not (self == other)
12590 
 
12591 
class markTransactionAsProcessed_result:
12592 
 
12593 
  thrift_spec = (
12594 
  )
12595 
 
12596 
  def read(self, iprot):
12597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12599 
      return
12600 
    iprot.readStructBegin()
12601 
    while True:
12602 
      (fname, ftype, fid) = iprot.readFieldBegin()
12603 
      if ftype == TType.STOP:
12604 
        break
12605 
      else:
12606 
        iprot.skip(ftype)
12607 
      iprot.readFieldEnd()
12608 
    iprot.readStructEnd()
12609 
 
12610 
  def write(self, oprot):
12611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12613 
      return
12614 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12615 
    oprot.writeFieldStop()
12616 
    oprot.writeStructEnd()
12617 
 
12618 
  def validate(self):
12619 
    return
12620 
 
12621 
 
12622 
  def __repr__(self):
12623 
    L = ['%s=%r' % (key, value)
12624 
      for key, value in self.__dict__.iteritems()]
12625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12626 
 
12627 
  def __eq__(self, other):
12628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12629 
 
12630 
  def __ne__(self, other):
12631 
    return not (self == other)
4018 chandransh 12632 
 
12633 
class getItemWiseRiskyOrdersCount_args:
12634 
 
12635 
  thrift_spec = (
12636 
  )
12637 
 
12638 
  def read(self, iprot):
12639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12641 
      return
12642 
    iprot.readStructBegin()
12643 
    while True:
12644 
      (fname, ftype, fid) = iprot.readFieldBegin()
12645 
      if ftype == TType.STOP:
12646 
        break
12647 
      else:
12648 
        iprot.skip(ftype)
12649 
      iprot.readFieldEnd()
12650 
    iprot.readStructEnd()
12651 
 
12652 
  def write(self, oprot):
12653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12655 
      return
12656 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12657 
    oprot.writeFieldStop()
12658 
    oprot.writeStructEnd()
12659 
 
12660 
  def validate(self):
12661 
    return
12662 
 
12663 
 
12664 
  def __repr__(self):
12665 
    L = ['%s=%r' % (key, value)
12666 
      for key, value in self.__dict__.iteritems()]
12667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12668 
 
12669 
  def __eq__(self, other):
12670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12671 
 
12672 
  def __ne__(self, other):
12673 
    return not (self == other)
12674 
 
12675 
class getItemWiseRiskyOrdersCount_result:
12676 
  """
12677 
  Attributes:
12678 
   - success
12679 
  """
12680 
 
12681 
  thrift_spec = (
12682 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12683 
  )
12684 
 
12685 
  def __init__(self, success=None,):
12686 
    self.success = success
12687 
 
12688 
  def read(self, iprot):
12689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12691 
      return
12692 
    iprot.readStructBegin()
12693 
    while True:
12694 
      (fname, ftype, fid) = iprot.readFieldBegin()
12695 
      if ftype == TType.STOP:
12696 
        break
12697 
      if fid == 0:
12698 
        if ftype == TType.MAP:
12699 
          self.success = {}
4133 chandransh 12700 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12701 
          for _i242 in xrange(_size238):
12702 
            _key243 = iprot.readI64();
12703 
            _val244 = iprot.readI64();
12704 
            self.success[_key243] = _val244
4018 chandransh 12705 
          iprot.readMapEnd()
12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
12717 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12718 
    if self.success is not None:
12719 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12720 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12721 
      for kiter245,viter246 in self.success.items():
12722 
        oprot.writeI64(kiter245)
12723 
        oprot.writeI64(viter246)
4018 chandransh 12724 
      oprot.writeMapEnd()
12725 
      oprot.writeFieldEnd()
12726 
    oprot.writeFieldStop()
12727 
    oprot.writeStructEnd()
12728 
 
12729 
  def validate(self):
12730 
    return
12731 
 
12732 
 
12733 
  def __repr__(self):
12734 
    L = ['%s=%r' % (key, value)
12735 
      for key, value in self.__dict__.iteritems()]
12736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12737 
 
12738 
  def __eq__(self, other):
12739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12740 
 
12741 
  def __ne__(self, other):
12742 
    return not (self == other)
4247 rajveer 12743 
 
4295 varun.gupt 12744 
class getOrdersForItemIds_args:
12745 
  """
12746 
  Attributes:
12747 
   - itemIds
12748 
  """
12749 
 
12750 
  thrift_spec = (
12751 
    None, # 0
12752 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12753 
  )
12754 
 
12755 
  def __init__(self, itemIds=None,):
12756 
    self.itemIds = itemIds
12757 
 
12758 
  def read(self, iprot):
12759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12761 
      return
12762 
    iprot.readStructBegin()
12763 
    while True:
12764 
      (fname, ftype, fid) = iprot.readFieldBegin()
12765 
      if ftype == TType.STOP:
12766 
        break
12767 
      if fid == 1:
12768 
        if ftype == TType.LIST:
12769 
          self.itemIds = []
12770 
          (_etype250, _size247) = iprot.readListBegin()
12771 
          for _i251 in xrange(_size247):
12772 
            _elem252 = iprot.readI64();
12773 
            self.itemIds.append(_elem252)
12774 
          iprot.readListEnd()
12775 
        else:
12776 
          iprot.skip(ftype)
12777 
      else:
12778 
        iprot.skip(ftype)
12779 
      iprot.readFieldEnd()
12780 
    iprot.readStructEnd()
12781 
 
12782 
  def write(self, oprot):
12783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12785 
      return
12786 
    oprot.writeStructBegin('getOrdersForItemIds_args')
12787 
    if self.itemIds is not None:
12788 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12789 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12790 
      for iter253 in self.itemIds:
12791 
        oprot.writeI64(iter253)
12792 
      oprot.writeListEnd()
12793 
      oprot.writeFieldEnd()
12794 
    oprot.writeFieldStop()
12795 
    oprot.writeStructEnd()
12796 
 
12797 
  def validate(self):
12798 
    return
12799 
 
12800 
 
12801 
  def __repr__(self):
12802 
    L = ['%s=%r' % (key, value)
12803 
      for key, value in self.__dict__.iteritems()]
12804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12805 
 
12806 
  def __eq__(self, other):
12807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12808 
 
12809 
  def __ne__(self, other):
12810 
    return not (self == other)
12811 
 
12812 
class getOrdersForItemIds_result:
12813 
  """
12814 
  Attributes:
12815 
   - success
12816 
  """
12817 
 
12818 
  thrift_spec = (
12819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12820 
  )
12821 
 
12822 
  def __init__(self, success=None,):
12823 
    self.success = success
12824 
 
12825 
  def read(self, iprot):
12826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12828 
      return
12829 
    iprot.readStructBegin()
12830 
    while True:
12831 
      (fname, ftype, fid) = iprot.readFieldBegin()
12832 
      if ftype == TType.STOP:
12833 
        break
12834 
      if fid == 0:
12835 
        if ftype == TType.LIST:
12836 
          self.success = []
12837 
          (_etype257, _size254) = iprot.readListBegin()
12838 
          for _i258 in xrange(_size254):
12839 
            _elem259 = Order()
12840 
            _elem259.read(iprot)
12841 
            self.success.append(_elem259)
12842 
          iprot.readListEnd()
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('getOrdersForItemIds_result')
12855 
    if self.success is not None:
12856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12858 
      for iter260 in self.success:
12859 
        iter260.write(oprot)
12860 
      oprot.writeListEnd()
12861 
      oprot.writeFieldEnd()
12862 
    oprot.writeFieldStop()
12863 
    oprot.writeStructEnd()
12864 
 
12865 
  def validate(self):
12866 
    return
12867 
 
12868 
 
12869 
  def __repr__(self):
12870 
    L = ['%s=%r' % (key, value)
12871 
      for key, value in self.__dict__.iteritems()]
12872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12873 
 
12874 
  def __eq__(self, other):
12875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12876 
 
12877 
  def __ne__(self, other):
12878 
    return not (self == other)
12879 
 
4247 rajveer 12880 
class markOrderCancellationRequestReceived_args:
12881 
  """
12882 
  Attributes:
12883 
   - orderId
12884 
  """
12885 
 
12886 
  thrift_spec = (
12887 
    None, # 0
12888 
    (1, TType.I64, 'orderId', None, None, ), # 1
12889 
  )
12890 
 
12891 
  def __init__(self, orderId=None,):
12892 
    self.orderId = orderId
12893 
 
12894 
  def read(self, iprot):
12895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12897 
      return
12898 
    iprot.readStructBegin()
12899 
    while True:
12900 
      (fname, ftype, fid) = iprot.readFieldBegin()
12901 
      if ftype == TType.STOP:
12902 
        break
12903 
      if fid == 1:
12904 
        if ftype == TType.I64:
12905 
          self.orderId = iprot.readI64();
12906 
        else:
12907 
          iprot.skip(ftype)
12908 
      else:
12909 
        iprot.skip(ftype)
12910 
      iprot.readFieldEnd()
12911 
    iprot.readStructEnd()
12912 
 
12913 
  def write(self, oprot):
12914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12916 
      return
12917 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12918 
    if self.orderId is not None:
12919 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12920 
      oprot.writeI64(self.orderId)
12921 
      oprot.writeFieldEnd()
12922 
    oprot.writeFieldStop()
12923 
    oprot.writeStructEnd()
12924 
 
12925 
  def validate(self):
12926 
    return
12927 
 
12928 
 
12929 
  def __repr__(self):
12930 
    L = ['%s=%r' % (key, value)
12931 
      for key, value in self.__dict__.iteritems()]
12932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12933 
 
12934 
  def __eq__(self, other):
12935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12936 
 
12937 
  def __ne__(self, other):
12938 
    return not (self == other)
12939 
 
12940 
class markOrderCancellationRequestReceived_result:
12941 
  """
12942 
  Attributes:
12943 
   - ex
12944 
  """
12945 
 
12946 
  thrift_spec = (
12947 
    None, # 0
12948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12949 
  )
12950 
 
12951 
  def __init__(self, ex=None,):
12952 
    self.ex = ex
12953 
 
12954 
  def read(self, iprot):
12955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12957 
      return
12958 
    iprot.readStructBegin()
12959 
    while True:
12960 
      (fname, ftype, fid) = iprot.readFieldBegin()
12961 
      if ftype == TType.STOP:
12962 
        break
12963 
      if fid == 1:
12964 
        if ftype == TType.STRUCT:
12965 
          self.ex = TransactionServiceException()
12966 
          self.ex.read(iprot)
12967 
        else:
12968 
          iprot.skip(ftype)
12969 
      else:
12970 
        iprot.skip(ftype)
12971 
      iprot.readFieldEnd()
12972 
    iprot.readStructEnd()
12973 
 
12974 
  def write(self, oprot):
12975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12977 
      return
12978 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12979 
    if self.ex is not None:
12980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12981 
      self.ex.write(oprot)
12982 
      oprot.writeFieldEnd()
12983 
    oprot.writeFieldStop()
12984 
    oprot.writeStructEnd()
12985 
 
12986 
  def validate(self):
12987 
    return
12988 
 
12989 
 
12990 
  def __repr__(self):
12991 
    L = ['%s=%r' % (key, value)
12992 
      for key, value in self.__dict__.iteritems()]
12993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12994 
 
12995 
  def __eq__(self, other):
12996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12997 
 
12998 
  def __ne__(self, other):
12999 
    return not (self == other)
13000 
 
13001 
class markOrderCancellationRequestConfirmed_args:
13002 
  """
13003 
  Attributes:
13004 
   - orderId
13005 
  """
13006 
 
13007 
  thrift_spec = (
13008 
    None, # 0
13009 
    (1, TType.I64, 'orderId', None, None, ), # 1
13010 
  )
13011 
 
13012 
  def __init__(self, orderId=None,):
13013 
    self.orderId = orderId
13014 
 
13015 
  def read(self, iprot):
13016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13018 
      return
13019 
    iprot.readStructBegin()
13020 
    while True:
13021 
      (fname, ftype, fid) = iprot.readFieldBegin()
13022 
      if ftype == TType.STOP:
13023 
        break
13024 
      if fid == 1:
13025 
        if ftype == TType.I64:
13026 
          self.orderId = iprot.readI64();
13027 
        else:
13028 
          iprot.skip(ftype)
13029 
      else:
13030 
        iprot.skip(ftype)
13031 
      iprot.readFieldEnd()
13032 
    iprot.readStructEnd()
13033 
 
13034 
  def write(self, oprot):
13035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13037 
      return
13038 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13039 
    if self.orderId is not None:
13040 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13041 
      oprot.writeI64(self.orderId)
13042 
      oprot.writeFieldEnd()
13043 
    oprot.writeFieldStop()
13044 
    oprot.writeStructEnd()
13045 
 
13046 
  def validate(self):
13047 
    return
13048 
 
13049 
 
13050 
  def __repr__(self):
13051 
    L = ['%s=%r' % (key, value)
13052 
      for key, value in self.__dict__.iteritems()]
13053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13054 
 
13055 
  def __eq__(self, other):
13056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13057 
 
13058 
  def __ne__(self, other):
13059 
    return not (self == other)
13060 
 
13061 
class markOrderCancellationRequestConfirmed_result:
13062 
  """
13063 
  Attributes:
13064 
   - ex
13065 
  """
13066 
 
13067 
  thrift_spec = (
13068 
    None, # 0
13069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13070 
  )
13071 
 
13072 
  def __init__(self, ex=None,):
13073 
    self.ex = ex
13074 
 
13075 
  def read(self, iprot):
13076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13078 
      return
13079 
    iprot.readStructBegin()
13080 
    while True:
13081 
      (fname, ftype, fid) = iprot.readFieldBegin()
13082 
      if ftype == TType.STOP:
13083 
        break
13084 
      if fid == 1:
13085 
        if ftype == TType.STRUCT:
13086 
          self.ex = TransactionServiceException()
13087 
          self.ex.read(iprot)
13088 
        else:
13089 
          iprot.skip(ftype)
13090 
      else:
13091 
        iprot.skip(ftype)
13092 
      iprot.readFieldEnd()
13093 
    iprot.readStructEnd()
13094 
 
13095 
  def write(self, oprot):
13096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13098 
      return
13099 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13100 
    if self.ex is not None:
13101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13102 
      self.ex.write(oprot)
13103 
      oprot.writeFieldEnd()
13104 
    oprot.writeFieldStop()
13105 
    oprot.writeStructEnd()
13106 
 
13107 
  def validate(self):
13108 
    return
13109 
 
13110 
 
13111 
  def __repr__(self):
13112 
    L = ['%s=%r' % (key, value)
13113 
      for key, value in self.__dict__.iteritems()]
13114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13115 
 
13116 
  def __eq__(self, other):
13117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13118 
 
13119 
  def __ne__(self, other):
13120 
    return not (self == other)
13121 
 
13122 
class markOrderCancellationRequestDenied_args:
13123 
  """
13124 
  Attributes:
13125 
   - orderId
13126 
  """
13127 
 
13128 
  thrift_spec = (
13129 
    None, # 0
13130 
    (1, TType.I64, 'orderId', None, None, ), # 1
13131 
  )
13132 
 
13133 
  def __init__(self, orderId=None,):
13134 
    self.orderId = orderId
13135 
 
13136 
  def read(self, iprot):
13137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13139 
      return
13140 
    iprot.readStructBegin()
13141 
    while True:
13142 
      (fname, ftype, fid) = iprot.readFieldBegin()
13143 
      if ftype == TType.STOP:
13144 
        break
13145 
      if fid == 1:
13146 
        if ftype == TType.I64:
13147 
          self.orderId = iprot.readI64();
13148 
        else:
13149 
          iprot.skip(ftype)
13150 
      else:
13151 
        iprot.skip(ftype)
13152 
      iprot.readFieldEnd()
13153 
    iprot.readStructEnd()
13154 
 
13155 
  def write(self, oprot):
13156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13158 
      return
13159 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13160 
    if self.orderId is not None:
13161 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13162 
      oprot.writeI64(self.orderId)
13163 
      oprot.writeFieldEnd()
13164 
    oprot.writeFieldStop()
13165 
    oprot.writeStructEnd()
13166 
 
13167 
  def validate(self):
13168 
    return
13169 
 
13170 
 
13171 
  def __repr__(self):
13172 
    L = ['%s=%r' % (key, value)
13173 
      for key, value in self.__dict__.iteritems()]
13174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13175 
 
13176 
  def __eq__(self, other):
13177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13178 
 
13179 
  def __ne__(self, other):
13180 
    return not (self == other)
13181 
 
13182 
class markOrderCancellationRequestDenied_result:
13183 
  """
13184 
  Attributes:
13185 
   - ex
13186 
  """
13187 
 
13188 
  thrift_spec = (
13189 
    None, # 0
13190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13191 
  )
13192 
 
13193 
  def __init__(self, ex=None,):
13194 
    self.ex = ex
13195 
 
13196 
  def read(self, iprot):
13197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13199 
      return
13200 
    iprot.readStructBegin()
13201 
    while True:
13202 
      (fname, ftype, fid) = iprot.readFieldBegin()
13203 
      if ftype == TType.STOP:
13204 
        break
13205 
      if fid == 1:
13206 
        if ftype == TType.STRUCT:
13207 
          self.ex = TransactionServiceException()
13208 
          self.ex.read(iprot)
13209 
        else:
13210 
          iprot.skip(ftype)
13211 
      else:
13212 
        iprot.skip(ftype)
13213 
      iprot.readFieldEnd()
13214 
    iprot.readStructEnd()
13215 
 
13216 
  def write(self, oprot):
13217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13219 
      return
13220 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13221 
    if self.ex is not None:
13222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13223 
      self.ex.write(oprot)
13224 
      oprot.writeFieldEnd()
13225 
    oprot.writeFieldStop()
13226 
    oprot.writeStructEnd()
13227 
 
13228 
  def validate(self):
13229 
    return
13230 
 
13231 
 
13232 
  def __repr__(self):
13233 
    L = ['%s=%r' % (key, value)
13234 
      for key, value in self.__dict__.iteritems()]
13235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13236 
 
13237 
  def __eq__(self, other):
13238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13239 
 
13240 
  def __ne__(self, other):
13241 
    return not (self == other)
13242 
 
4258 rajveer 13243 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13244 
  """
13245 
  Attributes:
4258 rajveer 13246 
   - transactionId
4247 rajveer 13247 
  """
13248 
 
13249 
  thrift_spec = (
13250 
    None, # 0
4258 rajveer 13251 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13252 
  )
13253 
 
4258 rajveer 13254 
  def __init__(self, transactionId=None,):
13255 
    self.transactionId = transactionId
4247 rajveer 13256 
 
13257 
  def read(self, iprot):
13258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13260 
      return
13261 
    iprot.readStructBegin()
13262 
    while True:
13263 
      (fname, ftype, fid) = iprot.readFieldBegin()
13264 
      if ftype == TType.STOP:
13265 
        break
13266 
      if fid == 1:
13267 
        if ftype == TType.I64:
4258 rajveer 13268 
          self.transactionId = iprot.readI64();
4247 rajveer 13269 
        else:
13270 
          iprot.skip(ftype)
13271 
      else:
13272 
        iprot.skip(ftype)
13273 
      iprot.readFieldEnd()
13274 
    iprot.readStructEnd()
13275 
 
13276 
  def write(self, oprot):
13277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13279 
      return
4258 rajveer 13280 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13281 
    if self.transactionId is not None:
13282 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13283 
      oprot.writeI64(self.transactionId)
4247 rajveer 13284 
      oprot.writeFieldEnd()
13285 
    oprot.writeFieldStop()
13286 
    oprot.writeStructEnd()
13287 
 
13288 
  def validate(self):
13289 
    return
13290 
 
13291 
 
13292 
  def __repr__(self):
13293 
    L = ['%s=%r' % (key, value)
13294 
      for key, value in self.__dict__.iteritems()]
13295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13296 
 
13297 
  def __eq__(self, other):
13298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13299 
 
13300 
  def __ne__(self, other):
13301 
    return not (self == other)
13302 
 
4258 rajveer 13303 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13304 
  """
13305 
  Attributes:
13306 
   - ex
13307 
  """
13308 
 
13309 
  thrift_spec = (
13310 
    None, # 0
13311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13312 
  )
13313 
 
13314 
  def __init__(self, ex=None,):
13315 
    self.ex = ex
13316 
 
13317 
  def read(self, iprot):
13318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13320 
      return
13321 
    iprot.readStructBegin()
13322 
    while True:
13323 
      (fname, ftype, fid) = iprot.readFieldBegin()
13324 
      if ftype == TType.STOP:
13325 
        break
13326 
      if fid == 1:
13327 
        if ftype == TType.STRUCT:
13328 
          self.ex = TransactionServiceException()
13329 
          self.ex.read(iprot)
13330 
        else:
13331 
          iprot.skip(ftype)
13332 
      else:
13333 
        iprot.skip(ftype)
13334 
      iprot.readFieldEnd()
13335 
    iprot.readStructEnd()
13336 
 
13337 
  def write(self, oprot):
13338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13340 
      return
4258 rajveer 13341 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13342 
    if self.ex is not None:
13343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13344 
      self.ex.write(oprot)
13345 
      oprot.writeFieldEnd()
13346 
    oprot.writeFieldStop()
13347 
    oprot.writeStructEnd()
13348 
 
13349 
  def validate(self):
13350 
    return
13351 
 
13352 
 
13353 
  def __repr__(self):
13354 
    L = ['%s=%r' % (key, value)
13355 
      for key, value in self.__dict__.iteritems()]
13356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13357 
 
13358 
  def __eq__(self, other):
13359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13360 
 
13361 
  def __ne__(self, other):
13362 
    return not (self == other)
4259 anupam.sin 13363 
 
13364 
class refundTransaction_args:
13365 
  """
13366 
  Attributes:
13367 
   - transactionId
13368 
   - refundedBy
13369 
   - reason
13370 
  """
13371 
 
13372 
  thrift_spec = (
13373 
    None, # 0
13374 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13375 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13376 
    (3, TType.STRING, 'reason', None, None, ), # 3
13377 
  )
13378 
 
13379 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13380 
    self.transactionId = transactionId
13381 
    self.refundedBy = refundedBy
13382 
    self.reason = reason
13383 
 
13384 
  def read(self, iprot):
13385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13387 
      return
13388 
    iprot.readStructBegin()
13389 
    while True:
13390 
      (fname, ftype, fid) = iprot.readFieldBegin()
13391 
      if ftype == TType.STOP:
13392 
        break
13393 
      if fid == 1:
13394 
        if ftype == TType.I64:
13395 
          self.transactionId = iprot.readI64();
13396 
        else:
13397 
          iprot.skip(ftype)
13398 
      elif fid == 2:
13399 
        if ftype == TType.STRING:
13400 
          self.refundedBy = iprot.readString();
13401 
        else:
13402 
          iprot.skip(ftype)
13403 
      elif fid == 3:
13404 
        if ftype == TType.STRING:
13405 
          self.reason = iprot.readString();
13406 
        else:
13407 
          iprot.skip(ftype)
13408 
      else:
13409 
        iprot.skip(ftype)
13410 
      iprot.readFieldEnd()
13411 
    iprot.readStructEnd()
13412 
 
13413 
  def write(self, oprot):
13414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13416 
      return
13417 
    oprot.writeStructBegin('refundTransaction_args')
13418 
    if self.transactionId is not None:
13419 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13420 
      oprot.writeI64(self.transactionId)
13421 
      oprot.writeFieldEnd()
13422 
    if self.refundedBy is not None:
13423 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13424 
      oprot.writeString(self.refundedBy)
13425 
      oprot.writeFieldEnd()
13426 
    if self.reason is not None:
13427 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13428 
      oprot.writeString(self.reason)
13429 
      oprot.writeFieldEnd()
13430 
    oprot.writeFieldStop()
13431 
    oprot.writeStructEnd()
13432 
 
13433 
  def validate(self):
13434 
    return
13435 
 
13436 
 
13437 
  def __repr__(self):
13438 
    L = ['%s=%r' % (key, value)
13439 
      for key, value in self.__dict__.iteritems()]
13440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13441 
 
13442 
  def __eq__(self, other):
13443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13444 
 
13445 
  def __ne__(self, other):
13446 
    return not (self == other)
13447 
 
13448 
class refundTransaction_result:
13449 
  """
13450 
  Attributes:
13451 
   - ex
13452 
  """
13453 
 
13454 
  thrift_spec = (
13455 
    None, # 0
13456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13457 
  )
13458 
 
13459 
  def __init__(self, ex=None,):
13460 
    self.ex = ex
13461 
 
13462 
  def read(self, iprot):
13463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13465 
      return
13466 
    iprot.readStructBegin()
13467 
    while True:
13468 
      (fname, ftype, fid) = iprot.readFieldBegin()
13469 
      if ftype == TType.STOP:
13470 
        break
13471 
      if fid == 1:
13472 
        if ftype == TType.STRUCT:
13473 
          self.ex = TransactionServiceException()
13474 
          self.ex.read(iprot)
13475 
        else:
13476 
          iprot.skip(ftype)
13477 
      else:
13478 
        iprot.skip(ftype)
13479 
      iprot.readFieldEnd()
13480 
    iprot.readStructEnd()
13481 
 
13482 
  def write(self, oprot):
13483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13485 
      return
13486 
    oprot.writeStructBegin('refundTransaction_result')
13487 
    if self.ex is not None:
13488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13489 
      self.ex.write(oprot)
13490 
      oprot.writeFieldEnd()
13491 
    oprot.writeFieldStop()
13492 
    oprot.writeStructEnd()
13493 
 
13494 
  def validate(self):
13495 
    return
13496 
 
13497 
 
13498 
  def __repr__(self):
13499 
    L = ['%s=%r' % (key, value)
13500 
      for key, value in self.__dict__.iteritems()]
13501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13502 
 
13503 
  def __eq__(self, other):
13504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13505 
 
13506 
  def __ne__(self, other):
13507 
    return not (self == other)
4285 rajveer 13508 
 
4324 mandeep.dh 13509 
class updateShipmentAddress_args:
13510 
  """
13511 
  Attributes:
13512 
   - orderId
13513 
   - addressId
13514 
  """
13515 
 
13516 
  thrift_spec = (
13517 
    None, # 0
13518 
    (1, TType.I64, 'orderId', None, None, ), # 1
13519 
    (2, TType.I64, 'addressId', None, None, ), # 2
13520 
  )
13521 
 
13522 
  def __init__(self, orderId=None, addressId=None,):
13523 
    self.orderId = orderId
13524 
    self.addressId = addressId
13525 
 
13526 
  def read(self, iprot):
13527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13529 
      return
13530 
    iprot.readStructBegin()
13531 
    while True:
13532 
      (fname, ftype, fid) = iprot.readFieldBegin()
13533 
      if ftype == TType.STOP:
13534 
        break
13535 
      if fid == 1:
13536 
        if ftype == TType.I64:
13537 
          self.orderId = iprot.readI64();
13538 
        else:
13539 
          iprot.skip(ftype)
13540 
      elif fid == 2:
13541 
        if ftype == TType.I64:
13542 
          self.addressId = iprot.readI64();
13543 
        else:
13544 
          iprot.skip(ftype)
13545 
      else:
13546 
        iprot.skip(ftype)
13547 
      iprot.readFieldEnd()
13548 
    iprot.readStructEnd()
13549 
 
13550 
  def write(self, oprot):
13551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13553 
      return
13554 
    oprot.writeStructBegin('updateShipmentAddress_args')
13555 
    if self.orderId is not None:
13556 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13557 
      oprot.writeI64(self.orderId)
13558 
      oprot.writeFieldEnd()
13559 
    if self.addressId is not None:
13560 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
13561 
      oprot.writeI64(self.addressId)
13562 
      oprot.writeFieldEnd()
13563 
    oprot.writeFieldStop()
13564 
    oprot.writeStructEnd()
13565 
 
13566 
  def validate(self):
13567 
    return
13568 
 
13569 
 
13570 
  def __repr__(self):
13571 
    L = ['%s=%r' % (key, value)
13572 
      for key, value in self.__dict__.iteritems()]
13573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13574 
 
13575 
  def __eq__(self, other):
13576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13577 
 
13578 
  def __ne__(self, other):
13579 
    return not (self == other)
13580 
 
13581 
class updateShipmentAddress_result:
13582 
  """
13583 
  Attributes:
13584 
   - ex
13585 
  """
13586 
 
13587 
  thrift_spec = (
13588 
    None, # 0
13589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13590 
  )
13591 
 
13592 
  def __init__(self, ex=None,):
13593 
    self.ex = ex
13594 
 
13595 
  def read(self, iprot):
13596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13598 
      return
13599 
    iprot.readStructBegin()
13600 
    while True:
13601 
      (fname, ftype, fid) = iprot.readFieldBegin()
13602 
      if ftype == TType.STOP:
13603 
        break
13604 
      if fid == 1:
13605 
        if ftype == TType.STRUCT:
13606 
          self.ex = TransactionServiceException()
13607 
          self.ex.read(iprot)
13608 
        else:
13609 
          iprot.skip(ftype)
13610 
      else:
13611 
        iprot.skip(ftype)
13612 
      iprot.readFieldEnd()
13613 
    iprot.readStructEnd()
13614 
 
13615 
  def write(self, oprot):
13616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13618 
      return
13619 
    oprot.writeStructBegin('updateShipmentAddress_result')
13620 
    if self.ex is not None:
13621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13622 
      self.ex.write(oprot)
13623 
      oprot.writeFieldEnd()
13624 
    oprot.writeFieldStop()
13625 
    oprot.writeStructEnd()
13626 
 
13627 
  def validate(self):
13628 
    return
13629 
 
13630 
 
13631 
  def __repr__(self):
13632 
    L = ['%s=%r' % (key, value)
13633 
      for key, value in self.__dict__.iteritems()]
13634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13635 
 
13636 
  def __eq__(self, other):
13637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13638 
 
13639 
  def __ne__(self, other):
13640 
    return not (self == other)
13641 
 
4285 rajveer 13642 
class acceptOrdersForItemId_args:
13643 
  """
13644 
  Attributes:
13645 
   - itemId
13646 
   - inventory
13647 
  """
13648 
 
13649 
  thrift_spec = (
13650 
    None, # 0
13651 
    (1, TType.I64, 'itemId', None, None, ), # 1
13652 
    (2, TType.I64, 'inventory', None, None, ), # 2
13653 
  )
13654 
 
13655 
  def __init__(self, itemId=None, inventory=None,):
13656 
    self.itemId = itemId
13657 
    self.inventory = inventory
13658 
 
13659 
  def read(self, iprot):
13660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13662 
      return
13663 
    iprot.readStructBegin()
13664 
    while True:
13665 
      (fname, ftype, fid) = iprot.readFieldBegin()
13666 
      if ftype == TType.STOP:
13667 
        break
13668 
      if fid == 1:
13669 
        if ftype == TType.I64:
13670 
          self.itemId = iprot.readI64();
13671 
        else:
13672 
          iprot.skip(ftype)
13673 
      elif fid == 2:
13674 
        if ftype == TType.I64:
13675 
          self.inventory = iprot.readI64();
13676 
        else:
13677 
          iprot.skip(ftype)
13678 
      else:
13679 
        iprot.skip(ftype)
13680 
      iprot.readFieldEnd()
13681 
    iprot.readStructEnd()
13682 
 
13683 
  def write(self, oprot):
13684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13686 
      return
13687 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13688 
    if self.itemId is not None:
13689 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13690 
      oprot.writeI64(self.itemId)
13691 
      oprot.writeFieldEnd()
13692 
    if self.inventory is not None:
13693 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13694 
      oprot.writeI64(self.inventory)
13695 
      oprot.writeFieldEnd()
13696 
    oprot.writeFieldStop()
13697 
    oprot.writeStructEnd()
13698 
 
13699 
  def validate(self):
13700 
    return
13701 
 
13702 
 
13703 
  def __repr__(self):
13704 
    L = ['%s=%r' % (key, value)
13705 
      for key, value in self.__dict__.iteritems()]
13706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13707 
 
13708 
  def __eq__(self, other):
13709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13710 
 
13711 
  def __ne__(self, other):
13712 
    return not (self == other)
13713 
 
13714 
class acceptOrdersForItemId_result:
13715 
  """
13716 
  Attributes:
13717 
   - success
13718 
   - ex
13719 
  """
13720 
 
13721 
  thrift_spec = (
13722 
    (0, TType.BOOL, 'success', None, None, ), # 0
13723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13724 
  )
13725 
 
13726 
  def __init__(self, success=None, ex=None,):
13727 
    self.success = success
13728 
    self.ex = ex
13729 
 
13730 
  def read(self, iprot):
13731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13733 
      return
13734 
    iprot.readStructBegin()
13735 
    while True:
13736 
      (fname, ftype, fid) = iprot.readFieldBegin()
13737 
      if ftype == TType.STOP:
13738 
        break
13739 
      if fid == 0:
13740 
        if ftype == TType.BOOL:
13741 
          self.success = iprot.readBool();
13742 
        else:
13743 
          iprot.skip(ftype)
13744 
      elif fid == 1:
13745 
        if ftype == TType.STRUCT:
13746 
          self.ex = TransactionServiceException()
13747 
          self.ex.read(iprot)
13748 
        else:
13749 
          iprot.skip(ftype)
13750 
      else:
13751 
        iprot.skip(ftype)
13752 
      iprot.readFieldEnd()
13753 
    iprot.readStructEnd()
13754 
 
13755 
  def write(self, oprot):
13756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13758 
      return
13759 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13760 
    if self.success is not None:
13761 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13762 
      oprot.writeBool(self.success)
13763 
      oprot.writeFieldEnd()
13764 
    if self.ex is not None:
13765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13766 
      self.ex.write(oprot)
13767 
      oprot.writeFieldEnd()
13768 
    oprot.writeFieldStop()
13769 
    oprot.writeStructEnd()
13770 
 
13771 
  def validate(self):
13772 
    return
13773 
 
13774 
 
13775 
  def __repr__(self):
13776 
    L = ['%s=%r' % (key, value)
13777 
      for key, value in self.__dict__.iteritems()]
13778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13779 
 
13780 
  def __eq__(self, other):
13781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13782 
 
13783 
  def __ne__(self, other):
13784 
    return not (self == other)
4303 rajveer 13785 
 
13786 
class markOrdersAsPORaised_args:
13787 
  """
13788 
  Attributes:
13789 
   - vendorId
13790 
   - itemId
13791 
   - quantity
13792 
   - estimate
4369 rajveer 13793 
   - isReminder
4303 rajveer 13794 
  """
13795 
 
13796 
  thrift_spec = (
13797 
    None, # 0
13798 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13799 
    (2, TType.I64, 'itemId', None, None, ), # 2
13800 
    (3, TType.I64, 'quantity', None, None, ), # 3
13801 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 13802 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 13803 
  )
13804 
 
4369 rajveer 13805 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 13806 
    self.vendorId = vendorId
13807 
    self.itemId = itemId
13808 
    self.quantity = quantity
13809 
    self.estimate = estimate
4369 rajveer 13810 
    self.isReminder = isReminder
4303 rajveer 13811 
 
13812 
  def read(self, iprot):
13813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13815 
      return
13816 
    iprot.readStructBegin()
13817 
    while True:
13818 
      (fname, ftype, fid) = iprot.readFieldBegin()
13819 
      if ftype == TType.STOP:
13820 
        break
13821 
      if fid == 1:
13822 
        if ftype == TType.I64:
13823 
          self.vendorId = iprot.readI64();
13824 
        else:
13825 
          iprot.skip(ftype)
13826 
      elif fid == 2:
13827 
        if ftype == TType.I64:
13828 
          self.itemId = iprot.readI64();
13829 
        else:
13830 
          iprot.skip(ftype)
13831 
      elif fid == 3:
13832 
        if ftype == TType.I64:
13833 
          self.quantity = iprot.readI64();
13834 
        else:
13835 
          iprot.skip(ftype)
13836 
      elif fid == 4:
13837 
        if ftype == TType.I64:
13838 
          self.estimate = iprot.readI64();
13839 
        else:
13840 
          iprot.skip(ftype)
4369 rajveer 13841 
      elif fid == 5:
13842 
        if ftype == TType.BOOL:
13843 
          self.isReminder = iprot.readBool();
13844 
        else:
13845 
          iprot.skip(ftype)
4303 rajveer 13846 
      else:
13847 
        iprot.skip(ftype)
13848 
      iprot.readFieldEnd()
13849 
    iprot.readStructEnd()
13850 
 
13851 
  def write(self, oprot):
13852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13854 
      return
13855 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
13856 
    if self.vendorId is not None:
13857 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
13858 
      oprot.writeI64(self.vendorId)
13859 
      oprot.writeFieldEnd()
13860 
    if self.itemId is not None:
13861 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13862 
      oprot.writeI64(self.itemId)
13863 
      oprot.writeFieldEnd()
13864 
    if self.quantity is not None:
13865 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
13866 
      oprot.writeI64(self.quantity)
13867 
      oprot.writeFieldEnd()
13868 
    if self.estimate is not None:
13869 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
13870 
      oprot.writeI64(self.estimate)
13871 
      oprot.writeFieldEnd()
4369 rajveer 13872 
    if self.isReminder is not None:
13873 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
13874 
      oprot.writeBool(self.isReminder)
13875 
      oprot.writeFieldEnd()
4303 rajveer 13876 
    oprot.writeFieldStop()
13877 
    oprot.writeStructEnd()
13878 
 
13879 
  def validate(self):
13880 
    return
13881 
 
13882 
 
13883 
  def __repr__(self):
13884 
    L = ['%s=%r' % (key, value)
13885 
      for key, value in self.__dict__.iteritems()]
13886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13887 
 
13888 
  def __eq__(self, other):
13889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13890 
 
13891 
  def __ne__(self, other):
13892 
    return not (self == other)
13893 
 
13894 
class markOrdersAsPORaised_result:
13895 
  """
13896 
  Attributes:
13897 
   - ex
13898 
  """
13899 
 
13900 
  thrift_spec = (
13901 
    None, # 0
13902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13903 
  )
13904 
 
13905 
  def __init__(self, ex=None,):
13906 
    self.ex = ex
13907 
 
13908 
  def read(self, iprot):
13909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13911 
      return
13912 
    iprot.readStructBegin()
13913 
    while True:
13914 
      (fname, ftype, fid) = iprot.readFieldBegin()
13915 
      if ftype == TType.STOP:
13916 
        break
13917 
      if fid == 1:
13918 
        if ftype == TType.STRUCT:
13919 
          self.ex = TransactionServiceException()
13920 
          self.ex.read(iprot)
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      else:
13924 
        iprot.skip(ftype)
13925 
      iprot.readFieldEnd()
13926 
    iprot.readStructEnd()
13927 
 
13928 
  def write(self, oprot):
13929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13931 
      return
13932 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
13933 
    if self.ex is not None:
13934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13935 
      self.ex.write(oprot)
13936 
      oprot.writeFieldEnd()
13937 
    oprot.writeFieldStop()
13938 
    oprot.writeStructEnd()
13939 
 
13940 
  def validate(self):
13941 
    return
13942 
 
13943 
 
13944 
  def __repr__(self):
13945 
    L = ['%s=%r' % (key, value)
13946 
      for key, value in self.__dict__.iteritems()]
13947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13948 
 
13949 
  def __eq__(self, other):
13950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13951 
 
13952 
  def __ne__(self, other):
13953 
    return not (self == other)
13954 
 
13955 
class markOrdersAsReversalInitiated_args:
13956 
  """
13957 
  Attributes:
13958 
   - vendorId
13959 
   - itemId
13960 
   - quantity
13961 
   - estimate
4369 rajveer 13962 
   - isReminder
4303 rajveer 13963 
  """
13964 
 
13965 
  thrift_spec = (
13966 
    None, # 0
13967 
    (1, TType.I64, 'vendorId', None, None, ), # 1
13968 
    (2, TType.I64, 'itemId', None, None, ), # 2
13969 
    (3, TType.I64, 'quantity', None, None, ), # 3
13970 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 13971 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 13972 
  )
13973 
 
4369 rajveer 13974 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 13975 
    self.vendorId = vendorId
13976 
    self.itemId = itemId
13977 
    self.quantity = quantity
13978 
    self.estimate = estimate
4369 rajveer 13979 
    self.isReminder = isReminder
4303 rajveer 13980 
 
13981 
  def read(self, iprot):
13982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13984 
      return
13985 
    iprot.readStructBegin()
13986 
    while True:
13987 
      (fname, ftype, fid) = iprot.readFieldBegin()
13988 
      if ftype == TType.STOP:
13989 
        break
13990 
      if fid == 1:
13991 
        if ftype == TType.I64:
13992 
          self.vendorId = iprot.readI64();
13993 
        else:
13994 
          iprot.skip(ftype)
13995 
      elif fid == 2:
13996 
        if ftype == TType.I64:
13997 
          self.itemId = iprot.readI64();
13998 
        else:
13999 
          iprot.skip(ftype)
14000 
      elif fid == 3:
14001 
        if ftype == TType.I64:
14002 
          self.quantity = iprot.readI64();
14003 
        else:
14004 
          iprot.skip(ftype)
14005 
      elif fid == 4:
14006 
        if ftype == TType.I64:
14007 
          self.estimate = iprot.readI64();
14008 
        else:
14009 
          iprot.skip(ftype)
4369 rajveer 14010 
      elif fid == 5:
14011 
        if ftype == TType.BOOL:
14012 
          self.isReminder = iprot.readBool();
14013 
        else:
14014 
          iprot.skip(ftype)
4303 rajveer 14015 
      else:
14016 
        iprot.skip(ftype)
14017 
      iprot.readFieldEnd()
14018 
    iprot.readStructEnd()
14019 
 
14020 
  def write(self, oprot):
14021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14023 
      return
14024 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14025 
    if self.vendorId is not None:
14026 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14027 
      oprot.writeI64(self.vendorId)
14028 
      oprot.writeFieldEnd()
14029 
    if self.itemId is not None:
14030 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14031 
      oprot.writeI64(self.itemId)
14032 
      oprot.writeFieldEnd()
14033 
    if self.quantity is not None:
14034 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14035 
      oprot.writeI64(self.quantity)
14036 
      oprot.writeFieldEnd()
14037 
    if self.estimate is not None:
14038 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14039 
      oprot.writeI64(self.estimate)
14040 
      oprot.writeFieldEnd()
4369 rajveer 14041 
    if self.isReminder is not None:
14042 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14043 
      oprot.writeBool(self.isReminder)
14044 
      oprot.writeFieldEnd()
4303 rajveer 14045 
    oprot.writeFieldStop()
14046 
    oprot.writeStructEnd()
14047 
 
14048 
  def validate(self):
14049 
    return
14050 
 
14051 
 
14052 
  def __repr__(self):
14053 
    L = ['%s=%r' % (key, value)
14054 
      for key, value in self.__dict__.iteritems()]
14055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14056 
 
14057 
  def __eq__(self, other):
14058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14059 
 
14060 
  def __ne__(self, other):
14061 
    return not (self == other)
14062 
 
14063 
class markOrdersAsReversalInitiated_result:
14064 
  """
14065 
  Attributes:
14066 
   - ex
14067 
  """
14068 
 
14069 
  thrift_spec = (
14070 
    None, # 0
14071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14072 
  )
14073 
 
14074 
  def __init__(self, ex=None,):
14075 
    self.ex = ex
14076 
 
14077 
  def read(self, iprot):
14078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14080 
      return
14081 
    iprot.readStructBegin()
14082 
    while True:
14083 
      (fname, ftype, fid) = iprot.readFieldBegin()
14084 
      if ftype == TType.STOP:
14085 
        break
14086 
      if fid == 1:
14087 
        if ftype == TType.STRUCT:
14088 
          self.ex = TransactionServiceException()
14089 
          self.ex.read(iprot)
14090 
        else:
14091 
          iprot.skip(ftype)
14092 
      else:
14093 
        iprot.skip(ftype)
14094 
      iprot.readFieldEnd()
14095 
    iprot.readStructEnd()
14096 
 
14097 
  def write(self, oprot):
14098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14100 
      return
14101 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14102 
    if self.ex is not None:
14103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14104 
      self.ex.write(oprot)
14105 
      oprot.writeFieldEnd()
14106 
    oprot.writeFieldStop()
14107 
    oprot.writeStructEnd()
14108 
 
14109 
  def validate(self):
14110 
    return
14111 
 
14112 
 
14113 
  def __repr__(self):
14114 
    L = ['%s=%r' % (key, value)
14115 
      for key, value in self.__dict__.iteritems()]
14116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14117 
 
14118 
  def __eq__(self, other):
14119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14120 
 
14121 
  def __ne__(self, other):
14122 
    return not (self == other)
14123 
 
14124 
class markOrdersAsNotAvailabke_args:
14125 
  """
14126 
  Attributes:
14127 
   - vendorId
14128 
   - itemId
14129 
   - quantity
14130 
   - estimate
4369 rajveer 14131 
   - isReminder
4303 rajveer 14132 
  """
14133 
 
14134 
  thrift_spec = (
14135 
    None, # 0
14136 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14137 
    (2, TType.I64, 'itemId', None, None, ), # 2
14138 
    (3, TType.I64, 'quantity', None, None, ), # 3
14139 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14140 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14141 
  )
14142 
 
4369 rajveer 14143 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14144 
    self.vendorId = vendorId
14145 
    self.itemId = itemId
14146 
    self.quantity = quantity
14147 
    self.estimate = estimate
4369 rajveer 14148 
    self.isReminder = isReminder
4303 rajveer 14149 
 
14150 
  def read(self, iprot):
14151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14153 
      return
14154 
    iprot.readStructBegin()
14155 
    while True:
14156 
      (fname, ftype, fid) = iprot.readFieldBegin()
14157 
      if ftype == TType.STOP:
14158 
        break
14159 
      if fid == 1:
14160 
        if ftype == TType.I64:
14161 
          self.vendorId = iprot.readI64();
14162 
        else:
14163 
          iprot.skip(ftype)
14164 
      elif fid == 2:
14165 
        if ftype == TType.I64:
14166 
          self.itemId = iprot.readI64();
14167 
        else:
14168 
          iprot.skip(ftype)
14169 
      elif fid == 3:
14170 
        if ftype == TType.I64:
14171 
          self.quantity = iprot.readI64();
14172 
        else:
14173 
          iprot.skip(ftype)
14174 
      elif fid == 4:
14175 
        if ftype == TType.I64:
14176 
          self.estimate = iprot.readI64();
14177 
        else:
14178 
          iprot.skip(ftype)
4369 rajveer 14179 
      elif fid == 5:
14180 
        if ftype == TType.BOOL:
14181 
          self.isReminder = iprot.readBool();
14182 
        else:
14183 
          iprot.skip(ftype)
4303 rajveer 14184 
      else:
14185 
        iprot.skip(ftype)
14186 
      iprot.readFieldEnd()
14187 
    iprot.readStructEnd()
14188 
 
14189 
  def write(self, oprot):
14190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14192 
      return
14193 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14194 
    if self.vendorId is not None:
14195 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14196 
      oprot.writeI64(self.vendorId)
14197 
      oprot.writeFieldEnd()
14198 
    if self.itemId is not None:
14199 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14200 
      oprot.writeI64(self.itemId)
14201 
      oprot.writeFieldEnd()
14202 
    if self.quantity is not None:
14203 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14204 
      oprot.writeI64(self.quantity)
14205 
      oprot.writeFieldEnd()
14206 
    if self.estimate is not None:
14207 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14208 
      oprot.writeI64(self.estimate)
14209 
      oprot.writeFieldEnd()
4369 rajveer 14210 
    if self.isReminder is not None:
14211 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14212 
      oprot.writeBool(self.isReminder)
14213 
      oprot.writeFieldEnd()
4303 rajveer 14214 
    oprot.writeFieldStop()
14215 
    oprot.writeStructEnd()
14216 
 
14217 
  def validate(self):
14218 
    return
14219 
 
14220 
 
14221 
  def __repr__(self):
14222 
    L = ['%s=%r' % (key, value)
14223 
      for key, value in self.__dict__.iteritems()]
14224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14225 
 
14226 
  def __eq__(self, other):
14227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14228 
 
14229 
  def __ne__(self, other):
14230 
    return not (self == other)
14231 
 
14232 
class markOrdersAsNotAvailabke_result:
14233 
  """
14234 
  Attributes:
14235 
   - ex
14236 
  """
14237 
 
14238 
  thrift_spec = (
14239 
    None, # 0
14240 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14241 
  )
14242 
 
14243 
  def __init__(self, ex=None,):
14244 
    self.ex = ex
14245 
 
14246 
  def read(self, iprot):
14247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14249 
      return
14250 
    iprot.readStructBegin()
14251 
    while True:
14252 
      (fname, ftype, fid) = iprot.readFieldBegin()
14253 
      if ftype == TType.STOP:
14254 
        break
14255 
      if fid == 1:
14256 
        if ftype == TType.STRUCT:
14257 
          self.ex = TransactionServiceException()
14258 
          self.ex.read(iprot)
14259 
        else:
14260 
          iprot.skip(ftype)
14261 
      else:
14262 
        iprot.skip(ftype)
14263 
      iprot.readFieldEnd()
14264 
    iprot.readStructEnd()
14265 
 
14266 
  def write(self, oprot):
14267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14269 
      return
14270 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14271 
    if self.ex is not None:
14272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14273 
      self.ex.write(oprot)
14274 
      oprot.writeFieldEnd()
14275 
    oprot.writeFieldStop()
14276 
    oprot.writeStructEnd()
14277 
 
14278 
  def validate(self):
14279 
    return
14280 
 
14281 
 
14282 
  def __repr__(self):
14283 
    L = ['%s=%r' % (key, value)
14284 
      for key, value in self.__dict__.iteritems()]
14285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14286 
 
14287 
  def __eq__(self, other):
14288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14289 
 
14290 
  def __ne__(self, other):
14291 
    return not (self == other)
4369 rajveer 14292 
 
14293 
class markOrdersAsTimeout_args:
14294 
  """
14295 
  Attributes:
14296 
   - vendorId
14297 
  """
14298 
 
14299 
  thrift_spec = (
14300 
    None, # 0
14301 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14302 
  )
14303 
 
14304 
  def __init__(self, vendorId=None,):
14305 
    self.vendorId = vendorId
14306 
 
14307 
  def read(self, iprot):
14308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14310 
      return
14311 
    iprot.readStructBegin()
14312 
    while True:
14313 
      (fname, ftype, fid) = iprot.readFieldBegin()
14314 
      if ftype == TType.STOP:
14315 
        break
14316 
      if fid == 1:
14317 
        if ftype == TType.I64:
14318 
          self.vendorId = iprot.readI64();
14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      else:
14322 
        iprot.skip(ftype)
14323 
      iprot.readFieldEnd()
14324 
    iprot.readStructEnd()
14325 
 
14326 
  def write(self, oprot):
14327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14329 
      return
14330 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
14331 
    if self.vendorId is not None:
14332 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14333 
      oprot.writeI64(self.vendorId)
14334 
      oprot.writeFieldEnd()
14335 
    oprot.writeFieldStop()
14336 
    oprot.writeStructEnd()
14337 
 
14338 
  def validate(self):
14339 
    return
14340 
 
14341 
 
14342 
  def __repr__(self):
14343 
    L = ['%s=%r' % (key, value)
14344 
      for key, value in self.__dict__.iteritems()]
14345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14346 
 
14347 
  def __eq__(self, other):
14348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14349 
 
14350 
  def __ne__(self, other):
14351 
    return not (self == other)
14352 
 
14353 
class markOrdersAsTimeout_result:
14354 
  """
14355 
  Attributes:
14356 
   - success
14357 
   - ex
14358 
  """
14359 
 
14360 
  thrift_spec = (
14361 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
14362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14363 
  )
14364 
 
14365 
  def __init__(self, success=None, ex=None,):
14366 
    self.success = success
14367 
    self.ex = ex
14368 
 
14369 
  def read(self, iprot):
14370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14372 
      return
14373 
    iprot.readStructBegin()
14374 
    while True:
14375 
      (fname, ftype, fid) = iprot.readFieldBegin()
14376 
      if ftype == TType.STOP:
14377 
        break
14378 
      if fid == 0:
14379 
        if ftype == TType.MAP:
14380 
          self.success = {}
14381 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
14382 
          for _i265 in xrange(_size261):
14383 
            _key266 = iprot.readI32();
14384 
            _val267 = TimeoutSummary()
14385 
            _val267.read(iprot)
14386 
            self.success[_key266] = _val267
14387 
          iprot.readMapEnd()
14388 
        else:
14389 
          iprot.skip(ftype)
14390 
      elif fid == 1:
14391 
        if ftype == TType.STRUCT:
14392 
          self.ex = TransactionServiceException()
14393 
          self.ex.read(iprot)
14394 
        else:
14395 
          iprot.skip(ftype)
14396 
      else:
14397 
        iprot.skip(ftype)
14398 
      iprot.readFieldEnd()
14399 
    iprot.readStructEnd()
14400 
 
14401 
  def write(self, oprot):
14402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14404 
      return
14405 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
14406 
    if self.success is not None:
14407 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14408 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
14409 
      for kiter268,viter269 in self.success.items():
14410 
        oprot.writeI32(kiter268)
14411 
        viter269.write(oprot)
14412 
      oprot.writeMapEnd()
14413 
      oprot.writeFieldEnd()
14414 
    if self.ex is not None:
14415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14416 
      self.ex.write(oprot)
14417 
      oprot.writeFieldEnd()
14418 
    oprot.writeFieldStop()
14419 
    oprot.writeStructEnd()
14420 
 
14421 
  def validate(self):
14422 
    return
14423 
 
14424 
 
14425 
  def __repr__(self):
14426 
    L = ['%s=%r' % (key, value)
14427 
      for key, value in self.__dict__.iteritems()]
14428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14429 
 
14430 
  def __eq__(self, other):
14431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14432 
 
14433 
  def __ne__(self, other):
14434 
    return not (self == other)