Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
404 
    Returns the final flag status.
405 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4247 rajveer 659 
  def markOrderCancellationRequestReceived(self, orderId):
660 
    """
661 
    Mark order as cancellation request received. If customer sends request of cancellation of
662 
    a particular order, this method will be called. It will just change status of the order
663 
    depending on its current status. It also records the previous status, so that we can move
664 
    back to that status if cancellation request is denied.
4018 chandransh 665 
 
4247 rajveer 666 
    Parameters:
667 
     - orderId
668 
    """
669 
    pass
670 
 
671 
  def markOrderCancellationRequestConfirmed(self, orderId):
672 
    """
673 
    If we decide to to cancel order, CRM will call this method to move the status of order to
674 
    cancellation request confirmed. After this OM will be able to cancel the order.
675 
 
676 
    Parameters:
677 
     - orderId
678 
    """
679 
    pass
680 
 
681 
  def markOrderCancellationRequestDenied(self, orderId):
682 
    """
683 
    If we decide to not to cancel order, we will move the order ro previous status.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
4258 rajveer 690 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 691 
    """
4258 rajveer 692 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
693 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 694 
 
695 
    Parameters:
4258 rajveer 696 
     - transactionId
4247 rajveer 697 
    """
698 
    pass
699 
 
4259 anupam.sin 700 
  def refundTransaction(self, transactionId, refundedBy, reason):
701 
    """
702 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
703 
    need to be cancelled
4247 rajveer 704 
 
4259 anupam.sin 705 
    Parameters:
706 
     - transactionId
707 
     - refundedBy
708 
     - reason
709 
    """
710 
    pass
711 
 
712 
 
3376 rajveer 713 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 714 
  def __init__(self, iprot, oprot=None):
3376 rajveer 715 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 716 
 
717 
  def createTransaction(self, transaction):
718 
    """
719 
    Parameters:
720 
     - transaction
721 
    """
722 
    self.send_createTransaction(transaction)
132 ashish 723 
    return self.recv_createTransaction()
94 ashish 724 
 
725 
  def send_createTransaction(self, transaction):
726 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
727 
    args = createTransaction_args()
728 
    args.transaction = transaction
729 
    args.write(self._oprot)
730 
    self._oprot.writeMessageEnd()
731 
    self._oprot.trans.flush()
732 
 
733 
  def recv_createTransaction(self, ):
734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
735 
    if mtype == TMessageType.EXCEPTION:
736 
      x = TApplicationException()
737 
      x.read(self._iprot)
738 
      self._iprot.readMessageEnd()
739 
      raise x
740 
    result = createTransaction_result()
741 
    result.read(self._iprot)
742 
    self._iprot.readMessageEnd()
3431 rajveer 743 
    if result.success is not None:
132 ashish 744 
      return result.success
3431 rajveer 745 
    if result.ex is not None:
94 ashish 746 
      raise result.ex
132 ashish 747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 748 
 
749 
  def getTransaction(self, id):
750 
    """
751 
    Parameters:
752 
     - id
753 
    """
754 
    self.send_getTransaction(id)
755 
    return self.recv_getTransaction()
756 
 
757 
  def send_getTransaction(self, id):
758 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
759 
    args = getTransaction_args()
760 
    args.id = id
761 
    args.write(self._oprot)
762 
    self._oprot.writeMessageEnd()
763 
    self._oprot.trans.flush()
764 
 
765 
  def recv_getTransaction(self, ):
766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
767 
    if mtype == TMessageType.EXCEPTION:
768 
      x = TApplicationException()
769 
      x.read(self._iprot)
770 
      self._iprot.readMessageEnd()
771 
      raise x
772 
    result = getTransaction_result()
773 
    result.read(self._iprot)
774 
    self._iprot.readMessageEnd()
3431 rajveer 775 
    if result.success is not None:
94 ashish 776 
      return result.success
3431 rajveer 777 
    if result.ex is not None:
94 ashish 778 
      raise result.ex
779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
780 
 
781 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
782 
    """
783 
    Parameters:
784 
     - customerId
785 
     - from_date
786 
     - to_date
787 
     - status
788 
    """
789 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
790 
    return self.recv_getTransactionsForCustomer()
791 
 
792 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
793 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
794 
    args = getTransactionsForCustomer_args()
795 
    args.customerId = customerId
796 
    args.from_date = from_date
797 
    args.to_date = to_date
798 
    args.status = status
799 
    args.write(self._oprot)
800 
    self._oprot.writeMessageEnd()
801 
    self._oprot.trans.flush()
802 
 
803 
  def recv_getTransactionsForCustomer(self, ):
804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
805 
    if mtype == TMessageType.EXCEPTION:
806 
      x = TApplicationException()
807 
      x.read(self._iprot)
808 
      self._iprot.readMessageEnd()
809 
      raise x
810 
    result = getTransactionsForCustomer_result()
811 
    result.read(self._iprot)
812 
    self._iprot.readMessageEnd()
3431 rajveer 813 
    if result.success is not None:
94 ashish 814 
      return result.success
3431 rajveer 815 
    if result.ex is not None:
94 ashish 816 
      raise result.ex
817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
818 
 
132 ashish 819 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
820 
    """
821 
    Parameters:
822 
     - shoppingCartId
823 
    """
824 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
825 
    return self.recv_getTransactionsForShoppingCartId()
826 
 
827 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
828 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
829 
    args = getTransactionsForShoppingCartId_args()
830 
    args.shoppingCartId = shoppingCartId
831 
    args.write(self._oprot)
832 
    self._oprot.writeMessageEnd()
833 
    self._oprot.trans.flush()
834 
 
835 
  def recv_getTransactionsForShoppingCartId(self, ):
836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
837 
    if mtype == TMessageType.EXCEPTION:
838 
      x = TApplicationException()
839 
      x.read(self._iprot)
840 
      self._iprot.readMessageEnd()
841 
      raise x
842 
    result = getTransactionsForShoppingCartId_result()
843 
    result.read(self._iprot)
844 
    self._iprot.readMessageEnd()
3431 rajveer 845 
    if result.success is not None:
132 ashish 846 
      return result.success
3431 rajveer 847 
    if result.ex is not None:
132 ashish 848 
      raise result.ex
849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
850 
 
94 ashish 851 
  def getTransactionStatus(self, transactionId):
852 
    """
853 
    Parameters:
854 
     - transactionId
855 
    """
856 
    self.send_getTransactionStatus(transactionId)
857 
    return self.recv_getTransactionStatus()
858 
 
859 
  def send_getTransactionStatus(self, transactionId):
860 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
861 
    args = getTransactionStatus_args()
862 
    args.transactionId = transactionId
863 
    args.write(self._oprot)
864 
    self._oprot.writeMessageEnd()
865 
    self._oprot.trans.flush()
866 
 
867 
  def recv_getTransactionStatus(self, ):
868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
869 
    if mtype == TMessageType.EXCEPTION:
870 
      x = TApplicationException()
871 
      x.read(self._iprot)
872 
      self._iprot.readMessageEnd()
873 
      raise x
874 
    result = getTransactionStatus_result()
875 
    result.read(self._iprot)
876 
    self._iprot.readMessageEnd()
3431 rajveer 877 
    if result.success is not None:
94 ashish 878 
      return result.success
3431 rajveer 879 
    if result.ex is not None:
94 ashish 880 
      raise result.ex
881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
882 
 
883 
  def changeTransactionStatus(self, transactionId, status, description):
884 
    """
885 
    Parameters:
886 
     - transactionId
887 
     - status
888 
     - description
889 
    """
890 
    self.send_changeTransactionStatus(transactionId, status, description)
891 
    return self.recv_changeTransactionStatus()
892 
 
893 
  def send_changeTransactionStatus(self, transactionId, status, description):
894 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
895 
    args = changeTransactionStatus_args()
896 
    args.transactionId = transactionId
897 
    args.status = status
898 
    args.description = description
899 
    args.write(self._oprot)
900 
    self._oprot.writeMessageEnd()
901 
    self._oprot.trans.flush()
902 
 
903 
  def recv_changeTransactionStatus(self, ):
904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
905 
    if mtype == TMessageType.EXCEPTION:
906 
      x = TApplicationException()
907 
      x.read(self._iprot)
908 
      self._iprot.readMessageEnd()
909 
      raise x
910 
    result = changeTransactionStatus_result()
911 
    result.read(self._iprot)
912 
    self._iprot.readMessageEnd()
3431 rajveer 913 
    if result.success is not None:
94 ashish 914 
      return result.success
3431 rajveer 915 
    if result.ex is not None:
94 ashish 916 
      raise result.ex
917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
918 
 
1398 varun.gupt 919 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 920 
    """
921 
    Parameters:
922 
     - transactionId
923 
    """
1398 varun.gupt 924 
    self.send_enqueueTransactionInfoEmail(transactionId)
925 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 926 
 
1398 varun.gupt 927 
  def send_enqueueTransactionInfoEmail(self, transactionId):
928 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
929 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 930 
    args.transactionId = transactionId
931 
    args.write(self._oprot)
932 
    self._oprot.writeMessageEnd()
933 
    self._oprot.trans.flush()
934 
 
1398 varun.gupt 935 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
937 
    if mtype == TMessageType.EXCEPTION:
938 
      x = TApplicationException()
939 
      x.read(self._iprot)
940 
      self._iprot.readMessageEnd()
941 
      raise x
1398 varun.gupt 942 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 943 
    result.read(self._iprot)
944 
    self._iprot.readMessageEnd()
3431 rajveer 945 
    if result.success is not None:
1382 varun.gupt 946 
      return result.success
3431 rajveer 947 
    if result.ex is not None:
1382 varun.gupt 948 
      raise result.ex
1398 varun.gupt 949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 950 
 
483 rajveer 951 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 952 
    """
953 
    Parameters:
483 rajveer 954 
     - status
955 
     - from_date
956 
     - to_date
957 
     - warehouse_id
94 ashish 958 
    """
483 rajveer 959 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
960 
    return self.recv_getAllOrders()
94 ashish 961 
 
483 rajveer 962 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
963 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
964 
    args = getAllOrders_args()
965 
    args.status = status
966 
    args.from_date = from_date
967 
    args.to_date = to_date
968 
    args.warehouse_id = warehouse_id
94 ashish 969 
    args.write(self._oprot)
970 
    self._oprot.writeMessageEnd()
971 
    self._oprot.trans.flush()
972 
 
483 rajveer 973 
  def recv_getAllOrders(self, ):
94 ashish 974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
975 
    if mtype == TMessageType.EXCEPTION:
976 
      x = TApplicationException()
977 
      x.read(self._iprot)
978 
      self._iprot.readMessageEnd()
979 
      raise x
483 rajveer 980 
    result = getAllOrders_result()
94 ashish 981 
    result.read(self._iprot)
982 
    self._iprot.readMessageEnd()
3431 rajveer 983 
    if result.success is not None:
94 ashish 984 
      return result.success
3431 rajveer 985 
    if result.ex is not None:
94 ashish 986 
      raise result.ex
483 rajveer 987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 988 
 
4133 chandransh 989 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
990 
    """
991 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
992 
    Pass the status as null and the limit as 0 to ignore them.
993 
 
994 
    Parameters:
995 
     - statuses
996 
     - offset
997 
     - limit
998 
     - warehouse_id
999 
    """
1000 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1001 
    return self.recv_getOrdersInBatch()
1002 
 
1003 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1004 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1005 
    args = getOrdersInBatch_args()
1006 
    args.statuses = statuses
1007 
    args.offset = offset
1008 
    args.limit = limit
1009 
    args.warehouse_id = warehouse_id
1010 
    args.write(self._oprot)
1011 
    self._oprot.writeMessageEnd()
1012 
    self._oprot.trans.flush()
1013 
 
1014 
  def recv_getOrdersInBatch(self, ):
1015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1016 
    if mtype == TMessageType.EXCEPTION:
1017 
      x = TApplicationException()
1018 
      x.read(self._iprot)
1019 
      self._iprot.readMessageEnd()
1020 
      raise x
1021 
    result = getOrdersInBatch_result()
1022 
    result.read(self._iprot)
1023 
    self._iprot.readMessageEnd()
1024 
    if result.success is not None:
1025 
      return result.success
1026 
    if result.ex is not None:
1027 
      raise result.ex
1028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1029 
 
1030 
  def getOrderCount(self, statuses, warehouseId):
1031 
    """
1032 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1033 
 
1034 
    Parameters:
1035 
     - statuses
1036 
     - warehouseId
1037 
    """
1038 
    self.send_getOrderCount(statuses, warehouseId)
1039 
    return self.recv_getOrderCount()
1040 
 
1041 
  def send_getOrderCount(self, statuses, warehouseId):
1042 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1043 
    args = getOrderCount_args()
1044 
    args.statuses = statuses
1045 
    args.warehouseId = warehouseId
1046 
    args.write(self._oprot)
1047 
    self._oprot.writeMessageEnd()
1048 
    self._oprot.trans.flush()
1049 
 
1050 
  def recv_getOrderCount(self, ):
1051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1052 
    if mtype == TMessageType.EXCEPTION:
1053 
      x = TApplicationException()
1054 
      x.read(self._iprot)
1055 
      self._iprot.readMessageEnd()
1056 
      raise x
1057 
    result = getOrderCount_result()
1058 
    result.read(self._iprot)
1059 
    self._iprot.readMessageEnd()
1060 
    if result.success is not None:
1061 
      return result.success
1062 
    if result.ex is not None:
1063 
      raise result.ex
1064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1065 
 
999 varun.gupt 1066 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1067 
    """
1132 chandransh 1068 
    Returns orders within a range of their billing dates
3431 rajveer 1069 
 
999 varun.gupt 1070 
    Parameters:
1071 
     - status
1072 
     - start_billing_date
1073 
     - end_billing_date
1074 
     - warehouse_id
1075 
    """
1076 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1077 
    return self.recv_getOrdersByBillingDate()
1078 
 
1079 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1080 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1081 
    args = getOrdersByBillingDate_args()
1082 
    args.status = status
1083 
    args.start_billing_date = start_billing_date
1084 
    args.end_billing_date = end_billing_date
1085 
    args.warehouse_id = warehouse_id
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_getOrdersByBillingDate(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = getOrdersByBillingDate_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
3431 rajveer 1100 
    if result.success is not None:
999 varun.gupt 1101 
      return result.success
3431 rajveer 1102 
    if result.ex is not None:
999 varun.gupt 1103 
      raise result.ex
1104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1105 
 
3451 chandransh 1106 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1107 
    """
1108 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1109 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1110 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1111 
 
3427 chandransh 1112 
    Parameters:
1113 
     - fromShippingDate
1114 
     - toShippingDate
1115 
     - providerId
1116 
     - warehouseId
3451 chandransh 1117 
     - cod
3427 chandransh 1118 
    """
3451 chandransh 1119 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1120 
    return self.recv_getOrdersByShippingDate()
1121 
 
3451 chandransh 1122 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1123 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1124 
    args = getOrdersByShippingDate_args()
1125 
    args.fromShippingDate = fromShippingDate
1126 
    args.toShippingDate = toShippingDate
1127 
    args.providerId = providerId
1128 
    args.warehouseId = warehouseId
3451 chandransh 1129 
    args.cod = cod
3427 chandransh 1130 
    args.write(self._oprot)
1131 
    self._oprot.writeMessageEnd()
1132 
    self._oprot.trans.flush()
1133 
 
1134 
  def recv_getOrdersByShippingDate(self, ):
1135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1136 
    if mtype == TMessageType.EXCEPTION:
1137 
      x = TApplicationException()
1138 
      x.read(self._iprot)
1139 
      self._iprot.readMessageEnd()
1140 
      raise x
1141 
    result = getOrdersByShippingDate_result()
1142 
    result.read(self._iprot)
1143 
    self._iprot.readMessageEnd()
3431 rajveer 1144 
    if result.success is not None:
3427 chandransh 1145 
      return result.success
3431 rajveer 1146 
    if result.ex is not None:
3427 chandransh 1147 
      raise result.ex
1148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1149 
 
1382 varun.gupt 1150 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1151 
    """
1152 
    Returns order ids for orders which can be returned
3431 rajveer 1153 
 
1382 varun.gupt 1154 
    Parameters:
1155 
     - customer_id
1156 
     - limit
1157 
    """
1158 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1159 
    return self.recv_getReturnableOrdersForCustomer()
1160 
 
1161 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1162 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1163 
    args = getReturnableOrdersForCustomer_args()
1164 
    args.customer_id = customer_id
1165 
    args.limit = limit
1166 
    args.write(self._oprot)
1167 
    self._oprot.writeMessageEnd()
1168 
    self._oprot.trans.flush()
1169 
 
1170 
  def recv_getReturnableOrdersForCustomer(self, ):
1171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1172 
    if mtype == TMessageType.EXCEPTION:
1173 
      x = TApplicationException()
1174 
      x.read(self._iprot)
1175 
      self._iprot.readMessageEnd()
1176 
      raise x
1177 
    result = getReturnableOrdersForCustomer_result()
1178 
    result.read(self._iprot)
1179 
    self._iprot.readMessageEnd()
3431 rajveer 1180 
    if result.success is not None:
1382 varun.gupt 1181 
      return result.success
3431 rajveer 1182 
    if result.ex is not None:
1382 varun.gupt 1183 
      raise result.ex
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1185 
 
1186 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1187 
    """
1188 
    Returns order ids for orders which can be cancelled
3431 rajveer 1189 
 
1382 varun.gupt 1190 
    Parameters:
1191 
     - customer_id
1192 
     - limit
1193 
    """
1194 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1195 
    return self.recv_getCancellableOrdersForCustomer()
1196 
 
1197 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1198 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1199 
    args = getCancellableOrdersForCustomer_args()
1200 
    args.customer_id = customer_id
1201 
    args.limit = limit
1202 
    args.write(self._oprot)
1203 
    self._oprot.writeMessageEnd()
1204 
    self._oprot.trans.flush()
1205 
 
1206 
  def recv_getCancellableOrdersForCustomer(self, ):
1207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1208 
    if mtype == TMessageType.EXCEPTION:
1209 
      x = TApplicationException()
1210 
      x.read(self._iprot)
1211 
      self._iprot.readMessageEnd()
1212 
      raise x
1213 
    result = getCancellableOrdersForCustomer_result()
1214 
    result.read(self._iprot)
1215 
    self._iprot.readMessageEnd()
3431 rajveer 1216 
    if result.success is not None:
1382 varun.gupt 1217 
      return result.success
3431 rajveer 1218 
    if result.ex is not None:
1382 varun.gupt 1219 
      raise result.ex
1220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1221 
 
483 rajveer 1222 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1223 
    """
1224 
    Parameters:
483 rajveer 1225 
     - orderId
1226 
     - status
1227 
     - description
94 ashish 1228 
    """
483 rajveer 1229 
    self.send_changeOrderStatus(orderId, status, description)
1230 
    return self.recv_changeOrderStatus()
94 ashish 1231 
 
483 rajveer 1232 
  def send_changeOrderStatus(self, orderId, status, description):
1233 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1234 
    args = changeOrderStatus_args()
1235 
    args.orderId = orderId
1236 
    args.status = status
1237 
    args.description = description
94 ashish 1238 
    args.write(self._oprot)
1239 
    self._oprot.writeMessageEnd()
1240 
    self._oprot.trans.flush()
1241 
 
483 rajveer 1242 
  def recv_changeOrderStatus(self, ):
94 ashish 1243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1244 
    if mtype == TMessageType.EXCEPTION:
1245 
      x = TApplicationException()
1246 
      x.read(self._iprot)
1247 
      self._iprot.readMessageEnd()
1248 
      raise x
483 rajveer 1249 
    result = changeOrderStatus_result()
94 ashish 1250 
    result.read(self._iprot)
1251 
    self._iprot.readMessageEnd()
3431 rajveer 1252 
    if result.success is not None:
94 ashish 1253 
      return result.success
3431 rajveer 1254 
    if result.ex is not None:
94 ashish 1255 
      raise result.ex
483 rajveer 1256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1257 
 
1528 ankur.sing 1258 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1259 
    """
1528 ankur.sing 1260 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1261 
    only user who owns the transaction can view its order details.
3431 rajveer 1262 
 
94 ashish 1263 
    Parameters:
1264 
     - transactionId
1528 ankur.sing 1265 
     - customerId
94 ashish 1266 
    """
1528 ankur.sing 1267 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1268 
    return self.recv_getOrdersForTransaction()
94 ashish 1269 
 
1528 ankur.sing 1270 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1271 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1272 
    args = getOrdersForTransaction_args()
94 ashish 1273 
    args.transactionId = transactionId
1528 ankur.sing 1274 
    args.customerId = customerId
94 ashish 1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
483 rajveer 1279 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
483 rajveer 1286 
    result = getOrdersForTransaction_result()
94 ashish 1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
3431 rajveer 1289 
    if result.success is not None:
94 ashish 1290 
      return result.success
3431 rajveer 1291 
    if result.ex is not None:
94 ashish 1292 
      raise result.ex
483 rajveer 1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1294 
 
3014 chandransh 1295 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1296 
    """
3014 chandransh 1297 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1298 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1299 
 
94 ashish 1300 
    Parameters:
483 rajveer 1301 
     - customerId
1302 
     - from_date
1303 
     - to_date
3014 chandransh 1304 
     - statuses
94 ashish 1305 
    """
3014 chandransh 1306 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1307 
    return self.recv_getOrdersForCustomer()
94 ashish 1308 
 
3014 chandransh 1309 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1310 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1311 
    args = getOrdersForCustomer_args()
1312 
    args.customerId = customerId
1313 
    args.from_date = from_date
1314 
    args.to_date = to_date
3014 chandransh 1315 
    args.statuses = statuses
94 ashish 1316 
    args.write(self._oprot)
1317 
    self._oprot.writeMessageEnd()
1318 
    self._oprot.trans.flush()
1319 
 
483 rajveer 1320 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1322 
    if mtype == TMessageType.EXCEPTION:
1323 
      x = TApplicationException()
1324 
      x.read(self._iprot)
1325 
      self._iprot.readMessageEnd()
1326 
      raise x
483 rajveer 1327 
    result = getOrdersForCustomer_result()
94 ashish 1328 
    result.read(self._iprot)
1329 
    self._iprot.readMessageEnd()
3431 rajveer 1330 
    if result.success is not None:
94 ashish 1331 
      return result.success
3431 rajveer 1332 
    if result.ex is not None:
94 ashish 1333 
      raise result.ex
483 rajveer 1334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1335 
 
483 rajveer 1336 
  def createOrder(self, order):
94 ashish 1337 
    """
1338 
    Parameters:
483 rajveer 1339 
     - order
94 ashish 1340 
    """
483 rajveer 1341 
    self.send_createOrder(order)
1342 
    return self.recv_createOrder()
94 ashish 1343 
 
483 rajveer 1344 
  def send_createOrder(self, order):
1345 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1346 
    args = createOrder_args()
1347 
    args.order = order
94 ashish 1348 
    args.write(self._oprot)
1349 
    self._oprot.writeMessageEnd()
1350 
    self._oprot.trans.flush()
1351 
 
483 rajveer 1352 
  def recv_createOrder(self, ):
94 ashish 1353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1354 
    if mtype == TMessageType.EXCEPTION:
1355 
      x = TApplicationException()
1356 
      x.read(self._iprot)
1357 
      self._iprot.readMessageEnd()
1358 
      raise x
483 rajveer 1359 
    result = createOrder_result()
94 ashish 1360 
    result.read(self._iprot)
1361 
    self._iprot.readMessageEnd()
3431 rajveer 1362 
    if result.success is not None:
94 ashish 1363 
      return result.success
3431 rajveer 1364 
    if result.ex is not None:
94 ashish 1365 
      raise result.ex
483 rajveer 1366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1367 
 
483 rajveer 1368 
  def getOrder(self, id):
94 ashish 1369 
    """
1370 
    Parameters:
483 rajveer 1371 
     - id
94 ashish 1372 
    """
483 rajveer 1373 
    self.send_getOrder(id)
1374 
    return self.recv_getOrder()
94 ashish 1375 
 
483 rajveer 1376 
  def send_getOrder(self, id):
1377 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1378 
    args = getOrder_args()
1379 
    args.id = id
94 ashish 1380 
    args.write(self._oprot)
1381 
    self._oprot.writeMessageEnd()
1382 
    self._oprot.trans.flush()
1383 
 
483 rajveer 1384 
  def recv_getOrder(self, ):
94 ashish 1385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1386 
    if mtype == TMessageType.EXCEPTION:
1387 
      x = TApplicationException()
1388 
      x.read(self._iprot)
1389 
      self._iprot.readMessageEnd()
1390 
      raise x
483 rajveer 1391 
    result = getOrder_result()
94 ashish 1392 
    result.read(self._iprot)
1393 
    self._iprot.readMessageEnd()
3431 rajveer 1394 
    if result.success is not None:
94 ashish 1395 
      return result.success
3431 rajveer 1396 
    if result.ex is not None:
94 ashish 1397 
      raise result.ex
483 rajveer 1398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1399 
 
483 rajveer 1400 
  def getLineItemsForOrder(self, orderId):
94 ashish 1401 
    """
1402 
    Parameters:
483 rajveer 1403 
     - orderId
94 ashish 1404 
    """
483 rajveer 1405 
    self.send_getLineItemsForOrder(orderId)
1406 
    return self.recv_getLineItemsForOrder()
94 ashish 1407 
 
483 rajveer 1408 
  def send_getLineItemsForOrder(self, orderId):
1409 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1410 
    args = getLineItemsForOrder_args()
1411 
    args.orderId = orderId
94 ashish 1412 
    args.write(self._oprot)
1413 
    self._oprot.writeMessageEnd()
1414 
    self._oprot.trans.flush()
1415 
 
483 rajveer 1416 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1418 
    if mtype == TMessageType.EXCEPTION:
1419 
      x = TApplicationException()
1420 
      x.read(self._iprot)
1421 
      self._iprot.readMessageEnd()
1422 
      raise x
483 rajveer 1423 
    result = getLineItemsForOrder_result()
94 ashish 1424 
    result.read(self._iprot)
1425 
    self._iprot.readMessageEnd()
3431 rajveer 1426 
    if result.success is not None:
94 ashish 1427 
      return result.success
3431 rajveer 1428 
    if result.ex is not None:
94 ashish 1429 
      raise result.ex
483 rajveer 1430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1431 
 
1528 ankur.sing 1432 
  def getOrderForCustomer(self, orderId, customerId):
1433 
    """
1434 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1435 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1436 
 
1528 ankur.sing 1437 
    Parameters:
1438 
     - orderId
1439 
     - customerId
1440 
    """
1441 
    self.send_getOrderForCustomer(orderId, customerId)
1442 
    return self.recv_getOrderForCustomer()
1443 
 
1444 
  def send_getOrderForCustomer(self, orderId, customerId):
1445 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1446 
    args = getOrderForCustomer_args()
1447 
    args.orderId = orderId
1448 
    args.customerId = customerId
1449 
    args.write(self._oprot)
1450 
    self._oprot.writeMessageEnd()
1451 
    self._oprot.trans.flush()
1452 
 
1453 
  def recv_getOrderForCustomer(self, ):
1454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1455 
    if mtype == TMessageType.EXCEPTION:
1456 
      x = TApplicationException()
1457 
      x.read(self._iprot)
1458 
      self._iprot.readMessageEnd()
1459 
      raise x
1460 
    result = getOrderForCustomer_result()
1461 
    result.read(self._iprot)
1462 
    self._iprot.readMessageEnd()
3431 rajveer 1463 
    if result.success is not None:
1528 ankur.sing 1464 
      return result.success
3431 rajveer 1465 
    if result.ex is not None:
1528 ankur.sing 1466 
      raise result.ex
1467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1468 
 
3064 chandransh 1469 
  def getAlerts(self, orderId, valid):
1470 
    """
1471 
    Parameters:
1472 
     - orderId
1473 
     - valid
1474 
    """
1475 
    self.send_getAlerts(orderId, valid)
1476 
    return self.recv_getAlerts()
1477 
 
1478 
  def send_getAlerts(self, orderId, valid):
1479 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1480 
    args = getAlerts_args()
1481 
    args.orderId = orderId
1482 
    args.valid = valid
1483 
    args.write(self._oprot)
1484 
    self._oprot.writeMessageEnd()
1485 
    self._oprot.trans.flush()
1486 
 
1487 
  def recv_getAlerts(self, ):
1488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1489 
    if mtype == TMessageType.EXCEPTION:
1490 
      x = TApplicationException()
1491 
      x.read(self._iprot)
1492 
      self._iprot.readMessageEnd()
1493 
      raise x
1494 
    result = getAlerts_result()
1495 
    result.read(self._iprot)
1496 
    self._iprot.readMessageEnd()
3431 rajveer 1497 
    if result.success is not None:
3064 chandransh 1498 
      return result.success
1499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1500 
 
1501 
  def setAlert(self, orderId, unset, type, comment):
1502 
    """
1503 
    Parameters:
1504 
     - orderId
1505 
     - unset
1506 
     - type
1507 
     - comment
1508 
    """
1509 
    self.send_setAlert(orderId, unset, type, comment)
1510 
    self.recv_setAlert()
1511 
 
1512 
  def send_setAlert(self, orderId, unset, type, comment):
1513 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1514 
    args = setAlert_args()
1515 
    args.orderId = orderId
1516 
    args.unset = unset
1517 
    args.type = type
1518 
    args.comment = comment
1519 
    args.write(self._oprot)
1520 
    self._oprot.writeMessageEnd()
1521 
    self._oprot.trans.flush()
1522 
 
1523 
  def recv_setAlert(self, ):
1524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1525 
    if mtype == TMessageType.EXCEPTION:
1526 
      x = TApplicationException()
1527 
      x.read(self._iprot)
1528 
      self._iprot.readMessageEnd()
1529 
      raise x
1530 
    result = setAlert_result()
1531 
    result.read(self._iprot)
1532 
    self._iprot.readMessageEnd()
1533 
    return
1534 
 
1535 
  def getValidOrderCount(self, ):
1536 
    """
1537 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1538 
    """
1539 
    self.send_getValidOrderCount()
1540 
    return self.recv_getValidOrderCount()
1541 
 
1542 
  def send_getValidOrderCount(self, ):
1543 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1544 
    args = getValidOrderCount_args()
1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_getValidOrderCount(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = getValidOrderCount_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
3431 rajveer 1559 
    if result.success is not None:
3064 chandransh 1560 
      return result.success
1561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1562 
 
1563 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1564 
    """
1565 
    Returns the number of distinct customers who have done successful transactions
1566 
    """
1567 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1568 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1569 
 
1570 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1571 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1572 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
1577 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1579 
    if mtype == TMessageType.EXCEPTION:
1580 
      x = TApplicationException()
1581 
      x.read(self._iprot)
1582 
      self._iprot.readMessageEnd()
1583 
      raise x
1584 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
3431 rajveer 1587 
    if result.success is not None:
3064 chandransh 1588 
      return result.success
1589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1590 
 
1591 
  def getValidOrdersAmountRange(self, ):
1592 
    """
1593 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1594 
    List contains two values, first minimum amount and second maximum amount.
1595 
    """
1596 
    self.send_getValidOrdersAmountRange()
1597 
    return self.recv_getValidOrdersAmountRange()
1598 
 
1599 
  def send_getValidOrdersAmountRange(self, ):
1600 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1601 
    args = getValidOrdersAmountRange_args()
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getValidOrdersAmountRange(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getValidOrdersAmountRange_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
3064 chandransh 1617 
      return result.success
1618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1619 
 
1620 
  def getValidOrders(self, limit):
1621 
    """
1622 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1623 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1624 
 
3064 chandransh 1625 
    Parameters:
1626 
     - limit
1627 
    """
1628 
    self.send_getValidOrders(limit)
1629 
    return self.recv_getValidOrders()
1630 
 
1631 
  def send_getValidOrders(self, limit):
1632 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1633 
    args = getValidOrders_args()
1634 
    args.limit = limit
1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_getValidOrders(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = getValidOrders_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
3431 rajveer 1649 
    if result.success is not None:
3064 chandransh 1650 
      return result.success
1651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1652 
 
1220 chandransh 1653 
  def batchOrders(self, warehouseId):
1654 
    """
1655 
    Create a batch of all the pending orders for the given warehouse.
1656 
    The returned list is orderd by created_timestamp.
1657 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1658 
 
1220 chandransh 1659 
    Parameters:
1660 
     - warehouseId
1661 
    """
1662 
    self.send_batchOrders(warehouseId)
1663 
    return self.recv_batchOrders()
1664 
 
1665 
  def send_batchOrders(self, warehouseId):
1666 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1667 
    args = batchOrders_args()
1668 
    args.warehouseId = warehouseId
1669 
    args.write(self._oprot)
1670 
    self._oprot.writeMessageEnd()
1671 
    self._oprot.trans.flush()
1672 
 
1673 
  def recv_batchOrders(self, ):
1674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1675 
    if mtype == TMessageType.EXCEPTION:
1676 
      x = TApplicationException()
1677 
      x.read(self._iprot)
1678 
      self._iprot.readMessageEnd()
1679 
      raise x
1680 
    result = batchOrders_result()
1681 
    result.read(self._iprot)
1682 
    self._iprot.readMessageEnd()
3431 rajveer 1683 
    if result.success is not None:
1220 chandransh 1684 
      return result.success
3431 rajveer 1685 
    if result.ex is not None:
1220 chandransh 1686 
      raise result.ex
1687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1688 
 
1208 chandransh 1689 
  def markOrderAsOutOfStock(self, orderId):
1690 
    """
1691 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1692 
 
1208 chandransh 1693 
    Parameters:
1694 
     - orderId
1695 
    """
1696 
    self.send_markOrderAsOutOfStock(orderId)
1697 
    return self.recv_markOrderAsOutOfStock()
1698 
 
1699 
  def send_markOrderAsOutOfStock(self, orderId):
1700 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1701 
    args = markOrderAsOutOfStock_args()
1702 
    args.orderId = orderId
1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_markOrderAsOutOfStock(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = markOrderAsOutOfStock_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
3431 rajveer 1717 
    if result.success is not None:
1208 chandransh 1718 
      return result.success
3431 rajveer 1719 
    if result.ex is not None:
1208 chandransh 1720 
      raise result.ex
1721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1722 
 
3064 chandransh 1723 
  def verifyOrder(self, orderId):
759 chandransh 1724 
    """
3064 chandransh 1725 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1726 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1727 
    used for all other orders as well.
1728 
    Throws an exception if no such order exists.
3431 rajveer 1729 
 
759 chandransh 1730 
    Parameters:
3064 chandransh 1731 
     - orderId
759 chandransh 1732 
    """
3064 chandransh 1733 
    self.send_verifyOrder(orderId)
1734 
    return self.recv_verifyOrder()
759 chandransh 1735 
 
3064 chandransh 1736 
  def send_verifyOrder(self, orderId):
1737 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1738 
    args = verifyOrder_args()
1739 
    args.orderId = orderId
759 chandransh 1740 
    args.write(self._oprot)
1741 
    self._oprot.writeMessageEnd()
1742 
    self._oprot.trans.flush()
1743 
 
3064 chandransh 1744 
  def recv_verifyOrder(self, ):
759 chandransh 1745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1746 
    if mtype == TMessageType.EXCEPTION:
1747 
      x = TApplicationException()
1748 
      x.read(self._iprot)
1749 
      self._iprot.readMessageEnd()
1750 
      raise x
3064 chandransh 1751 
    result = verifyOrder_result()
759 chandransh 1752 
    result.read(self._iprot)
1753 
    self._iprot.readMessageEnd()
3431 rajveer 1754 
    if result.success is not None:
759 chandransh 1755 
      return result.success
3431 rajveer 1756 
    if result.ex is not None:
759 chandransh 1757 
      raise result.ex
3064 chandransh 1758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1759 
 
3064 chandransh 1760 
  def acceptOrder(self, orderId):
1113 chandransh 1761 
    """
3064 chandransh 1762 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1763 
    given order is not a COD order, it also captures the payment if the same has
1764 
    not been captured.
1765 
    Throws an exception if no such order exists.
3431 rajveer 1766 
 
1113 chandransh 1767 
    Parameters:
3064 chandransh 1768 
     - orderId
1113 chandransh 1769 
    """
3064 chandransh 1770 
    self.send_acceptOrder(orderId)
1771 
    return self.recv_acceptOrder()
1113 chandransh 1772 
 
3064 chandransh 1773 
  def send_acceptOrder(self, orderId):
1774 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1775 
    args = acceptOrder_args()
1776 
    args.orderId = orderId
1113 chandransh 1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
3064 chandransh 1781 
  def recv_acceptOrder(self, ):
1113 chandransh 1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
3064 chandransh 1788 
    result = acceptOrder_result()
1113 chandransh 1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
1113 chandransh 1792 
      return result.success
3431 rajveer 1793 
    if result.ex is not None:
1113 chandransh 1794 
      raise result.ex
3064 chandransh 1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1796 
 
4283 anupam.sin 1797 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1798 
    """
3064 chandransh 1799 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1800 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1801 
    the IMEI no. if a -1 is supplied.
1802 
    Also, it generates an invoice number for the order, marks the order as
1803 
    BILLED and sets the billing timestamp.
1804 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1805 
 
1135 chandransh 1806 
    Parameters:
3064 chandransh 1807 
     - orderId
1808 
     - invoice_number
4283 anupam.sin 1809 
     - imeiNumber
1810 
     - itemNumber
3064 chandransh 1811 
     - billed_by
4264 rajveer 1812 
     - jacketNumber
4283 anupam.sin 1813 
     - billingType
1814 
     - vendorId
1135 chandransh 1815 
    """
4283 anupam.sin 1816 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1817 
    return self.recv_addBillingDetails()
1135 chandransh 1818 
 
4283 anupam.sin 1819 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1820 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1821 
    args = addBillingDetails_args()
1822 
    args.orderId = orderId
1823 
    args.invoice_number = invoice_number
4283 anupam.sin 1824 
    args.imeiNumber = imeiNumber
1825 
    args.itemNumber = itemNumber
3064 chandransh 1826 
    args.billed_by = billed_by
4264 rajveer 1827 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1828 
    args.billingType = billingType
1829 
    args.vendorId = vendorId
1135 chandransh 1830 
    args.write(self._oprot)
1831 
    self._oprot.writeMessageEnd()
1832 
    self._oprot.trans.flush()
1833 
 
3064 chandransh 1834 
  def recv_addBillingDetails(self, ):
1135 chandransh 1835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1836 
    if mtype == TMessageType.EXCEPTION:
1837 
      x = TApplicationException()
1838 
      x.read(self._iprot)
1839 
      self._iprot.readMessageEnd()
1840 
      raise x
3064 chandransh 1841 
    result = addBillingDetails_result()
1135 chandransh 1842 
    result.read(self._iprot)
1843 
    self._iprot.readMessageEnd()
3431 rajveer 1844 
    if result.success is not None:
3064 chandransh 1845 
      return result.success
3431 rajveer 1846 
    if result.ex is not None:
1135 chandransh 1847 
      raise result.ex
3064 chandransh 1848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1849 
 
3064 chandransh 1850 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1851 
    """
3064 chandransh 1852 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1853 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1854 
 
1408 ankur.sing 1855 
    Parameters:
3064 chandransh 1856 
     - warehouseId
1408 ankur.sing 1857 
     - providerId
3064 chandransh 1858 
     - cod
1408 ankur.sing 1859 
    """
3064 chandransh 1860 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1861 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1862 
 
3064 chandransh 1863 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1864 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1865 
    args = markOrdersAsManifested_args()
1866 
    args.warehouseId = warehouseId
1408 ankur.sing 1867 
    args.providerId = providerId
3064 chandransh 1868 
    args.cod = cod
1408 ankur.sing 1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
3064 chandransh 1873 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
3064 chandransh 1880 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
3431 rajveer 1883 
    if result.success is not None:
1408 ankur.sing 1884 
      return result.success
3431 rajveer 1885 
    if result.ex is not None:
3064 chandransh 1886 
      raise result.ex
1887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1888 
 
3064 chandransh 1889 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1890 
    """
3064 chandransh 1891 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1892 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1893 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1894 
 
94 ashish 1895 
    Parameters:
3064 chandransh 1896 
     - providerId
1897 
     - pickupDetails
304 ashish 1898 
    """
3064 chandransh 1899 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1900 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1901 
 
3064 chandransh 1902 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1903 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1904 
    args = markOrdersAsPickedUp_args()
1905 
    args.providerId = providerId
1906 
    args.pickupDetails = pickupDetails
304 ashish 1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
3064 chandransh 1911 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
3064 chandransh 1918 
    result = markOrdersAsPickedUp_result()
304 ashish 1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
3431 rajveer 1921 
    if result.success is not None:
304 ashish 1922 
      return result.success
3431 rajveer 1923 
    if result.ex is not None:
3064 chandransh 1924 
      raise result.ex
1925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1926 
 
3064 chandransh 1927 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1928 
    """
3064 chandransh 1929 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1930 
    the name of the receiver.
1931 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1932 
 
304 ashish 1933 
    Parameters:
3064 chandransh 1934 
     - providerId
1935 
     - deliveredOrders
304 ashish 1936 
    """
3064 chandransh 1937 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1938 
    self.recv_markOrdersAsDelivered()
304 ashish 1939 
 
3064 chandransh 1940 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1941 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1942 
    args = markOrdersAsDelivered_args()
1943 
    args.providerId = providerId
1944 
    args.deliveredOrders = deliveredOrders
304 ashish 1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
3064 chandransh 1949 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
3064 chandransh 1956 
    result = markOrdersAsDelivered_result()
304 ashish 1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.ex is not None:
3064 chandransh 1960 
      raise result.ex
304 ashish 1961 
    return
1962 
 
3064 chandransh 1963 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 1964 
    """
3064 chandransh 1965 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1966 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1967 
 
3064 chandransh 1968 
    Parameters:
1969 
     - providerId
1970 
     - returnedOrders
1596 ankur.sing 1971 
    """
3064 chandransh 1972 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1973 
    self.recv_markOrdersAsFailed()
304 ashish 1974 
 
3064 chandransh 1975 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1976 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1977 
    args = markOrdersAsFailed_args()
1978 
    args.providerId = providerId
1979 
    args.returnedOrders = returnedOrders
1596 ankur.sing 1980 
    args.write(self._oprot)
1981 
    self._oprot.writeMessageEnd()
1982 
    self._oprot.trans.flush()
1983 
 
3064 chandransh 1984 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 1985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1986 
    if mtype == TMessageType.EXCEPTION:
1987 
      x = TApplicationException()
1988 
      x.read(self._iprot)
1989 
      self._iprot.readMessageEnd()
1990 
      raise x
3064 chandransh 1991 
    result = markOrdersAsFailed_result()
1596 ankur.sing 1992 
    result.read(self._iprot)
1993 
    self._iprot.readMessageEnd()
3431 rajveer 1994 
    if result.ex is not None:
3064 chandransh 1995 
      raise result.ex
1996 
    return
1596 ankur.sing 1997 
 
3064 chandransh 1998 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 1999 
    """
3064 chandransh 2000 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2001 
 
3064 chandransh 2002 
    Parameters:
2003 
     - providerId
2004 
     - undeliveredOrders
1627 ankur.sing 2005 
    """
3064 chandransh 2006 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2007 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2008 
 
3064 chandransh 2009 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2010 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2011 
    args = updateNonDeliveryReason_args()
2012 
    args.providerId = providerId
2013 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2014 
    args.write(self._oprot)
2015 
    self._oprot.writeMessageEnd()
2016 
    self._oprot.trans.flush()
2017 
 
3064 chandransh 2018 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2020 
    if mtype == TMessageType.EXCEPTION:
2021 
      x = TApplicationException()
2022 
      x.read(self._iprot)
2023 
      self._iprot.readMessageEnd()
2024 
      raise x
3064 chandransh 2025 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2026 
    result.read(self._iprot)
2027 
    self._iprot.readMessageEnd()
3431 rajveer 2028 
    if result.ex is not None:
3064 chandransh 2029 
      raise result.ex
2030 
    return
1627 ankur.sing 2031 
 
3064 chandransh 2032 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2033 
    """
3064 chandransh 2034 
    Returns the list of orders whose delivery time has passed but have not been
2035 
    delivered yet for the given provider and warehouse. To get a complete list of
2036 
    undelivered orders, pass them as -1.
2037 
    Returns an empty list if no such orders exist.
3431 rajveer 2038 
 
1886 ankur.sing 2039 
    Parameters:
3064 chandransh 2040 
     - providerId
2041 
     - warehouseId
1886 ankur.sing 2042 
    """
3064 chandransh 2043 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2044 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2045 
 
3064 chandransh 2046 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2047 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2048 
    args = getUndeliveredOrders_args()
2049 
    args.providerId = providerId
2050 
    args.warehouseId = warehouseId
1886 ankur.sing 2051 
    args.write(self._oprot)
2052 
    self._oprot.writeMessageEnd()
2053 
    self._oprot.trans.flush()
2054 
 
3064 chandransh 2055 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2057 
    if mtype == TMessageType.EXCEPTION:
2058 
      x = TApplicationException()
2059 
      x.read(self._iprot)
2060 
      self._iprot.readMessageEnd()
2061 
      raise x
3064 chandransh 2062 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2063 
    result.read(self._iprot)
2064 
    self._iprot.readMessageEnd()
3431 rajveer 2065 
    if result.success is not None:
1886 ankur.sing 2066 
      return result.success
3064 chandransh 2067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2068 
 
2536 chandransh 2069 
  def toggleDOAFlag(self, orderId):
2070 
    """
2071 
    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.
2072 
    Returns the final flag status.
2073 
    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 2074 
 
2536 chandransh 2075 
    Parameters:
2076 
     - orderId
2077 
    """
2078 
    self.send_toggleDOAFlag(orderId)
2079 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2080 
 
2536 chandransh 2081 
  def send_toggleDOAFlag(self, orderId):
2082 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2083 
    args = toggleDOAFlag_args()
2084 
    args.orderId = orderId
2085 
    args.write(self._oprot)
2086 
    self._oprot.writeMessageEnd()
2087 
    self._oprot.trans.flush()
2088 
 
2089 
  def recv_toggleDOAFlag(self, ):
2090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2091 
    if mtype == TMessageType.EXCEPTION:
2092 
      x = TApplicationException()
2093 
      x.read(self._iprot)
2094 
      self._iprot.readMessageEnd()
2095 
      raise x
2096 
    result = toggleDOAFlag_result()
2097 
    result.read(self._iprot)
2098 
    self._iprot.readMessageEnd()
3431 rajveer 2099 
    if result.success is not None:
2536 chandransh 2100 
      return result.success
3431 rajveer 2101 
    if result.ex is not None:
2536 chandransh 2102 
      raise result.ex
2103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2104 
 
2105 
  def requestPickupNumber(self, orderId):
2106 
    """
2107 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2108 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2109 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2110 
    For any other status, it returns false.
2111 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2112 
 
2536 chandransh 2113 
    Parameters:
2114 
     - orderId
2115 
    """
2116 
    self.send_requestPickupNumber(orderId)
2117 
    return self.recv_requestPickupNumber()
2118 
 
2119 
  def send_requestPickupNumber(self, orderId):
2120 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2121 
    args = requestPickupNumber_args()
2122 
    args.orderId = orderId
2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
2127 
  def recv_requestPickupNumber(self, ):
2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
2134 
    result = requestPickupNumber_result()
2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
3431 rajveer 2137 
    if result.success is not None:
2536 chandransh 2138 
      return result.success
3431 rajveer 2139 
    if result.ex is not None:
2536 chandransh 2140 
      raise result.ex
2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2142 
 
2143 
  def authorizePickup(self, orderId, pickupNumber):
2144 
    """
2145 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2146 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2147 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2148 
    	3. Returns true
2591 chandransh 2149 
    If the order is in any other status, it returns false.
2536 chandransh 2150 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2151 
 
2536 chandransh 2152 
    Parameters:
2153 
     - orderId
2154 
     - pickupNumber
2155 
    """
2156 
    self.send_authorizePickup(orderId, pickupNumber)
2157 
    return self.recv_authorizePickup()
2158 
 
2159 
  def send_authorizePickup(self, orderId, pickupNumber):
2160 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2161 
    args = authorizePickup_args()
2162 
    args.orderId = orderId
2163 
    args.pickupNumber = pickupNumber
2164 
    args.write(self._oprot)
2165 
    self._oprot.writeMessageEnd()
2166 
    self._oprot.trans.flush()
2167 
 
2168 
  def recv_authorizePickup(self, ):
2169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2170 
    if mtype == TMessageType.EXCEPTION:
2171 
      x = TApplicationException()
2172 
      x.read(self._iprot)
2173 
      self._iprot.readMessageEnd()
2174 
      raise x
2175 
    result = authorizePickup_result()
2176 
    result.read(self._iprot)
2177 
    self._iprot.readMessageEnd()
3431 rajveer 2178 
    if result.success is not None:
2536 chandransh 2179 
      return result.success
3431 rajveer 2180 
    if result.ex is not None:
2536 chandransh 2181 
      raise result.ex
2182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2183 
 
2764 chandransh 2184 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2185 
    """
2186 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2187 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2188 
 
2764 chandransh 2189 
    Parameters:
2190 
     - providerId
2191 
     - pickupDetails
2192 
    """
2193 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2194 
    return self.recv_markDoasAsPickedUp()
2195 
 
2196 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2197 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2198 
    args = markDoasAsPickedUp_args()
2199 
    args.providerId = providerId
2200 
    args.pickupDetails = pickupDetails
2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
2205 
  def recv_markDoasAsPickedUp(self, ):
2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
2212 
    result = markDoasAsPickedUp_result()
2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
3431 rajveer 2215 
    if result.success is not None:
2764 chandransh 2216 
      return result.success
2217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2218 
 
2616 chandransh 2219 
  def receiveReturn(self, orderId):
2591 chandransh 2220 
    """
2599 chandransh 2221 
    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 2222 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2223 
    If the order is in any other state, it returns false.
2224 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2225 
 
2591 chandransh 2226 
    Parameters:
2227 
     - orderId
2228 
    """
2616 chandransh 2229 
    self.send_receiveReturn(orderId)
2230 
    return self.recv_receiveReturn()
2536 chandransh 2231 
 
2616 chandransh 2232 
  def send_receiveReturn(self, orderId):
2233 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2234 
    args = receiveReturn_args()
2591 chandransh 2235 
    args.orderId = orderId
2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
2616 chandransh 2240 
  def recv_receiveReturn(self, ):
2591 chandransh 2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
2616 chandransh 2247 
    result = receiveReturn_result()
2591 chandransh 2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
3431 rajveer 2250 
    if result.success is not None:
2591 chandransh 2251 
      return result.success
3431 rajveer 2252 
    if result.ex is not None:
2591 chandransh 2253 
      raise result.ex
2616 chandransh 2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2255 
 
2256 
  def validateDoa(self, orderId, isValid):
2257 
    """
2599 chandransh 2258 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2259 
    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 2260 
    If the order is in any other state, it returns false.
2261 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2262 
 
2591 chandransh 2263 
    Parameters:
2264 
     - orderId
2265 
     - isValid
2266 
    """
2267 
    self.send_validateDoa(orderId, isValid)
2268 
    return self.recv_validateDoa()
2269 
 
2270 
  def send_validateDoa(self, orderId, isValid):
2271 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2272 
    args = validateDoa_args()
2273 
    args.orderId = orderId
2274 
    args.isValid = isValid
2275 
    args.write(self._oprot)
2276 
    self._oprot.writeMessageEnd()
2277 
    self._oprot.trans.flush()
2278 
 
2279 
  def recv_validateDoa(self, ):
2280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2281 
    if mtype == TMessageType.EXCEPTION:
2282 
      x = TApplicationException()
2283 
      x.read(self._iprot)
2284 
      self._iprot.readMessageEnd()
2285 
      raise x
2286 
    result = validateDoa_result()
2287 
    result.read(self._iprot)
2288 
    self._iprot.readMessageEnd()
3431 rajveer 2289 
    if result.success is not None:
2591 chandransh 2290 
      return result.success
3431 rajveer 2291 
    if result.ex is not None:
2591 chandransh 2292 
      raise result.ex
2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2294 
 
2616 chandransh 2295 
  def reshipOrder(self, orderId):
2296 
    """
2297 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2298 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2299 
    	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.
2300 
 
2301 
    If the order is in DOA_CERT_VALID state, it does the following:
2302 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2303 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2304 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2305 
 
2616 chandransh 2306 
    Returns the id of the newly created order.
3431 rajveer 2307 
 
2616 chandransh 2308 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2309 
 
2616 chandransh 2310 
    Parameters:
2311 
     - orderId
2312 
    """
2313 
    self.send_reshipOrder(orderId)
2314 
    return self.recv_reshipOrder()
2591 chandransh 2315 
 
2616 chandransh 2316 
  def send_reshipOrder(self, orderId):
2317 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2318 
    args = reshipOrder_args()
2319 
    args.orderId = orderId
2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
2324 
  def recv_reshipOrder(self, ):
2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
2331 
    result = reshipOrder_result()
2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
3431 rajveer 2334 
    if result.success is not None:
2616 chandransh 2335 
      return result.success
3431 rajveer 2336 
    if result.ex is not None:
2616 chandransh 2337 
      raise result.ex
2338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2339 
 
3226 chandransh 2340 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2341 
    """
2342 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2343 
    	1. Creates a refund request for batch processing.
2344 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2345 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2346 
 
2616 chandransh 2347 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2348 
    	1. Creates a refund request for batch processing.
3226 chandransh 2349 
    	2. Cancels the reservation of the item in the warehouse.
2350 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2351 
 
3226 chandransh 2352 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2353 
    	1. Cancels the reservation of the item in the warehouse.
2354 
    	2. Marks the current order as CANCELED.
2355 
 
2356 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2357 
 
2616 chandransh 2358 
    Returns True if it is successful, False otherwise.
3431 rajveer 2359 
 
2616 chandransh 2360 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2361 
 
2616 chandransh 2362 
    Parameters:
2363 
     - orderId
3226 chandransh 2364 
     - refundedBy
2365 
     - reason
2616 chandransh 2366 
    """
3226 chandransh 2367 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2368 
    return self.recv_refundOrder()
2369 
 
3226 chandransh 2370 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2371 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2372 
    args = refundOrder_args()
2373 
    args.orderId = orderId
3226 chandransh 2374 
    args.refundedBy = refundedBy
2375 
    args.reason = reason
2616 chandransh 2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_refundOrder(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = refundOrder_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
3431 rajveer 2390 
    if result.success is not None:
2616 chandransh 2391 
      return result.success
3431 rajveer 2392 
    if result.ex is not None:
2616 chandransh 2393 
      raise result.ex
2394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2395 
 
2690 chandransh 2396 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2397 
    """
2398 
    Get all return orders created between the from and to dates for the given warehouse.
2399 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2400 
 
2690 chandransh 2401 
    Parameters:
2402 
     - warehouseId
2403 
     - fromDate
2404 
     - toDate
2405 
    """
2406 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2407 
    return self.recv_getReturnOrders()
2616 chandransh 2408 
 
2690 chandransh 2409 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2410 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2411 
    args = getReturnOrders_args()
2412 
    args.warehouseId = warehouseId
2413 
    args.fromDate = fromDate
2414 
    args.toDate = toDate
2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_getReturnOrders(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = getReturnOrders_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
3431 rajveer 2429 
    if result.success is not None:
2690 chandransh 2430 
      return result.success
2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2432 
 
2700 chandransh 2433 
  def getReturnOrder(self, id):
2434 
    """
2435 
    Returns the ReturnOrder corresponding to the given id.
2436 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2437 
 
2700 chandransh 2438 
    Parameters:
2439 
     - id
2440 
    """
2441 
    self.send_getReturnOrder(id)
2442 
    return self.recv_getReturnOrder()
2443 
 
2444 
  def send_getReturnOrder(self, id):
2445 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2446 
    args = getReturnOrder_args()
2447 
    args.id = id
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_getReturnOrder(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = getReturnOrder_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.success is not None:
2700 chandransh 2463 
      return result.success
3431 rajveer 2464 
    if result.ex is not None:
2700 chandransh 2465 
      raise result.ex
2466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2467 
 
2690 chandransh 2468 
  def processReturn(self, returnOrderId):
2469 
    """
2470 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2471 
 
2690 chandransh 2472 
    Parameters:
2473 
     - returnOrderId
2474 
    """
2475 
    self.send_processReturn(returnOrderId)
2476 
    self.recv_processReturn()
2477 
 
2478 
  def send_processReturn(self, returnOrderId):
2479 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2480 
    args = processReturn_args()
2481 
    args.returnOrderId = returnOrderId
2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
2486 
  def recv_processReturn(self, ):
2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
2493 
    result = processReturn_result()
2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
3431 rajveer 2496 
    if result.ex is not None:
2690 chandransh 2497 
      raise result.ex
2498 
    return
2499 
 
2819 chandransh 2500 
  def createPurchaseOrder(self, warehouseId):
2501 
    """
2502 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2503 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2504 
 
2819 chandransh 2505 
    Parameters:
2506 
     - warehouseId
2507 
    """
2508 
    self.send_createPurchaseOrder(warehouseId)
2509 
    return self.recv_createPurchaseOrder()
2690 chandransh 2510 
 
2819 chandransh 2511 
  def send_createPurchaseOrder(self, warehouseId):
2512 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2513 
    args = createPurchaseOrder_args()
2514 
    args.warehouseId = warehouseId
2515 
    args.write(self._oprot)
2516 
    self._oprot.writeMessageEnd()
2517 
    self._oprot.trans.flush()
2518 
 
2519 
  def recv_createPurchaseOrder(self, ):
2520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2521 
    if mtype == TMessageType.EXCEPTION:
2522 
      x = TApplicationException()
2523 
      x.read(self._iprot)
2524 
      self._iprot.readMessageEnd()
2525 
      raise x
2526 
    result = createPurchaseOrder_result()
2527 
    result.read(self._iprot)
2528 
    self._iprot.readMessageEnd()
3431 rajveer 2529 
    if result.success is not None:
2819 chandransh 2530 
      return result.success
3431 rajveer 2531 
    if result.ex is not None:
2819 chandransh 2532 
      raise result.ex
2533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2534 
 
3451 chandransh 2535 
  def updateWeight(self, orderId, weight):
2536 
    """
2537 
    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 2538 
 
3451 chandransh 2539 
    Parameters:
2540 
     - orderId
2541 
     - weight
2542 
    """
2543 
    self.send_updateWeight(orderId, weight)
2544 
    return self.recv_updateWeight()
2545 
 
2546 
  def send_updateWeight(self, orderId, weight):
2547 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2548 
    args = updateWeight_args()
2549 
    args.orderId = orderId
2550 
    args.weight = weight
2551 
    args.write(self._oprot)
2552 
    self._oprot.writeMessageEnd()
2553 
    self._oprot.trans.flush()
2554 
 
2555 
  def recv_updateWeight(self, ):
2556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2557 
    if mtype == TMessageType.EXCEPTION:
2558 
      x = TApplicationException()
2559 
      x.read(self._iprot)
2560 
      self._iprot.readMessageEnd()
2561 
      raise x
2562 
    result = updateWeight_result()
2563 
    result.read(self._iprot)
2564 
    self._iprot.readMessageEnd()
2565 
    if result.success is not None:
2566 
      return result.success
2567 
    if result.ex is not None:
2568 
      raise result.ex
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2570 
 
3469 chandransh 2571 
  def changeItem(self, orderId, itemId):
2572 
    """
2573 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2574 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2575 
 
3469 chandransh 2576 
    Parameters:
2577 
     - orderId
2578 
     - itemId
2579 
    """
2580 
    self.send_changeItem(orderId, itemId)
2581 
    return self.recv_changeItem()
2582 
 
2583 
  def send_changeItem(self, orderId, itemId):
2584 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2585 
    args = changeItem_args()
2586 
    args.orderId = orderId
2587 
    args.itemId = itemId
2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
2592 
  def recv_changeItem(self, ):
2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
2599 
    result = changeItem_result()
2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
2602 
    if result.success is not None:
2603 
      return result.success
2604 
    if result.ex is not None:
2605 
      raise result.ex
2606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2607 
 
2608 
  def shiftToWarehouse(self, orderId, warehouseId):
2609 
    """
2610 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2611 
 
2612 
    Parameters:
2613 
     - orderId
2614 
     - warehouseId
2615 
    """
2616 
    self.send_shiftToWarehouse(orderId, warehouseId)
2617 
    return self.recv_shiftToWarehouse()
2618 
 
2619 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2620 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2621 
    args = shiftToWarehouse_args()
2622 
    args.orderId = orderId
2623 
    args.warehouseId = warehouseId
2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_shiftToWarehouse(self, ):
2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2635 
    result = shiftToWarehouse_result()
2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
2638 
    if result.success is not None:
2639 
      return result.success
2640 
    if result.ex is not None:
2641 
      raise result.ex
2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2643 
 
3986 chandransh 2644 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2645 
    """
2646 
    Adds the given delay reason to the given order.
3986 chandransh 2647 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2648 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2649 
 
3553 chandransh 2650 
    Parameters:
2651 
     - orderId
2652 
     - delayReason
3986 chandransh 2653 
     - furtherDelay
3553 chandransh 2654 
    """
3986 chandransh 2655 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2656 
    return self.recv_addDelayReason()
2657 
 
3986 chandransh 2658 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2659 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2660 
    args = addDelayReason_args()
2661 
    args.orderId = orderId
2662 
    args.delayReason = delayReason
3986 chandransh 2663 
    args.furtherDelay = furtherDelay
3553 chandransh 2664 
    args.write(self._oprot)
2665 
    self._oprot.writeMessageEnd()
2666 
    self._oprot.trans.flush()
2667 
 
2668 
  def recv_addDelayReason(self, ):
2669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2670 
    if mtype == TMessageType.EXCEPTION:
2671 
      x = TApplicationException()
2672 
      x.read(self._iprot)
2673 
      self._iprot.readMessageEnd()
2674 
      raise x
2675 
    result = addDelayReason_result()
2676 
    result.read(self._iprot)
2677 
    self._iprot.readMessageEnd()
2678 
    if result.success is not None:
2679 
      return result.success
2680 
    if result.ex is not None:
2681 
      raise result.ex
2682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2683 
 
3956 chandransh 2684 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2685 
    """
2686 
    Marks the COD orders with given AWB nos. as having been processed.
2687 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2688 
 
3956 chandransh 2689 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2690 
    1. There is no order corresponding to an AWB number.
2691 
    2. The captured amount for a payment exceeds the total payment.
2692 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2693 
 
2694 
    Parameters:
2695 
     - collectedAmountMap
2696 
     - xferBy
2697 
     - xferTxnId
2698 
     - xferDate
2699 
    """
2700 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2701 
    return self.recv_reconcileCodCollection()
2702 
 
2703 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2704 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2705 
    args = reconcileCodCollection_args()
2706 
    args.collectedAmountMap = collectedAmountMap
2707 
    args.xferBy = xferBy
2708 
    args.xferTxnId = xferTxnId
2709 
    args.xferDate = xferDate
2710 
    args.write(self._oprot)
2711 
    self._oprot.writeMessageEnd()
2712 
    self._oprot.trans.flush()
2713 
 
2714 
  def recv_reconcileCodCollection(self, ):
2715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2716 
    if mtype == TMessageType.EXCEPTION:
2717 
      x = TApplicationException()
2718 
      x.read(self._iprot)
2719 
      self._iprot.readMessageEnd()
2720 
      raise x
2721 
    result = reconcileCodCollection_result()
2722 
    result.read(self._iprot)
2723 
    self._iprot.readMessageEnd()
2724 
    if result.success is not None:
2725 
      return result.success
2726 
    if result.ex is not None:
2727 
      raise result.ex
2728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2729 
 
4008 mandeep.dh 2730 
  def getTransactionsRequiringExtraProcessing(self, category):
2731 
    """
4065 mandeep.dh 2732 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2733 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2734 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2735 
 
4008 mandeep.dh 2736 
    Parameters:
2737 
     - category
2738 
    """
2739 
    self.send_getTransactionsRequiringExtraProcessing(category)
2740 
    return self.recv_getTransactionsRequiringExtraProcessing()
2741 
 
2742 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2743 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2744 
    args = getTransactionsRequiringExtraProcessing_args()
2745 
    args.category = category
2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
2750 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
2757 
    result = getTransactionsRequiringExtraProcessing_result()
2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
2760 
    if result.success is not None:
2761 
      return result.success
2762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2763 
 
2764 
  def markTransactionAsProcessed(self, transactionId, category):
2765 
    """
2766 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2767 
    It essentially deletes the transaction id record for a particular
2768 
    processing type category (if present) from DB.
2769 
    This is currently used by CRM application.
4008 mandeep.dh 2770 
 
2771 
    Parameters:
2772 
     - transactionId
2773 
     - category
2774 
    """
2775 
    self.send_markTransactionAsProcessed(transactionId, category)
2776 
    self.recv_markTransactionAsProcessed()
2777 
 
2778 
  def send_markTransactionAsProcessed(self, transactionId, category):
2779 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2780 
    args = markTransactionAsProcessed_args()
2781 
    args.transactionId = transactionId
2782 
    args.category = category
2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
2787 
  def recv_markTransactionAsProcessed(self, ):
2788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2789 
    if mtype == TMessageType.EXCEPTION:
2790 
      x = TApplicationException()
2791 
      x.read(self._iprot)
2792 
      self._iprot.readMessageEnd()
2793 
      raise x
2794 
    result = markTransactionAsProcessed_result()
2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
2797 
    return
2798 
 
4018 chandransh 2799 
  def getItemWiseRiskyOrdersCount(self, ):
2800 
    """
2801 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2802 
    is defined as one whose shipping date is about to expire.
2803 
    """
2804 
    self.send_getItemWiseRiskyOrdersCount()
2805 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2806 
 
4018 chandransh 2807 
  def send_getItemWiseRiskyOrdersCount(self, ):
2808 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2809 
    args = getItemWiseRiskyOrdersCount_args()
2810 
    args.write(self._oprot)
2811 
    self._oprot.writeMessageEnd()
2812 
    self._oprot.trans.flush()
2813 
 
2814 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2816 
    if mtype == TMessageType.EXCEPTION:
2817 
      x = TApplicationException()
2818 
      x.read(self._iprot)
2819 
      self._iprot.readMessageEnd()
2820 
      raise x
2821 
    result = getItemWiseRiskyOrdersCount_result()
2822 
    result.read(self._iprot)
2823 
    self._iprot.readMessageEnd()
2824 
    if result.success is not None:
2825 
      return result.success
2826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2827 
 
4247 rajveer 2828 
  def markOrderCancellationRequestReceived(self, orderId):
2829 
    """
2830 
    Mark order as cancellation request received. If customer sends request of cancellation of
2831 
    a particular order, this method will be called. It will just change status of the order
2832 
    depending on its current status. It also records the previous status, so that we can move
2833 
    back to that status if cancellation request is denied.
4018 chandransh 2834 
 
4247 rajveer 2835 
    Parameters:
2836 
     - orderId
2837 
    """
2838 
    self.send_markOrderCancellationRequestReceived(orderId)
2839 
    self.recv_markOrderCancellationRequestReceived()
2840 
 
2841 
  def send_markOrderCancellationRequestReceived(self, orderId):
2842 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2843 
    args = markOrderCancellationRequestReceived_args()
2844 
    args.orderId = orderId
2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2849 
  def recv_markOrderCancellationRequestReceived(self, ):
2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2856 
    result = markOrderCancellationRequestReceived_result()
2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
2859 
    if result.ex is not None:
2860 
      raise result.ex
2861 
    return
2862 
 
2863 
  def markOrderCancellationRequestConfirmed(self, orderId):
2864 
    """
2865 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2866 
    cancellation request confirmed. After this OM will be able to cancel the order.
2867 
 
2868 
    Parameters:
2869 
     - orderId
2870 
    """
2871 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2872 
    self.recv_markOrderCancellationRequestConfirmed()
2873 
 
2874 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2875 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2876 
    args = markOrderCancellationRequestConfirmed_args()
2877 
    args.orderId = orderId
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = markOrderCancellationRequestConfirmed_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    if result.ex is not None:
2893 
      raise result.ex
2894 
    return
2895 
 
2896 
  def markOrderCancellationRequestDenied(self, orderId):
2897 
    """
2898 
    If we decide to not to cancel order, we will move the order ro previous status.
2899 
 
2900 
    Parameters:
2901 
     - orderId
2902 
    """
2903 
    self.send_markOrderCancellationRequestDenied(orderId)
2904 
    self.recv_markOrderCancellationRequestDenied()
2905 
 
2906 
  def send_markOrderCancellationRequestDenied(self, orderId):
2907 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2908 
    args = markOrderCancellationRequestDenied_args()
2909 
    args.orderId = orderId
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_markOrderCancellationRequestDenied(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = markOrderCancellationRequestDenied_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
2924 
    if result.ex is not None:
2925 
      raise result.ex
2926 
    return
2927 
 
4258 rajveer 2928 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 2929 
    """
4258 rajveer 2930 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
2931 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 2932 
 
2933 
    Parameters:
4258 rajveer 2934 
     - transactionId
4247 rajveer 2935 
    """
4258 rajveer 2936 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
2937 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 2938 
 
4258 rajveer 2939 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
2940 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
2941 
    args = markTransactionAsPaymentFlagRemoved_args()
2942 
    args.transactionId = transactionId
4247 rajveer 2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
4258 rajveer 2947 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
4258 rajveer 2954 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
2957 
    if result.ex is not None:
2958 
      raise result.ex
2959 
    return
2960 
 
4259 anupam.sin 2961 
  def refundTransaction(self, transactionId, refundedBy, reason):
2962 
    """
2963 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
2964 
    need to be cancelled
4247 rajveer 2965 
 
4259 anupam.sin 2966 
    Parameters:
2967 
     - transactionId
2968 
     - refundedBy
2969 
     - reason
2970 
    """
2971 
    self.send_refundTransaction(transactionId, refundedBy, reason)
2972 
    self.recv_refundTransaction()
2973 
 
2974 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
2975 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
2976 
    args = refundTransaction_args()
2977 
    args.transactionId = transactionId
2978 
    args.refundedBy = refundedBy
2979 
    args.reason = reason
2980 
    args.write(self._oprot)
2981 
    self._oprot.writeMessageEnd()
2982 
    self._oprot.trans.flush()
2983 
 
2984 
  def recv_refundTransaction(self, ):
2985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2986 
    if mtype == TMessageType.EXCEPTION:
2987 
      x = TApplicationException()
2988 
      x.read(self._iprot)
2989 
      self._iprot.readMessageEnd()
2990 
      raise x
2991 
    result = refundTransaction_result()
2992 
    result.read(self._iprot)
2993 
    self._iprot.readMessageEnd()
2994 
    if result.ex is not None:
2995 
      raise result.ex
2996 
    return
2997 
 
2998 
 
3376 rajveer 2999 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3000 
  def __init__(self, handler):
3376 rajveer 3001 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3002 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3003 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3004 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3005 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3006 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3007 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3008 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3009 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3010 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3011 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3012 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3013 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3014 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3015 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3016 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3017 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3018 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3019 
    self._processMap["createOrder"] = Processor.process_createOrder
3020 
    self._processMap["getOrder"] = Processor.process_getOrder
3021 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3022 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3023 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3024 
    self._processMap["setAlert"] = Processor.process_setAlert
3025 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3026 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3027 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3028 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3029 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3030 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3031 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3032 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3033 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3034 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3035 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3036 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3037 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3038 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3039 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3040 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3041 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3042 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3043 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3044 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3045 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3046 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3047 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3048 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3049 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3050 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3051 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3052 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3053 
    self._processMap["changeItem"] = Processor.process_changeItem
3054 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3055 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3056 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3057 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3058 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3059 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4247 rajveer 3060 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3061 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3062 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3063 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3064 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
94 ashish 3065 
 
3066 
  def process(self, iprot, oprot):
3067 
    (name, type, seqid) = iprot.readMessageBegin()
3068 
    if name not in self._processMap:
3069 
      iprot.skip(TType.STRUCT)
3070 
      iprot.readMessageEnd()
3071 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3072 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3073 
      x.write(oprot)
3074 
      oprot.writeMessageEnd()
3075 
      oprot.trans.flush()
3076 
      return
3077 
    else:
3078 
      self._processMap[name](self, seqid, iprot, oprot)
3079 
    return True
3080 
 
3081 
  def process_createTransaction(self, seqid, iprot, oprot):
3082 
    args = createTransaction_args()
3083 
    args.read(iprot)
3084 
    iprot.readMessageEnd()
3085 
    result = createTransaction_result()
3086 
    try:
132 ashish 3087 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3088 
    except TransactionServiceException, ex:
3089 
      result.ex = ex
3090 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3091 
    result.write(oprot)
3092 
    oprot.writeMessageEnd()
3093 
    oprot.trans.flush()
3094 
 
3095 
  def process_getTransaction(self, seqid, iprot, oprot):
3096 
    args = getTransaction_args()
3097 
    args.read(iprot)
3098 
    iprot.readMessageEnd()
3099 
    result = getTransaction_result()
3100 
    try:
3101 
      result.success = self._handler.getTransaction(args.id)
3102 
    except TransactionServiceException, ex:
3103 
      result.ex = ex
3104 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3105 
    result.write(oprot)
3106 
    oprot.writeMessageEnd()
3107 
    oprot.trans.flush()
3108 
 
3109 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3110 
    args = getTransactionsForCustomer_args()
3111 
    args.read(iprot)
3112 
    iprot.readMessageEnd()
3113 
    result = getTransactionsForCustomer_result()
3114 
    try:
3115 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3116 
    except TransactionServiceException, ex:
3117 
      result.ex = ex
3118 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3119 
    result.write(oprot)
3120 
    oprot.writeMessageEnd()
3121 
    oprot.trans.flush()
3122 
 
132 ashish 3123 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3124 
    args = getTransactionsForShoppingCartId_args()
3125 
    args.read(iprot)
3126 
    iprot.readMessageEnd()
3127 
    result = getTransactionsForShoppingCartId_result()
3128 
    try:
3129 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3130 
    except TransactionServiceException, ex:
3131 
      result.ex = ex
3132 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3133 
    result.write(oprot)
3134 
    oprot.writeMessageEnd()
3135 
    oprot.trans.flush()
3136 
 
94 ashish 3137 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3138 
    args = getTransactionStatus_args()
3139 
    args.read(iprot)
3140 
    iprot.readMessageEnd()
3141 
    result = getTransactionStatus_result()
3142 
    try:
3143 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3144 
    except TransactionServiceException, ex:
3145 
      result.ex = ex
3146 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3147 
    result.write(oprot)
3148 
    oprot.writeMessageEnd()
3149 
    oprot.trans.flush()
3150 
 
3151 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3152 
    args = changeTransactionStatus_args()
3153 
    args.read(iprot)
3154 
    iprot.readMessageEnd()
3155 
    result = changeTransactionStatus_result()
3156 
    try:
3157 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3158 
    except TransactionServiceException, ex:
3159 
      result.ex = ex
3160 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3161 
    result.write(oprot)
3162 
    oprot.writeMessageEnd()
3163 
    oprot.trans.flush()
3164 
 
1398 varun.gupt 3165 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3166 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3167 
    args.read(iprot)
3168 
    iprot.readMessageEnd()
1398 varun.gupt 3169 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3170 
    try:
1398 varun.gupt 3171 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3172 
    except TransactionServiceException, ex:
3173 
      result.ex = ex
1398 varun.gupt 3174 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3175 
    result.write(oprot)
3176 
    oprot.writeMessageEnd()
3177 
    oprot.trans.flush()
3178 
 
483 rajveer 3179 
  def process_getAllOrders(self, seqid, iprot, oprot):
3180 
    args = getAllOrders_args()
94 ashish 3181 
    args.read(iprot)
3182 
    iprot.readMessageEnd()
483 rajveer 3183 
    result = getAllOrders_result()
94 ashish 3184 
    try:
483 rajveer 3185 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3186 
    except TransactionServiceException, ex:
3187 
      result.ex = ex
483 rajveer 3188 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3189 
    result.write(oprot)
3190 
    oprot.writeMessageEnd()
3191 
    oprot.trans.flush()
3192 
 
4133 chandransh 3193 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3194 
    args = getOrdersInBatch_args()
3195 
    args.read(iprot)
3196 
    iprot.readMessageEnd()
3197 
    result = getOrdersInBatch_result()
3198 
    try:
3199 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3200 
    except TransactionServiceException, ex:
3201 
      result.ex = ex
3202 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3203 
    result.write(oprot)
3204 
    oprot.writeMessageEnd()
3205 
    oprot.trans.flush()
3206 
 
3207 
  def process_getOrderCount(self, seqid, iprot, oprot):
3208 
    args = getOrderCount_args()
3209 
    args.read(iprot)
3210 
    iprot.readMessageEnd()
3211 
    result = getOrderCount_result()
3212 
    try:
3213 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3214 
    except TransactionServiceException, ex:
3215 
      result.ex = ex
3216 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3217 
    result.write(oprot)
3218 
    oprot.writeMessageEnd()
3219 
    oprot.trans.flush()
3220 
 
999 varun.gupt 3221 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3222 
    args = getOrdersByBillingDate_args()
3223 
    args.read(iprot)
3224 
    iprot.readMessageEnd()
3225 
    result = getOrdersByBillingDate_result()
3226 
    try:
3227 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3228 
    except TransactionServiceException, ex:
3229 
      result.ex = ex
3230 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3231 
    result.write(oprot)
3232 
    oprot.writeMessageEnd()
3233 
    oprot.trans.flush()
3234 
 
3427 chandransh 3235 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3236 
    args = getOrdersByShippingDate_args()
3237 
    args.read(iprot)
3238 
    iprot.readMessageEnd()
3239 
    result = getOrdersByShippingDate_result()
3240 
    try:
3451 chandransh 3241 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3242 
    except TransactionServiceException, ex:
3243 
      result.ex = ex
3244 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3245 
    result.write(oprot)
3246 
    oprot.writeMessageEnd()
3247 
    oprot.trans.flush()
3248 
 
1382 varun.gupt 3249 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3250 
    args = getReturnableOrdersForCustomer_args()
3251 
    args.read(iprot)
3252 
    iprot.readMessageEnd()
3253 
    result = getReturnableOrdersForCustomer_result()
3254 
    try:
3255 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3256 
    except TransactionServiceException, ex:
3257 
      result.ex = ex
3258 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3259 
    result.write(oprot)
3260 
    oprot.writeMessageEnd()
3261 
    oprot.trans.flush()
3262 
 
3263 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3264 
    args = getCancellableOrdersForCustomer_args()
3265 
    args.read(iprot)
3266 
    iprot.readMessageEnd()
3267 
    result = getCancellableOrdersForCustomer_result()
3268 
    try:
3269 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3270 
    except TransactionServiceException, ex:
3271 
      result.ex = ex
3272 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3273 
    result.write(oprot)
3274 
    oprot.writeMessageEnd()
3275 
    oprot.trans.flush()
3276 
 
483 rajveer 3277 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3278 
    args = changeOrderStatus_args()
94 ashish 3279 
    args.read(iprot)
3280 
    iprot.readMessageEnd()
483 rajveer 3281 
    result = changeOrderStatus_result()
94 ashish 3282 
    try:
483 rajveer 3283 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3284 
    except TransactionServiceException, ex:
3285 
      result.ex = ex
483 rajveer 3286 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3287 
    result.write(oprot)
3288 
    oprot.writeMessageEnd()
3289 
    oprot.trans.flush()
3290 
 
483 rajveer 3291 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3292 
    args = getOrdersForTransaction_args()
94 ashish 3293 
    args.read(iprot)
3294 
    iprot.readMessageEnd()
483 rajveer 3295 
    result = getOrdersForTransaction_result()
94 ashish 3296 
    try:
1528 ankur.sing 3297 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3298 
    except TransactionServiceException, ex:
3299 
      result.ex = ex
483 rajveer 3300 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3301 
    result.write(oprot)
3302 
    oprot.writeMessageEnd()
3303 
    oprot.trans.flush()
3304 
 
483 rajveer 3305 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3306 
    args = getOrdersForCustomer_args()
94 ashish 3307 
    args.read(iprot)
3308 
    iprot.readMessageEnd()
483 rajveer 3309 
    result = getOrdersForCustomer_result()
94 ashish 3310 
    try:
3014 chandransh 3311 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3312 
    except TransactionServiceException, ex:
3313 
      result.ex = ex
483 rajveer 3314 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3315 
    result.write(oprot)
3316 
    oprot.writeMessageEnd()
3317 
    oprot.trans.flush()
3318 
 
483 rajveer 3319 
  def process_createOrder(self, seqid, iprot, oprot):
3320 
    args = createOrder_args()
94 ashish 3321 
    args.read(iprot)
3322 
    iprot.readMessageEnd()
483 rajveer 3323 
    result = createOrder_result()
94 ashish 3324 
    try:
483 rajveer 3325 
      result.success = self._handler.createOrder(args.order)
94 ashish 3326 
    except TransactionServiceException, ex:
3327 
      result.ex = ex
483 rajveer 3328 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3329 
    result.write(oprot)
3330 
    oprot.writeMessageEnd()
3331 
    oprot.trans.flush()
3332 
 
483 rajveer 3333 
  def process_getOrder(self, seqid, iprot, oprot):
3334 
    args = getOrder_args()
94 ashish 3335 
    args.read(iprot)
3336 
    iprot.readMessageEnd()
483 rajveer 3337 
    result = getOrder_result()
94 ashish 3338 
    try:
483 rajveer 3339 
      result.success = self._handler.getOrder(args.id)
94 ashish 3340 
    except TransactionServiceException, ex:
3341 
      result.ex = ex
483 rajveer 3342 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3343 
    result.write(oprot)
3344 
    oprot.writeMessageEnd()
3345 
    oprot.trans.flush()
3346 
 
483 rajveer 3347 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3348 
    args = getLineItemsForOrder_args()
94 ashish 3349 
    args.read(iprot)
3350 
    iprot.readMessageEnd()
483 rajveer 3351 
    result = getLineItemsForOrder_result()
94 ashish 3352 
    try:
483 rajveer 3353 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3354 
    except TransactionServiceException, ex:
3355 
      result.ex = ex
483 rajveer 3356 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3357 
    result.write(oprot)
3358 
    oprot.writeMessageEnd()
3359 
    oprot.trans.flush()
3360 
 
1528 ankur.sing 3361 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3362 
    args = getOrderForCustomer_args()
3363 
    args.read(iprot)
3364 
    iprot.readMessageEnd()
3365 
    result = getOrderForCustomer_result()
3366 
    try:
3367 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3368 
    except TransactionServiceException, ex:
3369 
      result.ex = ex
3370 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3371 
    result.write(oprot)
3372 
    oprot.writeMessageEnd()
3373 
    oprot.trans.flush()
3374 
 
3064 chandransh 3375 
  def process_getAlerts(self, seqid, iprot, oprot):
3376 
    args = getAlerts_args()
3377 
    args.read(iprot)
3378 
    iprot.readMessageEnd()
3379 
    result = getAlerts_result()
3380 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3381 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3382 
    result.write(oprot)
3383 
    oprot.writeMessageEnd()
3384 
    oprot.trans.flush()
3385 
 
3386 
  def process_setAlert(self, seqid, iprot, oprot):
3387 
    args = setAlert_args()
3388 
    args.read(iprot)
3389 
    iprot.readMessageEnd()
3390 
    result = setAlert_result()
3391 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3392 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3393 
    result.write(oprot)
3394 
    oprot.writeMessageEnd()
3395 
    oprot.trans.flush()
3396 
 
3397 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3398 
    args = getValidOrderCount_args()
3399 
    args.read(iprot)
3400 
    iprot.readMessageEnd()
3401 
    result = getValidOrderCount_result()
3402 
    result.success = self._handler.getValidOrderCount()
3403 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3404 
    result.write(oprot)
3405 
    oprot.writeMessageEnd()
3406 
    oprot.trans.flush()
3407 
 
3408 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3409 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3410 
    args.read(iprot)
3411 
    iprot.readMessageEnd()
3412 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3413 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3414 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3415 
    result.write(oprot)
3416 
    oprot.writeMessageEnd()
3417 
    oprot.trans.flush()
3418 
 
3419 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3420 
    args = getValidOrdersAmountRange_args()
3421 
    args.read(iprot)
3422 
    iprot.readMessageEnd()
3423 
    result = getValidOrdersAmountRange_result()
3424 
    result.success = self._handler.getValidOrdersAmountRange()
3425 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3426 
    result.write(oprot)
3427 
    oprot.writeMessageEnd()
3428 
    oprot.trans.flush()
3429 
 
3430 
  def process_getValidOrders(self, seqid, iprot, oprot):
3431 
    args = getValidOrders_args()
3432 
    args.read(iprot)
3433 
    iprot.readMessageEnd()
3434 
    result = getValidOrders_result()
3435 
    result.success = self._handler.getValidOrders(args.limit)
3436 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3437 
    result.write(oprot)
3438 
    oprot.writeMessageEnd()
3439 
    oprot.trans.flush()
3440 
 
1220 chandransh 3441 
  def process_batchOrders(self, seqid, iprot, oprot):
3442 
    args = batchOrders_args()
3443 
    args.read(iprot)
3444 
    iprot.readMessageEnd()
3445 
    result = batchOrders_result()
3446 
    try:
3447 
      result.success = self._handler.batchOrders(args.warehouseId)
3448 
    except TransactionServiceException, ex:
3449 
      result.ex = ex
3450 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3451 
    result.write(oprot)
3452 
    oprot.writeMessageEnd()
3453 
    oprot.trans.flush()
3454 
 
1208 chandransh 3455 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3456 
    args = markOrderAsOutOfStock_args()
3457 
    args.read(iprot)
3458 
    iprot.readMessageEnd()
3459 
    result = markOrderAsOutOfStock_result()
3460 
    try:
3461 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3462 
    except TransactionServiceException, ex:
3463 
      result.ex = ex
3464 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3465 
    result.write(oprot)
3466 
    oprot.writeMessageEnd()
3467 
    oprot.trans.flush()
3468 
 
3064 chandransh 3469 
  def process_verifyOrder(self, seqid, iprot, oprot):
3470 
    args = verifyOrder_args()
759 chandransh 3471 
    args.read(iprot)
3472 
    iprot.readMessageEnd()
3064 chandransh 3473 
    result = verifyOrder_result()
759 chandransh 3474 
    try:
3064 chandransh 3475 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3476 
    except TransactionServiceException, ex:
3477 
      result.ex = ex
3064 chandransh 3478 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3479 
    result.write(oprot)
3480 
    oprot.writeMessageEnd()
3481 
    oprot.trans.flush()
3482 
 
3064 chandransh 3483 
  def process_acceptOrder(self, seqid, iprot, oprot):
3484 
    args = acceptOrder_args()
1113 chandransh 3485 
    args.read(iprot)
3486 
    iprot.readMessageEnd()
3064 chandransh 3487 
    result = acceptOrder_result()
1113 chandransh 3488 
    try:
3064 chandransh 3489 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3490 
    except TransactionServiceException, ex:
3491 
      result.ex = ex
3064 chandransh 3492 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3493 
    result.write(oprot)
3494 
    oprot.writeMessageEnd()
3495 
    oprot.trans.flush()
3496 
 
3064 chandransh 3497 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3498 
    args = addBillingDetails_args()
1135 chandransh 3499 
    args.read(iprot)
3500 
    iprot.readMessageEnd()
3064 chandransh 3501 
    result = addBillingDetails_result()
1135 chandransh 3502 
    try:
4283 anupam.sin 3503 
      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 3504 
    except TransactionServiceException, ex:
3505 
      result.ex = ex
3064 chandransh 3506 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3507 
    result.write(oprot)
3508 
    oprot.writeMessageEnd()
3509 
    oprot.trans.flush()
3510 
 
3064 chandransh 3511 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3512 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3513 
    args.read(iprot)
3514 
    iprot.readMessageEnd()
3064 chandransh 3515 
    result = markOrdersAsManifested_result()
3516 
    try:
3517 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3518 
    except TransactionServiceException, ex:
3519 
      result.ex = ex
3520 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3521 
    result.write(oprot)
3522 
    oprot.writeMessageEnd()
3523 
    oprot.trans.flush()
3524 
 
3064 chandransh 3525 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3526 
    args = markOrdersAsPickedUp_args()
304 ashish 3527 
    args.read(iprot)
3528 
    iprot.readMessageEnd()
3064 chandransh 3529 
    result = markOrdersAsPickedUp_result()
3530 
    try:
3531 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3532 
    except TransactionServiceException, ex:
3533 
      result.ex = ex
3534 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3535 
    result.write(oprot)
3536 
    oprot.writeMessageEnd()
3537 
    oprot.trans.flush()
94 ashish 3538 
 
3064 chandransh 3539 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3540 
    args = markOrdersAsDelivered_args()
304 ashish 3541 
    args.read(iprot)
3542 
    iprot.readMessageEnd()
3064 chandransh 3543 
    result = markOrdersAsDelivered_result()
3544 
    try:
3545 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3546 
    except TransactionServiceException, ex:
3547 
      result.ex = ex
3548 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3549 
    result.write(oprot)
3550 
    oprot.writeMessageEnd()
3551 
    oprot.trans.flush()
3552 
 
3064 chandransh 3553 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3554 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3555 
    args.read(iprot)
3556 
    iprot.readMessageEnd()
3064 chandransh 3557 
    result = markOrdersAsFailed_result()
3558 
    try:
3559 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3560 
    except TransactionServiceException, ex:
3561 
      result.ex = ex
3562 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3563 
    result.write(oprot)
3564 
    oprot.writeMessageEnd()
3565 
    oprot.trans.flush()
304 ashish 3566 
 
3064 chandransh 3567 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3568 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3569 
    args.read(iprot)
3570 
    iprot.readMessageEnd()
3064 chandransh 3571 
    result = updateNonDeliveryReason_result()
3572 
    try:
3573 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3574 
    except TransactionServiceException, ex:
3575 
      result.ex = ex
3576 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3577 
    result.write(oprot)
3578 
    oprot.writeMessageEnd()
3579 
    oprot.trans.flush()
1596 ankur.sing 3580 
 
3064 chandransh 3581 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3582 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3583 
    args.read(iprot)
3584 
    iprot.readMessageEnd()
3064 chandransh 3585 
    result = getUndeliveredOrders_result()
3586 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3587 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3588 
    result.write(oprot)
3589 
    oprot.writeMessageEnd()
3590 
    oprot.trans.flush()
3591 
 
2536 chandransh 3592 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3593 
    args = toggleDOAFlag_args()
3594 
    args.read(iprot)
3595 
    iprot.readMessageEnd()
3596 
    result = toggleDOAFlag_result()
3597 
    try:
3598 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3599 
    except TransactionServiceException, ex:
3600 
      result.ex = ex
3601 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3602 
    result.write(oprot)
3603 
    oprot.writeMessageEnd()
3604 
    oprot.trans.flush()
1886 ankur.sing 3605 
 
2536 chandransh 3606 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3607 
    args = requestPickupNumber_args()
3608 
    args.read(iprot)
3609 
    iprot.readMessageEnd()
3610 
    result = requestPickupNumber_result()
3611 
    try:
3612 
      result.success = self._handler.requestPickupNumber(args.orderId)
3613 
    except TransactionServiceException, ex:
3614 
      result.ex = ex
3615 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3616 
    result.write(oprot)
3617 
    oprot.writeMessageEnd()
3618 
    oprot.trans.flush()
3619 
 
3620 
  def process_authorizePickup(self, seqid, iprot, oprot):
3621 
    args = authorizePickup_args()
3622 
    args.read(iprot)
3623 
    iprot.readMessageEnd()
3624 
    result = authorizePickup_result()
3625 
    try:
3626 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3627 
    except TransactionServiceException, ex:
3628 
      result.ex = ex
3629 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3630 
    result.write(oprot)
3631 
    oprot.writeMessageEnd()
3632 
    oprot.trans.flush()
3633 
 
2764 chandransh 3634 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3635 
    args = markDoasAsPickedUp_args()
3636 
    args.read(iprot)
3637 
    iprot.readMessageEnd()
3638 
    result = markDoasAsPickedUp_result()
3639 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3640 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3641 
    result.write(oprot)
3642 
    oprot.writeMessageEnd()
3643 
    oprot.trans.flush()
3644 
 
2616 chandransh 3645 
  def process_receiveReturn(self, seqid, iprot, oprot):
3646 
    args = receiveReturn_args()
2591 chandransh 3647 
    args.read(iprot)
3648 
    iprot.readMessageEnd()
2616 chandransh 3649 
    result = receiveReturn_result()
2591 chandransh 3650 
    try:
2616 chandransh 3651 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3652 
    except TransactionServiceException, ex:
3653 
      result.ex = ex
2616 chandransh 3654 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3655 
    result.write(oprot)
3656 
    oprot.writeMessageEnd()
3657 
    oprot.trans.flush()
2536 chandransh 3658 
 
2591 chandransh 3659 
  def process_validateDoa(self, seqid, iprot, oprot):
3660 
    args = validateDoa_args()
3661 
    args.read(iprot)
3662 
    iprot.readMessageEnd()
3663 
    result = validateDoa_result()
3664 
    try:
3665 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3666 
    except TransactionServiceException, ex:
3667 
      result.ex = ex
3668 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3669 
    result.write(oprot)
3670 
    oprot.writeMessageEnd()
3671 
    oprot.trans.flush()
3672 
 
2616 chandransh 3673 
  def process_reshipOrder(self, seqid, iprot, oprot):
3674 
    args = reshipOrder_args()
3675 
    args.read(iprot)
3676 
    iprot.readMessageEnd()
3677 
    result = reshipOrder_result()
3678 
    try:
3679 
      result.success = self._handler.reshipOrder(args.orderId)
3680 
    except TransactionServiceException, ex:
3681 
      result.ex = ex
3682 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3683 
    result.write(oprot)
3684 
    oprot.writeMessageEnd()
3685 
    oprot.trans.flush()
2591 chandransh 3686 
 
2616 chandransh 3687 
  def process_refundOrder(self, seqid, iprot, oprot):
3688 
    args = refundOrder_args()
3689 
    args.read(iprot)
3690 
    iprot.readMessageEnd()
3691 
    result = refundOrder_result()
3692 
    try:
3226 chandransh 3693 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3694 
    except TransactionServiceException, ex:
3695 
      result.ex = ex
3696 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3697 
    result.write(oprot)
3698 
    oprot.writeMessageEnd()
3699 
    oprot.trans.flush()
3700 
 
2690 chandransh 3701 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3702 
    args = getReturnOrders_args()
3703 
    args.read(iprot)
3704 
    iprot.readMessageEnd()
3705 
    result = getReturnOrders_result()
3706 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3707 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3708 
    result.write(oprot)
3709 
    oprot.writeMessageEnd()
3710 
    oprot.trans.flush()
2616 chandransh 3711 
 
2700 chandransh 3712 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3713 
    args = getReturnOrder_args()
3714 
    args.read(iprot)
3715 
    iprot.readMessageEnd()
3716 
    result = getReturnOrder_result()
3717 
    try:
3718 
      result.success = self._handler.getReturnOrder(args.id)
3719 
    except TransactionServiceException, ex:
3720 
      result.ex = ex
3721 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3722 
    result.write(oprot)
3723 
    oprot.writeMessageEnd()
3724 
    oprot.trans.flush()
3725 
 
2690 chandransh 3726 
  def process_processReturn(self, seqid, iprot, oprot):
3727 
    args = processReturn_args()
3728 
    args.read(iprot)
3729 
    iprot.readMessageEnd()
3730 
    result = processReturn_result()
3731 
    try:
3732 
      self._handler.processReturn(args.returnOrderId)
3733 
    except TransactionServiceException, ex:
3734 
      result.ex = ex
3735 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3736 
    result.write(oprot)
3737 
    oprot.writeMessageEnd()
3738 
    oprot.trans.flush()
3739 
 
2819 chandransh 3740 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3741 
    args = createPurchaseOrder_args()
3742 
    args.read(iprot)
3743 
    iprot.readMessageEnd()
3744 
    result = createPurchaseOrder_result()
3745 
    try:
3746 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3747 
    except TransactionServiceException, ex:
3748 
      result.ex = ex
3749 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3750 
    result.write(oprot)
3751 
    oprot.writeMessageEnd()
3752 
    oprot.trans.flush()
2690 chandransh 3753 
 
3451 chandransh 3754 
  def process_updateWeight(self, seqid, iprot, oprot):
3755 
    args = updateWeight_args()
3756 
    args.read(iprot)
3757 
    iprot.readMessageEnd()
3758 
    result = updateWeight_result()
3759 
    try:
3760 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3761 
    except TransactionServiceException, ex:
3762 
      result.ex = ex
3763 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3764 
    result.write(oprot)
3765 
    oprot.writeMessageEnd()
3766 
    oprot.trans.flush()
2819 chandransh 3767 
 
3469 chandransh 3768 
  def process_changeItem(self, seqid, iprot, oprot):
3769 
    args = changeItem_args()
3770 
    args.read(iprot)
3771 
    iprot.readMessageEnd()
3772 
    result = changeItem_result()
3773 
    try:
3774 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3775 
    except TransactionServiceException, ex:
3776 
      result.ex = ex
3777 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3778 
    result.write(oprot)
3779 
    oprot.writeMessageEnd()
3780 
    oprot.trans.flush()
3451 chandransh 3781 
 
3469 chandransh 3782 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3783 
    args = shiftToWarehouse_args()
3784 
    args.read(iprot)
3785 
    iprot.readMessageEnd()
3786 
    result = shiftToWarehouse_result()
3787 
    try:
3788 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3789 
    except TransactionServiceException, ex:
3790 
      result.ex = ex
3791 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3792 
    result.write(oprot)
3793 
    oprot.writeMessageEnd()
3794 
    oprot.trans.flush()
3795 
 
3553 chandransh 3796 
  def process_addDelayReason(self, seqid, iprot, oprot):
3797 
    args = addDelayReason_args()
3798 
    args.read(iprot)
3799 
    iprot.readMessageEnd()
3800 
    result = addDelayReason_result()
3801 
    try:
3986 chandransh 3802 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3803 
    except TransactionServiceException, ex:
3804 
      result.ex = ex
3805 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3806 
    result.write(oprot)
3807 
    oprot.writeMessageEnd()
3808 
    oprot.trans.flush()
3469 chandransh 3809 
 
3956 chandransh 3810 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3811 
    args = reconcileCodCollection_args()
3812 
    args.read(iprot)
3813 
    iprot.readMessageEnd()
3814 
    result = reconcileCodCollection_result()
3815 
    try:
3816 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3817 
    except TransactionServiceException, ex:
3818 
      result.ex = ex
3819 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3820 
    result.write(oprot)
3821 
    oprot.writeMessageEnd()
3822 
    oprot.trans.flush()
3553 chandransh 3823 
 
4008 mandeep.dh 3824 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3825 
    args = getTransactionsRequiringExtraProcessing_args()
3826 
    args.read(iprot)
3827 
    iprot.readMessageEnd()
3828 
    result = getTransactionsRequiringExtraProcessing_result()
3829 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3830 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3831 
    result.write(oprot)
3832 
    oprot.writeMessageEnd()
3833 
    oprot.trans.flush()
3956 chandransh 3834 
 
4008 mandeep.dh 3835 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3836 
    args = markTransactionAsProcessed_args()
3837 
    args.read(iprot)
3838 
    iprot.readMessageEnd()
3839 
    result = markTransactionAsProcessed_result()
3840 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3841 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
3845 
 
4018 chandransh 3846 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3847 
    args = getItemWiseRiskyOrdersCount_args()
3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
3850 
    result = getItemWiseRiskyOrdersCount_result()
3851 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3852 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3853 
    result.write(oprot)
3854 
    oprot.writeMessageEnd()
3855 
    oprot.trans.flush()
4008 mandeep.dh 3856 
 
4247 rajveer 3857 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3858 
    args = markOrderCancellationRequestReceived_args()
3859 
    args.read(iprot)
3860 
    iprot.readMessageEnd()
3861 
    result = markOrderCancellationRequestReceived_result()
3862 
    try:
3863 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3864 
    except TransactionServiceException, ex:
3865 
      result.ex = ex
3866 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3867 
    result.write(oprot)
3868 
    oprot.writeMessageEnd()
3869 
    oprot.trans.flush()
4018 chandransh 3870 
 
4247 rajveer 3871 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3872 
    args = markOrderCancellationRequestConfirmed_args()
3873 
    args.read(iprot)
3874 
    iprot.readMessageEnd()
3875 
    result = markOrderCancellationRequestConfirmed_result()
3876 
    try:
3877 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3878 
    except TransactionServiceException, ex:
3879 
      result.ex = ex
3880 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
3881 
    result.write(oprot)
3882 
    oprot.writeMessageEnd()
3883 
    oprot.trans.flush()
3884 
 
3885 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
3886 
    args = markOrderCancellationRequestDenied_args()
3887 
    args.read(iprot)
3888 
    iprot.readMessageEnd()
3889 
    result = markOrderCancellationRequestDenied_result()
3890 
    try:
3891 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
3892 
    except TransactionServiceException, ex:
3893 
      result.ex = ex
3894 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
3895 
    result.write(oprot)
3896 
    oprot.writeMessageEnd()
3897 
    oprot.trans.flush()
3898 
 
4258 rajveer 3899 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
3900 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 3901 
    args.read(iprot)
3902 
    iprot.readMessageEnd()
4258 rajveer 3903 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3904 
    try:
4258 rajveer 3905 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 3906 
    except TransactionServiceException, ex:
3907 
      result.ex = ex
4258 rajveer 3908 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 3909 
    result.write(oprot)
3910 
    oprot.writeMessageEnd()
3911 
    oprot.trans.flush()
3912 
 
4259 anupam.sin 3913 
  def process_refundTransaction(self, seqid, iprot, oprot):
3914 
    args = refundTransaction_args()
3915 
    args.read(iprot)
3916 
    iprot.readMessageEnd()
3917 
    result = refundTransaction_result()
3918 
    try:
3919 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
3920 
    except TransactionServiceException, ex:
3921 
      result.ex = ex
3922 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
3923 
    result.write(oprot)
3924 
    oprot.writeMessageEnd()
3925 
    oprot.trans.flush()
4247 rajveer 3926 
 
4259 anupam.sin 3927 
 
94 ashish 3928 
# HELPER FUNCTIONS AND STRUCTURES
3929 
 
3930 
class createTransaction_args:
3931 
  """
3932 
  Attributes:
3933 
   - transaction
3934 
  """
3935 
 
3936 
  thrift_spec = (
3937 
    None, # 0
3938 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
3939 
  )
3940 
 
3941 
  def __init__(self, transaction=None,):
3942 
    self.transaction = transaction
3943 
 
3944 
  def read(self, iprot):
3945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3947 
      return
3948 
    iprot.readStructBegin()
3949 
    while True:
3950 
      (fname, ftype, fid) = iprot.readFieldBegin()
3951 
      if ftype == TType.STOP:
3952 
        break
3953 
      if fid == 1:
3954 
        if ftype == TType.STRUCT:
3955 
          self.transaction = Transaction()
3956 
          self.transaction.read(iprot)
3957 
        else:
3958 
          iprot.skip(ftype)
3959 
      else:
3960 
        iprot.skip(ftype)
3961 
      iprot.readFieldEnd()
3962 
    iprot.readStructEnd()
3963 
 
3964 
  def write(self, oprot):
3965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3967 
      return
3968 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 3969 
    if self.transaction is not None:
94 ashish 3970 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
3971 
      self.transaction.write(oprot)
3972 
      oprot.writeFieldEnd()
3973 
    oprot.writeFieldStop()
3974 
    oprot.writeStructEnd()
3975 
 
3431 rajveer 3976 
  def validate(self):
3977 
    return
3978 
 
3979 
 
94 ashish 3980 
  def __repr__(self):
3981 
    L = ['%s=%r' % (key, value)
3982 
      for key, value in self.__dict__.iteritems()]
3983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3984 
 
3985 
  def __eq__(self, other):
3986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3987 
 
3988 
  def __ne__(self, other):
3989 
    return not (self == other)
3990 
 
3991 
class createTransaction_result:
3992 
  """
3993 
  Attributes:
132 ashish 3994 
   - success
94 ashish 3995 
   - ex
3996 
  """
3997 
 
3998 
  thrift_spec = (
132 ashish 3999 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4001 
  )
4002 
 
132 ashish 4003 
  def __init__(self, success=None, ex=None,):
4004 
    self.success = success
94 ashish 4005 
    self.ex = ex
4006 
 
4007 
  def read(self, iprot):
4008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4010 
      return
4011 
    iprot.readStructBegin()
4012 
    while True:
4013 
      (fname, ftype, fid) = iprot.readFieldBegin()
4014 
      if ftype == TType.STOP:
4015 
        break
132 ashish 4016 
      if fid == 0:
4017 
        if ftype == TType.I64:
4018 
          self.success = iprot.readI64();
4019 
        else:
4020 
          iprot.skip(ftype)
4021 
      elif fid == 1:
94 ashish 4022 
        if ftype == TType.STRUCT:
4023 
          self.ex = TransactionServiceException()
4024 
          self.ex.read(iprot)
4025 
        else:
4026 
          iprot.skip(ftype)
4027 
      else:
4028 
        iprot.skip(ftype)
4029 
      iprot.readFieldEnd()
4030 
    iprot.readStructEnd()
4031 
 
4032 
  def write(self, oprot):
4033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4035 
      return
4036 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4037 
    if self.success is not None:
132 ashish 4038 
      oprot.writeFieldBegin('success', TType.I64, 0)
4039 
      oprot.writeI64(self.success)
4040 
      oprot.writeFieldEnd()
3431 rajveer 4041 
    if self.ex is not None:
94 ashish 4042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4043 
      self.ex.write(oprot)
4044 
      oprot.writeFieldEnd()
4045 
    oprot.writeFieldStop()
4046 
    oprot.writeStructEnd()
4047 
 
3431 rajveer 4048 
  def validate(self):
4049 
    return
4050 
 
4051 
 
94 ashish 4052 
  def __repr__(self):
4053 
    L = ['%s=%r' % (key, value)
4054 
      for key, value in self.__dict__.iteritems()]
4055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4056 
 
4057 
  def __eq__(self, other):
4058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4059 
 
4060 
  def __ne__(self, other):
4061 
    return not (self == other)
4062 
 
4063 
class getTransaction_args:
4064 
  """
4065 
  Attributes:
4066 
   - id
4067 
  """
4068 
 
4069 
  thrift_spec = (
4070 
    None, # 0
4071 
    (1, TType.I64, 'id', None, None, ), # 1
4072 
  )
4073 
 
4074 
  def __init__(self, id=None,):
4075 
    self.id = id
4076 
 
4077 
  def read(self, iprot):
4078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4080 
      return
4081 
    iprot.readStructBegin()
4082 
    while True:
4083 
      (fname, ftype, fid) = iprot.readFieldBegin()
4084 
      if ftype == TType.STOP:
4085 
        break
4086 
      if fid == 1:
4087 
        if ftype == TType.I64:
4088 
          self.id = iprot.readI64();
4089 
        else:
4090 
          iprot.skip(ftype)
4091 
      else:
4092 
        iprot.skip(ftype)
4093 
      iprot.readFieldEnd()
4094 
    iprot.readStructEnd()
4095 
 
4096 
  def write(self, oprot):
4097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4099 
      return
4100 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4101 
    if self.id is not None:
94 ashish 4102 
      oprot.writeFieldBegin('id', TType.I64, 1)
4103 
      oprot.writeI64(self.id)
4104 
      oprot.writeFieldEnd()
4105 
    oprot.writeFieldStop()
4106 
    oprot.writeStructEnd()
4107 
 
3431 rajveer 4108 
  def validate(self):
4109 
    return
4110 
 
4111 
 
94 ashish 4112 
  def __repr__(self):
4113 
    L = ['%s=%r' % (key, value)
4114 
      for key, value in self.__dict__.iteritems()]
4115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4116 
 
4117 
  def __eq__(self, other):
4118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4119 
 
4120 
  def __ne__(self, other):
4121 
    return not (self == other)
4122 
 
4123 
class getTransaction_result:
4124 
  """
4125 
  Attributes:
4126 
   - success
4127 
   - ex
4128 
  """
4129 
 
4130 
  thrift_spec = (
4131 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4133 
  )
4134 
 
4135 
  def __init__(self, success=None, ex=None,):
4136 
    self.success = success
4137 
    self.ex = ex
4138 
 
4139 
  def read(self, iprot):
4140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4142 
      return
4143 
    iprot.readStructBegin()
4144 
    while True:
4145 
      (fname, ftype, fid) = iprot.readFieldBegin()
4146 
      if ftype == TType.STOP:
4147 
        break
4148 
      if fid == 0:
4149 
        if ftype == TType.STRUCT:
4150 
          self.success = Transaction()
4151 
          self.success.read(iprot)
4152 
        else:
4153 
          iprot.skip(ftype)
4154 
      elif fid == 1:
4155 
        if ftype == TType.STRUCT:
4156 
          self.ex = TransactionServiceException()
4157 
          self.ex.read(iprot)
4158 
        else:
4159 
          iprot.skip(ftype)
4160 
      else:
4161 
        iprot.skip(ftype)
4162 
      iprot.readFieldEnd()
4163 
    iprot.readStructEnd()
4164 
 
4165 
  def write(self, oprot):
4166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4168 
      return
4169 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4170 
    if self.success is not None:
94 ashish 4171 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4172 
      self.success.write(oprot)
4173 
      oprot.writeFieldEnd()
3431 rajveer 4174 
    if self.ex is not None:
94 ashish 4175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4176 
      self.ex.write(oprot)
4177 
      oprot.writeFieldEnd()
4178 
    oprot.writeFieldStop()
4179 
    oprot.writeStructEnd()
4180 
 
3431 rajveer 4181 
  def validate(self):
4182 
    return
4183 
 
4184 
 
94 ashish 4185 
  def __repr__(self):
4186 
    L = ['%s=%r' % (key, value)
4187 
      for key, value in self.__dict__.iteritems()]
4188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4189 
 
4190 
  def __eq__(self, other):
4191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4192 
 
4193 
  def __ne__(self, other):
4194 
    return not (self == other)
4195 
 
4196 
class getTransactionsForCustomer_args:
4197 
  """
4198 
  Attributes:
4199 
   - customerId
4200 
   - from_date
4201 
   - to_date
4202 
   - status
4203 
  """
4204 
 
4205 
  thrift_spec = (
4206 
    None, # 0
4207 
    (1, TType.I64, 'customerId', None, None, ), # 1
4208 
    (2, TType.I64, 'from_date', None, None, ), # 2
4209 
    (3, TType.I64, 'to_date', None, None, ), # 3
4210 
    (4, TType.I32, 'status', None, None, ), # 4
4211 
  )
4212 
 
4213 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4214 
    self.customerId = customerId
4215 
    self.from_date = from_date
4216 
    self.to_date = to_date
4217 
    self.status = status
4218 
 
4219 
  def read(self, iprot):
4220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4222 
      return
4223 
    iprot.readStructBegin()
4224 
    while True:
4225 
      (fname, ftype, fid) = iprot.readFieldBegin()
4226 
      if ftype == TType.STOP:
4227 
        break
4228 
      if fid == 1:
4229 
        if ftype == TType.I64:
4230 
          self.customerId = iprot.readI64();
4231 
        else:
4232 
          iprot.skip(ftype)
4233 
      elif fid == 2:
4234 
        if ftype == TType.I64:
4235 
          self.from_date = iprot.readI64();
4236 
        else:
4237 
          iprot.skip(ftype)
4238 
      elif fid == 3:
4239 
        if ftype == TType.I64:
4240 
          self.to_date = iprot.readI64();
4241 
        else:
4242 
          iprot.skip(ftype)
4243 
      elif fid == 4:
4244 
        if ftype == TType.I32:
4245 
          self.status = iprot.readI32();
4246 
        else:
4247 
          iprot.skip(ftype)
4248 
      else:
4249 
        iprot.skip(ftype)
4250 
      iprot.readFieldEnd()
4251 
    iprot.readStructEnd()
4252 
 
4253 
  def write(self, oprot):
4254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4256 
      return
4257 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4258 
    if self.customerId is not None:
94 ashish 4259 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4260 
      oprot.writeI64(self.customerId)
4261 
      oprot.writeFieldEnd()
3431 rajveer 4262 
    if self.from_date is not None:
94 ashish 4263 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4264 
      oprot.writeI64(self.from_date)
4265 
      oprot.writeFieldEnd()
3431 rajveer 4266 
    if self.to_date is not None:
94 ashish 4267 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4268 
      oprot.writeI64(self.to_date)
4269 
      oprot.writeFieldEnd()
3431 rajveer 4270 
    if self.status is not None:
94 ashish 4271 
      oprot.writeFieldBegin('status', TType.I32, 4)
4272 
      oprot.writeI32(self.status)
4273 
      oprot.writeFieldEnd()
4274 
    oprot.writeFieldStop()
4275 
    oprot.writeStructEnd()
4276 
 
3431 rajveer 4277 
  def validate(self):
4278 
    return
4279 
 
4280 
 
94 ashish 4281 
  def __repr__(self):
4282 
    L = ['%s=%r' % (key, value)
4283 
      for key, value in self.__dict__.iteritems()]
4284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4285 
 
4286 
  def __eq__(self, other):
4287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4288 
 
4289 
  def __ne__(self, other):
4290 
    return not (self == other)
4291 
 
4292 
class getTransactionsForCustomer_result:
4293 
  """
4294 
  Attributes:
4295 
   - success
4296 
   - ex
4297 
  """
4298 
 
4299 
  thrift_spec = (
4300 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4302 
  )
4303 
 
4304 
  def __init__(self, success=None, ex=None,):
4305 
    self.success = success
4306 
    self.ex = ex
4307 
 
4308 
  def read(self, iprot):
4309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4311 
      return
4312 
    iprot.readStructBegin()
4313 
    while True:
4314 
      (fname, ftype, fid) = iprot.readFieldBegin()
4315 
      if ftype == TType.STOP:
4316 
        break
4317 
      if fid == 0:
4318 
        if ftype == TType.LIST:
4319 
          self.success = []
685 chandransh 4320 
          (_etype17, _size14) = iprot.readListBegin()
4321 
          for _i18 in xrange(_size14):
4322 
            _elem19 = Transaction()
4323 
            _elem19.read(iprot)
4324 
            self.success.append(_elem19)
94 ashish 4325 
          iprot.readListEnd()
4326 
        else:
4327 
          iprot.skip(ftype)
4328 
      elif fid == 1:
4329 
        if ftype == TType.STRUCT:
4330 
          self.ex = TransactionServiceException()
4331 
          self.ex.read(iprot)
4332 
        else:
4333 
          iprot.skip(ftype)
4334 
      else:
4335 
        iprot.skip(ftype)
4336 
      iprot.readFieldEnd()
4337 
    iprot.readStructEnd()
4338 
 
4339 
  def write(self, oprot):
4340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4342 
      return
4343 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4344 
    if self.success is not None:
94 ashish 4345 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4346 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4347 
      for iter20 in self.success:
4348 
        iter20.write(oprot)
94 ashish 4349 
      oprot.writeListEnd()
4350 
      oprot.writeFieldEnd()
3431 rajveer 4351 
    if self.ex is not None:
94 ashish 4352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4353 
      self.ex.write(oprot)
4354 
      oprot.writeFieldEnd()
4355 
    oprot.writeFieldStop()
4356 
    oprot.writeStructEnd()
4357 
 
3431 rajveer 4358 
  def validate(self):
4359 
    return
4360 
 
4361 
 
94 ashish 4362 
  def __repr__(self):
4363 
    L = ['%s=%r' % (key, value)
4364 
      for key, value in self.__dict__.iteritems()]
4365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4366 
 
4367 
  def __eq__(self, other):
4368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4369 
 
4370 
  def __ne__(self, other):
4371 
    return not (self == other)
4372 
 
132 ashish 4373 
class getTransactionsForShoppingCartId_args:
4374 
  """
4375 
  Attributes:
4376 
   - shoppingCartId
4377 
  """
4378 
 
4379 
  thrift_spec = (
4380 
    None, # 0
4381 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4382 
  )
4383 
 
4384 
  def __init__(self, shoppingCartId=None,):
4385 
    self.shoppingCartId = shoppingCartId
4386 
 
4387 
  def read(self, iprot):
4388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4390 
      return
4391 
    iprot.readStructBegin()
4392 
    while True:
4393 
      (fname, ftype, fid) = iprot.readFieldBegin()
4394 
      if ftype == TType.STOP:
4395 
        break
4396 
      if fid == 1:
4397 
        if ftype == TType.I64:
4398 
          self.shoppingCartId = iprot.readI64();
4399 
        else:
4400 
          iprot.skip(ftype)
4401 
      else:
4402 
        iprot.skip(ftype)
4403 
      iprot.readFieldEnd()
4404 
    iprot.readStructEnd()
4405 
 
4406 
  def write(self, oprot):
4407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4409 
      return
4410 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4411 
    if self.shoppingCartId is not None:
132 ashish 4412 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4413 
      oprot.writeI64(self.shoppingCartId)
4414 
      oprot.writeFieldEnd()
4415 
    oprot.writeFieldStop()
4416 
    oprot.writeStructEnd()
4417 
 
3431 rajveer 4418 
  def validate(self):
4419 
    return
4420 
 
4421 
 
132 ashish 4422 
  def __repr__(self):
4423 
    L = ['%s=%r' % (key, value)
4424 
      for key, value in self.__dict__.iteritems()]
4425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4426 
 
4427 
  def __eq__(self, other):
4428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4429 
 
4430 
  def __ne__(self, other):
4431 
    return not (self == other)
4432 
 
4433 
class getTransactionsForShoppingCartId_result:
4434 
  """
4435 
  Attributes:
4436 
   - success
4437 
   - ex
4438 
  """
4439 
 
4440 
  thrift_spec = (
4441 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4443 
  )
4444 
 
4445 
  def __init__(self, success=None, ex=None,):
4446 
    self.success = success
4447 
    self.ex = ex
4448 
 
4449 
  def read(self, iprot):
4450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4452 
      return
4453 
    iprot.readStructBegin()
4454 
    while True:
4455 
      (fname, ftype, fid) = iprot.readFieldBegin()
4456 
      if ftype == TType.STOP:
4457 
        break
4458 
      if fid == 0:
4459 
        if ftype == TType.LIST:
4460 
          self.success = []
685 chandransh 4461 
          (_etype24, _size21) = iprot.readListBegin()
4462 
          for _i25 in xrange(_size21):
4463 
            _elem26 = Transaction()
4464 
            _elem26.read(iprot)
4465 
            self.success.append(_elem26)
132 ashish 4466 
          iprot.readListEnd()
4467 
        else:
4468 
          iprot.skip(ftype)
4469 
      elif fid == 1:
4470 
        if ftype == TType.STRUCT:
4471 
          self.ex = TransactionServiceException()
4472 
          self.ex.read(iprot)
4473 
        else:
4474 
          iprot.skip(ftype)
4475 
      else:
4476 
        iprot.skip(ftype)
4477 
      iprot.readFieldEnd()
4478 
    iprot.readStructEnd()
4479 
 
4480 
  def write(self, oprot):
4481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4483 
      return
4484 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4485 
    if self.success is not None:
132 ashish 4486 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4487 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4488 
      for iter27 in self.success:
4489 
        iter27.write(oprot)
132 ashish 4490 
      oprot.writeListEnd()
4491 
      oprot.writeFieldEnd()
3431 rajveer 4492 
    if self.ex is not None:
132 ashish 4493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4494 
      self.ex.write(oprot)
4495 
      oprot.writeFieldEnd()
4496 
    oprot.writeFieldStop()
4497 
    oprot.writeStructEnd()
4498 
 
3431 rajveer 4499 
  def validate(self):
4500 
    return
4501 
 
4502 
 
132 ashish 4503 
  def __repr__(self):
4504 
    L = ['%s=%r' % (key, value)
4505 
      for key, value in self.__dict__.iteritems()]
4506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4507 
 
4508 
  def __eq__(self, other):
4509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4510 
 
4511 
  def __ne__(self, other):
4512 
    return not (self == other)
4513 
 
94 ashish 4514 
class getTransactionStatus_args:
4515 
  """
4516 
  Attributes:
4517 
   - transactionId
4518 
  """
4519 
 
4520 
  thrift_spec = (
4521 
    None, # 0
4522 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4523 
  )
4524 
 
4525 
  def __init__(self, transactionId=None,):
4526 
    self.transactionId = transactionId
4527 
 
4528 
  def read(self, iprot):
4529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4531 
      return
4532 
    iprot.readStructBegin()
4533 
    while True:
4534 
      (fname, ftype, fid) = iprot.readFieldBegin()
4535 
      if ftype == TType.STOP:
4536 
        break
4537 
      if fid == 1:
4538 
        if ftype == TType.I64:
4539 
          self.transactionId = iprot.readI64();
4540 
        else:
4541 
          iprot.skip(ftype)
4542 
      else:
4543 
        iprot.skip(ftype)
4544 
      iprot.readFieldEnd()
4545 
    iprot.readStructEnd()
4546 
 
4547 
  def write(self, oprot):
4548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4550 
      return
4551 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4552 
    if self.transactionId is not None:
94 ashish 4553 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4554 
      oprot.writeI64(self.transactionId)
4555 
      oprot.writeFieldEnd()
4556 
    oprot.writeFieldStop()
4557 
    oprot.writeStructEnd()
4558 
 
3431 rajveer 4559 
  def validate(self):
4560 
    return
4561 
 
4562 
 
94 ashish 4563 
  def __repr__(self):
4564 
    L = ['%s=%r' % (key, value)
4565 
      for key, value in self.__dict__.iteritems()]
4566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4567 
 
4568 
  def __eq__(self, other):
4569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4570 
 
4571 
  def __ne__(self, other):
4572 
    return not (self == other)
4573 
 
4574 
class getTransactionStatus_result:
4575 
  """
4576 
  Attributes:
4577 
   - success
4578 
   - ex
4579 
  """
4580 
 
4581 
  thrift_spec = (
4582 
    (0, TType.I32, 'success', None, None, ), # 0
4583 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4584 
  )
4585 
 
4586 
  def __init__(self, success=None, ex=None,):
4587 
    self.success = success
4588 
    self.ex = ex
4589 
 
4590 
  def read(self, iprot):
4591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4593 
      return
4594 
    iprot.readStructBegin()
4595 
    while True:
4596 
      (fname, ftype, fid) = iprot.readFieldBegin()
4597 
      if ftype == TType.STOP:
4598 
        break
4599 
      if fid == 0:
4600 
        if ftype == TType.I32:
4601 
          self.success = iprot.readI32();
4602 
        else:
4603 
          iprot.skip(ftype)
4604 
      elif fid == 1:
4605 
        if ftype == TType.STRUCT:
4606 
          self.ex = TransactionServiceException()
4607 
          self.ex.read(iprot)
4608 
        else:
4609 
          iprot.skip(ftype)
4610 
      else:
4611 
        iprot.skip(ftype)
4612 
      iprot.readFieldEnd()
4613 
    iprot.readStructEnd()
4614 
 
4615 
  def write(self, oprot):
4616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4618 
      return
4619 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4620 
    if self.success is not None:
94 ashish 4621 
      oprot.writeFieldBegin('success', TType.I32, 0)
4622 
      oprot.writeI32(self.success)
4623 
      oprot.writeFieldEnd()
3431 rajveer 4624 
    if self.ex is not None:
94 ashish 4625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4626 
      self.ex.write(oprot)
4627 
      oprot.writeFieldEnd()
4628 
    oprot.writeFieldStop()
4629 
    oprot.writeStructEnd()
4630 
 
3431 rajveer 4631 
  def validate(self):
4632 
    return
4633 
 
4634 
 
94 ashish 4635 
  def __repr__(self):
4636 
    L = ['%s=%r' % (key, value)
4637 
      for key, value in self.__dict__.iteritems()]
4638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4639 
 
4640 
  def __eq__(self, other):
4641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4642 
 
4643 
  def __ne__(self, other):
4644 
    return not (self == other)
4645 
 
4646 
class changeTransactionStatus_args:
4647 
  """
4648 
  Attributes:
4649 
   - transactionId
4650 
   - status
4651 
   - description
4652 
  """
4653 
 
4654 
  thrift_spec = (
4655 
    None, # 0
4656 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4657 
    (2, TType.I32, 'status', None, None, ), # 2
4658 
    (3, TType.STRING, 'description', None, None, ), # 3
4659 
  )
4660 
 
4661 
  def __init__(self, transactionId=None, status=None, description=None,):
4662 
    self.transactionId = transactionId
4663 
    self.status = status
4664 
    self.description = description
4665 
 
4666 
  def read(self, iprot):
4667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4669 
      return
4670 
    iprot.readStructBegin()
4671 
    while True:
4672 
      (fname, ftype, fid) = iprot.readFieldBegin()
4673 
      if ftype == TType.STOP:
4674 
        break
4675 
      if fid == 1:
4676 
        if ftype == TType.I64:
4677 
          self.transactionId = iprot.readI64();
4678 
        else:
4679 
          iprot.skip(ftype)
4680 
      elif fid == 2:
4681 
        if ftype == TType.I32:
4682 
          self.status = iprot.readI32();
4683 
        else:
4684 
          iprot.skip(ftype)
4685 
      elif fid == 3:
4686 
        if ftype == TType.STRING:
4687 
          self.description = iprot.readString();
4688 
        else:
4689 
          iprot.skip(ftype)
4690 
      else:
4691 
        iprot.skip(ftype)
4692 
      iprot.readFieldEnd()
4693 
    iprot.readStructEnd()
4694 
 
4695 
  def write(self, oprot):
4696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4698 
      return
4699 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4700 
    if self.transactionId is not None:
94 ashish 4701 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4702 
      oprot.writeI64(self.transactionId)
4703 
      oprot.writeFieldEnd()
3431 rajveer 4704 
    if self.status is not None:
94 ashish 4705 
      oprot.writeFieldBegin('status', TType.I32, 2)
4706 
      oprot.writeI32(self.status)
4707 
      oprot.writeFieldEnd()
3431 rajveer 4708 
    if self.description is not None:
94 ashish 4709 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4710 
      oprot.writeString(self.description)
4711 
      oprot.writeFieldEnd()
4712 
    oprot.writeFieldStop()
4713 
    oprot.writeStructEnd()
4714 
 
3431 rajveer 4715 
  def validate(self):
4716 
    return
4717 
 
4718 
 
94 ashish 4719 
  def __repr__(self):
4720 
    L = ['%s=%r' % (key, value)
4721 
      for key, value in self.__dict__.iteritems()]
4722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4723 
 
4724 
  def __eq__(self, other):
4725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4726 
 
4727 
  def __ne__(self, other):
4728 
    return not (self == other)
4729 
 
4730 
class changeTransactionStatus_result:
4731 
  """
4732 
  Attributes:
4733 
   - success
4734 
   - ex
4735 
  """
4736 
 
4737 
  thrift_spec = (
4738 
    (0, TType.BOOL, 'success', None, None, ), # 0
4739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4740 
  )
4741 
 
4742 
  def __init__(self, success=None, ex=None,):
4743 
    self.success = success
4744 
    self.ex = ex
4745 
 
4746 
  def read(self, iprot):
4747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4749 
      return
4750 
    iprot.readStructBegin()
4751 
    while True:
4752 
      (fname, ftype, fid) = iprot.readFieldBegin()
4753 
      if ftype == TType.STOP:
4754 
        break
4755 
      if fid == 0:
4756 
        if ftype == TType.BOOL:
4757 
          self.success = iprot.readBool();
4758 
        else:
4759 
          iprot.skip(ftype)
4760 
      elif fid == 1:
4761 
        if ftype == TType.STRUCT:
4762 
          self.ex = TransactionServiceException()
4763 
          self.ex.read(iprot)
4764 
        else:
4765 
          iprot.skip(ftype)
4766 
      else:
4767 
        iprot.skip(ftype)
4768 
      iprot.readFieldEnd()
4769 
    iprot.readStructEnd()
4770 
 
4771 
  def write(self, oprot):
4772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4774 
      return
4775 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4776 
    if self.success is not None:
94 ashish 4777 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4778 
      oprot.writeBool(self.success)
4779 
      oprot.writeFieldEnd()
3431 rajveer 4780 
    if self.ex is not None:
94 ashish 4781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4782 
      self.ex.write(oprot)
4783 
      oprot.writeFieldEnd()
4784 
    oprot.writeFieldStop()
4785 
    oprot.writeStructEnd()
4786 
 
3431 rajveer 4787 
  def validate(self):
4788 
    return
4789 
 
4790 
 
94 ashish 4791 
  def __repr__(self):
4792 
    L = ['%s=%r' % (key, value)
4793 
      for key, value in self.__dict__.iteritems()]
4794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4795 
 
4796 
  def __eq__(self, other):
4797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4798 
 
4799 
  def __ne__(self, other):
4800 
    return not (self == other)
4801 
 
1398 varun.gupt 4802 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4803 
  """
4804 
  Attributes:
4805 
   - transactionId
4806 
  """
4807 
 
4808 
  thrift_spec = (
4809 
    None, # 0
4810 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4811 
  )
4812 
 
4813 
  def __init__(self, transactionId=None,):
4814 
    self.transactionId = transactionId
4815 
 
4816 
  def read(self, iprot):
4817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4819 
      return
4820 
    iprot.readStructBegin()
4821 
    while True:
4822 
      (fname, ftype, fid) = iprot.readFieldBegin()
4823 
      if ftype == TType.STOP:
4824 
        break
4825 
      if fid == 1:
4826 
        if ftype == TType.I64:
4827 
          self.transactionId = iprot.readI64();
4828 
        else:
4829 
          iprot.skip(ftype)
4830 
      else:
4831 
        iprot.skip(ftype)
4832 
      iprot.readFieldEnd()
4833 
    iprot.readStructEnd()
4834 
 
4835 
  def write(self, oprot):
4836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4838 
      return
1398 varun.gupt 4839 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4840 
    if self.transactionId is not None:
1382 varun.gupt 4841 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4842 
      oprot.writeI64(self.transactionId)
4843 
      oprot.writeFieldEnd()
4844 
    oprot.writeFieldStop()
4845 
    oprot.writeStructEnd()
4846 
 
3431 rajveer 4847 
  def validate(self):
4848 
    return
4849 
 
4850 
 
1382 varun.gupt 4851 
  def __repr__(self):
4852 
    L = ['%s=%r' % (key, value)
4853 
      for key, value in self.__dict__.iteritems()]
4854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4855 
 
4856 
  def __eq__(self, other):
4857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4858 
 
4859 
  def __ne__(self, other):
4860 
    return not (self == other)
4861 
 
1398 varun.gupt 4862 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4863 
  """
4864 
  Attributes:
4865 
   - success
4866 
   - ex
4867 
  """
4868 
 
4869 
  thrift_spec = (
4870 
    (0, TType.BOOL, 'success', None, None, ), # 0
4871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4872 
  )
4873 
 
4874 
  def __init__(self, success=None, ex=None,):
4875 
    self.success = success
4876 
    self.ex = ex
4877 
 
4878 
  def read(self, iprot):
4879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4881 
      return
4882 
    iprot.readStructBegin()
4883 
    while True:
4884 
      (fname, ftype, fid) = iprot.readFieldBegin()
4885 
      if ftype == TType.STOP:
4886 
        break
4887 
      if fid == 0:
4888 
        if ftype == TType.BOOL:
4889 
          self.success = iprot.readBool();
4890 
        else:
4891 
          iprot.skip(ftype)
4892 
      elif fid == 1:
4893 
        if ftype == TType.STRUCT:
4894 
          self.ex = TransactionServiceException()
4895 
          self.ex.read(iprot)
4896 
        else:
4897 
          iprot.skip(ftype)
4898 
      else:
4899 
        iprot.skip(ftype)
4900 
      iprot.readFieldEnd()
4901 
    iprot.readStructEnd()
4902 
 
4903 
  def write(self, oprot):
4904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4906 
      return
1398 varun.gupt 4907 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 4908 
    if self.success is not None:
1382 varun.gupt 4909 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4910 
      oprot.writeBool(self.success)
4911 
      oprot.writeFieldEnd()
3431 rajveer 4912 
    if self.ex is not None:
1382 varun.gupt 4913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4914 
      self.ex.write(oprot)
4915 
      oprot.writeFieldEnd()
4916 
    oprot.writeFieldStop()
4917 
    oprot.writeStructEnd()
4918 
 
3431 rajveer 4919 
  def validate(self):
4920 
    return
4921 
 
4922 
 
1382 varun.gupt 4923 
  def __repr__(self):
4924 
    L = ['%s=%r' % (key, value)
4925 
      for key, value in self.__dict__.iteritems()]
4926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4927 
 
4928 
  def __eq__(self, other):
4929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4930 
 
4931 
  def __ne__(self, other):
4932 
    return not (self == other)
4933 
 
483 rajveer 4934 
class getAllOrders_args:
94 ashish 4935 
  """
4936 
  Attributes:
483 rajveer 4937 
   - status
4938 
   - from_date
4939 
   - to_date
4940 
   - warehouse_id
94 ashish 4941 
  """
4942 
 
4943 
  thrift_spec = (
4944 
    None, # 0
483 rajveer 4945 
    (1, TType.I32, 'status', None, None, ), # 1
4946 
    (2, TType.I64, 'from_date', None, None, ), # 2
4947 
    (3, TType.I64, 'to_date', None, None, ), # 3
4948 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 4949 
  )
4950 
 
483 rajveer 4951 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
4952 
    self.status = status
4953 
    self.from_date = from_date
4954 
    self.to_date = to_date
4955 
    self.warehouse_id = warehouse_id
94 ashish 4956 
 
4957 
  def read(self, iprot):
4958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4960 
      return
4961 
    iprot.readStructBegin()
4962 
    while True:
4963 
      (fname, ftype, fid) = iprot.readFieldBegin()
4964 
      if ftype == TType.STOP:
4965 
        break
4966 
      if fid == 1:
483 rajveer 4967 
        if ftype == TType.I32:
4968 
          self.status = iprot.readI32();
94 ashish 4969 
        else:
4970 
          iprot.skip(ftype)
483 rajveer 4971 
      elif fid == 2:
4972 
        if ftype == TType.I64:
4973 
          self.from_date = iprot.readI64();
94 ashish 4974 
        else:
4975 
          iprot.skip(ftype)
483 rajveer 4976 
      elif fid == 3:
4977 
        if ftype == TType.I64:
4978 
          self.to_date = iprot.readI64();
94 ashish 4979 
        else:
4980 
          iprot.skip(ftype)
483 rajveer 4981 
      elif fid == 4:
94 ashish 4982 
        if ftype == TType.I64:
483 rajveer 4983 
          self.warehouse_id = iprot.readI64();
94 ashish 4984 
        else:
4985 
          iprot.skip(ftype)
4986 
      else:
4987 
        iprot.skip(ftype)
4988 
      iprot.readFieldEnd()
4989 
    iprot.readStructEnd()
4990 
 
4991 
  def write(self, oprot):
4992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4994 
      return
483 rajveer 4995 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 4996 
    if self.status is not None:
483 rajveer 4997 
      oprot.writeFieldBegin('status', TType.I32, 1)
4998 
      oprot.writeI32(self.status)
94 ashish 4999 
      oprot.writeFieldEnd()
3431 rajveer 5000 
    if self.from_date is not None:
483 rajveer 5001 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5002 
      oprot.writeI64(self.from_date)
94 ashish 5003 
      oprot.writeFieldEnd()
3431 rajveer 5004 
    if self.to_date is not None:
483 rajveer 5005 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5006 
      oprot.writeI64(self.to_date)
94 ashish 5007 
      oprot.writeFieldEnd()
3431 rajveer 5008 
    if self.warehouse_id is not None:
483 rajveer 5009 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5010 
      oprot.writeI64(self.warehouse_id)
94 ashish 5011 
      oprot.writeFieldEnd()
5012 
    oprot.writeFieldStop()
5013 
    oprot.writeStructEnd()
5014 
 
3431 rajveer 5015 
  def validate(self):
5016 
    return
5017 
 
5018 
 
94 ashish 5019 
  def __repr__(self):
5020 
    L = ['%s=%r' % (key, value)
5021 
      for key, value in self.__dict__.iteritems()]
5022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5023 
 
5024 
  def __eq__(self, other):
5025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5026 
 
5027 
  def __ne__(self, other):
5028 
    return not (self == other)
5029 
 
483 rajveer 5030 
class getAllOrders_result:
94 ashish 5031 
  """
5032 
  Attributes:
5033 
   - success
5034 
   - ex
5035 
  """
5036 
 
5037 
  thrift_spec = (
483 rajveer 5038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5040 
  )
5041 
 
5042 
  def __init__(self, success=None, ex=None,):
5043 
    self.success = success
5044 
    self.ex = ex
5045 
 
5046 
  def read(self, iprot):
5047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5049 
      return
5050 
    iprot.readStructBegin()
5051 
    while True:
5052 
      (fname, ftype, fid) = iprot.readFieldBegin()
5053 
      if ftype == TType.STOP:
5054 
        break
5055 
      if fid == 0:
483 rajveer 5056 
        if ftype == TType.LIST:
5057 
          self.success = []
685 chandransh 5058 
          (_etype31, _size28) = iprot.readListBegin()
5059 
          for _i32 in xrange(_size28):
5060 
            _elem33 = Order()
5061 
            _elem33.read(iprot)
5062 
            self.success.append(_elem33)
483 rajveer 5063 
          iprot.readListEnd()
94 ashish 5064 
        else:
5065 
          iprot.skip(ftype)
5066 
      elif fid == 1:
5067 
        if ftype == TType.STRUCT:
5068 
          self.ex = TransactionServiceException()
5069 
          self.ex.read(iprot)
5070 
        else:
5071 
          iprot.skip(ftype)
5072 
      else:
5073 
        iprot.skip(ftype)
5074 
      iprot.readFieldEnd()
5075 
    iprot.readStructEnd()
5076 
 
5077 
  def write(self, oprot):
5078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5080 
      return
483 rajveer 5081 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5082 
    if self.success is not None:
483 rajveer 5083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5085 
      for iter34 in self.success:
5086 
        iter34.write(oprot)
483 rajveer 5087 
      oprot.writeListEnd()
94 ashish 5088 
      oprot.writeFieldEnd()
3431 rajveer 5089 
    if self.ex is not None:
94 ashish 5090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5091 
      self.ex.write(oprot)
5092 
      oprot.writeFieldEnd()
5093 
    oprot.writeFieldStop()
5094 
    oprot.writeStructEnd()
5095 
 
3431 rajveer 5096 
  def validate(self):
5097 
    return
5098 
 
5099 
 
94 ashish 5100 
  def __repr__(self):
5101 
    L = ['%s=%r' % (key, value)
5102 
      for key, value in self.__dict__.iteritems()]
5103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5104 
 
5105 
  def __eq__(self, other):
5106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5107 
 
5108 
  def __ne__(self, other):
5109 
    return not (self == other)
5110 
 
4133 chandransh 5111 
class getOrdersInBatch_args:
5112 
  """
5113 
  Attributes:
5114 
   - statuses
5115 
   - offset
5116 
   - limit
5117 
   - warehouse_id
5118 
  """
5119 
 
5120 
  thrift_spec = (
5121 
    None, # 0
5122 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5123 
    (2, TType.I64, 'offset', None, None, ), # 2
5124 
    (3, TType.I64, 'limit', None, None, ), # 3
5125 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5126 
  )
5127 
 
5128 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5129 
    self.statuses = statuses
5130 
    self.offset = offset
5131 
    self.limit = limit
5132 
    self.warehouse_id = warehouse_id
5133 
 
5134 
  def read(self, iprot):
5135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5137 
      return
5138 
    iprot.readStructBegin()
5139 
    while True:
5140 
      (fname, ftype, fid) = iprot.readFieldBegin()
5141 
      if ftype == TType.STOP:
5142 
        break
5143 
      if fid == 1:
5144 
        if ftype == TType.LIST:
5145 
          self.statuses = []
5146 
          (_etype38, _size35) = iprot.readListBegin()
5147 
          for _i39 in xrange(_size35):
5148 
            _elem40 = iprot.readI32();
5149 
            self.statuses.append(_elem40)
5150 
          iprot.readListEnd()
5151 
        else:
5152 
          iprot.skip(ftype)
5153 
      elif fid == 2:
5154 
        if ftype == TType.I64:
5155 
          self.offset = iprot.readI64();
5156 
        else:
5157 
          iprot.skip(ftype)
5158 
      elif fid == 3:
5159 
        if ftype == TType.I64:
5160 
          self.limit = iprot.readI64();
5161 
        else:
5162 
          iprot.skip(ftype)
5163 
      elif fid == 4:
5164 
        if ftype == TType.I64:
5165 
          self.warehouse_id = iprot.readI64();
5166 
        else:
5167 
          iprot.skip(ftype)
5168 
      else:
5169 
        iprot.skip(ftype)
5170 
      iprot.readFieldEnd()
5171 
    iprot.readStructEnd()
5172 
 
5173 
  def write(self, oprot):
5174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5176 
      return
5177 
    oprot.writeStructBegin('getOrdersInBatch_args')
5178 
    if self.statuses is not None:
5179 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5180 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5181 
      for iter41 in self.statuses:
5182 
        oprot.writeI32(iter41)
5183 
      oprot.writeListEnd()
5184 
      oprot.writeFieldEnd()
5185 
    if self.offset is not None:
5186 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5187 
      oprot.writeI64(self.offset)
5188 
      oprot.writeFieldEnd()
5189 
    if self.limit is not None:
5190 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5191 
      oprot.writeI64(self.limit)
5192 
      oprot.writeFieldEnd()
5193 
    if self.warehouse_id is not None:
5194 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5195 
      oprot.writeI64(self.warehouse_id)
5196 
      oprot.writeFieldEnd()
5197 
    oprot.writeFieldStop()
5198 
    oprot.writeStructEnd()
5199 
 
5200 
  def validate(self):
5201 
    return
5202 
 
5203 
 
5204 
  def __repr__(self):
5205 
    L = ['%s=%r' % (key, value)
5206 
      for key, value in self.__dict__.iteritems()]
5207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5208 
 
5209 
  def __eq__(self, other):
5210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5211 
 
5212 
  def __ne__(self, other):
5213 
    return not (self == other)
5214 
 
5215 
class getOrdersInBatch_result:
5216 
  """
5217 
  Attributes:
5218 
   - success
5219 
   - ex
5220 
  """
5221 
 
5222 
  thrift_spec = (
5223 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5225 
  )
5226 
 
5227 
  def __init__(self, success=None, ex=None,):
5228 
    self.success = success
5229 
    self.ex = ex
5230 
 
5231 
  def read(self, iprot):
5232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5234 
      return
5235 
    iprot.readStructBegin()
5236 
    while True:
5237 
      (fname, ftype, fid) = iprot.readFieldBegin()
5238 
      if ftype == TType.STOP:
5239 
        break
5240 
      if fid == 0:
5241 
        if ftype == TType.LIST:
5242 
          self.success = []
5243 
          (_etype45, _size42) = iprot.readListBegin()
5244 
          for _i46 in xrange(_size42):
5245 
            _elem47 = Order()
5246 
            _elem47.read(iprot)
5247 
            self.success.append(_elem47)
5248 
          iprot.readListEnd()
5249 
        else:
5250 
          iprot.skip(ftype)
5251 
      elif fid == 1:
5252 
        if ftype == TType.STRUCT:
5253 
          self.ex = TransactionServiceException()
5254 
          self.ex.read(iprot)
5255 
        else:
5256 
          iprot.skip(ftype)
5257 
      else:
5258 
        iprot.skip(ftype)
5259 
      iprot.readFieldEnd()
5260 
    iprot.readStructEnd()
5261 
 
5262 
  def write(self, oprot):
5263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5265 
      return
5266 
    oprot.writeStructBegin('getOrdersInBatch_result')
5267 
    if self.success is not None:
5268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5269 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5270 
      for iter48 in self.success:
5271 
        iter48.write(oprot)
5272 
      oprot.writeListEnd()
5273 
      oprot.writeFieldEnd()
5274 
    if self.ex is not None:
5275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5276 
      self.ex.write(oprot)
5277 
      oprot.writeFieldEnd()
5278 
    oprot.writeFieldStop()
5279 
    oprot.writeStructEnd()
5280 
 
5281 
  def validate(self):
5282 
    return
5283 
 
5284 
 
5285 
  def __repr__(self):
5286 
    L = ['%s=%r' % (key, value)
5287 
      for key, value in self.__dict__.iteritems()]
5288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5289 
 
5290 
  def __eq__(self, other):
5291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5292 
 
5293 
  def __ne__(self, other):
5294 
    return not (self == other)
5295 
 
5296 
class getOrderCount_args:
5297 
  """
5298 
  Attributes:
5299 
   - statuses
5300 
   - warehouseId
5301 
  """
5302 
 
5303 
  thrift_spec = (
5304 
    None, # 0
5305 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5306 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5307 
  )
5308 
 
5309 
  def __init__(self, statuses=None, warehouseId=None,):
5310 
    self.statuses = statuses
5311 
    self.warehouseId = warehouseId
5312 
 
5313 
  def read(self, iprot):
5314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5316 
      return
5317 
    iprot.readStructBegin()
5318 
    while True:
5319 
      (fname, ftype, fid) = iprot.readFieldBegin()
5320 
      if ftype == TType.STOP:
5321 
        break
5322 
      if fid == 1:
5323 
        if ftype == TType.LIST:
5324 
          self.statuses = []
5325 
          (_etype52, _size49) = iprot.readListBegin()
5326 
          for _i53 in xrange(_size49):
5327 
            _elem54 = iprot.readI32();
5328 
            self.statuses.append(_elem54)
5329 
          iprot.readListEnd()
5330 
        else:
5331 
          iprot.skip(ftype)
5332 
      elif fid == 2:
5333 
        if ftype == TType.I64:
5334 
          self.warehouseId = iprot.readI64();
5335 
        else:
5336 
          iprot.skip(ftype)
5337 
      else:
5338 
        iprot.skip(ftype)
5339 
      iprot.readFieldEnd()
5340 
    iprot.readStructEnd()
5341 
 
5342 
  def write(self, oprot):
5343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5345 
      return
5346 
    oprot.writeStructBegin('getOrderCount_args')
5347 
    if self.statuses is not None:
5348 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5349 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5350 
      for iter55 in self.statuses:
5351 
        oprot.writeI32(iter55)
5352 
      oprot.writeListEnd()
5353 
      oprot.writeFieldEnd()
5354 
    if self.warehouseId is not None:
5355 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5356 
      oprot.writeI64(self.warehouseId)
5357 
      oprot.writeFieldEnd()
5358 
    oprot.writeFieldStop()
5359 
    oprot.writeStructEnd()
5360 
 
5361 
  def validate(self):
5362 
    return
5363 
 
5364 
 
5365 
  def __repr__(self):
5366 
    L = ['%s=%r' % (key, value)
5367 
      for key, value in self.__dict__.iteritems()]
5368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5369 
 
5370 
  def __eq__(self, other):
5371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5372 
 
5373 
  def __ne__(self, other):
5374 
    return not (self == other)
5375 
 
5376 
class getOrderCount_result:
5377 
  """
5378 
  Attributes:
5379 
   - success
5380 
   - ex
5381 
  """
5382 
 
5383 
  thrift_spec = (
5384 
    (0, TType.I32, 'success', None, None, ), # 0
5385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5386 
  )
5387 
 
5388 
  def __init__(self, success=None, ex=None,):
5389 
    self.success = success
5390 
    self.ex = ex
5391 
 
5392 
  def read(self, iprot):
5393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5395 
      return
5396 
    iprot.readStructBegin()
5397 
    while True:
5398 
      (fname, ftype, fid) = iprot.readFieldBegin()
5399 
      if ftype == TType.STOP:
5400 
        break
5401 
      if fid == 0:
5402 
        if ftype == TType.I32:
5403 
          self.success = iprot.readI32();
5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      elif fid == 1:
5407 
        if ftype == TType.STRUCT:
5408 
          self.ex = TransactionServiceException()
5409 
          self.ex.read(iprot)
5410 
        else:
5411 
          iprot.skip(ftype)
5412 
      else:
5413 
        iprot.skip(ftype)
5414 
      iprot.readFieldEnd()
5415 
    iprot.readStructEnd()
5416 
 
5417 
  def write(self, oprot):
5418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5420 
      return
5421 
    oprot.writeStructBegin('getOrderCount_result')
5422 
    if self.success is not None:
5423 
      oprot.writeFieldBegin('success', TType.I32, 0)
5424 
      oprot.writeI32(self.success)
5425 
      oprot.writeFieldEnd()
5426 
    if self.ex is not None:
5427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5428 
      self.ex.write(oprot)
5429 
      oprot.writeFieldEnd()
5430 
    oprot.writeFieldStop()
5431 
    oprot.writeStructEnd()
5432 
 
5433 
  def validate(self):
5434 
    return
5435 
 
5436 
 
5437 
  def __repr__(self):
5438 
    L = ['%s=%r' % (key, value)
5439 
      for key, value in self.__dict__.iteritems()]
5440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5441 
 
5442 
  def __eq__(self, other):
5443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5444 
 
5445 
  def __ne__(self, other):
5446 
    return not (self == other)
5447 
 
999 varun.gupt 5448 
class getOrdersByBillingDate_args:
5449 
  """
5450 
  Attributes:
5451 
   - status
5452 
   - start_billing_date
5453 
   - end_billing_date
5454 
   - warehouse_id
5455 
  """
5456 
 
5457 
  thrift_spec = (
5458 
    None, # 0
5459 
    (1, TType.I32, 'status', None, None, ), # 1
5460 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5461 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5462 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5463 
  )
5464 
 
5465 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5466 
    self.status = status
5467 
    self.start_billing_date = start_billing_date
5468 
    self.end_billing_date = end_billing_date
5469 
    self.warehouse_id = warehouse_id
5470 
 
5471 
  def read(self, iprot):
5472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5474 
      return
5475 
    iprot.readStructBegin()
5476 
    while True:
5477 
      (fname, ftype, fid) = iprot.readFieldBegin()
5478 
      if ftype == TType.STOP:
5479 
        break
5480 
      if fid == 1:
5481 
        if ftype == TType.I32:
5482 
          self.status = iprot.readI32();
5483 
        else:
5484 
          iprot.skip(ftype)
5485 
      elif fid == 2:
5486 
        if ftype == TType.I64:
5487 
          self.start_billing_date = iprot.readI64();
5488 
        else:
5489 
          iprot.skip(ftype)
5490 
      elif fid == 3:
5491 
        if ftype == TType.I64:
5492 
          self.end_billing_date = iprot.readI64();
5493 
        else:
5494 
          iprot.skip(ftype)
5495 
      elif fid == 4:
5496 
        if ftype == TType.I64:
5497 
          self.warehouse_id = iprot.readI64();
5498 
        else:
5499 
          iprot.skip(ftype)
5500 
      else:
5501 
        iprot.skip(ftype)
5502 
      iprot.readFieldEnd()
5503 
    iprot.readStructEnd()
5504 
 
5505 
  def write(self, oprot):
5506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5508 
      return
5509 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5510 
    if self.status is not None:
999 varun.gupt 5511 
      oprot.writeFieldBegin('status', TType.I32, 1)
5512 
      oprot.writeI32(self.status)
5513 
      oprot.writeFieldEnd()
3431 rajveer 5514 
    if self.start_billing_date is not None:
999 varun.gupt 5515 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5516 
      oprot.writeI64(self.start_billing_date)
5517 
      oprot.writeFieldEnd()
3431 rajveer 5518 
    if self.end_billing_date is not None:
999 varun.gupt 5519 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5520 
      oprot.writeI64(self.end_billing_date)
5521 
      oprot.writeFieldEnd()
3431 rajveer 5522 
    if self.warehouse_id is not None:
999 varun.gupt 5523 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5524 
      oprot.writeI64(self.warehouse_id)
5525 
      oprot.writeFieldEnd()
5526 
    oprot.writeFieldStop()
5527 
    oprot.writeStructEnd()
5528 
 
3431 rajveer 5529 
  def validate(self):
5530 
    return
5531 
 
5532 
 
999 varun.gupt 5533 
  def __repr__(self):
5534 
    L = ['%s=%r' % (key, value)
5535 
      for key, value in self.__dict__.iteritems()]
5536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5537 
 
5538 
  def __eq__(self, other):
5539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5540 
 
5541 
  def __ne__(self, other):
5542 
    return not (self == other)
5543 
 
5544 
class getOrdersByBillingDate_result:
5545 
  """
5546 
  Attributes:
5547 
   - success
5548 
   - ex
5549 
  """
5550 
 
5551 
  thrift_spec = (
5552 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5554 
  )
5555 
 
5556 
  def __init__(self, success=None, ex=None,):
5557 
    self.success = success
5558 
    self.ex = ex
5559 
 
5560 
  def read(self, iprot):
5561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5563 
      return
5564 
    iprot.readStructBegin()
5565 
    while True:
5566 
      (fname, ftype, fid) = iprot.readFieldBegin()
5567 
      if ftype == TType.STOP:
5568 
        break
5569 
      if fid == 0:
5570 
        if ftype == TType.LIST:
5571 
          self.success = []
4133 chandransh 5572 
          (_etype59, _size56) = iprot.readListBegin()
5573 
          for _i60 in xrange(_size56):
5574 
            _elem61 = Order()
5575 
            _elem61.read(iprot)
5576 
            self.success.append(_elem61)
999 varun.gupt 5577 
          iprot.readListEnd()
5578 
        else:
5579 
          iprot.skip(ftype)
5580 
      elif fid == 1:
5581 
        if ftype == TType.STRUCT:
5582 
          self.ex = TransactionServiceException()
5583 
          self.ex.read(iprot)
5584 
        else:
5585 
          iprot.skip(ftype)
5586 
      else:
5587 
        iprot.skip(ftype)
5588 
      iprot.readFieldEnd()
5589 
    iprot.readStructEnd()
5590 
 
5591 
  def write(self, oprot):
5592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5594 
      return
5595 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5596 
    if self.success is not None:
999 varun.gupt 5597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5598 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5599 
      for iter62 in self.success:
5600 
        iter62.write(oprot)
999 varun.gupt 5601 
      oprot.writeListEnd()
5602 
      oprot.writeFieldEnd()
3431 rajveer 5603 
    if self.ex is not None:
999 varun.gupt 5604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5605 
      self.ex.write(oprot)
5606 
      oprot.writeFieldEnd()
5607 
    oprot.writeFieldStop()
5608 
    oprot.writeStructEnd()
5609 
 
3431 rajveer 5610 
  def validate(self):
5611 
    return
5612 
 
5613 
 
999 varun.gupt 5614 
  def __repr__(self):
5615 
    L = ['%s=%r' % (key, value)
5616 
      for key, value in self.__dict__.iteritems()]
5617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5618 
 
5619 
  def __eq__(self, other):
5620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5621 
 
5622 
  def __ne__(self, other):
5623 
    return not (self == other)
5624 
 
3427 chandransh 5625 
class getOrdersByShippingDate_args:
5626 
  """
5627 
  Attributes:
5628 
   - fromShippingDate
5629 
   - toShippingDate
5630 
   - providerId
5631 
   - warehouseId
3451 chandransh 5632 
   - cod
3427 chandransh 5633 
  """
5634 
 
5635 
  thrift_spec = (
5636 
    None, # 0
5637 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5638 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5639 
    (3, TType.I64, 'providerId', None, None, ), # 3
5640 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5641 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5642 
  )
5643 
 
3451 chandransh 5644 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5645 
    self.fromShippingDate = fromShippingDate
5646 
    self.toShippingDate = toShippingDate
5647 
    self.providerId = providerId
5648 
    self.warehouseId = warehouseId
3451 chandransh 5649 
    self.cod = cod
3427 chandransh 5650 
 
5651 
  def read(self, iprot):
5652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5654 
      return
5655 
    iprot.readStructBegin()
5656 
    while True:
5657 
      (fname, ftype, fid) = iprot.readFieldBegin()
5658 
      if ftype == TType.STOP:
5659 
        break
5660 
      if fid == 1:
5661 
        if ftype == TType.I64:
5662 
          self.fromShippingDate = iprot.readI64();
5663 
        else:
5664 
          iprot.skip(ftype)
5665 
      elif fid == 2:
5666 
        if ftype == TType.I64:
5667 
          self.toShippingDate = iprot.readI64();
5668 
        else:
5669 
          iprot.skip(ftype)
5670 
      elif fid == 3:
5671 
        if ftype == TType.I64:
5672 
          self.providerId = iprot.readI64();
5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      elif fid == 4:
5676 
        if ftype == TType.I64:
5677 
          self.warehouseId = iprot.readI64();
5678 
        else:
5679 
          iprot.skip(ftype)
3451 chandransh 5680 
      elif fid == 5:
5681 
        if ftype == TType.BOOL:
5682 
          self.cod = iprot.readBool();
5683 
        else:
5684 
          iprot.skip(ftype)
3427 chandransh 5685 
      else:
5686 
        iprot.skip(ftype)
5687 
      iprot.readFieldEnd()
5688 
    iprot.readStructEnd()
5689 
 
5690 
  def write(self, oprot):
5691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5693 
      return
5694 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5695 
    if self.fromShippingDate is not None:
3427 chandransh 5696 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5697 
      oprot.writeI64(self.fromShippingDate)
5698 
      oprot.writeFieldEnd()
3431 rajveer 5699 
    if self.toShippingDate is not None:
3427 chandransh 5700 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5701 
      oprot.writeI64(self.toShippingDate)
5702 
      oprot.writeFieldEnd()
3431 rajveer 5703 
    if self.providerId is not None:
3427 chandransh 5704 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5705 
      oprot.writeI64(self.providerId)
5706 
      oprot.writeFieldEnd()
3431 rajveer 5707 
    if self.warehouseId is not None:
3427 chandransh 5708 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5709 
      oprot.writeI64(self.warehouseId)
5710 
      oprot.writeFieldEnd()
3451 chandransh 5711 
    if self.cod is not None:
5712 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5713 
      oprot.writeBool(self.cod)
5714 
      oprot.writeFieldEnd()
3427 chandransh 5715 
    oprot.writeFieldStop()
5716 
    oprot.writeStructEnd()
5717 
 
3431 rajveer 5718 
  def validate(self):
5719 
    return
5720 
 
5721 
 
3427 chandransh 5722 
  def __repr__(self):
5723 
    L = ['%s=%r' % (key, value)
5724 
      for key, value in self.__dict__.iteritems()]
5725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5726 
 
5727 
  def __eq__(self, other):
5728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5729 
 
5730 
  def __ne__(self, other):
5731 
    return not (self == other)
5732 
 
5733 
class getOrdersByShippingDate_result:
5734 
  """
5735 
  Attributes:
5736 
   - success
5737 
   - ex
5738 
  """
5739 
 
5740 
  thrift_spec = (
5741 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5743 
  )
5744 
 
5745 
  def __init__(self, success=None, ex=None,):
5746 
    self.success = success
5747 
    self.ex = ex
5748 
 
5749 
  def read(self, iprot):
5750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5752 
      return
5753 
    iprot.readStructBegin()
5754 
    while True:
5755 
      (fname, ftype, fid) = iprot.readFieldBegin()
5756 
      if ftype == TType.STOP:
5757 
        break
5758 
      if fid == 0:
5759 
        if ftype == TType.LIST:
5760 
          self.success = []
4133 chandransh 5761 
          (_etype66, _size63) = iprot.readListBegin()
5762 
          for _i67 in xrange(_size63):
5763 
            _elem68 = Order()
5764 
            _elem68.read(iprot)
5765 
            self.success.append(_elem68)
3427 chandransh 5766 
          iprot.readListEnd()
5767 
        else:
5768 
          iprot.skip(ftype)
5769 
      elif fid == 1:
5770 
        if ftype == TType.STRUCT:
5771 
          self.ex = TransactionServiceException()
5772 
          self.ex.read(iprot)
5773 
        else:
5774 
          iprot.skip(ftype)
5775 
      else:
5776 
        iprot.skip(ftype)
5777 
      iprot.readFieldEnd()
5778 
    iprot.readStructEnd()
5779 
 
5780 
  def write(self, oprot):
5781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5783 
      return
5784 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5785 
    if self.success is not None:
3427 chandransh 5786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5788 
      for iter69 in self.success:
5789 
        iter69.write(oprot)
3427 chandransh 5790 
      oprot.writeListEnd()
5791 
      oprot.writeFieldEnd()
3431 rajveer 5792 
    if self.ex is not None:
3427 chandransh 5793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5794 
      self.ex.write(oprot)
5795 
      oprot.writeFieldEnd()
5796 
    oprot.writeFieldStop()
5797 
    oprot.writeStructEnd()
5798 
 
3431 rajveer 5799 
  def validate(self):
5800 
    return
5801 
 
5802 
 
3427 chandransh 5803 
  def __repr__(self):
5804 
    L = ['%s=%r' % (key, value)
5805 
      for key, value in self.__dict__.iteritems()]
5806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5807 
 
5808 
  def __eq__(self, other):
5809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5810 
 
5811 
  def __ne__(self, other):
5812 
    return not (self == other)
5813 
 
1382 varun.gupt 5814 
class getReturnableOrdersForCustomer_args:
5815 
  """
5816 
  Attributes:
5817 
   - customer_id
5818 
   - limit
5819 
  """
5820 
 
5821 
  thrift_spec = (
5822 
    None, # 0
5823 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5824 
    (2, TType.I64, 'limit', None, None, ), # 2
5825 
  )
5826 
 
5827 
  def __init__(self, customer_id=None, limit=None,):
5828 
    self.customer_id = customer_id
5829 
    self.limit = limit
5830 
 
5831 
  def read(self, iprot):
5832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5834 
      return
5835 
    iprot.readStructBegin()
5836 
    while True:
5837 
      (fname, ftype, fid) = iprot.readFieldBegin()
5838 
      if ftype == TType.STOP:
5839 
        break
5840 
      if fid == 1:
5841 
        if ftype == TType.I64:
5842 
          self.customer_id = iprot.readI64();
5843 
        else:
5844 
          iprot.skip(ftype)
5845 
      elif fid == 2:
5846 
        if ftype == TType.I64:
5847 
          self.limit = iprot.readI64();
5848 
        else:
5849 
          iprot.skip(ftype)
5850 
      else:
5851 
        iprot.skip(ftype)
5852 
      iprot.readFieldEnd()
5853 
    iprot.readStructEnd()
5854 
 
5855 
  def write(self, oprot):
5856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5858 
      return
5859 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5860 
    if self.customer_id is not None:
1382 varun.gupt 5861 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5862 
      oprot.writeI64(self.customer_id)
5863 
      oprot.writeFieldEnd()
3431 rajveer 5864 
    if self.limit is not None:
1382 varun.gupt 5865 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5866 
      oprot.writeI64(self.limit)
5867 
      oprot.writeFieldEnd()
5868 
    oprot.writeFieldStop()
5869 
    oprot.writeStructEnd()
5870 
 
3431 rajveer 5871 
  def validate(self):
5872 
    return
5873 
 
5874 
 
1382 varun.gupt 5875 
  def __repr__(self):
5876 
    L = ['%s=%r' % (key, value)
5877 
      for key, value in self.__dict__.iteritems()]
5878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5879 
 
5880 
  def __eq__(self, other):
5881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5882 
 
5883 
  def __ne__(self, other):
5884 
    return not (self == other)
5885 
 
5886 
class getReturnableOrdersForCustomer_result:
5887 
  """
5888 
  Attributes:
5889 
   - success
5890 
   - ex
5891 
  """
5892 
 
5893 
  thrift_spec = (
5894 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5896 
  )
5897 
 
5898 
  def __init__(self, success=None, ex=None,):
5899 
    self.success = success
5900 
    self.ex = ex
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 == 0:
5912 
        if ftype == TType.LIST:
5913 
          self.success = []
4133 chandransh 5914 
          (_etype73, _size70) = iprot.readListBegin()
5915 
          for _i74 in xrange(_size70):
5916 
            _elem75 = iprot.readI64();
5917 
            self.success.append(_elem75)
1382 varun.gupt 5918 
          iprot.readListEnd()
5919 
        else:
5920 
          iprot.skip(ftype)
5921 
      elif fid == 1:
5922 
        if ftype == TType.STRUCT:
5923 
          self.ex = TransactionServiceException()
5924 
          self.ex.read(iprot)
5925 
        else:
5926 
          iprot.skip(ftype)
5927 
      else:
5928 
        iprot.skip(ftype)
5929 
      iprot.readFieldEnd()
5930 
    iprot.readStructEnd()
5931 
 
5932 
  def write(self, oprot):
5933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5935 
      return
5936 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 5937 
    if self.success is not None:
1382 varun.gupt 5938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5939 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 5940 
      for iter76 in self.success:
5941 
        oprot.writeI64(iter76)
1382 varun.gupt 5942 
      oprot.writeListEnd()
5943 
      oprot.writeFieldEnd()
3431 rajveer 5944 
    if self.ex is not None:
1382 varun.gupt 5945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5946 
      self.ex.write(oprot)
5947 
      oprot.writeFieldEnd()
5948 
    oprot.writeFieldStop()
5949 
    oprot.writeStructEnd()
5950 
 
3431 rajveer 5951 
  def validate(self):
5952 
    return
5953 
 
5954 
 
1382 varun.gupt 5955 
  def __repr__(self):
5956 
    L = ['%s=%r' % (key, value)
5957 
      for key, value in self.__dict__.iteritems()]
5958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5959 
 
5960 
  def __eq__(self, other):
5961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5962 
 
5963 
  def __ne__(self, other):
5964 
    return not (self == other)
5965 
 
5966 
class getCancellableOrdersForCustomer_args:
5967 
  """
5968 
  Attributes:
5969 
   - customer_id
5970 
   - limit
5971 
  """
5972 
 
5973 
  thrift_spec = (
5974 
    None, # 0
5975 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5976 
    (2, TType.I64, 'limit', None, None, ), # 2
5977 
  )
5978 
 
5979 
  def __init__(self, customer_id=None, limit=None,):
5980 
    self.customer_id = customer_id
5981 
    self.limit = limit
5982 
 
5983 
  def read(self, iprot):
5984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5986 
      return
5987 
    iprot.readStructBegin()
5988 
    while True:
5989 
      (fname, ftype, fid) = iprot.readFieldBegin()
5990 
      if ftype == TType.STOP:
5991 
        break
5992 
      if fid == 1:
5993 
        if ftype == TType.I64:
5994 
          self.customer_id = iprot.readI64();
5995 
        else:
5996 
          iprot.skip(ftype)
5997 
      elif fid == 2:
5998 
        if ftype == TType.I64:
5999 
          self.limit = iprot.readI64();
6000 
        else:
6001 
          iprot.skip(ftype)
6002 
      else:
6003 
        iprot.skip(ftype)
6004 
      iprot.readFieldEnd()
6005 
    iprot.readStructEnd()
6006 
 
6007 
  def write(self, oprot):
6008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6010 
      return
6011 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6012 
    if self.customer_id is not None:
1382 varun.gupt 6013 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6014 
      oprot.writeI64(self.customer_id)
6015 
      oprot.writeFieldEnd()
3431 rajveer 6016 
    if self.limit is not None:
1382 varun.gupt 6017 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6018 
      oprot.writeI64(self.limit)
6019 
      oprot.writeFieldEnd()
6020 
    oprot.writeFieldStop()
6021 
    oprot.writeStructEnd()
6022 
 
3431 rajveer 6023 
  def validate(self):
6024 
    return
6025 
 
6026 
 
1382 varun.gupt 6027 
  def __repr__(self):
6028 
    L = ['%s=%r' % (key, value)
6029 
      for key, value in self.__dict__.iteritems()]
6030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6031 
 
6032 
  def __eq__(self, other):
6033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6034 
 
6035 
  def __ne__(self, other):
6036 
    return not (self == other)
6037 
 
6038 
class getCancellableOrdersForCustomer_result:
6039 
  """
6040 
  Attributes:
6041 
   - success
6042 
   - ex
6043 
  """
6044 
 
6045 
  thrift_spec = (
6046 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6048 
  )
6049 
 
6050 
  def __init__(self, success=None, ex=None,):
6051 
    self.success = success
6052 
    self.ex = ex
6053 
 
6054 
  def read(self, iprot):
6055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6057 
      return
6058 
    iprot.readStructBegin()
6059 
    while True:
6060 
      (fname, ftype, fid) = iprot.readFieldBegin()
6061 
      if ftype == TType.STOP:
6062 
        break
6063 
      if fid == 0:
6064 
        if ftype == TType.LIST:
6065 
          self.success = []
4133 chandransh 6066 
          (_etype80, _size77) = iprot.readListBegin()
6067 
          for _i81 in xrange(_size77):
6068 
            _elem82 = iprot.readI64();
6069 
            self.success.append(_elem82)
1382 varun.gupt 6070 
          iprot.readListEnd()
6071 
        else:
6072 
          iprot.skip(ftype)
6073 
      elif fid == 1:
6074 
        if ftype == TType.STRUCT:
6075 
          self.ex = TransactionServiceException()
6076 
          self.ex.read(iprot)
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      else:
6080 
        iprot.skip(ftype)
6081 
      iprot.readFieldEnd()
6082 
    iprot.readStructEnd()
6083 
 
6084 
  def write(self, oprot):
6085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6087 
      return
6088 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6089 
    if self.success is not None:
1382 varun.gupt 6090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6091 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6092 
      for iter83 in self.success:
6093 
        oprot.writeI64(iter83)
1382 varun.gupt 6094 
      oprot.writeListEnd()
6095 
      oprot.writeFieldEnd()
3431 rajveer 6096 
    if self.ex is not None:
1382 varun.gupt 6097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6098 
      self.ex.write(oprot)
6099 
      oprot.writeFieldEnd()
6100 
    oprot.writeFieldStop()
6101 
    oprot.writeStructEnd()
6102 
 
3431 rajveer 6103 
  def validate(self):
6104 
    return
6105 
 
6106 
 
1382 varun.gupt 6107 
  def __repr__(self):
6108 
    L = ['%s=%r' % (key, value)
6109 
      for key, value in self.__dict__.iteritems()]
6110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6111 
 
6112 
  def __eq__(self, other):
6113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6114 
 
6115 
  def __ne__(self, other):
6116 
    return not (self == other)
6117 
 
483 rajveer 6118 
class changeOrderStatus_args:
94 ashish 6119 
  """
6120 
  Attributes:
483 rajveer 6121 
   - orderId
6122 
   - status
6123 
   - description
94 ashish 6124 
  """
6125 
 
6126 
  thrift_spec = (
6127 
    None, # 0
483 rajveer 6128 
    (1, TType.I64, 'orderId', None, None, ), # 1
6129 
    (2, TType.I32, 'status', None, None, ), # 2
6130 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6131 
  )
6132 
 
483 rajveer 6133 
  def __init__(self, orderId=None, status=None, description=None,):
6134 
    self.orderId = orderId
6135 
    self.status = status
6136 
    self.description = description
94 ashish 6137 
 
6138 
  def read(self, iprot):
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6141 
      return
6142 
    iprot.readStructBegin()
6143 
    while True:
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
6145 
      if ftype == TType.STOP:
6146 
        break
6147 
      if fid == 1:
6148 
        if ftype == TType.I64:
483 rajveer 6149 
          self.orderId = iprot.readI64();
94 ashish 6150 
        else:
6151 
          iprot.skip(ftype)
6152 
      elif fid == 2:
483 rajveer 6153 
        if ftype == TType.I32:
6154 
          self.status = iprot.readI32();
94 ashish 6155 
        else:
6156 
          iprot.skip(ftype)
483 rajveer 6157 
      elif fid == 3:
6158 
        if ftype == TType.STRING:
6159 
          self.description = iprot.readString();
6160 
        else:
6161 
          iprot.skip(ftype)
94 ashish 6162 
      else:
6163 
        iprot.skip(ftype)
6164 
      iprot.readFieldEnd()
6165 
    iprot.readStructEnd()
6166 
 
6167 
  def write(self, oprot):
6168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6170 
      return
483 rajveer 6171 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6172 
    if self.orderId is not None:
483 rajveer 6173 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6174 
      oprot.writeI64(self.orderId)
94 ashish 6175 
      oprot.writeFieldEnd()
3431 rajveer 6176 
    if self.status is not None:
483 rajveer 6177 
      oprot.writeFieldBegin('status', TType.I32, 2)
6178 
      oprot.writeI32(self.status)
94 ashish 6179 
      oprot.writeFieldEnd()
3431 rajveer 6180 
    if self.description is not None:
483 rajveer 6181 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6182 
      oprot.writeString(self.description)
6183 
      oprot.writeFieldEnd()
94 ashish 6184 
    oprot.writeFieldStop()
6185 
    oprot.writeStructEnd()
6186 
 
3431 rajveer 6187 
  def validate(self):
6188 
    return
6189 
 
6190 
 
94 ashish 6191 
  def __repr__(self):
6192 
    L = ['%s=%r' % (key, value)
6193 
      for key, value in self.__dict__.iteritems()]
6194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6195 
 
6196 
  def __eq__(self, other):
6197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6198 
 
6199 
  def __ne__(self, other):
6200 
    return not (self == other)
6201 
 
483 rajveer 6202 
class changeOrderStatus_result:
94 ashish 6203 
  """
6204 
  Attributes:
6205 
   - success
6206 
   - ex
6207 
  """
6208 
 
6209 
  thrift_spec = (
6210 
    (0, TType.BOOL, 'success', None, None, ), # 0
6211 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6212 
  )
6213 
 
6214 
  def __init__(self, success=None, ex=None,):
6215 
    self.success = success
6216 
    self.ex = ex
6217 
 
6218 
  def read(self, iprot):
6219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6221 
      return
6222 
    iprot.readStructBegin()
6223 
    while True:
6224 
      (fname, ftype, fid) = iprot.readFieldBegin()
6225 
      if ftype == TType.STOP:
6226 
        break
6227 
      if fid == 0:
6228 
        if ftype == TType.BOOL:
6229 
          self.success = iprot.readBool();
6230 
        else:
6231 
          iprot.skip(ftype)
6232 
      elif fid == 1:
6233 
        if ftype == TType.STRUCT:
6234 
          self.ex = TransactionServiceException()
6235 
          self.ex.read(iprot)
6236 
        else:
6237 
          iprot.skip(ftype)
6238 
      else:
6239 
        iprot.skip(ftype)
6240 
      iprot.readFieldEnd()
6241 
    iprot.readStructEnd()
6242 
 
6243 
  def write(self, oprot):
6244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6246 
      return
483 rajveer 6247 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6248 
    if self.success is not None:
94 ashish 6249 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6250 
      oprot.writeBool(self.success)
6251 
      oprot.writeFieldEnd()
3431 rajveer 6252 
    if self.ex is not None:
94 ashish 6253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6254 
      self.ex.write(oprot)
6255 
      oprot.writeFieldEnd()
6256 
    oprot.writeFieldStop()
6257 
    oprot.writeStructEnd()
6258 
 
3431 rajveer 6259 
  def validate(self):
6260 
    return
6261 
 
6262 
 
94 ashish 6263 
  def __repr__(self):
6264 
    L = ['%s=%r' % (key, value)
6265 
      for key, value in self.__dict__.iteritems()]
6266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6267 
 
6268 
  def __eq__(self, other):
6269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6270 
 
6271 
  def __ne__(self, other):
6272 
    return not (self == other)
6273 
 
3064 chandransh 6274 
class getOrdersForTransaction_args:
494 rajveer 6275 
  """
6276 
  Attributes:
3064 chandransh 6277 
   - transactionId
6278 
   - customerId
494 rajveer 6279 
  """
6280 
 
6281 
  thrift_spec = (
6282 
    None, # 0
3064 chandransh 6283 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6284 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6285 
  )
6286 
 
3064 chandransh 6287 
  def __init__(self, transactionId=None, customerId=None,):
6288 
    self.transactionId = transactionId
6289 
    self.customerId = customerId
494 rajveer 6290 
 
6291 
  def read(self, iprot):
6292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6294 
      return
6295 
    iprot.readStructBegin()
6296 
    while True:
6297 
      (fname, ftype, fid) = iprot.readFieldBegin()
6298 
      if ftype == TType.STOP:
6299 
        break
6300 
      if fid == 1:
6301 
        if ftype == TType.I64:
3064 chandransh 6302 
          self.transactionId = iprot.readI64();
494 rajveer 6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      elif fid == 2:
3064 chandransh 6306 
        if ftype == TType.I64:
6307 
          self.customerId = iprot.readI64();
494 rajveer 6308 
        else:
6309 
          iprot.skip(ftype)
6310 
      else:
6311 
        iprot.skip(ftype)
6312 
      iprot.readFieldEnd()
6313 
    iprot.readStructEnd()
6314 
 
6315 
  def write(self, oprot):
6316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6318 
      return
3064 chandransh 6319 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6320 
    if self.transactionId is not None:
3064 chandransh 6321 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6322 
      oprot.writeI64(self.transactionId)
494 rajveer 6323 
      oprot.writeFieldEnd()
3431 rajveer 6324 
    if self.customerId is not None:
3064 chandransh 6325 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6326 
      oprot.writeI64(self.customerId)
494 rajveer 6327 
      oprot.writeFieldEnd()
6328 
    oprot.writeFieldStop()
6329 
    oprot.writeStructEnd()
6330 
 
3431 rajveer 6331 
  def validate(self):
6332 
    return
6333 
 
6334 
 
494 rajveer 6335 
  def __repr__(self):
6336 
    L = ['%s=%r' % (key, value)
6337 
      for key, value in self.__dict__.iteritems()]
6338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6339 
 
6340 
  def __eq__(self, other):
6341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6342 
 
6343 
  def __ne__(self, other):
6344 
    return not (self == other)
6345 
 
3064 chandransh 6346 
class getOrdersForTransaction_result:
494 rajveer 6347 
  """
6348 
  Attributes:
6349 
   - success
6350 
   - ex
6351 
  """
6352 
 
6353 
  thrift_spec = (
3064 chandransh 6354 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6356 
  )
6357 
 
6358 
  def __init__(self, success=None, ex=None,):
6359 
    self.success = success
6360 
    self.ex = ex
6361 
 
6362 
  def read(self, iprot):
6363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6365 
      return
6366 
    iprot.readStructBegin()
6367 
    while True:
6368 
      (fname, ftype, fid) = iprot.readFieldBegin()
6369 
      if ftype == TType.STOP:
6370 
        break
6371 
      if fid == 0:
3064 chandransh 6372 
        if ftype == TType.LIST:
6373 
          self.success = []
4133 chandransh 6374 
          (_etype87, _size84) = iprot.readListBegin()
6375 
          for _i88 in xrange(_size84):
6376 
            _elem89 = Order()
6377 
            _elem89.read(iprot)
6378 
            self.success.append(_elem89)
3064 chandransh 6379 
          iprot.readListEnd()
494 rajveer 6380 
        else:
6381 
          iprot.skip(ftype)
6382 
      elif fid == 1:
6383 
        if ftype == TType.STRUCT:
6384 
          self.ex = TransactionServiceException()
6385 
          self.ex.read(iprot)
6386 
        else:
6387 
          iprot.skip(ftype)
6388 
      else:
6389 
        iprot.skip(ftype)
6390 
      iprot.readFieldEnd()
6391 
    iprot.readStructEnd()
6392 
 
6393 
  def write(self, oprot):
6394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6396 
      return
3064 chandransh 6397 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6398 
    if self.success is not None:
3064 chandransh 6399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6400 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6401 
      for iter90 in self.success:
6402 
        iter90.write(oprot)
3064 chandransh 6403 
      oprot.writeListEnd()
494 rajveer 6404 
      oprot.writeFieldEnd()
3431 rajveer 6405 
    if self.ex is not None:
494 rajveer 6406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6407 
      self.ex.write(oprot)
6408 
      oprot.writeFieldEnd()
6409 
    oprot.writeFieldStop()
6410 
    oprot.writeStructEnd()
6411 
 
3431 rajveer 6412 
  def validate(self):
6413 
    return
6414 
 
6415 
 
494 rajveer 6416 
  def __repr__(self):
6417 
    L = ['%s=%r' % (key, value)
6418 
      for key, value in self.__dict__.iteritems()]
6419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6420 
 
6421 
  def __eq__(self, other):
6422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6423 
 
6424 
  def __ne__(self, other):
6425 
    return not (self == other)
6426 
 
3064 chandransh 6427 
class getOrdersForCustomer_args:
1149 chandransh 6428 
  """
6429 
  Attributes:
3064 chandransh 6430 
   - customerId
6431 
   - from_date
6432 
   - to_date
6433 
   - statuses
1149 chandransh 6434 
  """
6435 
 
6436 
  thrift_spec = (
6437 
    None, # 0
3064 chandransh 6438 
    (1, TType.I64, 'customerId', None, None, ), # 1
6439 
    (2, TType.I64, 'from_date', None, None, ), # 2
6440 
    (3, TType.I64, 'to_date', None, None, ), # 3
6441 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6442 
  )
6443 
 
3064 chandransh 6444 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6445 
    self.customerId = customerId
6446 
    self.from_date = from_date
6447 
    self.to_date = to_date
6448 
    self.statuses = statuses
1149 chandransh 6449 
 
6450 
  def read(self, iprot):
6451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6453 
      return
6454 
    iprot.readStructBegin()
6455 
    while True:
6456 
      (fname, ftype, fid) = iprot.readFieldBegin()
6457 
      if ftype == TType.STOP:
6458 
        break
6459 
      if fid == 1:
6460 
        if ftype == TType.I64:
3064 chandransh 6461 
          self.customerId = iprot.readI64();
1149 chandransh 6462 
        else:
6463 
          iprot.skip(ftype)
6464 
      elif fid == 2:
6465 
        if ftype == TType.I64:
3064 chandransh 6466 
          self.from_date = iprot.readI64();
1149 chandransh 6467 
        else:
6468 
          iprot.skip(ftype)
2783 chandransh 6469 
      elif fid == 3:
6470 
        if ftype == TType.I64:
3064 chandransh 6471 
          self.to_date = iprot.readI64();
2783 chandransh 6472 
        else:
6473 
          iprot.skip(ftype)
6474 
      elif fid == 4:
3064 chandransh 6475 
        if ftype == TType.LIST:
6476 
          self.statuses = []
4133 chandransh 6477 
          (_etype94, _size91) = iprot.readListBegin()
6478 
          for _i95 in xrange(_size91):
6479 
            _elem96 = iprot.readI32();
6480 
            self.statuses.append(_elem96)
3064 chandransh 6481 
          iprot.readListEnd()
2783 chandransh 6482 
        else:
6483 
          iprot.skip(ftype)
1149 chandransh 6484 
      else:
6485 
        iprot.skip(ftype)
6486 
      iprot.readFieldEnd()
6487 
    iprot.readStructEnd()
6488 
 
6489 
  def write(self, oprot):
6490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6492 
      return
3064 chandransh 6493 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6494 
    if self.customerId is not None:
3064 chandransh 6495 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6496 
      oprot.writeI64(self.customerId)
1149 chandransh 6497 
      oprot.writeFieldEnd()
3431 rajveer 6498 
    if self.from_date is not None:
3064 chandransh 6499 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6500 
      oprot.writeI64(self.from_date)
1149 chandransh 6501 
      oprot.writeFieldEnd()
3431 rajveer 6502 
    if self.to_date is not None:
3064 chandransh 6503 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6504 
      oprot.writeI64(self.to_date)
2783 chandransh 6505 
      oprot.writeFieldEnd()
3431 rajveer 6506 
    if self.statuses is not None:
3064 chandransh 6507 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6508 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6509 
      for iter97 in self.statuses:
6510 
        oprot.writeI32(iter97)
3064 chandransh 6511 
      oprot.writeListEnd()
2783 chandransh 6512 
      oprot.writeFieldEnd()
1149 chandransh 6513 
    oprot.writeFieldStop()
6514 
    oprot.writeStructEnd()
6515 
 
3431 rajveer 6516 
  def validate(self):
6517 
    return
6518 
 
6519 
 
1149 chandransh 6520 
  def __repr__(self):
6521 
    L = ['%s=%r' % (key, value)
6522 
      for key, value in self.__dict__.iteritems()]
6523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6524 
 
6525 
  def __eq__(self, other):
6526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6527 
 
6528 
  def __ne__(self, other):
6529 
    return not (self == other)
6530 
 
3064 chandransh 6531 
class getOrdersForCustomer_result:
1149 chandransh 6532 
  """
6533 
  Attributes:
6534 
   - success
6535 
   - ex
6536 
  """
6537 
 
6538 
  thrift_spec = (
3064 chandransh 6539 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6541 
  )
6542 
 
6543 
  def __init__(self, success=None, ex=None,):
6544 
    self.success = success
6545 
    self.ex = ex
6546 
 
6547 
  def read(self, iprot):
6548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6550 
      return
6551 
    iprot.readStructBegin()
6552 
    while True:
6553 
      (fname, ftype, fid) = iprot.readFieldBegin()
6554 
      if ftype == TType.STOP:
6555 
        break
6556 
      if fid == 0:
3064 chandransh 6557 
        if ftype == TType.LIST:
6558 
          self.success = []
4133 chandransh 6559 
          (_etype101, _size98) = iprot.readListBegin()
6560 
          for _i102 in xrange(_size98):
6561 
            _elem103 = Order()
6562 
            _elem103.read(iprot)
6563 
            self.success.append(_elem103)
3064 chandransh 6564 
          iprot.readListEnd()
1149 chandransh 6565 
        else:
6566 
          iprot.skip(ftype)
6567 
      elif fid == 1:
6568 
        if ftype == TType.STRUCT:
6569 
          self.ex = TransactionServiceException()
6570 
          self.ex.read(iprot)
6571 
        else:
6572 
          iprot.skip(ftype)
6573 
      else:
6574 
        iprot.skip(ftype)
6575 
      iprot.readFieldEnd()
6576 
    iprot.readStructEnd()
6577 
 
6578 
  def write(self, oprot):
6579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6581 
      return
3064 chandransh 6582 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6583 
    if self.success is not None:
3064 chandransh 6584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6586 
      for iter104 in self.success:
6587 
        iter104.write(oprot)
3064 chandransh 6588 
      oprot.writeListEnd()
1149 chandransh 6589 
      oprot.writeFieldEnd()
3431 rajveer 6590 
    if self.ex is not None:
1149 chandransh 6591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6592 
      self.ex.write(oprot)
6593 
      oprot.writeFieldEnd()
6594 
    oprot.writeFieldStop()
6595 
    oprot.writeStructEnd()
6596 
 
3431 rajveer 6597 
  def validate(self):
6598 
    return
6599 
 
6600 
 
1149 chandransh 6601 
  def __repr__(self):
6602 
    L = ['%s=%r' % (key, value)
6603 
      for key, value in self.__dict__.iteritems()]
6604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6605 
 
6606 
  def __eq__(self, other):
6607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6608 
 
6609 
  def __ne__(self, other):
6610 
    return not (self == other)
6611 
 
3064 chandransh 6612 
class createOrder_args:
921 rajveer 6613 
  """
6614 
  Attributes:
3064 chandransh 6615 
   - order
921 rajveer 6616 
  """
6617 
 
6618 
  thrift_spec = (
6619 
    None, # 0
3064 chandransh 6620 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6621 
  )
6622 
 
3064 chandransh 6623 
  def __init__(self, order=None,):
6624 
    self.order = order
921 rajveer 6625 
 
6626 
  def read(self, iprot):
6627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6629 
      return
6630 
    iprot.readStructBegin()
6631 
    while True:
6632 
      (fname, ftype, fid) = iprot.readFieldBegin()
6633 
      if ftype == TType.STOP:
6634 
        break
6635 
      if fid == 1:
3064 chandransh 6636 
        if ftype == TType.STRUCT:
6637 
          self.order = Order()
6638 
          self.order.read(iprot)
921 rajveer 6639 
        else:
6640 
          iprot.skip(ftype)
6641 
      else:
6642 
        iprot.skip(ftype)
6643 
      iprot.readFieldEnd()
6644 
    iprot.readStructEnd()
6645 
 
6646 
  def write(self, oprot):
6647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6649 
      return
3064 chandransh 6650 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6651 
    if self.order is not None:
3064 chandransh 6652 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6653 
      self.order.write(oprot)
921 rajveer 6654 
      oprot.writeFieldEnd()
6655 
    oprot.writeFieldStop()
6656 
    oprot.writeStructEnd()
6657 
 
3431 rajveer 6658 
  def validate(self):
6659 
    return
6660 
 
6661 
 
921 rajveer 6662 
  def __repr__(self):
6663 
    L = ['%s=%r' % (key, value)
6664 
      for key, value in self.__dict__.iteritems()]
6665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6666 
 
6667 
  def __eq__(self, other):
6668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6669 
 
6670 
  def __ne__(self, other):
6671 
    return not (self == other)
6672 
 
3064 chandransh 6673 
class createOrder_result:
921 rajveer 6674 
  """
6675 
  Attributes:
6676 
   - success
6677 
   - ex
6678 
  """
6679 
 
6680 
  thrift_spec = (
3064 chandransh 6681 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6683 
  )
6684 
 
6685 
  def __init__(self, success=None, ex=None,):
6686 
    self.success = success
6687 
    self.ex = ex
6688 
 
6689 
  def read(self, iprot):
6690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6692 
      return
6693 
    iprot.readStructBegin()
6694 
    while True:
6695 
      (fname, ftype, fid) = iprot.readFieldBegin()
6696 
      if ftype == TType.STOP:
6697 
        break
6698 
      if fid == 0:
3064 chandransh 6699 
        if ftype == TType.I64:
6700 
          self.success = iprot.readI64();
921 rajveer 6701 
        else:
6702 
          iprot.skip(ftype)
6703 
      elif fid == 1:
6704 
        if ftype == TType.STRUCT:
6705 
          self.ex = TransactionServiceException()
6706 
          self.ex.read(iprot)
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      else:
6710 
        iprot.skip(ftype)
6711 
      iprot.readFieldEnd()
6712 
    iprot.readStructEnd()
6713 
 
6714 
  def write(self, oprot):
6715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6717 
      return
3064 chandransh 6718 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6719 
    if self.success is not None:
3064 chandransh 6720 
      oprot.writeFieldBegin('success', TType.I64, 0)
6721 
      oprot.writeI64(self.success)
921 rajveer 6722 
      oprot.writeFieldEnd()
3431 rajveer 6723 
    if self.ex is not None:
921 rajveer 6724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6725 
      self.ex.write(oprot)
6726 
      oprot.writeFieldEnd()
6727 
    oprot.writeFieldStop()
6728 
    oprot.writeStructEnd()
6729 
 
3431 rajveer 6730 
  def validate(self):
6731 
    return
6732 
 
6733 
 
921 rajveer 6734 
  def __repr__(self):
6735 
    L = ['%s=%r' % (key, value)
6736 
      for key, value in self.__dict__.iteritems()]
6737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6738 
 
6739 
  def __eq__(self, other):
6740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6741 
 
6742 
  def __ne__(self, other):
6743 
    return not (self == other)
6744 
 
3064 chandransh 6745 
class getOrder_args:
921 rajveer 6746 
  """
6747 
  Attributes:
3064 chandransh 6748 
   - id
921 rajveer 6749 
  """
6750 
 
6751 
  thrift_spec = (
6752 
    None, # 0
3064 chandransh 6753 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6754 
  )
6755 
 
3064 chandransh 6756 
  def __init__(self, id=None,):
6757 
    self.id = id
921 rajveer 6758 
 
6759 
  def read(self, iprot):
6760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6762 
      return
6763 
    iprot.readStructBegin()
6764 
    while True:
6765 
      (fname, ftype, fid) = iprot.readFieldBegin()
6766 
      if ftype == TType.STOP:
6767 
        break
6768 
      if fid == 1:
6769 
        if ftype == TType.I64:
3064 chandransh 6770 
          self.id = iprot.readI64();
921 rajveer 6771 
        else:
6772 
          iprot.skip(ftype)
6773 
      else:
6774 
        iprot.skip(ftype)
6775 
      iprot.readFieldEnd()
6776 
    iprot.readStructEnd()
6777 
 
6778 
  def write(self, oprot):
6779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6781 
      return
3064 chandransh 6782 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 6783 
    if self.id is not None:
3064 chandransh 6784 
      oprot.writeFieldBegin('id', TType.I64, 1)
6785 
      oprot.writeI64(self.id)
921 rajveer 6786 
      oprot.writeFieldEnd()
6787 
    oprot.writeFieldStop()
6788 
    oprot.writeStructEnd()
6789 
 
3431 rajveer 6790 
  def validate(self):
6791 
    return
6792 
 
6793 
 
921 rajveer 6794 
  def __repr__(self):
6795 
    L = ['%s=%r' % (key, value)
6796 
      for key, value in self.__dict__.iteritems()]
6797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6798 
 
6799 
  def __eq__(self, other):
6800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6801 
 
6802 
  def __ne__(self, other):
6803 
    return not (self == other)
6804 
 
3064 chandransh 6805 
class getOrder_result:
921 rajveer 6806 
  """
6807 
  Attributes:
6808 
   - success
6809 
   - ex
6810 
  """
6811 
 
6812 
  thrift_spec = (
3064 chandransh 6813 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6815 
  )
6816 
 
6817 
  def __init__(self, success=None, ex=None,):
6818 
    self.success = success
6819 
    self.ex = ex
6820 
 
6821 
  def read(self, iprot):
6822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6824 
      return
6825 
    iprot.readStructBegin()
6826 
    while True:
6827 
      (fname, ftype, fid) = iprot.readFieldBegin()
6828 
      if ftype == TType.STOP:
6829 
        break
6830 
      if fid == 0:
3064 chandransh 6831 
        if ftype == TType.STRUCT:
6832 
          self.success = Order()
6833 
          self.success.read(iprot)
921 rajveer 6834 
        else:
6835 
          iprot.skip(ftype)
6836 
      elif fid == 1:
6837 
        if ftype == TType.STRUCT:
6838 
          self.ex = TransactionServiceException()
6839 
          self.ex.read(iprot)
6840 
        else:
6841 
          iprot.skip(ftype)
6842 
      else:
6843 
        iprot.skip(ftype)
6844 
      iprot.readFieldEnd()
6845 
    iprot.readStructEnd()
6846 
 
6847 
  def write(self, oprot):
6848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6850 
      return
3064 chandransh 6851 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6852 
    if self.success is not None:
3064 chandransh 6853 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6854 
      self.success.write(oprot)
921 rajveer 6855 
      oprot.writeFieldEnd()
3431 rajveer 6856 
    if self.ex is not None:
921 rajveer 6857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6858 
      self.ex.write(oprot)
6859 
      oprot.writeFieldEnd()
6860 
    oprot.writeFieldStop()
6861 
    oprot.writeStructEnd()
6862 
 
3431 rajveer 6863 
  def validate(self):
6864 
    return
6865 
 
6866 
 
921 rajveer 6867 
  def __repr__(self):
6868 
    L = ['%s=%r' % (key, value)
6869 
      for key, value in self.__dict__.iteritems()]
6870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6871 
 
6872 
  def __eq__(self, other):
6873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6874 
 
6875 
  def __ne__(self, other):
6876 
    return not (self == other)
6877 
 
3064 chandransh 6878 
class getLineItemsForOrder_args:
94 ashish 6879 
  """
6880 
  Attributes:
3064 chandransh 6881 
   - orderId
94 ashish 6882 
  """
6883 
 
6884 
  thrift_spec = (
6885 
    None, # 0
3064 chandransh 6886 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 6887 
  )
6888 
 
3064 chandransh 6889 
  def __init__(self, orderId=None,):
6890 
    self.orderId = orderId
94 ashish 6891 
 
6892 
  def read(self, iprot):
6893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6895 
      return
6896 
    iprot.readStructBegin()
6897 
    while True:
6898 
      (fname, ftype, fid) = iprot.readFieldBegin()
6899 
      if ftype == TType.STOP:
6900 
        break
6901 
      if fid == 1:
6902 
        if ftype == TType.I64:
3064 chandransh 6903 
          self.orderId = iprot.readI64();
94 ashish 6904 
        else:
6905 
          iprot.skip(ftype)
6906 
      else:
6907 
        iprot.skip(ftype)
6908 
      iprot.readFieldEnd()
6909 
    iprot.readStructEnd()
6910 
 
6911 
  def write(self, oprot):
6912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6914 
      return
3064 chandransh 6915 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 6916 
    if self.orderId is not None:
3064 chandransh 6917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6918 
      oprot.writeI64(self.orderId)
94 ashish 6919 
      oprot.writeFieldEnd()
6920 
    oprot.writeFieldStop()
6921 
    oprot.writeStructEnd()
6922 
 
3431 rajveer 6923 
  def validate(self):
6924 
    return
6925 
 
6926 
 
94 ashish 6927 
  def __repr__(self):
6928 
    L = ['%s=%r' % (key, value)
6929 
      for key, value in self.__dict__.iteritems()]
6930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6931 
 
6932 
  def __eq__(self, other):
6933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6934 
 
6935 
  def __ne__(self, other):
6936 
    return not (self == other)
6937 
 
3064 chandransh 6938 
class getLineItemsForOrder_result:
94 ashish 6939 
  """
6940 
  Attributes:
6941 
   - success
6942 
   - ex
6943 
  """
6944 
 
6945 
  thrift_spec = (
3064 chandransh 6946 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 6947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6948 
  )
6949 
 
6950 
  def __init__(self, success=None, ex=None,):
6951 
    self.success = success
6952 
    self.ex = ex
6953 
 
6954 
  def read(self, iprot):
6955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6957 
      return
6958 
    iprot.readStructBegin()
6959 
    while True:
6960 
      (fname, ftype, fid) = iprot.readFieldBegin()
6961 
      if ftype == TType.STOP:
6962 
        break
6963 
      if fid == 0:
483 rajveer 6964 
        if ftype == TType.LIST:
6965 
          self.success = []
4133 chandransh 6966 
          (_etype108, _size105) = iprot.readListBegin()
6967 
          for _i109 in xrange(_size105):
6968 
            _elem110 = LineItem()
6969 
            _elem110.read(iprot)
6970 
            self.success.append(_elem110)
483 rajveer 6971 
          iprot.readListEnd()
94 ashish 6972 
        else:
6973 
          iprot.skip(ftype)
6974 
      elif fid == 1:
6975 
        if ftype == TType.STRUCT:
6976 
          self.ex = TransactionServiceException()
6977 
          self.ex.read(iprot)
6978 
        else:
6979 
          iprot.skip(ftype)
6980 
      else:
6981 
        iprot.skip(ftype)
6982 
      iprot.readFieldEnd()
6983 
    iprot.readStructEnd()
6984 
 
6985 
  def write(self, oprot):
6986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6988 
      return
3064 chandransh 6989 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 6990 
    if self.success is not None:
483 rajveer 6991 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6992 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6993 
      for iter111 in self.success:
6994 
        iter111.write(oprot)
483 rajveer 6995 
      oprot.writeListEnd()
94 ashish 6996 
      oprot.writeFieldEnd()
3431 rajveer 6997 
    if self.ex is not None:
94 ashish 6998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6999 
      self.ex.write(oprot)
7000 
      oprot.writeFieldEnd()
7001 
    oprot.writeFieldStop()
7002 
    oprot.writeStructEnd()
7003 
 
3431 rajveer 7004 
  def validate(self):
7005 
    return
7006 
 
7007 
 
94 ashish 7008 
  def __repr__(self):
7009 
    L = ['%s=%r' % (key, value)
7010 
      for key, value in self.__dict__.iteritems()]
7011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7012 
 
7013 
  def __eq__(self, other):
7014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7015 
 
7016 
  def __ne__(self, other):
7017 
    return not (self == other)
7018 
 
3064 chandransh 7019 
class getOrderForCustomer_args:
94 ashish 7020 
  """
7021 
  Attributes:
3064 chandransh 7022 
   - orderId
483 rajveer 7023 
   - customerId
94 ashish 7024 
  """
7025 
 
7026 
  thrift_spec = (
7027 
    None, # 0
3064 chandransh 7028 
    (1, TType.I64, 'orderId', None, None, ), # 1
7029 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7030 
  )
7031 
 
3064 chandransh 7032 
  def __init__(self, orderId=None, customerId=None,):
7033 
    self.orderId = orderId
483 rajveer 7034 
    self.customerId = customerId
94 ashish 7035 
 
7036 
  def read(self, iprot):
7037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7039 
      return
7040 
    iprot.readStructBegin()
7041 
    while True:
7042 
      (fname, ftype, fid) = iprot.readFieldBegin()
7043 
      if ftype == TType.STOP:
7044 
        break
7045 
      if fid == 1:
7046 
        if ftype == TType.I64:
3064 chandransh 7047 
          self.orderId = iprot.readI64();
94 ashish 7048 
        else:
7049 
          iprot.skip(ftype)
7050 
      elif fid == 2:
7051 
        if ftype == TType.I64:
3064 chandransh 7052 
          self.customerId = iprot.readI64();
94 ashish 7053 
        else:
7054 
          iprot.skip(ftype)
7055 
      else:
7056 
        iprot.skip(ftype)
7057 
      iprot.readFieldEnd()
7058 
    iprot.readStructEnd()
7059 
 
7060 
  def write(self, oprot):
7061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7063 
      return
3064 chandransh 7064 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7065 
    if self.orderId is not None:
3064 chandransh 7066 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7067 
      oprot.writeI64(self.orderId)
7068 
      oprot.writeFieldEnd()
3431 rajveer 7069 
    if self.customerId is not None:
3064 chandransh 7070 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7071 
      oprot.writeI64(self.customerId)
94 ashish 7072 
      oprot.writeFieldEnd()
7073 
    oprot.writeFieldStop()
7074 
    oprot.writeStructEnd()
7075 
 
3431 rajveer 7076 
  def validate(self):
7077 
    return
7078 
 
7079 
 
94 ashish 7080 
  def __repr__(self):
7081 
    L = ['%s=%r' % (key, value)
7082 
      for key, value in self.__dict__.iteritems()]
7083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7084 
 
7085 
  def __eq__(self, other):
7086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7087 
 
7088 
  def __ne__(self, other):
7089 
    return not (self == other)
7090 
 
3064 chandransh 7091 
class getOrderForCustomer_result:
94 ashish 7092 
  """
7093 
  Attributes:
7094 
   - success
7095 
   - ex
7096 
  """
7097 
 
7098 
  thrift_spec = (
3064 chandransh 7099 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7101 
  )
7102 
 
7103 
  def __init__(self, success=None, ex=None,):
7104 
    self.success = success
7105 
    self.ex = ex
7106 
 
7107 
  def read(self, iprot):
7108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7110 
      return
7111 
    iprot.readStructBegin()
7112 
    while True:
7113 
      (fname, ftype, fid) = iprot.readFieldBegin()
7114 
      if ftype == TType.STOP:
7115 
        break
7116 
      if fid == 0:
3064 chandransh 7117 
        if ftype == TType.STRUCT:
7118 
          self.success = Order()
7119 
          self.success.read(iprot)
94 ashish 7120 
        else:
7121 
          iprot.skip(ftype)
7122 
      elif fid == 1:
7123 
        if ftype == TType.STRUCT:
7124 
          self.ex = TransactionServiceException()
7125 
          self.ex.read(iprot)
7126 
        else:
7127 
          iprot.skip(ftype)
7128 
      else:
7129 
        iprot.skip(ftype)
7130 
      iprot.readFieldEnd()
7131 
    iprot.readStructEnd()
7132 
 
7133 
  def write(self, oprot):
7134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7136 
      return
3064 chandransh 7137 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7138 
    if self.success is not None:
3064 chandransh 7139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7140 
      self.success.write(oprot)
94 ashish 7141 
      oprot.writeFieldEnd()
3431 rajveer 7142 
    if self.ex is not None:
94 ashish 7143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7144 
      self.ex.write(oprot)
7145 
      oprot.writeFieldEnd()
7146 
    oprot.writeFieldStop()
7147 
    oprot.writeStructEnd()
7148 
 
3431 rajveer 7149 
  def validate(self):
7150 
    return
7151 
 
7152 
 
94 ashish 7153 
  def __repr__(self):
7154 
    L = ['%s=%r' % (key, value)
7155 
      for key, value in self.__dict__.iteritems()]
7156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7157 
 
7158 
  def __eq__(self, other):
7159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7160 
 
7161 
  def __ne__(self, other):
7162 
    return not (self == other)
7163 
 
3064 chandransh 7164 
class getAlerts_args:
94 ashish 7165 
  """
7166 
  Attributes:
3064 chandransh 7167 
   - orderId
7168 
   - valid
94 ashish 7169 
  """
7170 
 
7171 
  thrift_spec = (
7172 
    None, # 0
3064 chandransh 7173 
    (1, TType.I64, 'orderId', None, None, ), # 1
7174 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7175 
  )
7176 
 
3064 chandransh 7177 
  def __init__(self, orderId=None, valid=None,):
7178 
    self.orderId = orderId
7179 
    self.valid = valid
94 ashish 7180 
 
7181 
  def read(self, iprot):
7182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7184 
      return
7185 
    iprot.readStructBegin()
7186 
    while True:
7187 
      (fname, ftype, fid) = iprot.readFieldBegin()
7188 
      if ftype == TType.STOP:
7189 
        break
7190 
      if fid == 1:
3064 chandransh 7191 
        if ftype == TType.I64:
7192 
          self.orderId = iprot.readI64();
94 ashish 7193 
        else:
7194 
          iprot.skip(ftype)
3064 chandransh 7195 
      elif fid == 2:
7196 
        if ftype == TType.BOOL:
7197 
          self.valid = iprot.readBool();
7198 
        else:
7199 
          iprot.skip(ftype)
94 ashish 7200 
      else:
7201 
        iprot.skip(ftype)
7202 
      iprot.readFieldEnd()
7203 
    iprot.readStructEnd()
7204 
 
7205 
  def write(self, oprot):
7206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7208 
      return
3064 chandransh 7209 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7210 
    if self.orderId is not None:
3064 chandransh 7211 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7212 
      oprot.writeI64(self.orderId)
94 ashish 7213 
      oprot.writeFieldEnd()
3431 rajveer 7214 
    if self.valid is not None:
3064 chandransh 7215 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7216 
      oprot.writeBool(self.valid)
7217 
      oprot.writeFieldEnd()
94 ashish 7218 
    oprot.writeFieldStop()
7219 
    oprot.writeStructEnd()
7220 
 
3431 rajveer 7221 
  def validate(self):
7222 
    return
7223 
 
7224 
 
94 ashish 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 getAlerts_result:
94 ashish 7237 
  """
7238 
  Attributes:
7239 
   - success
7240 
  """
7241 
 
7242 
  thrift_spec = (
3064 chandransh 7243 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7244 
  )
7245 
 
3064 chandransh 7246 
  def __init__(self, success=None,):
94 ashish 7247 
    self.success = success
7248 
 
7249 
  def read(self, iprot):
7250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7252 
      return
7253 
    iprot.readStructBegin()
7254 
    while True:
7255 
      (fname, ftype, fid) = iprot.readFieldBegin()
7256 
      if ftype == TType.STOP:
7257 
        break
7258 
      if fid == 0:
3064 chandransh 7259 
        if ftype == TType.LIST:
7260 
          self.success = []
4133 chandransh 7261 
          (_etype115, _size112) = iprot.readListBegin()
7262 
          for _i116 in xrange(_size112):
7263 
            _elem117 = Alert()
7264 
            _elem117.read(iprot)
7265 
            self.success.append(_elem117)
3064 chandransh 7266 
          iprot.readListEnd()
94 ashish 7267 
        else:
7268 
          iprot.skip(ftype)
7269 
      else:
7270 
        iprot.skip(ftype)
7271 
      iprot.readFieldEnd()
7272 
    iprot.readStructEnd()
7273 
 
7274 
  def write(self, oprot):
7275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7277 
      return
3064 chandransh 7278 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7279 
    if self.success is not None:
3064 chandransh 7280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7282 
      for iter118 in self.success:
7283 
        iter118.write(oprot)
3064 chandransh 7284 
      oprot.writeListEnd()
94 ashish 7285 
      oprot.writeFieldEnd()
7286 
    oprot.writeFieldStop()
7287 
    oprot.writeStructEnd()
7288 
 
3431 rajveer 7289 
  def validate(self):
7290 
    return
7291 
 
7292 
 
94 ashish 7293 
  def __repr__(self):
7294 
    L = ['%s=%r' % (key, value)
7295 
      for key, value in self.__dict__.iteritems()]
7296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7297 
 
7298 
  def __eq__(self, other):
7299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7300 
 
7301 
  def __ne__(self, other):
7302 
    return not (self == other)
7303 
 
3064 chandransh 7304 
class setAlert_args:
94 ashish 7305 
  """
7306 
  Attributes:
3064 chandransh 7307 
   - orderId
7308 
   - unset
7309 
   - type
7310 
   - comment
94 ashish 7311 
  """
7312 
 
7313 
  thrift_spec = (
7314 
    None, # 0
3064 chandransh 7315 
    (1, TType.I64, 'orderId', None, None, ), # 1
7316 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7317 
    (3, TType.I64, 'type', None, None, ), # 3
7318 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7319 
  )
7320 
 
3064 chandransh 7321 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7322 
    self.orderId = orderId
7323 
    self.unset = unset
7324 
    self.type = type
7325 
    self.comment = comment
94 ashish 7326 
 
7327 
  def read(self, iprot):
7328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7330 
      return
7331 
    iprot.readStructBegin()
7332 
    while True:
7333 
      (fname, ftype, fid) = iprot.readFieldBegin()
7334 
      if ftype == TType.STOP:
7335 
        break
7336 
      if fid == 1:
7337 
        if ftype == TType.I64:
3064 chandransh 7338 
          self.orderId = iprot.readI64();
94 ashish 7339 
        else:
7340 
          iprot.skip(ftype)
3064 chandransh 7341 
      elif fid == 2:
7342 
        if ftype == TType.BOOL:
7343 
          self.unset = iprot.readBool();
7344 
        else:
7345 
          iprot.skip(ftype)
7346 
      elif fid == 3:
7347 
        if ftype == TType.I64:
7348 
          self.type = iprot.readI64();
7349 
        else:
7350 
          iprot.skip(ftype)
7351 
      elif fid == 4:
7352 
        if ftype == TType.STRING:
7353 
          self.comment = iprot.readString();
7354 
        else:
7355 
          iprot.skip(ftype)
94 ashish 7356 
      else:
7357 
        iprot.skip(ftype)
7358 
      iprot.readFieldEnd()
7359 
    iprot.readStructEnd()
7360 
 
7361 
  def write(self, oprot):
7362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7364 
      return
3064 chandransh 7365 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7366 
    if self.orderId is not None:
3064 chandransh 7367 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7368 
      oprot.writeI64(self.orderId)
94 ashish 7369 
      oprot.writeFieldEnd()
3431 rajveer 7370 
    if self.unset is not None:
3064 chandransh 7371 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7372 
      oprot.writeBool(self.unset)
7373 
      oprot.writeFieldEnd()
3431 rajveer 7374 
    if self.type is not None:
3064 chandransh 7375 
      oprot.writeFieldBegin('type', TType.I64, 3)
7376 
      oprot.writeI64(self.type)
7377 
      oprot.writeFieldEnd()
3431 rajveer 7378 
    if self.comment is not None:
3064 chandransh 7379 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7380 
      oprot.writeString(self.comment)
7381 
      oprot.writeFieldEnd()
94 ashish 7382 
    oprot.writeFieldStop()
7383 
    oprot.writeStructEnd()
7384 
 
3431 rajveer 7385 
  def validate(self):
7386 
    return
7387 
 
7388 
 
94 ashish 7389 
  def __repr__(self):
7390 
    L = ['%s=%r' % (key, value)
7391 
      for key, value in self.__dict__.iteritems()]
7392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7393 
 
7394 
  def __eq__(self, other):
7395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7396 
 
7397 
  def __ne__(self, other):
7398 
    return not (self == other)
7399 
 
3064 chandransh 7400 
class setAlert_result:
7401 
 
7402 
  thrift_spec = (
7403 
  )
7404 
 
7405 
  def read(self, iprot):
7406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7408 
      return
7409 
    iprot.readStructBegin()
7410 
    while True:
7411 
      (fname, ftype, fid) = iprot.readFieldBegin()
7412 
      if ftype == TType.STOP:
7413 
        break
7414 
      else:
7415 
        iprot.skip(ftype)
7416 
      iprot.readFieldEnd()
7417 
    iprot.readStructEnd()
7418 
 
7419 
  def write(self, oprot):
7420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7422 
      return
7423 
    oprot.writeStructBegin('setAlert_result')
7424 
    oprot.writeFieldStop()
7425 
    oprot.writeStructEnd()
7426 
 
3431 rajveer 7427 
  def validate(self):
7428 
    return
7429 
 
7430 
 
3064 chandransh 7431 
  def __repr__(self):
7432 
    L = ['%s=%r' % (key, value)
7433 
      for key, value in self.__dict__.iteritems()]
7434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7435 
 
7436 
  def __eq__(self, other):
7437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7438 
 
7439 
  def __ne__(self, other):
7440 
    return not (self == other)
7441 
 
7442 
class getValidOrderCount_args:
7443 
 
7444 
  thrift_spec = (
7445 
  )
7446 
 
7447 
  def read(self, iprot):
7448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7450 
      return
7451 
    iprot.readStructBegin()
7452 
    while True:
7453 
      (fname, ftype, fid) = iprot.readFieldBegin()
7454 
      if ftype == TType.STOP:
7455 
        break
7456 
      else:
7457 
        iprot.skip(ftype)
7458 
      iprot.readFieldEnd()
7459 
    iprot.readStructEnd()
7460 
 
7461 
  def write(self, oprot):
7462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7464 
      return
7465 
    oprot.writeStructBegin('getValidOrderCount_args')
7466 
    oprot.writeFieldStop()
7467 
    oprot.writeStructEnd()
7468 
 
3431 rajveer 7469 
  def validate(self):
7470 
    return
7471 
 
7472 
 
3064 chandransh 7473 
  def __repr__(self):
7474 
    L = ['%s=%r' % (key, value)
7475 
      for key, value in self.__dict__.iteritems()]
7476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7477 
 
7478 
  def __eq__(self, other):
7479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7480 
 
7481 
  def __ne__(self, other):
7482 
    return not (self == other)
7483 
 
7484 
class getValidOrderCount_result:
94 ashish 7485 
  """
7486 
  Attributes:
7487 
   - success
7488 
  """
7489 
 
7490 
  thrift_spec = (
3064 chandransh 7491 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7492 
  )
7493 
 
3064 chandransh 7494 
  def __init__(self, success=None,):
94 ashish 7495 
    self.success = success
7496 
 
7497 
  def read(self, iprot):
7498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7500 
      return
7501 
    iprot.readStructBegin()
7502 
    while True:
7503 
      (fname, ftype, fid) = iprot.readFieldBegin()
7504 
      if ftype == TType.STOP:
7505 
        break
7506 
      if fid == 0:
3064 chandransh 7507 
        if ftype == TType.I64:
7508 
          self.success = iprot.readI64();
94 ashish 7509 
        else:
7510 
          iprot.skip(ftype)
7511 
      else:
7512 
        iprot.skip(ftype)
7513 
      iprot.readFieldEnd()
7514 
    iprot.readStructEnd()
7515 
 
7516 
  def write(self, oprot):
7517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7519 
      return
3064 chandransh 7520 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7521 
    if self.success is not None:
3064 chandransh 7522 
      oprot.writeFieldBegin('success', TType.I64, 0)
7523 
      oprot.writeI64(self.success)
94 ashish 7524 
      oprot.writeFieldEnd()
7525 
    oprot.writeFieldStop()
7526 
    oprot.writeStructEnd()
7527 
 
3431 rajveer 7528 
  def validate(self):
7529 
    return
7530 
 
7531 
 
94 ashish 7532 
  def __repr__(self):
7533 
    L = ['%s=%r' % (key, value)
7534 
      for key, value in self.__dict__.iteritems()]
7535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7536 
 
7537 
  def __eq__(self, other):
7538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7539 
 
7540 
  def __ne__(self, other):
7541 
    return not (self == other)
7542 
 
3064 chandransh 7543 
class getNoOfCustomersWithSuccessfulTransaction_args:
7544 
 
7545 
  thrift_spec = (
7546 
  )
7547 
 
7548 
  def read(self, iprot):
7549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7551 
      return
7552 
    iprot.readStructBegin()
7553 
    while True:
7554 
      (fname, ftype, fid) = iprot.readFieldBegin()
7555 
      if ftype == TType.STOP:
7556 
        break
7557 
      else:
7558 
        iprot.skip(ftype)
7559 
      iprot.readFieldEnd()
7560 
    iprot.readStructEnd()
7561 
 
7562 
  def write(self, oprot):
7563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7565 
      return
7566 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7567 
    oprot.writeFieldStop()
7568 
    oprot.writeStructEnd()
7569 
 
3431 rajveer 7570 
  def validate(self):
7571 
    return
7572 
 
7573 
 
3064 chandransh 7574 
  def __repr__(self):
7575 
    L = ['%s=%r' % (key, value)
7576 
      for key, value in self.__dict__.iteritems()]
7577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7578 
 
7579 
  def __eq__(self, other):
7580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7581 
 
7582 
  def __ne__(self, other):
7583 
    return not (self == other)
7584 
 
7585 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7586 
  """
7587 
  Attributes:
3064 chandransh 7588 
   - success
94 ashish 7589 
  """
7590 
 
7591 
  thrift_spec = (
3064 chandransh 7592 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7593 
  )
7594 
 
3064 chandransh 7595 
  def __init__(self, success=None,):
7596 
    self.success = success
94 ashish 7597 
 
7598 
  def read(self, iprot):
7599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7601 
      return
7602 
    iprot.readStructBegin()
7603 
    while True:
7604 
      (fname, ftype, fid) = iprot.readFieldBegin()
7605 
      if ftype == TType.STOP:
7606 
        break
3064 chandransh 7607 
      if fid == 0:
94 ashish 7608 
        if ftype == TType.I64:
3064 chandransh 7609 
          self.success = iprot.readI64();
94 ashish 7610 
        else:
7611 
          iprot.skip(ftype)
7612 
      else:
7613 
        iprot.skip(ftype)
7614 
      iprot.readFieldEnd()
7615 
    iprot.readStructEnd()
7616 
 
7617 
  def write(self, oprot):
7618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7620 
      return
3064 chandransh 7621 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7622 
    if self.success is not None:
3064 chandransh 7623 
      oprot.writeFieldBegin('success', TType.I64, 0)
7624 
      oprot.writeI64(self.success)
94 ashish 7625 
      oprot.writeFieldEnd()
7626 
    oprot.writeFieldStop()
7627 
    oprot.writeStructEnd()
7628 
 
3431 rajveer 7629 
  def validate(self):
7630 
    return
7631 
 
7632 
 
94 ashish 7633 
  def __repr__(self):
7634 
    L = ['%s=%r' % (key, value)
7635 
      for key, value in self.__dict__.iteritems()]
7636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7637 
 
7638 
  def __eq__(self, other):
7639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7640 
 
7641 
  def __ne__(self, other):
7642 
    return not (self == other)
7643 
 
3064 chandransh 7644 
class getValidOrdersAmountRange_args:
7645 
 
7646 
  thrift_spec = (
7647 
  )
7648 
 
7649 
  def read(self, iprot):
7650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7652 
      return
7653 
    iprot.readStructBegin()
7654 
    while True:
7655 
      (fname, ftype, fid) = iprot.readFieldBegin()
7656 
      if ftype == TType.STOP:
7657 
        break
7658 
      else:
7659 
        iprot.skip(ftype)
7660 
      iprot.readFieldEnd()
7661 
    iprot.readStructEnd()
7662 
 
7663 
  def write(self, oprot):
7664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7666 
      return
7667 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7668 
    oprot.writeFieldStop()
7669 
    oprot.writeStructEnd()
7670 
 
3431 rajveer 7671 
  def validate(self):
7672 
    return
7673 
 
7674 
 
3064 chandransh 7675 
  def __repr__(self):
7676 
    L = ['%s=%r' % (key, value)
7677 
      for key, value in self.__dict__.iteritems()]
7678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7679 
 
7680 
  def __eq__(self, other):
7681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7682 
 
7683 
  def __ne__(self, other):
7684 
    return not (self == other)
7685 
 
7686 
class getValidOrdersAmountRange_result:
94 ashish 7687 
  """
7688 
  Attributes:
7689 
   - success
7690 
  """
7691 
 
7692 
  thrift_spec = (
3064 chandransh 7693 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7694 
  )
7695 
 
3064 chandransh 7696 
  def __init__(self, success=None,):
94 ashish 7697 
    self.success = success
7698 
 
7699 
  def read(self, iprot):
7700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7702 
      return
7703 
    iprot.readStructBegin()
7704 
    while True:
7705 
      (fname, ftype, fid) = iprot.readFieldBegin()
7706 
      if ftype == TType.STOP:
7707 
        break
7708 
      if fid == 0:
483 rajveer 7709 
        if ftype == TType.LIST:
7710 
          self.success = []
4133 chandransh 7711 
          (_etype122, _size119) = iprot.readListBegin()
7712 
          for _i123 in xrange(_size119):
7713 
            _elem124 = iprot.readDouble();
7714 
            self.success.append(_elem124)
483 rajveer 7715 
          iprot.readListEnd()
94 ashish 7716 
        else:
7717 
          iprot.skip(ftype)
7718 
      else:
7719 
        iprot.skip(ftype)
7720 
      iprot.readFieldEnd()
7721 
    iprot.readStructEnd()
7722 
 
7723 
  def write(self, oprot):
7724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7726 
      return
3064 chandransh 7727 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7728 
    if self.success is not None:
483 rajveer 7729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7730 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7731 
      for iter125 in self.success:
7732 
        oprot.writeDouble(iter125)
483 rajveer 7733 
      oprot.writeListEnd()
94 ashish 7734 
      oprot.writeFieldEnd()
7735 
    oprot.writeFieldStop()
7736 
    oprot.writeStructEnd()
7737 
 
3431 rajveer 7738 
  def validate(self):
7739 
    return
7740 
 
7741 
 
94 ashish 7742 
  def __repr__(self):
7743 
    L = ['%s=%r' % (key, value)
7744 
      for key, value in self.__dict__.iteritems()]
7745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7746 
 
7747 
  def __eq__(self, other):
7748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7749 
 
7750 
  def __ne__(self, other):
7751 
    return not (self == other)
7752 
 
3064 chandransh 7753 
class getValidOrders_args:
1528 ankur.sing 7754 
  """
7755 
  Attributes:
3064 chandransh 7756 
   - limit
1528 ankur.sing 7757 
  """
7758 
 
7759 
  thrift_spec = (
7760 
    None, # 0
3064 chandransh 7761 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7762 
  )
7763 
 
3064 chandransh 7764 
  def __init__(self, limit=None,):
7765 
    self.limit = limit
1528 ankur.sing 7766 
 
7767 
  def read(self, iprot):
7768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7770 
      return
7771 
    iprot.readStructBegin()
7772 
    while True:
7773 
      (fname, ftype, fid) = iprot.readFieldBegin()
7774 
      if ftype == TType.STOP:
7775 
        break
7776 
      if fid == 1:
7777 
        if ftype == TType.I64:
3064 chandransh 7778 
          self.limit = iprot.readI64();
1528 ankur.sing 7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      else:
7782 
        iprot.skip(ftype)
7783 
      iprot.readFieldEnd()
7784 
    iprot.readStructEnd()
7785 
 
7786 
  def write(self, oprot):
7787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7789 
      return
3064 chandransh 7790 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7791 
    if self.limit is not None:
3064 chandransh 7792 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7793 
      oprot.writeI64(self.limit)
1528 ankur.sing 7794 
      oprot.writeFieldEnd()
7795 
    oprot.writeFieldStop()
7796 
    oprot.writeStructEnd()
7797 
 
3431 rajveer 7798 
  def validate(self):
7799 
    return
7800 
 
7801 
 
1528 ankur.sing 7802 
  def __repr__(self):
7803 
    L = ['%s=%r' % (key, value)
7804 
      for key, value in self.__dict__.iteritems()]
7805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7806 
 
7807 
  def __eq__(self, other):
7808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7809 
 
7810 
  def __ne__(self, other):
7811 
    return not (self == other)
7812 
 
3064 chandransh 7813 
class getValidOrders_result:
1528 ankur.sing 7814 
  """
7815 
  Attributes:
7816 
   - success
7817 
  """
7818 
 
7819 
  thrift_spec = (
3064 chandransh 7820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7821 
  )
7822 
 
3064 chandransh 7823 
  def __init__(self, success=None,):
1528 ankur.sing 7824 
    self.success = success
7825 
 
7826 
  def read(self, iprot):
7827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7829 
      return
7830 
    iprot.readStructBegin()
7831 
    while True:
7832 
      (fname, ftype, fid) = iprot.readFieldBegin()
7833 
      if ftype == TType.STOP:
7834 
        break
7835 
      if fid == 0:
3064 chandransh 7836 
        if ftype == TType.LIST:
7837 
          self.success = []
4133 chandransh 7838 
          (_etype129, _size126) = iprot.readListBegin()
7839 
          for _i130 in xrange(_size126):
7840 
            _elem131 = Order()
7841 
            _elem131.read(iprot)
7842 
            self.success.append(_elem131)
3064 chandransh 7843 
          iprot.readListEnd()
1528 ankur.sing 7844 
        else:
7845 
          iprot.skip(ftype)
7846 
      else:
7847 
        iprot.skip(ftype)
7848 
      iprot.readFieldEnd()
7849 
    iprot.readStructEnd()
7850 
 
7851 
  def write(self, oprot):
7852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7854 
      return
3064 chandransh 7855 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7856 
    if self.success is not None:
3064 chandransh 7857 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7858 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7859 
      for iter132 in self.success:
7860 
        iter132.write(oprot)
3064 chandransh 7861 
      oprot.writeListEnd()
1528 ankur.sing 7862 
      oprot.writeFieldEnd()
7863 
    oprot.writeFieldStop()
7864 
    oprot.writeStructEnd()
7865 
 
3431 rajveer 7866 
  def validate(self):
7867 
    return
7868 
 
7869 
 
1528 ankur.sing 7870 
  def __repr__(self):
7871 
    L = ['%s=%r' % (key, value)
7872 
      for key, value in self.__dict__.iteritems()]
7873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7874 
 
7875 
  def __eq__(self, other):
7876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7877 
 
7878 
  def __ne__(self, other):
7879 
    return not (self == other)
7880 
 
1220 chandransh 7881 
class batchOrders_args:
7882 
  """
7883 
  Attributes:
7884 
   - warehouseId
7885 
  """
7886 
 
7887 
  thrift_spec = (
7888 
    None, # 0
7889 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
7890 
  )
7891 
 
7892 
  def __init__(self, warehouseId=None,):
7893 
    self.warehouseId = warehouseId
7894 
 
7895 
  def read(self, iprot):
7896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7898 
      return
7899 
    iprot.readStructBegin()
7900 
    while True:
7901 
      (fname, ftype, fid) = iprot.readFieldBegin()
7902 
      if ftype == TType.STOP:
7903 
        break
7904 
      if fid == 1:
7905 
        if ftype == TType.I64:
7906 
          self.warehouseId = iprot.readI64();
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
7918 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 7919 
    if self.warehouseId is not None:
1220 chandransh 7920 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7921 
      oprot.writeI64(self.warehouseId)
7922 
      oprot.writeFieldEnd()
7923 
    oprot.writeFieldStop()
7924 
    oprot.writeStructEnd()
7925 
 
3431 rajveer 7926 
  def validate(self):
7927 
    return
7928 
 
7929 
 
1220 chandransh 7930 
  def __repr__(self):
7931 
    L = ['%s=%r' % (key, value)
7932 
      for key, value in self.__dict__.iteritems()]
7933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7934 
 
7935 
  def __eq__(self, other):
7936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7937 
 
7938 
  def __ne__(self, other):
7939 
    return not (self == other)
7940 
 
7941 
class batchOrders_result:
7942 
  """
7943 
  Attributes:
7944 
   - success
7945 
   - ex
7946 
  """
7947 
 
7948 
  thrift_spec = (
7949 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7951 
  )
7952 
 
7953 
  def __init__(self, success=None, ex=None,):
7954 
    self.success = success
7955 
    self.ex = ex
7956 
 
7957 
  def read(self, iprot):
7958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7960 
      return
7961 
    iprot.readStructBegin()
7962 
    while True:
7963 
      (fname, ftype, fid) = iprot.readFieldBegin()
7964 
      if ftype == TType.STOP:
7965 
        break
7966 
      if fid == 0:
7967 
        if ftype == TType.LIST:
7968 
          self.success = []
4133 chandransh 7969 
          (_etype136, _size133) = iprot.readListBegin()
7970 
          for _i137 in xrange(_size133):
7971 
            _elem138 = Order()
7972 
            _elem138.read(iprot)
7973 
            self.success.append(_elem138)
1220 chandransh 7974 
          iprot.readListEnd()
7975 
        else:
7976 
          iprot.skip(ftype)
7977 
      elif fid == 1:
7978 
        if ftype == TType.STRUCT:
7979 
          self.ex = TransactionServiceException()
7980 
          self.ex.read(iprot)
7981 
        else:
7982 
          iprot.skip(ftype)
7983 
      else:
7984 
        iprot.skip(ftype)
7985 
      iprot.readFieldEnd()
7986 
    iprot.readStructEnd()
7987 
 
7988 
  def write(self, oprot):
7989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7991 
      return
7992 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 7993 
    if self.success is not None:
1220 chandransh 7994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7996 
      for iter139 in self.success:
7997 
        iter139.write(oprot)
1220 chandransh 7998 
      oprot.writeListEnd()
7999 
      oprot.writeFieldEnd()
3431 rajveer 8000 
    if self.ex is not None:
1220 chandransh 8001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8002 
      self.ex.write(oprot)
8003 
      oprot.writeFieldEnd()
8004 
    oprot.writeFieldStop()
8005 
    oprot.writeStructEnd()
8006 
 
3431 rajveer 8007 
  def validate(self):
8008 
    return
8009 
 
8010 
 
1220 chandransh 8011 
  def __repr__(self):
8012 
    L = ['%s=%r' % (key, value)
8013 
      for key, value in self.__dict__.iteritems()]
8014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8015 
 
8016 
  def __eq__(self, other):
8017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8018 
 
8019 
  def __ne__(self, other):
8020 
    return not (self == other)
8021 
 
1208 chandransh 8022 
class markOrderAsOutOfStock_args:
8023 
  """
8024 
  Attributes:
8025 
   - orderId
8026 
  """
8027 
 
8028 
  thrift_spec = (
8029 
    None, # 0
8030 
    (1, TType.I64, 'orderId', None, None, ), # 1
8031 
  )
8032 
 
8033 
  def __init__(self, orderId=None,):
8034 
    self.orderId = orderId
8035 
 
8036 
  def read(self, iprot):
8037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8039 
      return
8040 
    iprot.readStructBegin()
8041 
    while True:
8042 
      (fname, ftype, fid) = iprot.readFieldBegin()
8043 
      if ftype == TType.STOP:
8044 
        break
8045 
      if fid == 1:
8046 
        if ftype == TType.I64:
8047 
          self.orderId = iprot.readI64();
8048 
        else:
8049 
          iprot.skip(ftype)
8050 
      else:
8051 
        iprot.skip(ftype)
8052 
      iprot.readFieldEnd()
8053 
    iprot.readStructEnd()
8054 
 
8055 
  def write(self, oprot):
8056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8058 
      return
8059 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8060 
    if self.orderId is not None:
1208 chandransh 8061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8062 
      oprot.writeI64(self.orderId)
8063 
      oprot.writeFieldEnd()
8064 
    oprot.writeFieldStop()
8065 
    oprot.writeStructEnd()
8066 
 
3431 rajveer 8067 
  def validate(self):
8068 
    return
8069 
 
8070 
 
1208 chandransh 8071 
  def __repr__(self):
8072 
    L = ['%s=%r' % (key, value)
8073 
      for key, value in self.__dict__.iteritems()]
8074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8075 
 
8076 
  def __eq__(self, other):
8077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8078 
 
8079 
  def __ne__(self, other):
8080 
    return not (self == other)
8081 
 
8082 
class markOrderAsOutOfStock_result:
8083 
  """
8084 
  Attributes:
8085 
   - success
8086 
   - ex
8087 
  """
8088 
 
8089 
  thrift_spec = (
8090 
    (0, TType.BOOL, 'success', None, None, ), # 0
8091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8092 
  )
8093 
 
8094 
  def __init__(self, success=None, ex=None,):
8095 
    self.success = success
8096 
    self.ex = ex
8097 
 
8098 
  def read(self, iprot):
8099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8101 
      return
8102 
    iprot.readStructBegin()
8103 
    while True:
8104 
      (fname, ftype, fid) = iprot.readFieldBegin()
8105 
      if ftype == TType.STOP:
8106 
        break
8107 
      if fid == 0:
8108 
        if ftype == TType.BOOL:
8109 
          self.success = iprot.readBool();
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      elif fid == 1:
8113 
        if ftype == TType.STRUCT:
8114 
          self.ex = TransactionServiceException()
8115 
          self.ex.read(iprot)
8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      else:
8119 
        iprot.skip(ftype)
8120 
      iprot.readFieldEnd()
8121 
    iprot.readStructEnd()
8122 
 
8123 
  def write(self, oprot):
8124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8126 
      return
8127 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8128 
    if self.success is not None:
1208 chandransh 8129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8130 
      oprot.writeBool(self.success)
8131 
      oprot.writeFieldEnd()
3431 rajveer 8132 
    if self.ex is not None:
1208 chandransh 8133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8134 
      self.ex.write(oprot)
8135 
      oprot.writeFieldEnd()
8136 
    oprot.writeFieldStop()
8137 
    oprot.writeStructEnd()
8138 
 
3431 rajveer 8139 
  def validate(self):
8140 
    return
8141 
 
8142 
 
1208 chandransh 8143 
  def __repr__(self):
8144 
    L = ['%s=%r' % (key, value)
8145 
      for key, value in self.__dict__.iteritems()]
8146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8147 
 
8148 
  def __eq__(self, other):
8149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8150 
 
8151 
  def __ne__(self, other):
8152 
    return not (self == other)
8153 
 
3064 chandransh 8154 
class verifyOrder_args:
759 chandransh 8155 
  """
8156 
  Attributes:
3064 chandransh 8157 
   - orderId
759 chandransh 8158 
  """
8159 
 
8160 
  thrift_spec = (
8161 
    None, # 0
3064 chandransh 8162 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8163 
  )
8164 
 
3064 chandransh 8165 
  def __init__(self, orderId=None,):
8166 
    self.orderId = orderId
759 chandransh 8167 
 
8168 
  def read(self, iprot):
8169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8171 
      return
8172 
    iprot.readStructBegin()
8173 
    while True:
8174 
      (fname, ftype, fid) = iprot.readFieldBegin()
8175 
      if ftype == TType.STOP:
8176 
        break
8177 
      if fid == 1:
8178 
        if ftype == TType.I64:
3064 chandransh 8179 
          self.orderId = iprot.readI64();
759 chandransh 8180 
        else:
8181 
          iprot.skip(ftype)
8182 
      else:
8183 
        iprot.skip(ftype)
8184 
      iprot.readFieldEnd()
8185 
    iprot.readStructEnd()
8186 
 
8187 
  def write(self, oprot):
8188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8190 
      return
3064 chandransh 8191 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8192 
    if self.orderId is not None:
3064 chandransh 8193 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8194 
      oprot.writeI64(self.orderId)
759 chandransh 8195 
      oprot.writeFieldEnd()
8196 
    oprot.writeFieldStop()
8197 
    oprot.writeStructEnd()
8198 
 
3431 rajveer 8199 
  def validate(self):
8200 
    return
8201 
 
8202 
 
759 chandransh 8203 
  def __repr__(self):
8204 
    L = ['%s=%r' % (key, value)
8205 
      for key, value in self.__dict__.iteritems()]
8206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8207 
 
8208 
  def __eq__(self, other):
8209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8210 
 
8211 
  def __ne__(self, other):
8212 
    return not (self == other)
8213 
 
3064 chandransh 8214 
class verifyOrder_result:
759 chandransh 8215 
  """
8216 
  Attributes:
8217 
   - success
8218 
   - ex
8219 
  """
8220 
 
8221 
  thrift_spec = (
8222 
    (0, TType.BOOL, 'success', None, None, ), # 0
8223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8224 
  )
8225 
 
8226 
  def __init__(self, success=None, ex=None,):
8227 
    self.success = success
8228 
    self.ex = ex
8229 
 
8230 
  def read(self, iprot):
8231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8233 
      return
8234 
    iprot.readStructBegin()
8235 
    while True:
8236 
      (fname, ftype, fid) = iprot.readFieldBegin()
8237 
      if ftype == TType.STOP:
8238 
        break
8239 
      if fid == 0:
8240 
        if ftype == TType.BOOL:
8241 
          self.success = iprot.readBool();
8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      elif fid == 1:
8245 
        if ftype == TType.STRUCT:
8246 
          self.ex = TransactionServiceException()
8247 
          self.ex.read(iprot)
8248 
        else:
8249 
          iprot.skip(ftype)
8250 
      else:
8251 
        iprot.skip(ftype)
8252 
      iprot.readFieldEnd()
8253 
    iprot.readStructEnd()
8254 
 
8255 
  def write(self, oprot):
8256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8258 
      return
3064 chandransh 8259 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8260 
    if self.success is not None:
759 chandransh 8261 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8262 
      oprot.writeBool(self.success)
8263 
      oprot.writeFieldEnd()
3431 rajveer 8264 
    if self.ex is not None:
759 chandransh 8265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8266 
      self.ex.write(oprot)
8267 
      oprot.writeFieldEnd()
8268 
    oprot.writeFieldStop()
8269 
    oprot.writeStructEnd()
8270 
 
3431 rajveer 8271 
  def validate(self):
8272 
    return
8273 
 
8274 
 
759 chandransh 8275 
  def __repr__(self):
8276 
    L = ['%s=%r' % (key, value)
8277 
      for key, value in self.__dict__.iteritems()]
8278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8279 
 
8280 
  def __eq__(self, other):
8281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8282 
 
8283 
  def __ne__(self, other):
8284 
    return not (self == other)
8285 
 
3064 chandransh 8286 
class acceptOrder_args:
1113 chandransh 8287 
  """
8288 
  Attributes:
3064 chandransh 8289 
   - orderId
1113 chandransh 8290 
  """
8291 
 
8292 
  thrift_spec = (
8293 
    None, # 0
3064 chandransh 8294 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8295 
  )
8296 
 
3064 chandransh 8297 
  def __init__(self, orderId=None,):
8298 
    self.orderId = orderId
1113 chandransh 8299 
 
8300 
  def read(self, iprot):
8301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8303 
      return
8304 
    iprot.readStructBegin()
8305 
    while True:
8306 
      (fname, ftype, fid) = iprot.readFieldBegin()
8307 
      if ftype == TType.STOP:
8308 
        break
8309 
      if fid == 1:
8310 
        if ftype == TType.I64:
3064 chandransh 8311 
          self.orderId = iprot.readI64();
1113 chandransh 8312 
        else:
8313 
          iprot.skip(ftype)
8314 
      else:
8315 
        iprot.skip(ftype)
8316 
      iprot.readFieldEnd()
8317 
    iprot.readStructEnd()
8318 
 
8319 
  def write(self, oprot):
8320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8322 
      return
3064 chandransh 8323 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8324 
    if self.orderId is not None:
3064 chandransh 8325 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8326 
      oprot.writeI64(self.orderId)
1113 chandransh 8327 
      oprot.writeFieldEnd()
8328 
    oprot.writeFieldStop()
8329 
    oprot.writeStructEnd()
8330 
 
3431 rajveer 8331 
  def validate(self):
8332 
    return
8333 
 
8334 
 
1113 chandransh 8335 
  def __repr__(self):
8336 
    L = ['%s=%r' % (key, value)
8337 
      for key, value in self.__dict__.iteritems()]
8338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8339 
 
8340 
  def __eq__(self, other):
8341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8342 
 
8343 
  def __ne__(self, other):
8344 
    return not (self == other)
8345 
 
3064 chandransh 8346 
class acceptOrder_result:
1113 chandransh 8347 
  """
8348 
  Attributes:
8349 
   - success
8350 
   - ex
8351 
  """
8352 
 
8353 
  thrift_spec = (
3064 chandransh 8354 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8356 
  )
8357 
 
8358 
  def __init__(self, success=None, ex=None,):
8359 
    self.success = success
8360 
    self.ex = ex
8361 
 
8362 
  def read(self, iprot):
8363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8365 
      return
8366 
    iprot.readStructBegin()
8367 
    while True:
8368 
      (fname, ftype, fid) = iprot.readFieldBegin()
8369 
      if ftype == TType.STOP:
8370 
        break
8371 
      if fid == 0:
3064 chandransh 8372 
        if ftype == TType.BOOL:
8373 
          self.success = iprot.readBool();
1113 chandransh 8374 
        else:
8375 
          iprot.skip(ftype)
8376 
      elif fid == 1:
8377 
        if ftype == TType.STRUCT:
8378 
          self.ex = TransactionServiceException()
8379 
          self.ex.read(iprot)
8380 
        else:
8381 
          iprot.skip(ftype)
8382 
      else:
8383 
        iprot.skip(ftype)
8384 
      iprot.readFieldEnd()
8385 
    iprot.readStructEnd()
8386 
 
8387 
  def write(self, oprot):
8388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8390 
      return
3064 chandransh 8391 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8392 
    if self.success is not None:
3064 chandransh 8393 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8394 
      oprot.writeBool(self.success)
1113 chandransh 8395 
      oprot.writeFieldEnd()
3431 rajveer 8396 
    if self.ex is not None:
1113 chandransh 8397 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8398 
      self.ex.write(oprot)
8399 
      oprot.writeFieldEnd()
8400 
    oprot.writeFieldStop()
8401 
    oprot.writeStructEnd()
8402 
 
3431 rajveer 8403 
  def validate(self):
8404 
    return
8405 
 
8406 
 
1113 chandransh 8407 
  def __repr__(self):
8408 
    L = ['%s=%r' % (key, value)
8409 
      for key, value in self.__dict__.iteritems()]
8410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8411 
 
8412 
  def __eq__(self, other):
8413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8414 
 
8415 
  def __ne__(self, other):
8416 
    return not (self == other)
8417 
 
3064 chandransh 8418 
class addBillingDetails_args:
1135 chandransh 8419 
  """
8420 
  Attributes:
3064 chandransh 8421 
   - orderId
8422 
   - invoice_number
4283 anupam.sin 8423 
   - imeiNumber
8424 
   - itemNumber
3064 chandransh 8425 
   - billed_by
4264 rajveer 8426 
   - jacketNumber
4283 anupam.sin 8427 
   - billingType
8428 
   - vendorId
1135 chandransh 8429 
  """
8430 
 
8431 
  thrift_spec = (
8432 
    None, # 0
3064 chandransh 8433 
    (1, TType.I64, 'orderId', None, None, ), # 1
8434 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8435 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8436 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8437 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8438 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8439 
    (7, TType.I64, 'billingType', None, None, ), # 7
8440 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8441 
  )
8442 
 
4283 anupam.sin 8443 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8444 
    self.orderId = orderId
8445 
    self.invoice_number = invoice_number
4283 anupam.sin 8446 
    self.imeiNumber = imeiNumber
8447 
    self.itemNumber = itemNumber
3064 chandransh 8448 
    self.billed_by = billed_by
4264 rajveer 8449 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8450 
    self.billingType = billingType
8451 
    self.vendorId = vendorId
1135 chandransh 8452 
 
8453 
  def read(self, iprot):
8454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8456 
      return
8457 
    iprot.readStructBegin()
8458 
    while True:
8459 
      (fname, ftype, fid) = iprot.readFieldBegin()
8460 
      if ftype == TType.STOP:
8461 
        break
8462 
      if fid == 1:
8463 
        if ftype == TType.I64:
3064 chandransh 8464 
          self.orderId = iprot.readI64();
1135 chandransh 8465 
        else:
8466 
          iprot.skip(ftype)
8467 
      elif fid == 2:
3064 chandransh 8468 
        if ftype == TType.STRING:
8469 
          self.invoice_number = iprot.readString();
1135 chandransh 8470 
        else:
8471 
          iprot.skip(ftype)
3064 chandransh 8472 
      elif fid == 3:
4264 rajveer 8473 
        if ftype == TType.I64:
3064 chandransh 8474 
          self.imeiNumber = iprot.readI64();
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      elif fid == 4:
8478 
        if ftype == TType.STRING:
8479 
          self.itemNumber = iprot.readString();
8480 
        else:
8481 
          iprot.skip(ftype)
8482 
      elif fid == 5:
8483 
        if ftype == TType.STRING:
4283 anupam.sin 8484 
          self.billed_by = iprot.readString();
3064 chandransh 8485 
        else:
8486 
          iprot.skip(ftype)
8487 
      elif fid == 6:
8488 
        if ftype == TType.I64:
4283 anupam.sin 8489 
          self.jacketNumber = iprot.readI64();
8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      elif fid == 7:
8493 
        if ftype == TType.I64:
3064 chandransh 8494 
          self.billingType = iprot.readI64();
8495 
        else:
8496 
          iprot.skip(ftype)
4283 anupam.sin 8497 
      elif fid == 8:
8498 
        if ftype == TType.I64:
8499 
          self.vendorId = iprot.readI64();
8500 
        else:
8501 
          iprot.skip(ftype)
1246 chandransh 8502 
      else:
8503 
        iprot.skip(ftype)
8504 
      iprot.readFieldEnd()
8505 
    iprot.readStructEnd()
8506 
 
8507 
  def write(self, oprot):
8508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8510 
      return
4283 anupam.sin 8511 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8512 
    if self.orderId is not None:
3064 chandransh 8513 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8514 
      oprot.writeI64(self.orderId)
1246 chandransh 8515 
      oprot.writeFieldEnd()
4283 anupam.sin 8516 
    if self.invoice_number is not None:
8517 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8518 
      oprot.writeString(self.invoice_number)
1246 chandransh 8519 
      oprot.writeFieldEnd()
3431 rajveer 8520 
    if self.imeiNumber is not None:
3064 chandransh 8521 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8522 
      oprot.writeI64(self.imeiNumber)
8523 
      oprot.writeFieldEnd()
3431 rajveer 8524 
    if self.itemNumber is not None:
3064 chandransh 8525 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8526 
      oprot.writeString(self.itemNumber)
8527 
      oprot.writeFieldEnd()
4283 anupam.sin 8528 
    if self.billed_by is not None:
8529 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8530 
      oprot.writeString(self.billed_by)
3064 chandransh 8531 
      oprot.writeFieldEnd()
4283 anupam.sin 8532 
    if self.jacketNumber is not None:
8533 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8534 
      oprot.writeI64(self.jacketNumber)
8535 
      oprot.writeFieldEnd()
3431 rajveer 8536 
    if self.billingType is not None:
4283 anupam.sin 8537 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8538 
      oprot.writeI64(self.billingType)
8539 
      oprot.writeFieldEnd()
4283 anupam.sin 8540 
    if self.vendorId is not None:
8541 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8542 
      oprot.writeI64(self.vendorId)
8543 
      oprot.writeFieldEnd()
1246 chandransh 8544 
    oprot.writeFieldStop()
8545 
    oprot.writeStructEnd()
8546 
 
3431 rajveer 8547 
  def validate(self):
8548 
    return
8549 
 
8550 
 
1246 chandransh 8551 
  def __repr__(self):
8552 
    L = ['%s=%r' % (key, value)
8553 
      for key, value in self.__dict__.iteritems()]
8554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8555 
 
8556 
  def __eq__(self, other):
8557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8558 
 
8559 
  def __ne__(self, other):
8560 
    return not (self == other)
8561 
 
4283 anupam.sin 8562 
class addBillingDetails_result:
1246 chandransh 8563 
  """
8564 
  Attributes:
3064 chandransh 8565 
   - success
1246 chandransh 8566 
   - ex
8567 
  """
8568 
 
8569 
  thrift_spec = (
3064 chandransh 8570 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8572 
  )
8573 
 
3064 chandransh 8574 
  def __init__(self, success=None, ex=None,):
8575 
    self.success = success
1246 chandransh 8576 
    self.ex = ex
8577 
 
8578 
  def read(self, iprot):
8579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8581 
      return
8582 
    iprot.readStructBegin()
8583 
    while True:
8584 
      (fname, ftype, fid) = iprot.readFieldBegin()
8585 
      if ftype == TType.STOP:
8586 
        break
3064 chandransh 8587 
      if fid == 0:
8588 
        if ftype == TType.BOOL:
8589 
          self.success = iprot.readBool();
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      elif fid == 1:
1246 chandransh 8593 
        if ftype == TType.STRUCT:
8594 
          self.ex = TransactionServiceException()
8595 
          self.ex.read(iprot)
8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      else:
8599 
        iprot.skip(ftype)
8600 
      iprot.readFieldEnd()
8601 
    iprot.readStructEnd()
8602 
 
8603 
  def write(self, oprot):
8604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8606 
      return
4283 anupam.sin 8607 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8608 
    if self.success is not None:
3064 chandransh 8609 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8610 
      oprot.writeBool(self.success)
8611 
      oprot.writeFieldEnd()
3431 rajveer 8612 
    if self.ex is not None:
1246 chandransh 8613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8614 
      self.ex.write(oprot)
8615 
      oprot.writeFieldEnd()
8616 
    oprot.writeFieldStop()
8617 
    oprot.writeStructEnd()
8618 
 
3431 rajveer 8619 
  def validate(self):
8620 
    return
8621 
 
8622 
 
1246 chandransh 8623 
  def __repr__(self):
8624 
    L = ['%s=%r' % (key, value)
8625 
      for key, value in self.__dict__.iteritems()]
8626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8627 
 
8628 
  def __eq__(self, other):
8629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8630 
 
8631 
  def __ne__(self, other):
8632 
    return not (self == other)
8633 
 
3064 chandransh 8634 
class markOrdersAsManifested_args:
1408 ankur.sing 8635 
  """
8636 
  Attributes:
3064 chandransh 8637 
   - warehouseId
1408 ankur.sing 8638 
   - providerId
3064 chandransh 8639 
   - cod
1408 ankur.sing 8640 
  """
8641 
 
8642 
  thrift_spec = (
8643 
    None, # 0
3064 chandransh 8644 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8645 
    (2, TType.I64, 'providerId', None, None, ), # 2
8646 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8647 
  )
8648 
 
3064 chandransh 8649 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8650 
    self.warehouseId = warehouseId
1408 ankur.sing 8651 
    self.providerId = providerId
3064 chandransh 8652 
    self.cod = cod
1408 ankur.sing 8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 1:
8664 
        if ftype == TType.I64:
3064 chandransh 8665 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      elif fid == 2:
8669 
        if ftype == TType.I64:
3064 chandransh 8670 
          self.providerId = iprot.readI64();
1408 ankur.sing 8671 
        else:
8672 
          iprot.skip(ftype)
3064 chandransh 8673 
      elif fid == 3:
8674 
        if ftype == TType.BOOL:
8675 
          self.cod = iprot.readBool();
8676 
        else:
8677 
          iprot.skip(ftype)
1408 ankur.sing 8678 
      else:
8679 
        iprot.skip(ftype)
8680 
      iprot.readFieldEnd()
8681 
    iprot.readStructEnd()
8682 
 
8683 
  def write(self, oprot):
8684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8686 
      return
3064 chandransh 8687 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 8688 
    if self.warehouseId is not None:
3064 chandransh 8689 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8690 
      oprot.writeI64(self.warehouseId)
8691 
      oprot.writeFieldEnd()
3431 rajveer 8692 
    if self.providerId is not None:
3064 chandransh 8693 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 8694 
      oprot.writeI64(self.providerId)
8695 
      oprot.writeFieldEnd()
3431 rajveer 8696 
    if self.cod is not None:
3064 chandransh 8697 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
8698 
      oprot.writeBool(self.cod)
1408 ankur.sing 8699 
      oprot.writeFieldEnd()
8700 
    oprot.writeFieldStop()
8701 
    oprot.writeStructEnd()
8702 
 
3431 rajveer 8703 
  def validate(self):
8704 
    return
8705 
 
8706 
 
1408 ankur.sing 8707 
  def __repr__(self):
8708 
    L = ['%s=%r' % (key, value)
8709 
      for key, value in self.__dict__.iteritems()]
8710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8711 
 
8712 
  def __eq__(self, other):
8713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8714 
 
8715 
  def __ne__(self, other):
8716 
    return not (self == other)
8717 
 
3064 chandransh 8718 
class markOrdersAsManifested_result:
1408 ankur.sing 8719 
  """
8720 
  Attributes:
8721 
   - success
3064 chandransh 8722 
   - ex
1408 ankur.sing 8723 
  """
8724 
 
8725 
  thrift_spec = (
3064 chandransh 8726 
    (0, TType.BOOL, 'success', None, None, ), # 0
8727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 8728 
  )
8729 
 
3064 chandransh 8730 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 8731 
    self.success = success
3064 chandransh 8732 
    self.ex = ex
1408 ankur.sing 8733 
 
8734 
  def read(self, iprot):
8735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8737 
      return
8738 
    iprot.readStructBegin()
8739 
    while True:
8740 
      (fname, ftype, fid) = iprot.readFieldBegin()
8741 
      if ftype == TType.STOP:
8742 
        break
8743 
      if fid == 0:
3064 chandransh 8744 
        if ftype == TType.BOOL:
8745 
          self.success = iprot.readBool();
1408 ankur.sing 8746 
        else:
8747 
          iprot.skip(ftype)
3064 chandransh 8748 
      elif fid == 1:
8749 
        if ftype == TType.STRUCT:
8750 
          self.ex = TransactionServiceException()
8751 
          self.ex.read(iprot)
8752 
        else:
8753 
          iprot.skip(ftype)
1408 ankur.sing 8754 
      else:
8755 
        iprot.skip(ftype)
8756 
      iprot.readFieldEnd()
8757 
    iprot.readStructEnd()
8758 
 
8759 
  def write(self, oprot):
8760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8762 
      return
3064 chandransh 8763 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 8764 
    if self.success is not None:
3064 chandransh 8765 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8766 
      oprot.writeBool(self.success)
1408 ankur.sing 8767 
      oprot.writeFieldEnd()
3431 rajveer 8768 
    if self.ex is not None:
3064 chandransh 8769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8770 
      self.ex.write(oprot)
8771 
      oprot.writeFieldEnd()
1408 ankur.sing 8772 
    oprot.writeFieldStop()
8773 
    oprot.writeStructEnd()
8774 
 
3431 rajveer 8775 
  def validate(self):
8776 
    return
8777 
 
8778 
 
1408 ankur.sing 8779 
  def __repr__(self):
8780 
    L = ['%s=%r' % (key, value)
8781 
      for key, value in self.__dict__.iteritems()]
8782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8783 
 
8784 
  def __eq__(self, other):
8785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8786 
 
8787 
  def __ne__(self, other):
8788 
    return not (self == other)
8789 
 
3064 chandransh 8790 
class markOrdersAsPickedUp_args:
304 ashish 8791 
  """
8792 
  Attributes:
3064 chandransh 8793 
   - providerId
8794 
   - pickupDetails
304 ashish 8795 
  """
94 ashish 8796 
 
304 ashish 8797 
  thrift_spec = (
8798 
    None, # 0
3064 chandransh 8799 
    (1, TType.I64, 'providerId', None, None, ), # 1
8800 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8801 
  )
8802 
 
3064 chandransh 8803 
  def __init__(self, providerId=None, pickupDetails=None,):
8804 
    self.providerId = providerId
8805 
    self.pickupDetails = pickupDetails
304 ashish 8806 
 
8807 
  def read(self, iprot):
8808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8810 
      return
8811 
    iprot.readStructBegin()
8812 
    while True:
8813 
      (fname, ftype, fid) = iprot.readFieldBegin()
8814 
      if ftype == TType.STOP:
8815 
        break
8816 
      if fid == 1:
8817 
        if ftype == TType.I64:
3064 chandransh 8818 
          self.providerId = iprot.readI64();
304 ashish 8819 
        else:
8820 
          iprot.skip(ftype)
8821 
      elif fid == 2:
3064 chandransh 8822 
        if ftype == TType.MAP:
8823 
          self.pickupDetails = {}
4133 chandransh 8824 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
8825 
          for _i144 in xrange(_size140):
8826 
            _key145 = iprot.readString();
8827 
            _val146 = iprot.readString();
8828 
            self.pickupDetails[_key145] = _val146
3064 chandransh 8829 
          iprot.readMapEnd()
304 ashish 8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      else:
8833 
        iprot.skip(ftype)
8834 
      iprot.readFieldEnd()
8835 
    iprot.readStructEnd()
8836 
 
8837 
  def write(self, oprot):
8838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8840 
      return
3064 chandransh 8841 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 8842 
    if self.providerId is not None:
3064 chandransh 8843 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8844 
      oprot.writeI64(self.providerId)
304 ashish 8845 
      oprot.writeFieldEnd()
3431 rajveer 8846 
    if self.pickupDetails is not None:
3064 chandransh 8847 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
8848 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 8849 
      for kiter147,viter148 in self.pickupDetails.items():
8850 
        oprot.writeString(kiter147)
8851 
        oprot.writeString(viter148)
3064 chandransh 8852 
      oprot.writeMapEnd()
304 ashish 8853 
      oprot.writeFieldEnd()
8854 
    oprot.writeFieldStop()
8855 
    oprot.writeStructEnd()
8856 
 
3431 rajveer 8857 
  def validate(self):
8858 
    return
8859 
 
8860 
 
304 ashish 8861 
  def __repr__(self):
8862 
    L = ['%s=%r' % (key, value)
8863 
      for key, value in self.__dict__.iteritems()]
8864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8865 
 
8866 
  def __eq__(self, other):
8867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8868 
 
8869 
  def __ne__(self, other):
8870 
    return not (self == other)
8871 
 
3064 chandransh 8872 
class markOrdersAsPickedUp_result:
304 ashish 8873 
  """
8874 
  Attributes:
8875 
   - success
3064 chandransh 8876 
   - ex
304 ashish 8877 
  """
8878 
 
8879 
  thrift_spec = (
3064 chandransh 8880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 8882 
  )
8883 
 
3064 chandransh 8884 
  def __init__(self, success=None, ex=None,):
304 ashish 8885 
    self.success = success
3064 chandransh 8886 
    self.ex = ex
304 ashish 8887 
 
8888 
  def read(self, iprot):
8889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8891 
      return
8892 
    iprot.readStructBegin()
8893 
    while True:
8894 
      (fname, ftype, fid) = iprot.readFieldBegin()
8895 
      if ftype == TType.STOP:
8896 
        break
8897 
      if fid == 0:
8898 
        if ftype == TType.LIST:
8899 
          self.success = []
4133 chandransh 8900 
          (_etype152, _size149) = iprot.readListBegin()
8901 
          for _i153 in xrange(_size149):
8902 
            _elem154 = Order()
8903 
            _elem154.read(iprot)
8904 
            self.success.append(_elem154)
304 ashish 8905 
          iprot.readListEnd()
8906 
        else:
8907 
          iprot.skip(ftype)
3064 chandransh 8908 
      elif fid == 1:
8909 
        if ftype == TType.STRUCT:
8910 
          self.ex = TransactionServiceException()
8911 
          self.ex.read(iprot)
8912 
        else:
8913 
          iprot.skip(ftype)
304 ashish 8914 
      else:
8915 
        iprot.skip(ftype)
8916 
      iprot.readFieldEnd()
8917 
    iprot.readStructEnd()
8918 
 
8919 
  def write(self, oprot):
8920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8922 
      return
3064 chandransh 8923 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 8924 
    if self.success is not None:
304 ashish 8925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8927 
      for iter155 in self.success:
8928 
        iter155.write(oprot)
304 ashish 8929 
      oprot.writeListEnd()
8930 
      oprot.writeFieldEnd()
3431 rajveer 8931 
    if self.ex is not None:
3064 chandransh 8932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8933 
      self.ex.write(oprot)
8934 
      oprot.writeFieldEnd()
304 ashish 8935 
    oprot.writeFieldStop()
8936 
    oprot.writeStructEnd()
8937 
 
3431 rajveer 8938 
  def validate(self):
8939 
    return
8940 
 
8941 
 
304 ashish 8942 
  def __repr__(self):
8943 
    L = ['%s=%r' % (key, value)
8944 
      for key, value in self.__dict__.iteritems()]
8945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8946 
 
8947 
  def __eq__(self, other):
8948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8949 
 
8950 
  def __ne__(self, other):
8951 
    return not (self == other)
8952 
 
3064 chandransh 8953 
class markOrdersAsDelivered_args:
304 ashish 8954 
  """
8955 
  Attributes:
3064 chandransh 8956 
   - providerId
8957 
   - deliveredOrders
304 ashish 8958 
  """
8959 
 
8960 
  thrift_spec = (
8961 
    None, # 0
3064 chandransh 8962 
    (1, TType.I64, 'providerId', None, None, ), # 1
8963 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8964 
  )
8965 
 
3064 chandransh 8966 
  def __init__(self, providerId=None, deliveredOrders=None,):
8967 
    self.providerId = providerId
8968 
    self.deliveredOrders = deliveredOrders
304 ashish 8969 
 
8970 
  def read(self, iprot):
8971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8973 
      return
8974 
    iprot.readStructBegin()
8975 
    while True:
8976 
      (fname, ftype, fid) = iprot.readFieldBegin()
8977 
      if ftype == TType.STOP:
8978 
        break
8979 
      if fid == 1:
8980 
        if ftype == TType.I64:
3064 chandransh 8981 
          self.providerId = iprot.readI64();
304 ashish 8982 
        else:
8983 
          iprot.skip(ftype)
8984 
      elif fid == 2:
3064 chandransh 8985 
        if ftype == TType.MAP:
8986 
          self.deliveredOrders = {}
4133 chandransh 8987 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
8988 
          for _i160 in xrange(_size156):
8989 
            _key161 = iprot.readString();
8990 
            _val162 = iprot.readString();
8991 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 8992 
          iprot.readMapEnd()
304 ashish 8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      else:
8996 
        iprot.skip(ftype)
8997 
      iprot.readFieldEnd()
8998 
    iprot.readStructEnd()
8999 
 
9000 
  def write(self, oprot):
9001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9003 
      return
3064 chandransh 9004 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9005 
    if self.providerId is not None:
3064 chandransh 9006 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9007 
      oprot.writeI64(self.providerId)
304 ashish 9008 
      oprot.writeFieldEnd()
3431 rajveer 9009 
    if self.deliveredOrders is not None:
3064 chandransh 9010 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9011 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9012 
      for kiter163,viter164 in self.deliveredOrders.items():
9013 
        oprot.writeString(kiter163)
9014 
        oprot.writeString(viter164)
3064 chandransh 9015 
      oprot.writeMapEnd()
304 ashish 9016 
      oprot.writeFieldEnd()
9017 
    oprot.writeFieldStop()
9018 
    oprot.writeStructEnd()
9019 
 
3431 rajveer 9020 
  def validate(self):
9021 
    return
9022 
 
9023 
 
304 ashish 9024 
  def __repr__(self):
9025 
    L = ['%s=%r' % (key, value)
9026 
      for key, value in self.__dict__.iteritems()]
9027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9028 
 
9029 
  def __eq__(self, other):
9030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9031 
 
9032 
  def __ne__(self, other):
9033 
    return not (self == other)
9034 
 
3064 chandransh 9035 
class markOrdersAsDelivered_result:
9036 
  """
9037 
  Attributes:
9038 
   - ex
9039 
  """
304 ashish 9040 
 
9041 
  thrift_spec = (
3064 chandransh 9042 
    None, # 0
9043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9044 
  )
9045 
 
3064 chandransh 9046 
  def __init__(self, ex=None,):
9047 
    self.ex = ex
304 ashish 9048 
 
1596 ankur.sing 9049 
  def read(self, iprot):
9050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9052 
      return
9053 
    iprot.readStructBegin()
9054 
    while True:
9055 
      (fname, ftype, fid) = iprot.readFieldBegin()
9056 
      if ftype == TType.STOP:
9057 
        break
3064 chandransh 9058 
      if fid == 1:
9059 
        if ftype == TType.STRUCT:
9060 
          self.ex = TransactionServiceException()
9061 
          self.ex.read(iprot)
9062 
        else:
9063 
          iprot.skip(ftype)
1596 ankur.sing 9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
3064 chandransh 9073 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9074 
    if self.ex is not None:
3064 chandransh 9075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9076 
      self.ex.write(oprot)
9077 
      oprot.writeFieldEnd()
1596 ankur.sing 9078 
    oprot.writeFieldStop()
9079 
    oprot.writeStructEnd()
9080 
 
3431 rajveer 9081 
  def validate(self):
9082 
    return
9083 
 
9084 
 
1596 ankur.sing 9085 
  def __repr__(self):
9086 
    L = ['%s=%r' % (key, value)
9087 
      for key, value in self.__dict__.iteritems()]
9088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9089 
 
9090 
  def __eq__(self, other):
9091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9092 
 
9093 
  def __ne__(self, other):
9094 
    return not (self == other)
9095 
 
3064 chandransh 9096 
class markOrdersAsFailed_args:
1596 ankur.sing 9097 
  """
9098 
  Attributes:
3064 chandransh 9099 
   - providerId
9100 
   - returnedOrders
1596 ankur.sing 9101 
  """
9102 
 
9103 
  thrift_spec = (
3064 chandransh 9104 
    None, # 0
9105 
    (1, TType.I64, 'providerId', None, None, ), # 1
9106 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9107 
  )
9108 
 
3064 chandransh 9109 
  def __init__(self, providerId=None, returnedOrders=None,):
9110 
    self.providerId = providerId
9111 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9112 
 
9113 
  def read(self, iprot):
9114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9116 
      return
9117 
    iprot.readStructBegin()
9118 
    while True:
9119 
      (fname, ftype, fid) = iprot.readFieldBegin()
9120 
      if ftype == TType.STOP:
9121 
        break
3064 chandransh 9122 
      if fid == 1:
1596 ankur.sing 9123 
        if ftype == TType.I64:
3064 chandransh 9124 
          self.providerId = iprot.readI64();
1596 ankur.sing 9125 
        else:
9126 
          iprot.skip(ftype)
3064 chandransh 9127 
      elif fid == 2:
9128 
        if ftype == TType.MAP:
9129 
          self.returnedOrders = {}
4133 chandransh 9130 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9131 
          for _i169 in xrange(_size165):
9132 
            _key170 = iprot.readString();
9133 
            _val171 = iprot.readString();
9134 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9135 
          iprot.readMapEnd()
9136 
        else:
9137 
          iprot.skip(ftype)
1596 ankur.sing 9138 
      else:
9139 
        iprot.skip(ftype)
9140 
      iprot.readFieldEnd()
9141 
    iprot.readStructEnd()
9142 
 
9143 
  def write(self, oprot):
9144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9146 
      return
3064 chandransh 9147 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9148 
    if self.providerId is not None:
3064 chandransh 9149 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9150 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9151 
      oprot.writeFieldEnd()
3431 rajveer 9152 
    if self.returnedOrders is not None:
3064 chandransh 9153 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9154 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9155 
      for kiter172,viter173 in self.returnedOrders.items():
9156 
        oprot.writeString(kiter172)
9157 
        oprot.writeString(viter173)
3064 chandransh 9158 
      oprot.writeMapEnd()
9159 
      oprot.writeFieldEnd()
1596 ankur.sing 9160 
    oprot.writeFieldStop()
9161 
    oprot.writeStructEnd()
9162 
 
3431 rajveer 9163 
  def validate(self):
9164 
    return
9165 
 
9166 
 
1596 ankur.sing 9167 
  def __repr__(self):
9168 
    L = ['%s=%r' % (key, value)
9169 
      for key, value in self.__dict__.iteritems()]
9170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9171 
 
9172 
  def __eq__(self, other):
9173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9174 
 
9175 
  def __ne__(self, other):
9176 
    return not (self == other)
9177 
 
3064 chandransh 9178 
class markOrdersAsFailed_result:
9179 
  """
9180 
  Attributes:
9181 
   - ex
9182 
  """
1596 ankur.sing 9183 
 
1627 ankur.sing 9184 
  thrift_spec = (
3064 chandransh 9185 
    None, # 0
9186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9187 
  )
9188 
 
3064 chandransh 9189 
  def __init__(self, ex=None,):
9190 
    self.ex = ex
9191 
 
1627 ankur.sing 9192 
  def read(self, iprot):
9193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9195 
      return
9196 
    iprot.readStructBegin()
9197 
    while True:
9198 
      (fname, ftype, fid) = iprot.readFieldBegin()
9199 
      if ftype == TType.STOP:
9200 
        break
3064 chandransh 9201 
      if fid == 1:
9202 
        if ftype == TType.STRUCT:
9203 
          self.ex = TransactionServiceException()
9204 
          self.ex.read(iprot)
9205 
        else:
9206 
          iprot.skip(ftype)
1627 ankur.sing 9207 
      else:
9208 
        iprot.skip(ftype)
9209 
      iprot.readFieldEnd()
9210 
    iprot.readStructEnd()
9211 
 
9212 
  def write(self, oprot):
9213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9215 
      return
3064 chandransh 9216 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9217 
    if self.ex is not None:
3064 chandransh 9218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9219 
      self.ex.write(oprot)
9220 
      oprot.writeFieldEnd()
1627 ankur.sing 9221 
    oprot.writeFieldStop()
9222 
    oprot.writeStructEnd()
9223 
 
3431 rajveer 9224 
  def validate(self):
9225 
    return
9226 
 
9227 
 
1627 ankur.sing 9228 
  def __repr__(self):
9229 
    L = ['%s=%r' % (key, value)
9230 
      for key, value in self.__dict__.iteritems()]
9231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9232 
 
9233 
  def __eq__(self, other):
9234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9235 
 
9236 
  def __ne__(self, other):
9237 
    return not (self == other)
9238 
 
3064 chandransh 9239 
class updateNonDeliveryReason_args:
1627 ankur.sing 9240 
  """
9241 
  Attributes:
3064 chandransh 9242 
   - providerId
9243 
   - undeliveredOrders
1627 ankur.sing 9244 
  """
9245 
 
9246 
  thrift_spec = (
3064 chandransh 9247 
    None, # 0
9248 
    (1, TType.I64, 'providerId', None, None, ), # 1
9249 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9250 
  )
9251 
 
3064 chandransh 9252 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9253 
    self.providerId = providerId
9254 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9255 
 
9256 
  def read(self, iprot):
9257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9259 
      return
9260 
    iprot.readStructBegin()
9261 
    while True:
9262 
      (fname, ftype, fid) = iprot.readFieldBegin()
9263 
      if ftype == TType.STOP:
9264 
        break
3064 chandransh 9265 
      if fid == 1:
1627 ankur.sing 9266 
        if ftype == TType.I64:
3064 chandransh 9267 
          self.providerId = iprot.readI64();
1627 ankur.sing 9268 
        else:
9269 
          iprot.skip(ftype)
3064 chandransh 9270 
      elif fid == 2:
9271 
        if ftype == TType.MAP:
9272 
          self.undeliveredOrders = {}
4133 chandransh 9273 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9274 
          for _i178 in xrange(_size174):
9275 
            _key179 = iprot.readString();
9276 
            _val180 = iprot.readString();
9277 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9278 
          iprot.readMapEnd()
9279 
        else:
9280 
          iprot.skip(ftype)
1627 ankur.sing 9281 
      else:
9282 
        iprot.skip(ftype)
9283 
      iprot.readFieldEnd()
9284 
    iprot.readStructEnd()
9285 
 
9286 
  def write(self, oprot):
9287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9289 
      return
3064 chandransh 9290 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9291 
    if self.providerId is not None:
3064 chandransh 9292 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9293 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9294 
      oprot.writeFieldEnd()
3431 rajveer 9295 
    if self.undeliveredOrders is not None:
3064 chandransh 9296 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9297 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9298 
      for kiter181,viter182 in self.undeliveredOrders.items():
9299 
        oprot.writeString(kiter181)
9300 
        oprot.writeString(viter182)
3064 chandransh 9301 
      oprot.writeMapEnd()
9302 
      oprot.writeFieldEnd()
1627 ankur.sing 9303 
    oprot.writeFieldStop()
9304 
    oprot.writeStructEnd()
9305 
 
3431 rajveer 9306 
  def validate(self):
9307 
    return
9308 
 
9309 
 
1627 ankur.sing 9310 
  def __repr__(self):
9311 
    L = ['%s=%r' % (key, value)
9312 
      for key, value in self.__dict__.iteritems()]
9313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9314 
 
9315 
  def __eq__(self, other):
9316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9317 
 
9318 
  def __ne__(self, other):
9319 
    return not (self == other)
9320 
 
3064 chandransh 9321 
class updateNonDeliveryReason_result:
1627 ankur.sing 9322 
  """
9323 
  Attributes:
3064 chandransh 9324 
   - ex
1627 ankur.sing 9325 
  """
9326 
 
9327 
  thrift_spec = (
3064 chandransh 9328 
    None, # 0
9329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9330 
  )
9331 
 
3064 chandransh 9332 
  def __init__(self, ex=None,):
9333 
    self.ex = ex
1627 ankur.sing 9334 
 
9335 
  def read(self, iprot):
9336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9338 
      return
9339 
    iprot.readStructBegin()
9340 
    while True:
9341 
      (fname, ftype, fid) = iprot.readFieldBegin()
9342 
      if ftype == TType.STOP:
9343 
        break
3064 chandransh 9344 
      if fid == 1:
9345 
        if ftype == TType.STRUCT:
9346 
          self.ex = TransactionServiceException()
9347 
          self.ex.read(iprot)
1627 ankur.sing 9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      else:
9351 
        iprot.skip(ftype)
9352 
      iprot.readFieldEnd()
9353 
    iprot.readStructEnd()
9354 
 
9355 
  def write(self, oprot):
9356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9358 
      return
3064 chandransh 9359 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9360 
    if self.ex is not None:
3064 chandransh 9361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9362 
      self.ex.write(oprot)
1627 ankur.sing 9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
3431 rajveer 9367 
  def validate(self):
9368 
    return
9369 
 
9370 
 
1627 ankur.sing 9371 
  def __repr__(self):
9372 
    L = ['%s=%r' % (key, value)
9373 
      for key, value in self.__dict__.iteritems()]
9374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9375 
 
9376 
  def __eq__(self, other):
9377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9378 
 
9379 
  def __ne__(self, other):
9380 
    return not (self == other)
9381 
 
3064 chandransh 9382 
class getUndeliveredOrders_args:
1886 ankur.sing 9383 
  """
9384 
  Attributes:
3064 chandransh 9385 
   - providerId
9386 
   - warehouseId
1886 ankur.sing 9387 
  """
1627 ankur.sing 9388 
 
1886 ankur.sing 9389 
  thrift_spec = (
9390 
    None, # 0
3064 chandransh 9391 
    (1, TType.I64, 'providerId', None, None, ), # 1
9392 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9393 
  )
9394 
 
3064 chandransh 9395 
  def __init__(self, providerId=None, warehouseId=None,):
9396 
    self.providerId = providerId
9397 
    self.warehouseId = warehouseId
1886 ankur.sing 9398 
 
9399 
  def read(self, iprot):
9400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9402 
      return
9403 
    iprot.readStructBegin()
9404 
    while True:
9405 
      (fname, ftype, fid) = iprot.readFieldBegin()
9406 
      if ftype == TType.STOP:
9407 
        break
9408 
      if fid == 1:
9409 
        if ftype == TType.I64:
3064 chandransh 9410 
          self.providerId = iprot.readI64();
1886 ankur.sing 9411 
        else:
9412 
          iprot.skip(ftype)
3064 chandransh 9413 
      elif fid == 2:
9414 
        if ftype == TType.I64:
9415 
          self.warehouseId = iprot.readI64();
9416 
        else:
9417 
          iprot.skip(ftype)
1886 ankur.sing 9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
3064 chandransh 9427 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9428 
    if self.providerId is not None:
3064 chandransh 9429 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9430 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9431 
      oprot.writeFieldEnd()
3431 rajveer 9432 
    if self.warehouseId is not None:
3064 chandransh 9433 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9434 
      oprot.writeI64(self.warehouseId)
9435 
      oprot.writeFieldEnd()
1886 ankur.sing 9436 
    oprot.writeFieldStop()
9437 
    oprot.writeStructEnd()
9438 
 
3431 rajveer 9439 
  def validate(self):
9440 
    return
9441 
 
9442 
 
1886 ankur.sing 9443 
  def __repr__(self):
9444 
    L = ['%s=%r' % (key, value)
9445 
      for key, value in self.__dict__.iteritems()]
9446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9447 
 
9448 
  def __eq__(self, other):
9449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9450 
 
9451 
  def __ne__(self, other):
9452 
    return not (self == other)
9453 
 
3064 chandransh 9454 
class getUndeliveredOrders_result:
1886 ankur.sing 9455 
  """
9456 
  Attributes:
9457 
   - success
9458 
  """
9459 
 
9460 
  thrift_spec = (
9461 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9462 
  )
9463 
 
9464 
  def __init__(self, success=None,):
9465 
    self.success = success
9466 
 
9467 
  def read(self, iprot):
9468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9470 
      return
9471 
    iprot.readStructBegin()
9472 
    while True:
9473 
      (fname, ftype, fid) = iprot.readFieldBegin()
9474 
      if ftype == TType.STOP:
9475 
        break
9476 
      if fid == 0:
9477 
        if ftype == TType.LIST:
9478 
          self.success = []
4133 chandransh 9479 
          (_etype186, _size183) = iprot.readListBegin()
9480 
          for _i187 in xrange(_size183):
9481 
            _elem188 = Order()
9482 
            _elem188.read(iprot)
9483 
            self.success.append(_elem188)
1886 ankur.sing 9484 
          iprot.readListEnd()
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      else:
9488 
        iprot.skip(ftype)
9489 
      iprot.readFieldEnd()
9490 
    iprot.readStructEnd()
9491 
 
9492 
  def write(self, oprot):
9493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9495 
      return
3064 chandransh 9496 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9497 
    if self.success is not None:
1886 ankur.sing 9498 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9499 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9500 
      for iter189 in self.success:
9501 
        iter189.write(oprot)
1886 ankur.sing 9502 
      oprot.writeListEnd()
9503 
      oprot.writeFieldEnd()
9504 
    oprot.writeFieldStop()
9505 
    oprot.writeStructEnd()
9506 
 
3431 rajveer 9507 
  def validate(self):
9508 
    return
9509 
 
9510 
 
1886 ankur.sing 9511 
  def __repr__(self):
9512 
    L = ['%s=%r' % (key, value)
9513 
      for key, value in self.__dict__.iteritems()]
9514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9515 
 
9516 
  def __eq__(self, other):
9517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9518 
 
9519 
  def __ne__(self, other):
9520 
    return not (self == other)
9521 
 
2536 chandransh 9522 
class toggleDOAFlag_args:
9523 
  """
9524 
  Attributes:
9525 
   - orderId
9526 
  """
1886 ankur.sing 9527 
 
2536 chandransh 9528 
  thrift_spec = (
9529 
    None, # 0
9530 
    (1, TType.I64, 'orderId', None, None, ), # 1
9531 
  )
9532 
 
9533 
  def __init__(self, orderId=None,):
9534 
    self.orderId = orderId
9535 
 
9536 
  def read(self, iprot):
9537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9539 
      return
9540 
    iprot.readStructBegin()
9541 
    while True:
9542 
      (fname, ftype, fid) = iprot.readFieldBegin()
9543 
      if ftype == TType.STOP:
9544 
        break
9545 
      if fid == 1:
9546 
        if ftype == TType.I64:
9547 
          self.orderId = iprot.readI64();
9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      else:
9551 
        iprot.skip(ftype)
9552 
      iprot.readFieldEnd()
9553 
    iprot.readStructEnd()
9554 
 
9555 
  def write(self, oprot):
9556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9558 
      return
9559 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9560 
    if self.orderId is not None:
2536 chandransh 9561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9562 
      oprot.writeI64(self.orderId)
9563 
      oprot.writeFieldEnd()
9564 
    oprot.writeFieldStop()
9565 
    oprot.writeStructEnd()
9566 
 
3431 rajveer 9567 
  def validate(self):
9568 
    return
9569 
 
9570 
 
2536 chandransh 9571 
  def __repr__(self):
9572 
    L = ['%s=%r' % (key, value)
9573 
      for key, value in self.__dict__.iteritems()]
9574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9575 
 
9576 
  def __eq__(self, other):
9577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9578 
 
9579 
  def __ne__(self, other):
9580 
    return not (self == other)
9581 
 
9582 
class toggleDOAFlag_result:
9583 
  """
9584 
  Attributes:
9585 
   - success
9586 
   - ex
9587 
  """
9588 
 
9589 
  thrift_spec = (
9590 
    (0, TType.BOOL, 'success', None, None, ), # 0
9591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9592 
  )
9593 
 
9594 
  def __init__(self, success=None, ex=None,):
9595 
    self.success = success
9596 
    self.ex = ex
9597 
 
9598 
  def read(self, iprot):
9599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9601 
      return
9602 
    iprot.readStructBegin()
9603 
    while True:
9604 
      (fname, ftype, fid) = iprot.readFieldBegin()
9605 
      if ftype == TType.STOP:
9606 
        break
9607 
      if fid == 0:
9608 
        if ftype == TType.BOOL:
9609 
          self.success = iprot.readBool();
9610 
        else:
9611 
          iprot.skip(ftype)
9612 
      elif fid == 1:
9613 
        if ftype == TType.STRUCT:
9614 
          self.ex = TransactionServiceException()
9615 
          self.ex.read(iprot)
9616 
        else:
9617 
          iprot.skip(ftype)
9618 
      else:
9619 
        iprot.skip(ftype)
9620 
      iprot.readFieldEnd()
9621 
    iprot.readStructEnd()
9622 
 
9623 
  def write(self, oprot):
9624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9626 
      return
9627 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9628 
    if self.success is not None:
2536 chandransh 9629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9630 
      oprot.writeBool(self.success)
9631 
      oprot.writeFieldEnd()
3431 rajveer 9632 
    if self.ex is not None:
2536 chandransh 9633 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9634 
      self.ex.write(oprot)
9635 
      oprot.writeFieldEnd()
9636 
    oprot.writeFieldStop()
9637 
    oprot.writeStructEnd()
9638 
 
3431 rajveer 9639 
  def validate(self):
9640 
    return
9641 
 
9642 
 
2536 chandransh 9643 
  def __repr__(self):
9644 
    L = ['%s=%r' % (key, value)
9645 
      for key, value in self.__dict__.iteritems()]
9646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9647 
 
9648 
  def __eq__(self, other):
9649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9650 
 
9651 
  def __ne__(self, other):
9652 
    return not (self == other)
9653 
 
9654 
class requestPickupNumber_args:
9655 
  """
9656 
  Attributes:
9657 
   - orderId
9658 
  """
9659 
 
9660 
  thrift_spec = (
9661 
    None, # 0
9662 
    (1, TType.I64, 'orderId', None, None, ), # 1
9663 
  )
9664 
 
9665 
  def __init__(self, orderId=None,):
9666 
    self.orderId = orderId
9667 
 
9668 
  def read(self, iprot):
9669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9671 
      return
9672 
    iprot.readStructBegin()
9673 
    while True:
9674 
      (fname, ftype, fid) = iprot.readFieldBegin()
9675 
      if ftype == TType.STOP:
9676 
        break
9677 
      if fid == 1:
9678 
        if ftype == TType.I64:
9679 
          self.orderId = iprot.readI64();
9680 
        else:
9681 
          iprot.skip(ftype)
9682 
      else:
9683 
        iprot.skip(ftype)
9684 
      iprot.readFieldEnd()
9685 
    iprot.readStructEnd()
9686 
 
9687 
  def write(self, oprot):
9688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9690 
      return
9691 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 9692 
    if self.orderId is not None:
2536 chandransh 9693 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9694 
      oprot.writeI64(self.orderId)
9695 
      oprot.writeFieldEnd()
9696 
    oprot.writeFieldStop()
9697 
    oprot.writeStructEnd()
9698 
 
3431 rajveer 9699 
  def validate(self):
9700 
    return
9701 
 
9702 
 
2536 chandransh 9703 
  def __repr__(self):
9704 
    L = ['%s=%r' % (key, value)
9705 
      for key, value in self.__dict__.iteritems()]
9706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9707 
 
9708 
  def __eq__(self, other):
9709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9710 
 
9711 
  def __ne__(self, other):
9712 
    return not (self == other)
9713 
 
9714 
class requestPickupNumber_result:
9715 
  """
9716 
  Attributes:
9717 
   - success
9718 
   - ex
9719 
  """
9720 
 
9721 
  thrift_spec = (
9722 
    (0, TType.BOOL, 'success', None, None, ), # 0
9723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9724 
  )
9725 
 
9726 
  def __init__(self, success=None, ex=None,):
9727 
    self.success = success
9728 
    self.ex = ex
9729 
 
9730 
  def read(self, iprot):
9731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9733 
      return
9734 
    iprot.readStructBegin()
9735 
    while True:
9736 
      (fname, ftype, fid) = iprot.readFieldBegin()
9737 
      if ftype == TType.STOP:
9738 
        break
9739 
      if fid == 0:
9740 
        if ftype == TType.BOOL:
9741 
          self.success = iprot.readBool();
9742 
        else:
9743 
          iprot.skip(ftype)
9744 
      elif fid == 1:
9745 
        if ftype == TType.STRUCT:
9746 
          self.ex = TransactionServiceException()
9747 
          self.ex.read(iprot)
9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      else:
9751 
        iprot.skip(ftype)
9752 
      iprot.readFieldEnd()
9753 
    iprot.readStructEnd()
9754 
 
9755 
  def write(self, oprot):
9756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9758 
      return
9759 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 9760 
    if self.success is not None:
2536 chandransh 9761 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9762 
      oprot.writeBool(self.success)
9763 
      oprot.writeFieldEnd()
3431 rajveer 9764 
    if self.ex is not None:
2536 chandransh 9765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9766 
      self.ex.write(oprot)
9767 
      oprot.writeFieldEnd()
9768 
    oprot.writeFieldStop()
9769 
    oprot.writeStructEnd()
9770 
 
3431 rajveer 9771 
  def validate(self):
9772 
    return
9773 
 
9774 
 
2536 chandransh 9775 
  def __repr__(self):
9776 
    L = ['%s=%r' % (key, value)
9777 
      for key, value in self.__dict__.iteritems()]
9778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9779 
 
9780 
  def __eq__(self, other):
9781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9782 
 
9783 
  def __ne__(self, other):
9784 
    return not (self == other)
9785 
 
9786 
class authorizePickup_args:
9787 
  """
9788 
  Attributes:
9789 
   - orderId
9790 
   - pickupNumber
9791 
  """
9792 
 
9793 
  thrift_spec = (
9794 
    None, # 0
9795 
    (1, TType.I64, 'orderId', None, None, ), # 1
9796 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
9797 
  )
9798 
 
9799 
  def __init__(self, orderId=None, pickupNumber=None,):
9800 
    self.orderId = orderId
9801 
    self.pickupNumber = pickupNumber
9802 
 
9803 
  def read(self, iprot):
9804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9806 
      return
9807 
    iprot.readStructBegin()
9808 
    while True:
9809 
      (fname, ftype, fid) = iprot.readFieldBegin()
9810 
      if ftype == TType.STOP:
9811 
        break
9812 
      if fid == 1:
9813 
        if ftype == TType.I64:
9814 
          self.orderId = iprot.readI64();
9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      elif fid == 2:
9818 
        if ftype == TType.STRING:
9819 
          self.pickupNumber = iprot.readString();
9820 
        else:
9821 
          iprot.skip(ftype)
9822 
      else:
9823 
        iprot.skip(ftype)
9824 
      iprot.readFieldEnd()
9825 
    iprot.readStructEnd()
9826 
 
9827 
  def write(self, oprot):
9828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9830 
      return
9831 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 9832 
    if self.orderId is not None:
2536 chandransh 9833 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9834 
      oprot.writeI64(self.orderId)
9835 
      oprot.writeFieldEnd()
3431 rajveer 9836 
    if self.pickupNumber is not None:
2536 chandransh 9837 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
9838 
      oprot.writeString(self.pickupNumber)
9839 
      oprot.writeFieldEnd()
9840 
    oprot.writeFieldStop()
9841 
    oprot.writeStructEnd()
9842 
 
3431 rajveer 9843 
  def validate(self):
9844 
    return
9845 
 
9846 
 
2536 chandransh 9847 
  def __repr__(self):
9848 
    L = ['%s=%r' % (key, value)
9849 
      for key, value in self.__dict__.iteritems()]
9850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9851 
 
9852 
  def __eq__(self, other):
9853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9854 
 
9855 
  def __ne__(self, other):
9856 
    return not (self == other)
9857 
 
9858 
class authorizePickup_result:
9859 
  """
9860 
  Attributes:
9861 
   - success
9862 
   - ex
9863 
  """
9864 
 
9865 
  thrift_spec = (
9866 
    (0, TType.BOOL, 'success', None, None, ), # 0
9867 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9868 
  )
9869 
 
9870 
  def __init__(self, success=None, ex=None,):
9871 
    self.success = success
9872 
    self.ex = ex
9873 
 
9874 
  def read(self, iprot):
9875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9877 
      return
9878 
    iprot.readStructBegin()
9879 
    while True:
9880 
      (fname, ftype, fid) = iprot.readFieldBegin()
9881 
      if ftype == TType.STOP:
9882 
        break
9883 
      if fid == 0:
9884 
        if ftype == TType.BOOL:
9885 
          self.success = iprot.readBool();
9886 
        else:
9887 
          iprot.skip(ftype)
9888 
      elif fid == 1:
9889 
        if ftype == TType.STRUCT:
9890 
          self.ex = TransactionServiceException()
9891 
          self.ex.read(iprot)
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      else:
9895 
        iprot.skip(ftype)
9896 
      iprot.readFieldEnd()
9897 
    iprot.readStructEnd()
9898 
 
9899 
  def write(self, oprot):
9900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9902 
      return
9903 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 9904 
    if self.success is not None:
2536 chandransh 9905 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9906 
      oprot.writeBool(self.success)
9907 
      oprot.writeFieldEnd()
3431 rajveer 9908 
    if self.ex is not None:
2536 chandransh 9909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9910 
      self.ex.write(oprot)
9911 
      oprot.writeFieldEnd()
9912 
    oprot.writeFieldStop()
9913 
    oprot.writeStructEnd()
9914 
 
3431 rajveer 9915 
  def validate(self):
9916 
    return
9917 
 
9918 
 
2536 chandransh 9919 
  def __repr__(self):
9920 
    L = ['%s=%r' % (key, value)
9921 
      for key, value in self.__dict__.iteritems()]
9922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9923 
 
9924 
  def __eq__(self, other):
9925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9926 
 
9927 
  def __ne__(self, other):
9928 
    return not (self == other)
9929 
 
2764 chandransh 9930 
class markDoasAsPickedUp_args:
9931 
  """
9932 
  Attributes:
9933 
   - providerId
9934 
   - pickupDetails
9935 
  """
9936 
 
9937 
  thrift_spec = (
9938 
    None, # 0
9939 
    (1, TType.I64, 'providerId', None, None, ), # 1
9940 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
9941 
  )
9942 
 
9943 
  def __init__(self, providerId=None, pickupDetails=None,):
9944 
    self.providerId = providerId
9945 
    self.pickupDetails = pickupDetails
9946 
 
9947 
  def read(self, iprot):
9948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9950 
      return
9951 
    iprot.readStructBegin()
9952 
    while True:
9953 
      (fname, ftype, fid) = iprot.readFieldBegin()
9954 
      if ftype == TType.STOP:
9955 
        break
9956 
      if fid == 1:
9957 
        if ftype == TType.I64:
9958 
          self.providerId = iprot.readI64();
9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      elif fid == 2:
9962 
        if ftype == TType.MAP:
9963 
          self.pickupDetails = {}
4133 chandransh 9964 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
9965 
          for _i194 in xrange(_size190):
9966 
            _key195 = iprot.readString();
9967 
            _val196 = iprot.readString();
9968 
            self.pickupDetails[_key195] = _val196
2764 chandransh 9969 
          iprot.readMapEnd()
9970 
        else:
9971 
          iprot.skip(ftype)
9972 
      else:
9973 
        iprot.skip(ftype)
9974 
      iprot.readFieldEnd()
9975 
    iprot.readStructEnd()
9976 
 
9977 
  def write(self, oprot):
9978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9980 
      return
9981 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 9982 
    if self.providerId is not None:
2764 chandransh 9983 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9984 
      oprot.writeI64(self.providerId)
9985 
      oprot.writeFieldEnd()
3431 rajveer 9986 
    if self.pickupDetails is not None:
2764 chandransh 9987 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9988 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9989 
      for kiter197,viter198 in self.pickupDetails.items():
9990 
        oprot.writeString(kiter197)
9991 
        oprot.writeString(viter198)
2764 chandransh 9992 
      oprot.writeMapEnd()
9993 
      oprot.writeFieldEnd()
9994 
    oprot.writeFieldStop()
9995 
    oprot.writeStructEnd()
9996 
 
3431 rajveer 9997 
  def validate(self):
9998 
    return
9999 
 
10000 
 
2764 chandransh 10001 
  def __repr__(self):
10002 
    L = ['%s=%r' % (key, value)
10003 
      for key, value in self.__dict__.iteritems()]
10004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10005 
 
10006 
  def __eq__(self, other):
10007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10008 
 
10009 
  def __ne__(self, other):
10010 
    return not (self == other)
10011 
 
10012 
class markDoasAsPickedUp_result:
10013 
  """
10014 
  Attributes:
10015 
   - success
10016 
  """
10017 
 
10018 
  thrift_spec = (
10019 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10020 
  )
10021 
 
10022 
  def __init__(self, success=None,):
10023 
    self.success = success
10024 
 
10025 
  def read(self, iprot):
10026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10028 
      return
10029 
    iprot.readStructBegin()
10030 
    while True:
10031 
      (fname, ftype, fid) = iprot.readFieldBegin()
10032 
      if ftype == TType.STOP:
10033 
        break
10034 
      if fid == 0:
10035 
        if ftype == TType.LIST:
10036 
          self.success = []
4133 chandransh 10037 
          (_etype202, _size199) = iprot.readListBegin()
10038 
          for _i203 in xrange(_size199):
10039 
            _elem204 = Order()
10040 
            _elem204.read(iprot)
10041 
            self.success.append(_elem204)
2764 chandransh 10042 
          iprot.readListEnd()
10043 
        else:
10044 
          iprot.skip(ftype)
10045 
      else:
10046 
        iprot.skip(ftype)
10047 
      iprot.readFieldEnd()
10048 
    iprot.readStructEnd()
10049 
 
10050 
  def write(self, oprot):
10051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10053 
      return
10054 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10055 
    if self.success is not None:
2764 chandransh 10056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10057 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10058 
      for iter205 in self.success:
10059 
        iter205.write(oprot)
2764 chandransh 10060 
      oprot.writeListEnd()
10061 
      oprot.writeFieldEnd()
10062 
    oprot.writeFieldStop()
10063 
    oprot.writeStructEnd()
10064 
 
3431 rajveer 10065 
  def validate(self):
10066 
    return
10067 
 
10068 
 
2764 chandransh 10069 
  def __repr__(self):
10070 
    L = ['%s=%r' % (key, value)
10071 
      for key, value in self.__dict__.iteritems()]
10072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10073 
 
10074 
  def __eq__(self, other):
10075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10076 
 
10077 
  def __ne__(self, other):
10078 
    return not (self == other)
10079 
 
2616 chandransh 10080 
class receiveReturn_args:
2591 chandransh 10081 
  """
10082 
  Attributes:
10083 
   - orderId
10084 
  """
2536 chandransh 10085 
 
2591 chandransh 10086 
  thrift_spec = (
10087 
    None, # 0
10088 
    (1, TType.I64, 'orderId', None, None, ), # 1
10089 
  )
10090 
 
10091 
  def __init__(self, orderId=None,):
10092 
    self.orderId = orderId
10093 
 
10094 
  def read(self, iprot):
10095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10097 
      return
10098 
    iprot.readStructBegin()
10099 
    while True:
10100 
      (fname, ftype, fid) = iprot.readFieldBegin()
10101 
      if ftype == TType.STOP:
10102 
        break
10103 
      if fid == 1:
10104 
        if ftype == TType.I64:
10105 
          self.orderId = iprot.readI64();
10106 
        else:
10107 
          iprot.skip(ftype)
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
2616 chandransh 10117 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10118 
    if self.orderId is not None:
2591 chandransh 10119 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10120 
      oprot.writeI64(self.orderId)
10121 
      oprot.writeFieldEnd()
10122 
    oprot.writeFieldStop()
10123 
    oprot.writeStructEnd()
10124 
 
3431 rajveer 10125 
  def validate(self):
10126 
    return
10127 
 
10128 
 
2591 chandransh 10129 
  def __repr__(self):
10130 
    L = ['%s=%r' % (key, value)
10131 
      for key, value in self.__dict__.iteritems()]
10132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10133 
 
10134 
  def __eq__(self, other):
10135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10136 
 
10137 
  def __ne__(self, other):
10138 
    return not (self == other)
10139 
 
2616 chandransh 10140 
class receiveReturn_result:
2591 chandransh 10141 
  """
10142 
  Attributes:
10143 
   - success
10144 
   - ex
10145 
  """
10146 
 
10147 
  thrift_spec = (
10148 
    (0, TType.BOOL, 'success', None, None, ), # 0
10149 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10150 
  )
10151 
 
10152 
  def __init__(self, success=None, ex=None,):
10153 
    self.success = success
10154 
    self.ex = ex
10155 
 
10156 
  def read(self, iprot):
10157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10159 
      return
10160 
    iprot.readStructBegin()
10161 
    while True:
10162 
      (fname, ftype, fid) = iprot.readFieldBegin()
10163 
      if ftype == TType.STOP:
10164 
        break
10165 
      if fid == 0:
10166 
        if ftype == TType.BOOL:
10167 
          self.success = iprot.readBool();
10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      elif fid == 1:
10171 
        if ftype == TType.STRUCT:
10172 
          self.ex = TransactionServiceException()
10173 
          self.ex.read(iprot)
10174 
        else:
10175 
          iprot.skip(ftype)
10176 
      else:
10177 
        iprot.skip(ftype)
10178 
      iprot.readFieldEnd()
10179 
    iprot.readStructEnd()
10180 
 
10181 
  def write(self, oprot):
10182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10184 
      return
2616 chandransh 10185 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10186 
    if self.success is not None:
2591 chandransh 10187 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10188 
      oprot.writeBool(self.success)
10189 
      oprot.writeFieldEnd()
3431 rajveer 10190 
    if self.ex is not None:
2591 chandransh 10191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10192 
      self.ex.write(oprot)
10193 
      oprot.writeFieldEnd()
10194 
    oprot.writeFieldStop()
10195 
    oprot.writeStructEnd()
10196 
 
3431 rajveer 10197 
  def validate(self):
10198 
    return
10199 
 
10200 
 
2591 chandransh 10201 
  def __repr__(self):
10202 
    L = ['%s=%r' % (key, value)
10203 
      for key, value in self.__dict__.iteritems()]
10204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10205 
 
10206 
  def __eq__(self, other):
10207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10208 
 
10209 
  def __ne__(self, other):
10210 
    return not (self == other)
10211 
 
10212 
class validateDoa_args:
10213 
  """
10214 
  Attributes:
10215 
   - orderId
10216 
   - isValid
10217 
  """
10218 
 
10219 
  thrift_spec = (
10220 
    None, # 0
10221 
    (1, TType.I64, 'orderId', None, None, ), # 1
10222 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10223 
  )
10224 
 
10225 
  def __init__(self, orderId=None, isValid=None,):
10226 
    self.orderId = orderId
10227 
    self.isValid = isValid
10228 
 
10229 
  def read(self, iprot):
10230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10232 
      return
10233 
    iprot.readStructBegin()
10234 
    while True:
10235 
      (fname, ftype, fid) = iprot.readFieldBegin()
10236 
      if ftype == TType.STOP:
10237 
        break
10238 
      if fid == 1:
10239 
        if ftype == TType.I64:
10240 
          self.orderId = iprot.readI64();
10241 
        else:
10242 
          iprot.skip(ftype)
10243 
      elif fid == 2:
10244 
        if ftype == TType.BOOL:
10245 
          self.isValid = iprot.readBool();
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      else:
10249 
        iprot.skip(ftype)
10250 
      iprot.readFieldEnd()
10251 
    iprot.readStructEnd()
10252 
 
10253 
  def write(self, oprot):
10254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10256 
      return
10257 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10258 
    if self.orderId is not None:
2591 chandransh 10259 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10260 
      oprot.writeI64(self.orderId)
10261 
      oprot.writeFieldEnd()
3431 rajveer 10262 
    if self.isValid is not None:
2591 chandransh 10263 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10264 
      oprot.writeBool(self.isValid)
10265 
      oprot.writeFieldEnd()
10266 
    oprot.writeFieldStop()
10267 
    oprot.writeStructEnd()
10268 
 
3431 rajveer 10269 
  def validate(self):
10270 
    return
10271 
 
10272 
 
2591 chandransh 10273 
  def __repr__(self):
10274 
    L = ['%s=%r' % (key, value)
10275 
      for key, value in self.__dict__.iteritems()]
10276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10277 
 
10278 
  def __eq__(self, other):
10279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10280 
 
10281 
  def __ne__(self, other):
10282 
    return not (self == other)
10283 
 
10284 
class validateDoa_result:
10285 
  """
10286 
  Attributes:
10287 
   - success
10288 
   - ex
10289 
  """
10290 
 
10291 
  thrift_spec = (
10292 
    (0, TType.BOOL, 'success', None, None, ), # 0
10293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10294 
  )
10295 
 
10296 
  def __init__(self, success=None, ex=None,):
10297 
    self.success = success
10298 
    self.ex = ex
10299 
 
10300 
  def read(self, iprot):
10301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10303 
      return
10304 
    iprot.readStructBegin()
10305 
    while True:
10306 
      (fname, ftype, fid) = iprot.readFieldBegin()
10307 
      if ftype == TType.STOP:
10308 
        break
10309 
      if fid == 0:
10310 
        if ftype == TType.BOOL:
10311 
          self.success = iprot.readBool();
10312 
        else:
10313 
          iprot.skip(ftype)
10314 
      elif fid == 1:
10315 
        if ftype == TType.STRUCT:
10316 
          self.ex = TransactionServiceException()
10317 
          self.ex.read(iprot)
10318 
        else:
10319 
          iprot.skip(ftype)
10320 
      else:
10321 
        iprot.skip(ftype)
10322 
      iprot.readFieldEnd()
10323 
    iprot.readStructEnd()
10324 
 
10325 
  def write(self, oprot):
10326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10328 
      return
10329 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10330 
    if self.success is not None:
2591 chandransh 10331 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10332 
      oprot.writeBool(self.success)
10333 
      oprot.writeFieldEnd()
3431 rajveer 10334 
    if self.ex is not None:
2591 chandransh 10335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10336 
      self.ex.write(oprot)
10337 
      oprot.writeFieldEnd()
10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
3431 rajveer 10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
2591 chandransh 10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
2616 chandransh 10356 
class reshipOrder_args:
10357 
  """
10358 
  Attributes:
10359 
   - orderId
10360 
  """
2591 chandransh 10361 
 
2616 chandransh 10362 
  thrift_spec = (
10363 
    None, # 0
10364 
    (1, TType.I64, 'orderId', None, None, ), # 1
10365 
  )
10366 
 
10367 
  def __init__(self, orderId=None,):
10368 
    self.orderId = orderId
10369 
 
10370 
  def read(self, iprot):
10371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10373 
      return
10374 
    iprot.readStructBegin()
10375 
    while True:
10376 
      (fname, ftype, fid) = iprot.readFieldBegin()
10377 
      if ftype == TType.STOP:
10378 
        break
10379 
      if fid == 1:
10380 
        if ftype == TType.I64:
10381 
          self.orderId = iprot.readI64();
10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      else:
10385 
        iprot.skip(ftype)
10386 
      iprot.readFieldEnd()
10387 
    iprot.readStructEnd()
10388 
 
10389 
  def write(self, oprot):
10390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10392 
      return
10393 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10394 
    if self.orderId is not None:
2616 chandransh 10395 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10396 
      oprot.writeI64(self.orderId)
10397 
      oprot.writeFieldEnd()
10398 
    oprot.writeFieldStop()
10399 
    oprot.writeStructEnd()
10400 
 
3431 rajveer 10401 
  def validate(self):
10402 
    return
10403 
 
10404 
 
2616 chandransh 10405 
  def __repr__(self):
10406 
    L = ['%s=%r' % (key, value)
10407 
      for key, value in self.__dict__.iteritems()]
10408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10409 
 
10410 
  def __eq__(self, other):
10411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10412 
 
10413 
  def __ne__(self, other):
10414 
    return not (self == other)
10415 
 
10416 
class reshipOrder_result:
10417 
  """
10418 
  Attributes:
10419 
   - success
10420 
   - ex
10421 
  """
10422 
 
10423 
  thrift_spec = (
10424 
    (0, TType.I64, 'success', None, None, ), # 0
10425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10426 
  )
10427 
 
10428 
  def __init__(self, success=None, ex=None,):
10429 
    self.success = success
10430 
    self.ex = ex
10431 
 
10432 
  def read(self, iprot):
10433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10435 
      return
10436 
    iprot.readStructBegin()
10437 
    while True:
10438 
      (fname, ftype, fid) = iprot.readFieldBegin()
10439 
      if ftype == TType.STOP:
10440 
        break
10441 
      if fid == 0:
10442 
        if ftype == TType.I64:
10443 
          self.success = iprot.readI64();
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      elif fid == 1:
10447 
        if ftype == TType.STRUCT:
10448 
          self.ex = TransactionServiceException()
10449 
          self.ex.read(iprot)
10450 
        else:
10451 
          iprot.skip(ftype)
10452 
      else:
10453 
        iprot.skip(ftype)
10454 
      iprot.readFieldEnd()
10455 
    iprot.readStructEnd()
10456 
 
10457 
  def write(self, oprot):
10458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10460 
      return
10461 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10462 
    if self.success is not None:
2616 chandransh 10463 
      oprot.writeFieldBegin('success', TType.I64, 0)
10464 
      oprot.writeI64(self.success)
10465 
      oprot.writeFieldEnd()
3431 rajveer 10466 
    if self.ex is not None:
2616 chandransh 10467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10468 
      self.ex.write(oprot)
10469 
      oprot.writeFieldEnd()
10470 
    oprot.writeFieldStop()
10471 
    oprot.writeStructEnd()
10472 
 
3431 rajveer 10473 
  def validate(self):
10474 
    return
10475 
 
10476 
 
2616 chandransh 10477 
  def __repr__(self):
10478 
    L = ['%s=%r' % (key, value)
10479 
      for key, value in self.__dict__.iteritems()]
10480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10481 
 
10482 
  def __eq__(self, other):
10483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10484 
 
10485 
  def __ne__(self, other):
10486 
    return not (self == other)
10487 
 
10488 
class refundOrder_args:
10489 
  """
10490 
  Attributes:
10491 
   - orderId
3226 chandransh 10492 
   - refundedBy
10493 
   - reason
2616 chandransh 10494 
  """
10495 
 
10496 
  thrift_spec = (
10497 
    None, # 0
10498 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10499 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10500 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10501 
  )
10502 
 
3226 chandransh 10503 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10504 
    self.orderId = orderId
3226 chandransh 10505 
    self.refundedBy = refundedBy
10506 
    self.reason = reason
2616 chandransh 10507 
 
10508 
  def read(self, iprot):
10509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10511 
      return
10512 
    iprot.readStructBegin()
10513 
    while True:
10514 
      (fname, ftype, fid) = iprot.readFieldBegin()
10515 
      if ftype == TType.STOP:
10516 
        break
10517 
      if fid == 1:
10518 
        if ftype == TType.I64:
10519 
          self.orderId = iprot.readI64();
10520 
        else:
10521 
          iprot.skip(ftype)
3226 chandransh 10522 
      elif fid == 2:
10523 
        if ftype == TType.STRING:
10524 
          self.refundedBy = iprot.readString();
10525 
        else:
10526 
          iprot.skip(ftype)
10527 
      elif fid == 3:
10528 
        if ftype == TType.STRING:
10529 
          self.reason = iprot.readString();
10530 
        else:
10531 
          iprot.skip(ftype)
2616 chandransh 10532 
      else:
10533 
        iprot.skip(ftype)
10534 
      iprot.readFieldEnd()
10535 
    iprot.readStructEnd()
10536 
 
10537 
  def write(self, oprot):
10538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10540 
      return
10541 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10542 
    if self.orderId is not None:
2616 chandransh 10543 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10544 
      oprot.writeI64(self.orderId)
10545 
      oprot.writeFieldEnd()
3431 rajveer 10546 
    if self.refundedBy is not None:
3226 chandransh 10547 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10548 
      oprot.writeString(self.refundedBy)
10549 
      oprot.writeFieldEnd()
3431 rajveer 10550 
    if self.reason is not None:
3226 chandransh 10551 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10552 
      oprot.writeString(self.reason)
10553 
      oprot.writeFieldEnd()
2616 chandransh 10554 
    oprot.writeFieldStop()
10555 
    oprot.writeStructEnd()
10556 
 
3431 rajveer 10557 
  def validate(self):
10558 
    return
10559 
 
10560 
 
2616 chandransh 10561 
  def __repr__(self):
10562 
    L = ['%s=%r' % (key, value)
10563 
      for key, value in self.__dict__.iteritems()]
10564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10565 
 
10566 
  def __eq__(self, other):
10567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10568 
 
10569 
  def __ne__(self, other):
10570 
    return not (self == other)
10571 
 
10572 
class refundOrder_result:
10573 
  """
10574 
  Attributes:
10575 
   - success
10576 
   - ex
10577 
  """
10578 
 
10579 
  thrift_spec = (
10580 
    (0, TType.BOOL, 'success', None, None, ), # 0
10581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10582 
  )
10583 
 
10584 
  def __init__(self, success=None, ex=None,):
10585 
    self.success = success
10586 
    self.ex = ex
10587 
 
10588 
  def read(self, iprot):
10589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10591 
      return
10592 
    iprot.readStructBegin()
10593 
    while True:
10594 
      (fname, ftype, fid) = iprot.readFieldBegin()
10595 
      if ftype == TType.STOP:
10596 
        break
10597 
      if fid == 0:
10598 
        if ftype == TType.BOOL:
10599 
          self.success = iprot.readBool();
10600 
        else:
10601 
          iprot.skip(ftype)
10602 
      elif fid == 1:
10603 
        if ftype == TType.STRUCT:
10604 
          self.ex = TransactionServiceException()
10605 
          self.ex.read(iprot)
10606 
        else:
10607 
          iprot.skip(ftype)
10608 
      else:
10609 
        iprot.skip(ftype)
10610 
      iprot.readFieldEnd()
10611 
    iprot.readStructEnd()
10612 
 
10613 
  def write(self, oprot):
10614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10616 
      return
10617 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10618 
    if self.success is not None:
2616 chandransh 10619 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10620 
      oprot.writeBool(self.success)
10621 
      oprot.writeFieldEnd()
3431 rajveer 10622 
    if self.ex is not None:
2616 chandransh 10623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10624 
      self.ex.write(oprot)
10625 
      oprot.writeFieldEnd()
10626 
    oprot.writeFieldStop()
10627 
    oprot.writeStructEnd()
10628 
 
3431 rajveer 10629 
  def validate(self):
10630 
    return
10631 
 
10632 
 
2616 chandransh 10633 
  def __repr__(self):
10634 
    L = ['%s=%r' % (key, value)
10635 
      for key, value in self.__dict__.iteritems()]
10636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10637 
 
10638 
  def __eq__(self, other):
10639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10640 
 
10641 
  def __ne__(self, other):
10642 
    return not (self == other)
10643 
 
2690 chandransh 10644 
class getReturnOrders_args:
10645 
  """
10646 
  Attributes:
10647 
   - warehouseId
10648 
   - fromDate
10649 
   - toDate
10650 
  """
2616 chandransh 10651 
 
2690 chandransh 10652 
  thrift_spec = (
10653 
    None, # 0
10654 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10655 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10656 
    (3, TType.I64, 'toDate', None, None, ), # 3
10657 
  )
10658 
 
10659 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10660 
    self.warehouseId = warehouseId
10661 
    self.fromDate = fromDate
10662 
    self.toDate = toDate
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 1:
10674 
        if ftype == TType.I64:
10675 
          self.warehouseId = iprot.readI64();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      elif fid == 2:
10679 
        if ftype == TType.I64:
10680 
          self.fromDate = iprot.readI64();
10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      elif fid == 3:
10684 
        if ftype == TType.I64:
10685 
          self.toDate = iprot.readI64();
10686 
        else:
10687 
          iprot.skip(ftype)
10688 
      else:
10689 
        iprot.skip(ftype)
10690 
      iprot.readFieldEnd()
10691 
    iprot.readStructEnd()
10692 
 
10693 
  def write(self, oprot):
10694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10696 
      return
10697 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 10698 
    if self.warehouseId is not None:
2690 chandransh 10699 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10700 
      oprot.writeI64(self.warehouseId)
10701 
      oprot.writeFieldEnd()
3431 rajveer 10702 
    if self.fromDate is not None:
2690 chandransh 10703 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
10704 
      oprot.writeI64(self.fromDate)
10705 
      oprot.writeFieldEnd()
3431 rajveer 10706 
    if self.toDate is not None:
2690 chandransh 10707 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
10708 
      oprot.writeI64(self.toDate)
10709 
      oprot.writeFieldEnd()
10710 
    oprot.writeFieldStop()
10711 
    oprot.writeStructEnd()
10712 
 
3431 rajveer 10713 
  def validate(self):
10714 
    return
10715 
 
10716 
 
2690 chandransh 10717 
  def __repr__(self):
10718 
    L = ['%s=%r' % (key, value)
10719 
      for key, value in self.__dict__.iteritems()]
10720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10721 
 
10722 
  def __eq__(self, other):
10723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10724 
 
10725 
  def __ne__(self, other):
10726 
    return not (self == other)
10727 
 
10728 
class getReturnOrders_result:
10729 
  """
10730 
  Attributes:
10731 
   - success
10732 
  """
10733 
 
10734 
  thrift_spec = (
10735 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
10736 
  )
10737 
 
10738 
  def __init__(self, success=None,):
10739 
    self.success = success
10740 
 
10741 
  def read(self, iprot):
10742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10744 
      return
10745 
    iprot.readStructBegin()
10746 
    while True:
10747 
      (fname, ftype, fid) = iprot.readFieldBegin()
10748 
      if ftype == TType.STOP:
10749 
        break
10750 
      if fid == 0:
10751 
        if ftype == TType.LIST:
10752 
          self.success = []
4133 chandransh 10753 
          (_etype209, _size206) = iprot.readListBegin()
10754 
          for _i210 in xrange(_size206):
10755 
            _elem211 = ReturnOrder()
10756 
            _elem211.read(iprot)
10757 
            self.success.append(_elem211)
2690 chandransh 10758 
          iprot.readListEnd()
10759 
        else:
10760 
          iprot.skip(ftype)
10761 
      else:
10762 
        iprot.skip(ftype)
10763 
      iprot.readFieldEnd()
10764 
    iprot.readStructEnd()
10765 
 
10766 
  def write(self, oprot):
10767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10769 
      return
10770 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 10771 
    if self.success is not None:
2690 chandransh 10772 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10773 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10774 
      for iter212 in self.success:
10775 
        iter212.write(oprot)
2690 chandransh 10776 
      oprot.writeListEnd()
10777 
      oprot.writeFieldEnd()
10778 
    oprot.writeFieldStop()
10779 
    oprot.writeStructEnd()
10780 
 
3431 rajveer 10781 
  def validate(self):
10782 
    return
10783 
 
10784 
 
2690 chandransh 10785 
  def __repr__(self):
10786 
    L = ['%s=%r' % (key, value)
10787 
      for key, value in self.__dict__.iteritems()]
10788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10789 
 
10790 
  def __eq__(self, other):
10791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10792 
 
10793 
  def __ne__(self, other):
10794 
    return not (self == other)
10795 
 
2700 chandransh 10796 
class getReturnOrder_args:
10797 
  """
10798 
  Attributes:
10799 
   - id
10800 
  """
10801 
 
10802 
  thrift_spec = (
10803 
    None, # 0
10804 
    (1, TType.I64, 'id', None, None, ), # 1
10805 
  )
10806 
 
10807 
  def __init__(self, id=None,):
10808 
    self.id = id
10809 
 
10810 
  def read(self, iprot):
10811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10813 
      return
10814 
    iprot.readStructBegin()
10815 
    while True:
10816 
      (fname, ftype, fid) = iprot.readFieldBegin()
10817 
      if ftype == TType.STOP:
10818 
        break
10819 
      if fid == 1:
10820 
        if ftype == TType.I64:
10821 
          self.id = iprot.readI64();
10822 
        else:
10823 
          iprot.skip(ftype)
10824 
      else:
10825 
        iprot.skip(ftype)
10826 
      iprot.readFieldEnd()
10827 
    iprot.readStructEnd()
10828 
 
10829 
  def write(self, oprot):
10830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10832 
      return
10833 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 10834 
    if self.id is not None:
2700 chandransh 10835 
      oprot.writeFieldBegin('id', TType.I64, 1)
10836 
      oprot.writeI64(self.id)
10837 
      oprot.writeFieldEnd()
10838 
    oprot.writeFieldStop()
10839 
    oprot.writeStructEnd()
10840 
 
3431 rajveer 10841 
  def validate(self):
10842 
    return
10843 
 
10844 
 
2700 chandransh 10845 
  def __repr__(self):
10846 
    L = ['%s=%r' % (key, value)
10847 
      for key, value in self.__dict__.iteritems()]
10848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10849 
 
10850 
  def __eq__(self, other):
10851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10852 
 
10853 
  def __ne__(self, other):
10854 
    return not (self == other)
10855 
 
10856 
class getReturnOrder_result:
10857 
  """
10858 
  Attributes:
10859 
   - success
10860 
   - ex
10861 
  """
10862 
 
10863 
  thrift_spec = (
10864 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
10865 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10866 
  )
10867 
 
10868 
  def __init__(self, success=None, ex=None,):
10869 
    self.success = success
10870 
    self.ex = ex
10871 
 
10872 
  def read(self, iprot):
10873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10875 
      return
10876 
    iprot.readStructBegin()
10877 
    while True:
10878 
      (fname, ftype, fid) = iprot.readFieldBegin()
10879 
      if ftype == TType.STOP:
10880 
        break
10881 
      if fid == 0:
10882 
        if ftype == TType.STRUCT:
10883 
          self.success = ReturnOrder()
10884 
          self.success.read(iprot)
10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      elif fid == 1:
10888 
        if ftype == TType.STRUCT:
10889 
          self.ex = TransactionServiceException()
10890 
          self.ex.read(iprot)
10891 
        else:
10892 
          iprot.skip(ftype)
10893 
      else:
10894 
        iprot.skip(ftype)
10895 
      iprot.readFieldEnd()
10896 
    iprot.readStructEnd()
10897 
 
10898 
  def write(self, oprot):
10899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10901 
      return
10902 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 10903 
    if self.success is not None:
2700 chandransh 10904 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10905 
      self.success.write(oprot)
10906 
      oprot.writeFieldEnd()
3431 rajveer 10907 
    if self.ex is not None:
2700 chandransh 10908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10909 
      self.ex.write(oprot)
10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
3431 rajveer 10914 
  def validate(self):
10915 
    return
10916 
 
10917 
 
2700 chandransh 10918 
  def __repr__(self):
10919 
    L = ['%s=%r' % (key, value)
10920 
      for key, value in self.__dict__.iteritems()]
10921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10922 
 
10923 
  def __eq__(self, other):
10924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10925 
 
10926 
  def __ne__(self, other):
10927 
    return not (self == other)
10928 
 
2690 chandransh 10929 
class processReturn_args:
10930 
  """
10931 
  Attributes:
10932 
   - returnOrderId
10933 
  """
10934 
 
10935 
  thrift_spec = (
10936 
    None, # 0
10937 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
10938 
  )
10939 
 
10940 
  def __init__(self, returnOrderId=None,):
10941 
    self.returnOrderId = returnOrderId
10942 
 
10943 
  def read(self, iprot):
10944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10946 
      return
10947 
    iprot.readStructBegin()
10948 
    while True:
10949 
      (fname, ftype, fid) = iprot.readFieldBegin()
10950 
      if ftype == TType.STOP:
10951 
        break
10952 
      if fid == 1:
10953 
        if ftype == TType.I64:
10954 
          self.returnOrderId = iprot.readI64();
10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      else:
10958 
        iprot.skip(ftype)
10959 
      iprot.readFieldEnd()
10960 
    iprot.readStructEnd()
10961 
 
10962 
  def write(self, oprot):
10963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10965 
      return
10966 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 10967 
    if self.returnOrderId is not None:
2690 chandransh 10968 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
10969 
      oprot.writeI64(self.returnOrderId)
10970 
      oprot.writeFieldEnd()
10971 
    oprot.writeFieldStop()
10972 
    oprot.writeStructEnd()
10973 
 
3431 rajveer 10974 
  def validate(self):
10975 
    return
10976 
 
10977 
 
2690 chandransh 10978 
  def __repr__(self):
10979 
    L = ['%s=%r' % (key, value)
10980 
      for key, value in self.__dict__.iteritems()]
10981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10982 
 
10983 
  def __eq__(self, other):
10984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10985 
 
10986 
  def __ne__(self, other):
10987 
    return not (self == other)
10988 
 
10989 
class processReturn_result:
10990 
  """
10991 
  Attributes:
10992 
   - ex
10993 
  """
10994 
 
10995 
  thrift_spec = (
10996 
    None, # 0
10997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10998 
  )
10999 
 
11000 
  def __init__(self, ex=None,):
11001 
    self.ex = ex
11002 
 
11003 
  def read(self, iprot):
11004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11006 
      return
11007 
    iprot.readStructBegin()
11008 
    while True:
11009 
      (fname, ftype, fid) = iprot.readFieldBegin()
11010 
      if ftype == TType.STOP:
11011 
        break
11012 
      if fid == 1:
11013 
        if ftype == TType.STRUCT:
11014 
          self.ex = TransactionServiceException()
11015 
          self.ex.read(iprot)
11016 
        else:
11017 
          iprot.skip(ftype)
11018 
      else:
11019 
        iprot.skip(ftype)
11020 
      iprot.readFieldEnd()
11021 
    iprot.readStructEnd()
11022 
 
11023 
  def write(self, oprot):
11024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11026 
      return
11027 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11028 
    if self.ex is not None:
2690 chandransh 11029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11030 
      self.ex.write(oprot)
11031 
      oprot.writeFieldEnd()
11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
3431 rajveer 11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
2690 chandransh 11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
2819 chandransh 11050 
class createPurchaseOrder_args:
11051 
  """
11052 
  Attributes:
11053 
   - warehouseId
11054 
  """
2690 chandransh 11055 
 
2819 chandransh 11056 
  thrift_spec = (
11057 
    None, # 0
11058 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11059 
  )
11060 
 
11061 
  def __init__(self, warehouseId=None,):
11062 
    self.warehouseId = warehouseId
11063 
 
11064 
  def read(self, iprot):
11065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11067 
      return
11068 
    iprot.readStructBegin()
11069 
    while True:
11070 
      (fname, ftype, fid) = iprot.readFieldBegin()
11071 
      if ftype == TType.STOP:
11072 
        break
11073 
      if fid == 1:
11074 
        if ftype == TType.I64:
11075 
          self.warehouseId = iprot.readI64();
11076 
        else:
11077 
          iprot.skip(ftype)
11078 
      else:
11079 
        iprot.skip(ftype)
11080 
      iprot.readFieldEnd()
11081 
    iprot.readStructEnd()
11082 
 
11083 
  def write(self, oprot):
11084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11086 
      return
11087 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11088 
    if self.warehouseId is not None:
2819 chandransh 11089 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11090 
      oprot.writeI64(self.warehouseId)
11091 
      oprot.writeFieldEnd()
11092 
    oprot.writeFieldStop()
11093 
    oprot.writeStructEnd()
11094 
 
3431 rajveer 11095 
  def validate(self):
11096 
    return
11097 
 
11098 
 
2819 chandransh 11099 
  def __repr__(self):
11100 
    L = ['%s=%r' % (key, value)
11101 
      for key, value in self.__dict__.iteritems()]
11102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11103 
 
11104 
  def __eq__(self, other):
11105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11106 
 
11107 
  def __ne__(self, other):
11108 
    return not (self == other)
11109 
 
11110 
class createPurchaseOrder_result:
11111 
  """
11112 
  Attributes:
11113 
   - success
11114 
   - ex
11115 
  """
11116 
 
11117 
  thrift_spec = (
11118 
    (0, TType.I64, 'success', None, None, ), # 0
11119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11120 
  )
11121 
 
11122 
  def __init__(self, success=None, ex=None,):
11123 
    self.success = success
11124 
    self.ex = ex
11125 
 
11126 
  def read(self, iprot):
11127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11129 
      return
11130 
    iprot.readStructBegin()
11131 
    while True:
11132 
      (fname, ftype, fid) = iprot.readFieldBegin()
11133 
      if ftype == TType.STOP:
11134 
        break
11135 
      if fid == 0:
11136 
        if ftype == TType.I64:
11137 
          self.success = iprot.readI64();
11138 
        else:
11139 
          iprot.skip(ftype)
11140 
      elif fid == 1:
11141 
        if ftype == TType.STRUCT:
11142 
          self.ex = TransactionServiceException()
11143 
          self.ex.read(iprot)
11144 
        else:
11145 
          iprot.skip(ftype)
11146 
      else:
11147 
        iprot.skip(ftype)
11148 
      iprot.readFieldEnd()
11149 
    iprot.readStructEnd()
11150 
 
11151 
  def write(self, oprot):
11152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11154 
      return
11155 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11156 
    if self.success is not None:
2819 chandransh 11157 
      oprot.writeFieldBegin('success', TType.I64, 0)
11158 
      oprot.writeI64(self.success)
11159 
      oprot.writeFieldEnd()
3431 rajveer 11160 
    if self.ex is not None:
2819 chandransh 11161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11162 
      self.ex.write(oprot)
11163 
      oprot.writeFieldEnd()
11164 
    oprot.writeFieldStop()
11165 
    oprot.writeStructEnd()
11166 
 
3431 rajveer 11167 
  def validate(self):
11168 
    return
11169 
 
11170 
 
2819 chandransh 11171 
  def __repr__(self):
11172 
    L = ['%s=%r' % (key, value)
11173 
      for key, value in self.__dict__.iteritems()]
11174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11175 
 
11176 
  def __eq__(self, other):
11177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11178 
 
11179 
  def __ne__(self, other):
11180 
    return not (self == other)
3451 chandransh 11181 
 
11182 
class updateWeight_args:
11183 
  """
11184 
  Attributes:
11185 
   - orderId
11186 
   - weight
11187 
  """
11188 
 
11189 
  thrift_spec = (
11190 
    None, # 0
11191 
    (1, TType.I64, 'orderId', None, None, ), # 1
11192 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11193 
  )
11194 
 
11195 
  def __init__(self, orderId=None, weight=None,):
11196 
    self.orderId = orderId
11197 
    self.weight = weight
11198 
 
11199 
  def read(self, iprot):
11200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11202 
      return
11203 
    iprot.readStructBegin()
11204 
    while True:
11205 
      (fname, ftype, fid) = iprot.readFieldBegin()
11206 
      if ftype == TType.STOP:
11207 
        break
11208 
      if fid == 1:
11209 
        if ftype == TType.I64:
11210 
          self.orderId = iprot.readI64();
11211 
        else:
11212 
          iprot.skip(ftype)
11213 
      elif fid == 2:
11214 
        if ftype == TType.DOUBLE:
11215 
          self.weight = iprot.readDouble();
11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      else:
11219 
        iprot.skip(ftype)
11220 
      iprot.readFieldEnd()
11221 
    iprot.readStructEnd()
11222 
 
11223 
  def write(self, oprot):
11224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11226 
      return
11227 
    oprot.writeStructBegin('updateWeight_args')
11228 
    if self.orderId is not None:
11229 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11230 
      oprot.writeI64(self.orderId)
11231 
      oprot.writeFieldEnd()
11232 
    if self.weight is not None:
11233 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11234 
      oprot.writeDouble(self.weight)
11235 
      oprot.writeFieldEnd()
11236 
    oprot.writeFieldStop()
11237 
    oprot.writeStructEnd()
11238 
 
11239 
  def validate(self):
11240 
    return
11241 
 
11242 
 
11243 
  def __repr__(self):
11244 
    L = ['%s=%r' % (key, value)
11245 
      for key, value in self.__dict__.iteritems()]
11246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11247 
 
11248 
  def __eq__(self, other):
11249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11250 
 
11251 
  def __ne__(self, other):
11252 
    return not (self == other)
11253 
 
11254 
class updateWeight_result:
11255 
  """
11256 
  Attributes:
11257 
   - success
11258 
   - ex
11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11264 
  )
11265 
 
11266 
  def __init__(self, success=None, ex=None,):
11267 
    self.success = success
11268 
    self.ex = ex
11269 
 
11270 
  def read(self, iprot):
11271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11273 
      return
11274 
    iprot.readStructBegin()
11275 
    while True:
11276 
      (fname, ftype, fid) = iprot.readFieldBegin()
11277 
      if ftype == TType.STOP:
11278 
        break
11279 
      if fid == 0:
11280 
        if ftype == TType.STRUCT:
11281 
          self.success = Order()
11282 
          self.success.read(iprot)
11283 
        else:
11284 
          iprot.skip(ftype)
11285 
      elif fid == 1:
11286 
        if ftype == TType.STRUCT:
11287 
          self.ex = TransactionServiceException()
11288 
          self.ex.read(iprot)
11289 
        else:
11290 
          iprot.skip(ftype)
11291 
      else:
11292 
        iprot.skip(ftype)
11293 
      iprot.readFieldEnd()
11294 
    iprot.readStructEnd()
11295 
 
11296 
  def write(self, oprot):
11297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11299 
      return
11300 
    oprot.writeStructBegin('updateWeight_result')
11301 
    if self.success is not None:
11302 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11303 
      self.success.write(oprot)
11304 
      oprot.writeFieldEnd()
11305 
    if self.ex is not None:
11306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11307 
      self.ex.write(oprot)
11308 
      oprot.writeFieldEnd()
11309 
    oprot.writeFieldStop()
11310 
    oprot.writeStructEnd()
11311 
 
11312 
  def validate(self):
11313 
    return
11314 
 
11315 
 
11316 
  def __repr__(self):
11317 
    L = ['%s=%r' % (key, value)
11318 
      for key, value in self.__dict__.iteritems()]
11319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11320 
 
11321 
  def __eq__(self, other):
11322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11323 
 
11324 
  def __ne__(self, other):
11325 
    return not (self == other)
3469 chandransh 11326 
 
11327 
class changeItem_args:
11328 
  """
11329 
  Attributes:
11330 
   - orderId
11331 
   - itemId
11332 
  """
11333 
 
11334 
  thrift_spec = (
11335 
    None, # 0
11336 
    (1, TType.I64, 'orderId', None, None, ), # 1
11337 
    (2, TType.I64, 'itemId', None, None, ), # 2
11338 
  )
11339 
 
11340 
  def __init__(self, orderId=None, itemId=None,):
11341 
    self.orderId = orderId
11342 
    self.itemId = itemId
11343 
 
11344 
  def read(self, iprot):
11345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11347 
      return
11348 
    iprot.readStructBegin()
11349 
    while True:
11350 
      (fname, ftype, fid) = iprot.readFieldBegin()
11351 
      if ftype == TType.STOP:
11352 
        break
11353 
      if fid == 1:
11354 
        if ftype == TType.I64:
11355 
          self.orderId = iprot.readI64();
11356 
        else:
11357 
          iprot.skip(ftype)
11358 
      elif fid == 2:
11359 
        if ftype == TType.I64:
11360 
          self.itemId = iprot.readI64();
11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      else:
11364 
        iprot.skip(ftype)
11365 
      iprot.readFieldEnd()
11366 
    iprot.readStructEnd()
11367 
 
11368 
  def write(self, oprot):
11369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11371 
      return
11372 
    oprot.writeStructBegin('changeItem_args')
11373 
    if self.orderId is not None:
11374 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11375 
      oprot.writeI64(self.orderId)
11376 
      oprot.writeFieldEnd()
11377 
    if self.itemId is not None:
11378 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11379 
      oprot.writeI64(self.itemId)
11380 
      oprot.writeFieldEnd()
11381 
    oprot.writeFieldStop()
11382 
    oprot.writeStructEnd()
11383 
 
11384 
  def validate(self):
11385 
    return
11386 
 
11387 
 
11388 
  def __repr__(self):
11389 
    L = ['%s=%r' % (key, value)
11390 
      for key, value in self.__dict__.iteritems()]
11391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11392 
 
11393 
  def __eq__(self, other):
11394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11395 
 
11396 
  def __ne__(self, other):
11397 
    return not (self == other)
11398 
 
11399 
class changeItem_result:
11400 
  """
11401 
  Attributes:
11402 
   - success
11403 
   - ex
11404 
  """
11405 
 
11406 
  thrift_spec = (
11407 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11409 
  )
11410 
 
11411 
  def __init__(self, success=None, ex=None,):
11412 
    self.success = success
11413 
    self.ex = ex
11414 
 
11415 
  def read(self, iprot):
11416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11418 
      return
11419 
    iprot.readStructBegin()
11420 
    while True:
11421 
      (fname, ftype, fid) = iprot.readFieldBegin()
11422 
      if ftype == TType.STOP:
11423 
        break
11424 
      if fid == 0:
11425 
        if ftype == TType.STRUCT:
11426 
          self.success = Order()
11427 
          self.success.read(iprot)
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      elif fid == 1:
11431 
        if ftype == TType.STRUCT:
11432 
          self.ex = TransactionServiceException()
11433 
          self.ex.read(iprot)
11434 
        else:
11435 
          iprot.skip(ftype)
11436 
      else:
11437 
        iprot.skip(ftype)
11438 
      iprot.readFieldEnd()
11439 
    iprot.readStructEnd()
11440 
 
11441 
  def write(self, oprot):
11442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11444 
      return
11445 
    oprot.writeStructBegin('changeItem_result')
11446 
    if self.success is not None:
11447 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11448 
      self.success.write(oprot)
11449 
      oprot.writeFieldEnd()
11450 
    if self.ex is not None:
11451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11452 
      self.ex.write(oprot)
11453 
      oprot.writeFieldEnd()
11454 
    oprot.writeFieldStop()
11455 
    oprot.writeStructEnd()
11456 
 
11457 
  def validate(self):
11458 
    return
11459 
 
11460 
 
11461 
  def __repr__(self):
11462 
    L = ['%s=%r' % (key, value)
11463 
      for key, value in self.__dict__.iteritems()]
11464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11465 
 
11466 
  def __eq__(self, other):
11467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11468 
 
11469 
  def __ne__(self, other):
11470 
    return not (self == other)
11471 
 
11472 
class shiftToWarehouse_args:
11473 
  """
11474 
  Attributes:
11475 
   - orderId
11476 
   - warehouseId
11477 
  """
11478 
 
11479 
  thrift_spec = (
11480 
    None, # 0
11481 
    (1, TType.I64, 'orderId', None, None, ), # 1
11482 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11483 
  )
11484 
 
11485 
  def __init__(self, orderId=None, warehouseId=None,):
11486 
    self.orderId = orderId
11487 
    self.warehouseId = warehouseId
11488 
 
11489 
  def read(self, iprot):
11490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11492 
      return
11493 
    iprot.readStructBegin()
11494 
    while True:
11495 
      (fname, ftype, fid) = iprot.readFieldBegin()
11496 
      if ftype == TType.STOP:
11497 
        break
11498 
      if fid == 1:
11499 
        if ftype == TType.I64:
11500 
          self.orderId = iprot.readI64();
11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      elif fid == 2:
11504 
        if ftype == TType.I64:
11505 
          self.warehouseId = iprot.readI64();
11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      else:
11509 
        iprot.skip(ftype)
11510 
      iprot.readFieldEnd()
11511 
    iprot.readStructEnd()
11512 
 
11513 
  def write(self, oprot):
11514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11516 
      return
11517 
    oprot.writeStructBegin('shiftToWarehouse_args')
11518 
    if self.orderId is not None:
11519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11520 
      oprot.writeI64(self.orderId)
11521 
      oprot.writeFieldEnd()
11522 
    if self.warehouseId is not None:
11523 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11524 
      oprot.writeI64(self.warehouseId)
11525 
      oprot.writeFieldEnd()
11526 
    oprot.writeFieldStop()
11527 
    oprot.writeStructEnd()
11528 
 
11529 
  def validate(self):
11530 
    return
11531 
 
11532 
 
11533 
  def __repr__(self):
11534 
    L = ['%s=%r' % (key, value)
11535 
      for key, value in self.__dict__.iteritems()]
11536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11537 
 
11538 
  def __eq__(self, other):
11539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11540 
 
11541 
  def __ne__(self, other):
11542 
    return not (self == other)
11543 
 
11544 
class shiftToWarehouse_result:
11545 
  """
11546 
  Attributes:
11547 
   - success
11548 
   - ex
11549 
  """
11550 
 
11551 
  thrift_spec = (
11552 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11554 
  )
11555 
 
11556 
  def __init__(self, success=None, ex=None,):
11557 
    self.success = success
11558 
    self.ex = ex
11559 
 
11560 
  def read(self, iprot):
11561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11563 
      return
11564 
    iprot.readStructBegin()
11565 
    while True:
11566 
      (fname, ftype, fid) = iprot.readFieldBegin()
11567 
      if ftype == TType.STOP:
11568 
        break
11569 
      if fid == 0:
11570 
        if ftype == TType.STRUCT:
11571 
          self.success = Order()
11572 
          self.success.read(iprot)
11573 
        else:
11574 
          iprot.skip(ftype)
11575 
      elif fid == 1:
11576 
        if ftype == TType.STRUCT:
11577 
          self.ex = TransactionServiceException()
11578 
          self.ex.read(iprot)
11579 
        else:
11580 
          iprot.skip(ftype)
11581 
      else:
11582 
        iprot.skip(ftype)
11583 
      iprot.readFieldEnd()
11584 
    iprot.readStructEnd()
11585 
 
11586 
  def write(self, oprot):
11587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11589 
      return
11590 
    oprot.writeStructBegin('shiftToWarehouse_result')
11591 
    if self.success is not None:
11592 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11593 
      self.success.write(oprot)
11594 
      oprot.writeFieldEnd()
11595 
    if self.ex is not None:
11596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11597 
      self.ex.write(oprot)
11598 
      oprot.writeFieldEnd()
11599 
    oprot.writeFieldStop()
11600 
    oprot.writeStructEnd()
11601 
 
11602 
  def validate(self):
11603 
    return
11604 
 
11605 
 
11606 
  def __repr__(self):
11607 
    L = ['%s=%r' % (key, value)
11608 
      for key, value in self.__dict__.iteritems()]
11609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11610 
 
11611 
  def __eq__(self, other):
11612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11613 
 
11614 
  def __ne__(self, other):
11615 
    return not (self == other)
3553 chandransh 11616 
 
11617 
class addDelayReason_args:
11618 
  """
11619 
  Attributes:
11620 
   - orderId
11621 
   - delayReason
3986 chandransh 11622 
   - furtherDelay
3553 chandransh 11623 
  """
11624 
 
11625 
  thrift_spec = (
11626 
    None, # 0
11627 
    (1, TType.I64, 'orderId', None, None, ), # 1
11628 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11629 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11630 
  )
11631 
 
3986 chandransh 11632 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 11633 
    self.orderId = orderId
11634 
    self.delayReason = delayReason
3986 chandransh 11635 
    self.furtherDelay = furtherDelay
3553 chandransh 11636 
 
11637 
  def read(self, iprot):
11638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11640 
      return
11641 
    iprot.readStructBegin()
11642 
    while True:
11643 
      (fname, ftype, fid) = iprot.readFieldBegin()
11644 
      if ftype == TType.STOP:
11645 
        break
11646 
      if fid == 1:
11647 
        if ftype == TType.I64:
11648 
          self.orderId = iprot.readI64();
11649 
        else:
11650 
          iprot.skip(ftype)
11651 
      elif fid == 2:
11652 
        if ftype == TType.I32:
11653 
          self.delayReason = iprot.readI32();
11654 
        else:
11655 
          iprot.skip(ftype)
3986 chandransh 11656 
      elif fid == 3:
11657 
        if ftype == TType.I64:
11658 
          self.furtherDelay = iprot.readI64();
11659 
        else:
11660 
          iprot.skip(ftype)
3553 chandransh 11661 
      else:
11662 
        iprot.skip(ftype)
11663 
      iprot.readFieldEnd()
11664 
    iprot.readStructEnd()
11665 
 
11666 
  def write(self, oprot):
11667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11669 
      return
11670 
    oprot.writeStructBegin('addDelayReason_args')
11671 
    if self.orderId is not None:
11672 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11673 
      oprot.writeI64(self.orderId)
11674 
      oprot.writeFieldEnd()
11675 
    if self.delayReason is not None:
11676 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11677 
      oprot.writeI32(self.delayReason)
11678 
      oprot.writeFieldEnd()
3986 chandransh 11679 
    if self.furtherDelay is not None:
11680 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
11681 
      oprot.writeI64(self.furtherDelay)
11682 
      oprot.writeFieldEnd()
3553 chandransh 11683 
    oprot.writeFieldStop()
11684 
    oprot.writeStructEnd()
11685 
 
11686 
  def validate(self):
11687 
    return
11688 
 
11689 
 
11690 
  def __repr__(self):
11691 
    L = ['%s=%r' % (key, value)
11692 
      for key, value in self.__dict__.iteritems()]
11693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11694 
 
11695 
  def __eq__(self, other):
11696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11697 
 
11698 
  def __ne__(self, other):
11699 
    return not (self == other)
11700 
 
11701 
class addDelayReason_result:
11702 
  """
11703 
  Attributes:
11704 
   - success
11705 
   - ex
11706 
  """
11707 
 
11708 
  thrift_spec = (
11709 
    (0, TType.BOOL, 'success', None, None, ), # 0
11710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11711 
  )
11712 
 
11713 
  def __init__(self, success=None, ex=None,):
11714 
    self.success = success
11715 
    self.ex = ex
11716 
 
11717 
  def read(self, iprot):
11718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11720 
      return
11721 
    iprot.readStructBegin()
11722 
    while True:
11723 
      (fname, ftype, fid) = iprot.readFieldBegin()
11724 
      if ftype == TType.STOP:
11725 
        break
11726 
      if fid == 0:
11727 
        if ftype == TType.BOOL:
11728 
          self.success = iprot.readBool();
11729 
        else:
11730 
          iprot.skip(ftype)
11731 
      elif fid == 1:
11732 
        if ftype == TType.STRUCT:
11733 
          self.ex = TransactionServiceException()
11734 
          self.ex.read(iprot)
11735 
        else:
11736 
          iprot.skip(ftype)
11737 
      else:
11738 
        iprot.skip(ftype)
11739 
      iprot.readFieldEnd()
11740 
    iprot.readStructEnd()
11741 
 
11742 
  def write(self, oprot):
11743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11745 
      return
11746 
    oprot.writeStructBegin('addDelayReason_result')
11747 
    if self.success is not None:
11748 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11749 
      oprot.writeBool(self.success)
11750 
      oprot.writeFieldEnd()
11751 
    if self.ex is not None:
11752 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11753 
      self.ex.write(oprot)
11754 
      oprot.writeFieldEnd()
11755 
    oprot.writeFieldStop()
11756 
    oprot.writeStructEnd()
11757 
 
11758 
  def validate(self):
11759 
    return
11760 
 
11761 
 
11762 
  def __repr__(self):
11763 
    L = ['%s=%r' % (key, value)
11764 
      for key, value in self.__dict__.iteritems()]
11765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11766 
 
11767 
  def __eq__(self, other):
11768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11769 
 
11770 
  def __ne__(self, other):
11771 
    return not (self == other)
3956 chandransh 11772 
 
11773 
class reconcileCodCollection_args:
11774 
  """
11775 
  Attributes:
11776 
   - collectedAmountMap
11777 
   - xferBy
11778 
   - xferTxnId
11779 
   - xferDate
11780 
  """
11781 
 
11782 
  thrift_spec = (
11783 
    None, # 0
11784 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
11785 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
11786 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
11787 
    (4, TType.I64, 'xferDate', None, None, ), # 4
11788 
  )
11789 
 
11790 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
11791 
    self.collectedAmountMap = collectedAmountMap
11792 
    self.xferBy = xferBy
11793 
    self.xferTxnId = xferTxnId
11794 
    self.xferDate = xferDate
11795 
 
11796 
  def read(self, iprot):
11797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11799 
      return
11800 
    iprot.readStructBegin()
11801 
    while True:
11802 
      (fname, ftype, fid) = iprot.readFieldBegin()
11803 
      if ftype == TType.STOP:
11804 
        break
11805 
      if fid == 1:
11806 
        if ftype == TType.MAP:
11807 
          self.collectedAmountMap = {}
4133 chandransh 11808 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
11809 
          for _i217 in xrange(_size213):
11810 
            _key218 = iprot.readString();
11811 
            _val219 = iprot.readDouble();
11812 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 11813 
          iprot.readMapEnd()
11814 
        else:
11815 
          iprot.skip(ftype)
11816 
      elif fid == 2:
11817 
        if ftype == TType.STRING:
11818 
          self.xferBy = iprot.readString();
11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      elif fid == 3:
11822 
        if ftype == TType.STRING:
11823 
          self.xferTxnId = iprot.readString();
11824 
        else:
11825 
          iprot.skip(ftype)
11826 
      elif fid == 4:
11827 
        if ftype == TType.I64:
11828 
          self.xferDate = iprot.readI64();
11829 
        else:
11830 
          iprot.skip(ftype)
11831 
      else:
11832 
        iprot.skip(ftype)
11833 
      iprot.readFieldEnd()
11834 
    iprot.readStructEnd()
11835 
 
11836 
  def write(self, oprot):
11837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11839 
      return
11840 
    oprot.writeStructBegin('reconcileCodCollection_args')
11841 
    if self.collectedAmountMap is not None:
11842 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
11843 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 11844 
      for kiter220,viter221 in self.collectedAmountMap.items():
11845 
        oprot.writeString(kiter220)
11846 
        oprot.writeDouble(viter221)
3956 chandransh 11847 
      oprot.writeMapEnd()
11848 
      oprot.writeFieldEnd()
11849 
    if self.xferBy is not None:
11850 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
11851 
      oprot.writeString(self.xferBy)
11852 
      oprot.writeFieldEnd()
11853 
    if self.xferTxnId is not None:
11854 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
11855 
      oprot.writeString(self.xferTxnId)
11856 
      oprot.writeFieldEnd()
11857 
    if self.xferDate is not None:
11858 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
11859 
      oprot.writeI64(self.xferDate)
11860 
      oprot.writeFieldEnd()
11861 
    oprot.writeFieldStop()
11862 
    oprot.writeStructEnd()
11863 
 
11864 
  def validate(self):
11865 
    return
11866 
 
11867 
 
11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
11879 
class reconcileCodCollection_result:
11880 
  """
11881 
  Attributes:
11882 
   - success
11883 
   - ex
11884 
  """
11885 
 
11886 
  thrift_spec = (
11887 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
11888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11889 
  )
11890 
 
11891 
  def __init__(self, success=None, ex=None,):
11892 
    self.success = success
11893 
    self.ex = ex
11894 
 
11895 
  def read(self, iprot):
11896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11898 
      return
11899 
    iprot.readStructBegin()
11900 
    while True:
11901 
      (fname, ftype, fid) = iprot.readFieldBegin()
11902 
      if ftype == TType.STOP:
11903 
        break
11904 
      if fid == 0:
11905 
        if ftype == TType.MAP:
11906 
          self.success = {}
4133 chandransh 11907 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
11908 
          for _i226 in xrange(_size222):
11909 
            _key227 = iprot.readString();
11910 
            _val228 = iprot.readString();
11911 
            self.success[_key227] = _val228
3956 chandransh 11912 
          iprot.readMapEnd()
11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      elif fid == 1:
11916 
        if ftype == TType.STRUCT:
11917 
          self.ex = TransactionServiceException()
11918 
          self.ex.read(iprot)
11919 
        else:
11920 
          iprot.skip(ftype)
11921 
      else:
11922 
        iprot.skip(ftype)
11923 
      iprot.readFieldEnd()
11924 
    iprot.readStructEnd()
11925 
 
11926 
  def write(self, oprot):
11927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11929 
      return
11930 
    oprot.writeStructBegin('reconcileCodCollection_result')
11931 
    if self.success is not None:
11932 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11933 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 11934 
      for kiter229,viter230 in self.success.items():
11935 
        oprot.writeString(kiter229)
11936 
        oprot.writeString(viter230)
3956 chandransh 11937 
      oprot.writeMapEnd()
11938 
      oprot.writeFieldEnd()
11939 
    if self.ex is not None:
11940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11941 
      self.ex.write(oprot)
11942 
      oprot.writeFieldEnd()
11943 
    oprot.writeFieldStop()
11944 
    oprot.writeStructEnd()
11945 
 
11946 
  def validate(self):
11947 
    return
11948 
 
11949 
 
11950 
  def __repr__(self):
11951 
    L = ['%s=%r' % (key, value)
11952 
      for key, value in self.__dict__.iteritems()]
11953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11954 
 
11955 
  def __eq__(self, other):
11956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11957 
 
11958 
  def __ne__(self, other):
11959 
    return not (self == other)
4008 mandeep.dh 11960 
 
11961 
class getTransactionsRequiringExtraProcessing_args:
11962 
  """
11963 
  Attributes:
11964 
   - category
11965 
  """
11966 
 
11967 
  thrift_spec = (
11968 
    None, # 0
11969 
    (1, TType.I32, 'category', None, None, ), # 1
11970 
  )
11971 
 
11972 
  def __init__(self, category=None,):
11973 
    self.category = category
11974 
 
11975 
  def read(self, iprot):
11976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11978 
      return
11979 
    iprot.readStructBegin()
11980 
    while True:
11981 
      (fname, ftype, fid) = iprot.readFieldBegin()
11982 
      if ftype == TType.STOP:
11983 
        break
11984 
      if fid == 1:
11985 
        if ftype == TType.I32:
11986 
          self.category = iprot.readI32();
11987 
        else:
11988 
          iprot.skip(ftype)
11989 
      else:
11990 
        iprot.skip(ftype)
11991 
      iprot.readFieldEnd()
11992 
    iprot.readStructEnd()
11993 
 
11994 
  def write(self, oprot):
11995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11997 
      return
11998 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
11999 
    if self.category is not None:
12000 
      oprot.writeFieldBegin('category', TType.I32, 1)
12001 
      oprot.writeI32(self.category)
12002 
      oprot.writeFieldEnd()
12003 
    oprot.writeFieldStop()
12004 
    oprot.writeStructEnd()
12005 
 
12006 
  def validate(self):
12007 
    return
12008 
 
12009 
 
12010 
  def __repr__(self):
12011 
    L = ['%s=%r' % (key, value)
12012 
      for key, value in self.__dict__.iteritems()]
12013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12014 
 
12015 
  def __eq__(self, other):
12016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12017 
 
12018 
  def __ne__(self, other):
12019 
    return not (self == other)
12020 
 
12021 
class getTransactionsRequiringExtraProcessing_result:
12022 
  """
12023 
  Attributes:
12024 
   - success
12025 
  """
12026 
 
12027 
  thrift_spec = (
12028 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12029 
  )
12030 
 
12031 
  def __init__(self, success=None,):
12032 
    self.success = success
12033 
 
12034 
  def read(self, iprot):
12035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12037 
      return
12038 
    iprot.readStructBegin()
12039 
    while True:
12040 
      (fname, ftype, fid) = iprot.readFieldBegin()
12041 
      if ftype == TType.STOP:
12042 
        break
12043 
      if fid == 0:
12044 
        if ftype == TType.LIST:
12045 
          self.success = []
4133 chandransh 12046 
          (_etype234, _size231) = iprot.readListBegin()
12047 
          for _i235 in xrange(_size231):
12048 
            _elem236 = iprot.readI64();
12049 
            self.success.append(_elem236)
4008 mandeep.dh 12050 
          iprot.readListEnd()
12051 
        else:
12052 
          iprot.skip(ftype)
12053 
      else:
12054 
        iprot.skip(ftype)
12055 
      iprot.readFieldEnd()
12056 
    iprot.readStructEnd()
12057 
 
12058 
  def write(self, oprot):
12059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12061 
      return
12062 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12063 
    if self.success is not None:
12064 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12065 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12066 
      for iter237 in self.success:
12067 
        oprot.writeI64(iter237)
4008 mandeep.dh 12068 
      oprot.writeListEnd()
12069 
      oprot.writeFieldEnd()
12070 
    oprot.writeFieldStop()
12071 
    oprot.writeStructEnd()
12072 
 
12073 
  def validate(self):
12074 
    return
12075 
 
12076 
 
12077 
  def __repr__(self):
12078 
    L = ['%s=%r' % (key, value)
12079 
      for key, value in self.__dict__.iteritems()]
12080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12081 
 
12082 
  def __eq__(self, other):
12083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12084 
 
12085 
  def __ne__(self, other):
12086 
    return not (self == other)
12087 
 
12088 
class markTransactionAsProcessed_args:
12089 
  """
12090 
  Attributes:
12091 
   - transactionId
12092 
   - category
12093 
  """
12094 
 
12095 
  thrift_spec = (
12096 
    None, # 0
12097 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12098 
    (2, TType.I32, 'category', None, None, ), # 2
12099 
  )
12100 
 
12101 
  def __init__(self, transactionId=None, category=None,):
12102 
    self.transactionId = transactionId
12103 
    self.category = category
12104 
 
12105 
  def read(self, iprot):
12106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12108 
      return
12109 
    iprot.readStructBegin()
12110 
    while True:
12111 
      (fname, ftype, fid) = iprot.readFieldBegin()
12112 
      if ftype == TType.STOP:
12113 
        break
12114 
      if fid == 1:
12115 
        if ftype == TType.I64:
12116 
          self.transactionId = iprot.readI64();
12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      elif fid == 2:
12120 
        if ftype == TType.I32:
12121 
          self.category = iprot.readI32();
12122 
        else:
12123 
          iprot.skip(ftype)
12124 
      else:
12125 
        iprot.skip(ftype)
12126 
      iprot.readFieldEnd()
12127 
    iprot.readStructEnd()
12128 
 
12129 
  def write(self, oprot):
12130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12132 
      return
12133 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12134 
    if self.transactionId is not None:
12135 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12136 
      oprot.writeI64(self.transactionId)
12137 
      oprot.writeFieldEnd()
12138 
    if self.category is not None:
12139 
      oprot.writeFieldBegin('category', TType.I32, 2)
12140 
      oprot.writeI32(self.category)
12141 
      oprot.writeFieldEnd()
12142 
    oprot.writeFieldStop()
12143 
    oprot.writeStructEnd()
12144 
 
12145 
  def validate(self):
12146 
    return
12147 
 
12148 
 
12149 
  def __repr__(self):
12150 
    L = ['%s=%r' % (key, value)
12151 
      for key, value in self.__dict__.iteritems()]
12152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12153 
 
12154 
  def __eq__(self, other):
12155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12156 
 
12157 
  def __ne__(self, other):
12158 
    return not (self == other)
12159 
 
12160 
class markTransactionAsProcessed_result:
12161 
 
12162 
  thrift_spec = (
12163 
  )
12164 
 
12165 
  def read(self, iprot):
12166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12168 
      return
12169 
    iprot.readStructBegin()
12170 
    while True:
12171 
      (fname, ftype, fid) = iprot.readFieldBegin()
12172 
      if ftype == TType.STOP:
12173 
        break
12174 
      else:
12175 
        iprot.skip(ftype)
12176 
      iprot.readFieldEnd()
12177 
    iprot.readStructEnd()
12178 
 
12179 
  def write(self, oprot):
12180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12182 
      return
12183 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12184 
    oprot.writeFieldStop()
12185 
    oprot.writeStructEnd()
12186 
 
12187 
  def validate(self):
12188 
    return
12189 
 
12190 
 
12191 
  def __repr__(self):
12192 
    L = ['%s=%r' % (key, value)
12193 
      for key, value in self.__dict__.iteritems()]
12194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12195 
 
12196 
  def __eq__(self, other):
12197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12198 
 
12199 
  def __ne__(self, other):
12200 
    return not (self == other)
4018 chandransh 12201 
 
12202 
class getItemWiseRiskyOrdersCount_args:
12203 
 
12204 
  thrift_spec = (
12205 
  )
12206 
 
12207 
  def read(self, iprot):
12208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12210 
      return
12211 
    iprot.readStructBegin()
12212 
    while True:
12213 
      (fname, ftype, fid) = iprot.readFieldBegin()
12214 
      if ftype == TType.STOP:
12215 
        break
12216 
      else:
12217 
        iprot.skip(ftype)
12218 
      iprot.readFieldEnd()
12219 
    iprot.readStructEnd()
12220 
 
12221 
  def write(self, oprot):
12222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12224 
      return
12225 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12226 
    oprot.writeFieldStop()
12227 
    oprot.writeStructEnd()
12228 
 
12229 
  def validate(self):
12230 
    return
12231 
 
12232 
 
12233 
  def __repr__(self):
12234 
    L = ['%s=%r' % (key, value)
12235 
      for key, value in self.__dict__.iteritems()]
12236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12237 
 
12238 
  def __eq__(self, other):
12239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12240 
 
12241 
  def __ne__(self, other):
12242 
    return not (self == other)
12243 
 
12244 
class getItemWiseRiskyOrdersCount_result:
12245 
  """
12246 
  Attributes:
12247 
   - success
12248 
  """
12249 
 
12250 
  thrift_spec = (
12251 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12252 
  )
12253 
 
12254 
  def __init__(self, success=None,):
12255 
    self.success = success
12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 0:
12267 
        if ftype == TType.MAP:
12268 
          self.success = {}
4133 chandransh 12269 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12270 
          for _i242 in xrange(_size238):
12271 
            _key243 = iprot.readI64();
12272 
            _val244 = iprot.readI64();
12273 
            self.success[_key243] = _val244
4018 chandransh 12274 
          iprot.readMapEnd()
12275 
        else:
12276 
          iprot.skip(ftype)
12277 
      else:
12278 
        iprot.skip(ftype)
12279 
      iprot.readFieldEnd()
12280 
    iprot.readStructEnd()
12281 
 
12282 
  def write(self, oprot):
12283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12285 
      return
12286 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12287 
    if self.success is not None:
12288 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12289 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12290 
      for kiter245,viter246 in self.success.items():
12291 
        oprot.writeI64(kiter245)
12292 
        oprot.writeI64(viter246)
4018 chandransh 12293 
      oprot.writeMapEnd()
12294 
      oprot.writeFieldEnd()
12295 
    oprot.writeFieldStop()
12296 
    oprot.writeStructEnd()
12297 
 
12298 
  def validate(self):
12299 
    return
12300 
 
12301 
 
12302 
  def __repr__(self):
12303 
    L = ['%s=%r' % (key, value)
12304 
      for key, value in self.__dict__.iteritems()]
12305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12306 
 
12307 
  def __eq__(self, other):
12308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12309 
 
12310 
  def __ne__(self, other):
12311 
    return not (self == other)
4247 rajveer 12312 
 
12313 
class markOrderCancellationRequestReceived_args:
12314 
  """
12315 
  Attributes:
12316 
   - orderId
12317 
  """
12318 
 
12319 
  thrift_spec = (
12320 
    None, # 0
12321 
    (1, TType.I64, 'orderId', None, None, ), # 1
12322 
  )
12323 
 
12324 
  def __init__(self, orderId=None,):
12325 
    self.orderId = orderId
12326 
 
12327 
  def read(self, iprot):
12328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12330 
      return
12331 
    iprot.readStructBegin()
12332 
    while True:
12333 
      (fname, ftype, fid) = iprot.readFieldBegin()
12334 
      if ftype == TType.STOP:
12335 
        break
12336 
      if fid == 1:
12337 
        if ftype == TType.I64:
12338 
          self.orderId = iprot.readI64();
12339 
        else:
12340 
          iprot.skip(ftype)
12341 
      else:
12342 
        iprot.skip(ftype)
12343 
      iprot.readFieldEnd()
12344 
    iprot.readStructEnd()
12345 
 
12346 
  def write(self, oprot):
12347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12349 
      return
12350 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12351 
    if self.orderId is not None:
12352 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12353 
      oprot.writeI64(self.orderId)
12354 
      oprot.writeFieldEnd()
12355 
    oprot.writeFieldStop()
12356 
    oprot.writeStructEnd()
12357 
 
12358 
  def validate(self):
12359 
    return
12360 
 
12361 
 
12362 
  def __repr__(self):
12363 
    L = ['%s=%r' % (key, value)
12364 
      for key, value in self.__dict__.iteritems()]
12365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12366 
 
12367 
  def __eq__(self, other):
12368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12369 
 
12370 
  def __ne__(self, other):
12371 
    return not (self == other)
12372 
 
12373 
class markOrderCancellationRequestReceived_result:
12374 
  """
12375 
  Attributes:
12376 
   - ex
12377 
  """
12378 
 
12379 
  thrift_spec = (
12380 
    None, # 0
12381 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12382 
  )
12383 
 
12384 
  def __init__(self, ex=None,):
12385 
    self.ex = ex
12386 
 
12387 
  def read(self, iprot):
12388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12390 
      return
12391 
    iprot.readStructBegin()
12392 
    while True:
12393 
      (fname, ftype, fid) = iprot.readFieldBegin()
12394 
      if ftype == TType.STOP:
12395 
        break
12396 
      if fid == 1:
12397 
        if ftype == TType.STRUCT:
12398 
          self.ex = TransactionServiceException()
12399 
          self.ex.read(iprot)
12400 
        else:
12401 
          iprot.skip(ftype)
12402 
      else:
12403 
        iprot.skip(ftype)
12404 
      iprot.readFieldEnd()
12405 
    iprot.readStructEnd()
12406 
 
12407 
  def write(self, oprot):
12408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12410 
      return
12411 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12412 
    if self.ex is not None:
12413 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12414 
      self.ex.write(oprot)
12415 
      oprot.writeFieldEnd()
12416 
    oprot.writeFieldStop()
12417 
    oprot.writeStructEnd()
12418 
 
12419 
  def validate(self):
12420 
    return
12421 
 
12422 
 
12423 
  def __repr__(self):
12424 
    L = ['%s=%r' % (key, value)
12425 
      for key, value in self.__dict__.iteritems()]
12426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12427 
 
12428 
  def __eq__(self, other):
12429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12430 
 
12431 
  def __ne__(self, other):
12432 
    return not (self == other)
12433 
 
12434 
class markOrderCancellationRequestConfirmed_args:
12435 
  """
12436 
  Attributes:
12437 
   - orderId
12438 
  """
12439 
 
12440 
  thrift_spec = (
12441 
    None, # 0
12442 
    (1, TType.I64, 'orderId', None, None, ), # 1
12443 
  )
12444 
 
12445 
  def __init__(self, orderId=None,):
12446 
    self.orderId = orderId
12447 
 
12448 
  def read(self, iprot):
12449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12451 
      return
12452 
    iprot.readStructBegin()
12453 
    while True:
12454 
      (fname, ftype, fid) = iprot.readFieldBegin()
12455 
      if ftype == TType.STOP:
12456 
        break
12457 
      if fid == 1:
12458 
        if ftype == TType.I64:
12459 
          self.orderId = iprot.readI64();
12460 
        else:
12461 
          iprot.skip(ftype)
12462 
      else:
12463 
        iprot.skip(ftype)
12464 
      iprot.readFieldEnd()
12465 
    iprot.readStructEnd()
12466 
 
12467 
  def write(self, oprot):
12468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12470 
      return
12471 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12472 
    if self.orderId is not None:
12473 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12474 
      oprot.writeI64(self.orderId)
12475 
      oprot.writeFieldEnd()
12476 
    oprot.writeFieldStop()
12477 
    oprot.writeStructEnd()
12478 
 
12479 
  def validate(self):
12480 
    return
12481 
 
12482 
 
12483 
  def __repr__(self):
12484 
    L = ['%s=%r' % (key, value)
12485 
      for key, value in self.__dict__.iteritems()]
12486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12487 
 
12488 
  def __eq__(self, other):
12489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12490 
 
12491 
  def __ne__(self, other):
12492 
    return not (self == other)
12493 
 
12494 
class markOrderCancellationRequestConfirmed_result:
12495 
  """
12496 
  Attributes:
12497 
   - ex
12498 
  """
12499 
 
12500 
  thrift_spec = (
12501 
    None, # 0
12502 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12503 
  )
12504 
 
12505 
  def __init__(self, ex=None,):
12506 
    self.ex = ex
12507 
 
12508 
  def read(self, iprot):
12509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12511 
      return
12512 
    iprot.readStructBegin()
12513 
    while True:
12514 
      (fname, ftype, fid) = iprot.readFieldBegin()
12515 
      if ftype == TType.STOP:
12516 
        break
12517 
      if fid == 1:
12518 
        if ftype == TType.STRUCT:
12519 
          self.ex = TransactionServiceException()
12520 
          self.ex.read(iprot)
12521 
        else:
12522 
          iprot.skip(ftype)
12523 
      else:
12524 
        iprot.skip(ftype)
12525 
      iprot.readFieldEnd()
12526 
    iprot.readStructEnd()
12527 
 
12528 
  def write(self, oprot):
12529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12531 
      return
12532 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12533 
    if self.ex is not None:
12534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12535 
      self.ex.write(oprot)
12536 
      oprot.writeFieldEnd()
12537 
    oprot.writeFieldStop()
12538 
    oprot.writeStructEnd()
12539 
 
12540 
  def validate(self):
12541 
    return
12542 
 
12543 
 
12544 
  def __repr__(self):
12545 
    L = ['%s=%r' % (key, value)
12546 
      for key, value in self.__dict__.iteritems()]
12547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12548 
 
12549 
  def __eq__(self, other):
12550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12551 
 
12552 
  def __ne__(self, other):
12553 
    return not (self == other)
12554 
 
12555 
class markOrderCancellationRequestDenied_args:
12556 
  """
12557 
  Attributes:
12558 
   - orderId
12559 
  """
12560 
 
12561 
  thrift_spec = (
12562 
    None, # 0
12563 
    (1, TType.I64, 'orderId', None, None, ), # 1
12564 
  )
12565 
 
12566 
  def __init__(self, orderId=None,):
12567 
    self.orderId = orderId
12568 
 
12569 
  def read(self, iprot):
12570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12572 
      return
12573 
    iprot.readStructBegin()
12574 
    while True:
12575 
      (fname, ftype, fid) = iprot.readFieldBegin()
12576 
      if ftype == TType.STOP:
12577 
        break
12578 
      if fid == 1:
12579 
        if ftype == TType.I64:
12580 
          self.orderId = iprot.readI64();
12581 
        else:
12582 
          iprot.skip(ftype)
12583 
      else:
12584 
        iprot.skip(ftype)
12585 
      iprot.readFieldEnd()
12586 
    iprot.readStructEnd()
12587 
 
12588 
  def write(self, oprot):
12589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12591 
      return
12592 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12593 
    if self.orderId is not None:
12594 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12595 
      oprot.writeI64(self.orderId)
12596 
      oprot.writeFieldEnd()
12597 
    oprot.writeFieldStop()
12598 
    oprot.writeStructEnd()
12599 
 
12600 
  def validate(self):
12601 
    return
12602 
 
12603 
 
12604 
  def __repr__(self):
12605 
    L = ['%s=%r' % (key, value)
12606 
      for key, value in self.__dict__.iteritems()]
12607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12608 
 
12609 
  def __eq__(self, other):
12610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12611 
 
12612 
  def __ne__(self, other):
12613 
    return not (self == other)
12614 
 
12615 
class markOrderCancellationRequestDenied_result:
12616 
  """
12617 
  Attributes:
12618 
   - ex
12619 
  """
12620 
 
12621 
  thrift_spec = (
12622 
    None, # 0
12623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12624 
  )
12625 
 
12626 
  def __init__(self, ex=None,):
12627 
    self.ex = ex
12628 
 
12629 
  def read(self, iprot):
12630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12632 
      return
12633 
    iprot.readStructBegin()
12634 
    while True:
12635 
      (fname, ftype, fid) = iprot.readFieldBegin()
12636 
      if ftype == TType.STOP:
12637 
        break
12638 
      if fid == 1:
12639 
        if ftype == TType.STRUCT:
12640 
          self.ex = TransactionServiceException()
12641 
          self.ex.read(iprot)
12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
12654 
    if self.ex is not None:
12655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12656 
      self.ex.write(oprot)
12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
4258 rajveer 12676 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 12677 
  """
12678 
  Attributes:
4258 rajveer 12679 
   - transactionId
4247 rajveer 12680 
  """
12681 
 
12682 
  thrift_spec = (
12683 
    None, # 0
4258 rajveer 12684 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 12685 
  )
12686 
 
4258 rajveer 12687 
  def __init__(self, transactionId=None,):
12688 
    self.transactionId = transactionId
4247 rajveer 12689 
 
12690 
  def read(self, iprot):
12691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12693 
      return
12694 
    iprot.readStructBegin()
12695 
    while True:
12696 
      (fname, ftype, fid) = iprot.readFieldBegin()
12697 
      if ftype == TType.STOP:
12698 
        break
12699 
      if fid == 1:
12700 
        if ftype == TType.I64:
4258 rajveer 12701 
          self.transactionId = iprot.readI64();
4247 rajveer 12702 
        else:
12703 
          iprot.skip(ftype)
12704 
      else:
12705 
        iprot.skip(ftype)
12706 
      iprot.readFieldEnd()
12707 
    iprot.readStructEnd()
12708 
 
12709 
  def write(self, oprot):
12710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12712 
      return
4258 rajveer 12713 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
12714 
    if self.transactionId is not None:
12715 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12716 
      oprot.writeI64(self.transactionId)
4247 rajveer 12717 
      oprot.writeFieldEnd()
12718 
    oprot.writeFieldStop()
12719 
    oprot.writeStructEnd()
12720 
 
12721 
  def validate(self):
12722 
    return
12723 
 
12724 
 
12725 
  def __repr__(self):
12726 
    L = ['%s=%r' % (key, value)
12727 
      for key, value in self.__dict__.iteritems()]
12728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12729 
 
12730 
  def __eq__(self, other):
12731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12732 
 
12733 
  def __ne__(self, other):
12734 
    return not (self == other)
12735 
 
4258 rajveer 12736 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 12737 
  """
12738 
  Attributes:
12739 
   - ex
12740 
  """
12741 
 
12742 
  thrift_spec = (
12743 
    None, # 0
12744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12745 
  )
12746 
 
12747 
  def __init__(self, ex=None,):
12748 
    self.ex = ex
12749 
 
12750 
  def read(self, iprot):
12751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12753 
      return
12754 
    iprot.readStructBegin()
12755 
    while True:
12756 
      (fname, ftype, fid) = iprot.readFieldBegin()
12757 
      if ftype == TType.STOP:
12758 
        break
12759 
      if fid == 1:
12760 
        if ftype == TType.STRUCT:
12761 
          self.ex = TransactionServiceException()
12762 
          self.ex.read(iprot)
12763 
        else:
12764 
          iprot.skip(ftype)
12765 
      else:
12766 
        iprot.skip(ftype)
12767 
      iprot.readFieldEnd()
12768 
    iprot.readStructEnd()
12769 
 
12770 
  def write(self, oprot):
12771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12773 
      return
4258 rajveer 12774 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 12775 
    if self.ex is not None:
12776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12777 
      self.ex.write(oprot)
12778 
      oprot.writeFieldEnd()
12779 
    oprot.writeFieldStop()
12780 
    oprot.writeStructEnd()
12781 
 
12782 
  def validate(self):
12783 
    return
12784 
 
12785 
 
12786 
  def __repr__(self):
12787 
    L = ['%s=%r' % (key, value)
12788 
      for key, value in self.__dict__.iteritems()]
12789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12790 
 
12791 
  def __eq__(self, other):
12792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12793 
 
12794 
  def __ne__(self, other):
12795 
    return not (self == other)
4259 anupam.sin 12796 
 
12797 
class refundTransaction_args:
12798 
  """
12799 
  Attributes:
12800 
   - transactionId
12801 
   - refundedBy
12802 
   - reason
12803 
  """
12804 
 
12805 
  thrift_spec = (
12806 
    None, # 0
12807 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12808 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12809 
    (3, TType.STRING, 'reason', None, None, ), # 3
12810 
  )
12811 
 
12812 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
12813 
    self.transactionId = transactionId
12814 
    self.refundedBy = refundedBy
12815 
    self.reason = reason
12816 
 
12817 
  def read(self, iprot):
12818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12820 
      return
12821 
    iprot.readStructBegin()
12822 
    while True:
12823 
      (fname, ftype, fid) = iprot.readFieldBegin()
12824 
      if ftype == TType.STOP:
12825 
        break
12826 
      if fid == 1:
12827 
        if ftype == TType.I64:
12828 
          self.transactionId = iprot.readI64();
12829 
        else:
12830 
          iprot.skip(ftype)
12831 
      elif fid == 2:
12832 
        if ftype == TType.STRING:
12833 
          self.refundedBy = iprot.readString();
12834 
        else:
12835 
          iprot.skip(ftype)
12836 
      elif fid == 3:
12837 
        if ftype == TType.STRING:
12838 
          self.reason = iprot.readString();
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
12850 
    oprot.writeStructBegin('refundTransaction_args')
12851 
    if self.transactionId is not None:
12852 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12853 
      oprot.writeI64(self.transactionId)
12854 
      oprot.writeFieldEnd()
12855 
    if self.refundedBy is not None:
12856 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12857 
      oprot.writeString(self.refundedBy)
12858 
      oprot.writeFieldEnd()
12859 
    if self.reason is not None:
12860 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12861 
      oprot.writeString(self.reason)
12862 
      oprot.writeFieldEnd()
12863 
    oprot.writeFieldStop()
12864 
    oprot.writeStructEnd()
12865 
 
12866 
  def validate(self):
12867 
    return
12868 
 
12869 
 
12870 
  def __repr__(self):
12871 
    L = ['%s=%r' % (key, value)
12872 
      for key, value in self.__dict__.iteritems()]
12873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12874 
 
12875 
  def __eq__(self, other):
12876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12877 
 
12878 
  def __ne__(self, other):
12879 
    return not (self == other)
12880 
 
12881 
class refundTransaction_result:
12882 
  """
12883 
  Attributes:
12884 
   - ex
12885 
  """
12886 
 
12887 
  thrift_spec = (
12888 
    None, # 0
12889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12890 
  )
12891 
 
12892 
  def __init__(self, ex=None,):
12893 
    self.ex = ex
12894 
 
12895 
  def read(self, iprot):
12896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12898 
      return
12899 
    iprot.readStructBegin()
12900 
    while True:
12901 
      (fname, ftype, fid) = iprot.readFieldBegin()
12902 
      if ftype == TType.STOP:
12903 
        break
12904 
      if fid == 1:
12905 
        if ftype == TType.STRUCT:
12906 
          self.ex = TransactionServiceException()
12907 
          self.ex.read(iprot)
12908 
        else:
12909 
          iprot.skip(ftype)
12910 
      else:
12911 
        iprot.skip(ftype)
12912 
      iprot.readFieldEnd()
12913 
    iprot.readStructEnd()
12914 
 
12915 
  def write(self, oprot):
12916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12918 
      return
12919 
    oprot.writeStructBegin('refundTransaction_result')
12920 
    if self.ex is not None:
12921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12922 
      self.ex.write(oprot)
12923 
      oprot.writeFieldEnd()
12924 
    oprot.writeFieldStop()
12925 
    oprot.writeStructEnd()
12926 
 
12927 
  def validate(self):
12928 
    return
12929 
 
12930 
 
12931 
  def __repr__(self):
12932 
    L = ['%s=%r' % (key, value)
12933 
      for key, value in self.__dict__.iteritems()]
12934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12935 
 
12936 
  def __eq__(self, other):
12937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12938 
 
12939 
  def __ne__(self, other):
12940 
    return not (self == other)