Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
483 rajveer 74 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
483 rajveer 77 
     - status
78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
1528 ankur.sing 208 
  def getOrderForCustomer(self, orderId, customerId):
209 
    """
210 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
211 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 212 
 
1528 ankur.sing 213 
    Parameters:
214 
     - orderId
215 
     - customerId
216 
    """
217 
    pass
218 
 
3064 chandransh 219 
  def getAlerts(self, orderId, valid):
220 
    """
221 
    Parameters:
222 
     - orderId
223 
     - valid
224 
    """
225 
    pass
226 
 
227 
  def setAlert(self, orderId, unset, type, comment):
228 
    """
229 
    Parameters:
230 
     - orderId
231 
     - unset
232 
     - type
233 
     - comment
234 
    """
235 
    pass
236 
 
237 
  def getValidOrderCount(self, ):
238 
    """
239 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
240 
    """
241 
    pass
242 
 
243 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
244 
    """
245 
    Returns the number of distinct customers who have done successful transactions
246 
    """
247 
    pass
248 
 
249 
  def getValidOrdersAmountRange(self, ):
250 
    """
251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
252 
    List contains two values, first minimum amount and second maximum amount.
253 
    """
254 
    pass
255 
 
256 
  def getValidOrders(self, limit):
257 
    """
258 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
259 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 260 
 
3064 chandransh 261 
    Parameters:
262 
     - limit
263 
    """
264 
    pass
265 
 
1220 chandransh 266 
  def batchOrders(self, warehouseId):
267 
    """
268 
    Create a batch of all the pending orders for the given warehouse.
269 
    The returned list is orderd by created_timestamp.
270 
    If there are no pending orders, an empty list is returned.
3431 rajveer 271 
 
1220 chandransh 272 
    Parameters:
273 
     - warehouseId
274 
    """
275 
    pass
276 
 
1208 chandransh 277 
  def markOrderAsOutOfStock(self, orderId):
278 
    """
279 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 280 
 
1208 chandransh 281 
    Parameters:
282 
     - orderId
283 
    """
284 
    pass
285 
 
3064 chandransh 286 
  def verifyOrder(self, orderId):
759 chandransh 287 
    """
3064 chandransh 288 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
289 
    timestamp. It is intended to be used for COD orders but can be harmlessly
290 
    used for all other orders as well.
291 
    Throws an exception if no such order exists.
3431 rajveer 292 
 
759 chandransh 293 
    Parameters:
3064 chandransh 294 
     - orderId
295 
    """
296 
    pass
297 
 
298 
  def acceptOrder(self, orderId):
299 
    """
300 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
301 
    given order is not a COD order, it also captures the payment if the same has
302 
    not been captured.
303 
    Throws an exception if no such order exists.
3431 rajveer 304 
 
3064 chandransh 305 
    Parameters:
306 
     - orderId
307 
    """
308 
    pass
309 
 
4283 anupam.sin 310 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 311 
    """
312 
    Add billing details such as the bill number and the biller to the Order.
313 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
314 
    the IMEI no. if a -1 is supplied.
315 
    Also, it generates an invoice number for the order, marks the order as
316 
    BILLED and sets the billing timestamp.
317 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 318 
 
3064 chandransh 319 
    Parameters:
320 
     - orderId
4283 anupam.sin 321 
     - invoice_number
3064 chandransh 322 
     - imeiNumber
323 
     - itemNumber
4283 anupam.sin 324 
     - billed_by
325 
     - jacketNumber
3064 chandransh 326 
     - billingType
4283 anupam.sin 327 
     - vendorId
3064 chandransh 328 
    """
329 
    pass
330 
 
331 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
332 
    """
333 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
334 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 335 
 
3064 chandransh 336 
    Parameters:
759 chandransh 337 
     - warehouseId
338 
     - providerId
3064 chandransh 339 
     - cod
759 chandransh 340 
    """
341 
    pass
342 
 
1113 chandransh 343 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
344 
    """
345 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
346 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
347 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 348 
 
1113 chandransh 349 
    Parameters:
350 
     - providerId
351 
     - pickupDetails
352 
    """
353 
    pass
354 
 
1132 chandransh 355 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
356 
    """
357 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
358 
    the name of the receiver.
359 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 360 
 
1132 chandransh 361 
    Parameters:
362 
     - providerId
363 
     - deliveredOrders
364 
    """
365 
    pass
366 
 
1135 chandransh 367 
  def markOrdersAsFailed(self, providerId, returnedOrders):
368 
    """
369 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
370 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 371 
 
1135 chandransh 372 
    Parameters:
373 
     - providerId
374 
     - returnedOrders
375 
    """
376 
    pass
377 
 
1246 chandransh 378 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
379 
    """
380 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 381 
 
1246 chandransh 382 
    Parameters:
383 
     - providerId
384 
     - undeliveredOrders
385 
    """
386 
    pass
387 
 
1408 ankur.sing 388 
  def getUndeliveredOrders(self, providerId, warehouseId):
389 
    """
390 
    Returns the list of orders whose delivery time has passed but have not been
391 
    delivered yet for the given provider and warehouse. To get a complete list of
392 
    undelivered orders, pass them as -1.
393 
    Returns an empty list if no such orders exist.
3431 rajveer 394 
 
1408 ankur.sing 395 
    Parameters:
396 
     - providerId
397 
     - warehouseId
398 
    """
399 
    pass
400 
 
2536 chandransh 401 
  def toggleDOAFlag(self, orderId):
402 
    """
403 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
404 
    Returns the final flag status.
405 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 406 
 
2536 chandransh 407 
    Parameters:
408 
     - orderId
409 
    """
410 
    pass
1886 ankur.sing 411 
 
2536 chandransh 412 
  def requestPickupNumber(self, orderId):
413 
    """
414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
416 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
417 
    For any other status, it returns false.
418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 419 
 
2536 chandransh 420 
    Parameters:
421 
     - orderId
422 
    """
423 
    pass
424 
 
425 
  def authorizePickup(self, orderId, pickupNumber):
426 
    """
427 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
428 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
429 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
430 
    	3. Returns true
2591 chandransh 431 
    If the order is in any other status, it returns false.
2536 chandransh 432 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 433 
 
2536 chandransh 434 
    Parameters:
435 
     - orderId
436 
     - pickupNumber
437 
    """
438 
    pass
439 
 
2764 chandransh 440 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
441 
    """
442 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
443 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 444 
 
2764 chandransh 445 
    Parameters:
446 
     - providerId
447 
     - pickupDetails
448 
    """
449 
    pass
450 
 
2616 chandransh 451 
  def receiveReturn(self, orderId):
2591 chandransh 452 
    """
2599 chandransh 453 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 454 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 455 
    If the order is in any other state, it returns false.
456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 457 
 
2591 chandransh 458 
    Parameters:
459 
     - orderId
460 
    """
461 
    pass
2536 chandransh 462 
 
2591 chandransh 463 
  def validateDoa(self, orderId, isValid):
464 
    """
2599 chandransh 465 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 466 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 467 
    If the order is in any other state, it returns false.
468 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 469 
 
2591 chandransh 470 
    Parameters:
471 
     - orderId
472 
     - isValid
473 
    """
474 
    pass
475 
 
2616 chandransh 476 
  def reshipOrder(self, orderId):
477 
    """
478 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
479 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
480 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
481 
 
482 
    If the order is in DOA_CERT_VALID state, it does the following:
483 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
484 
    	2. Creates a return order for the warehouse executive to return the DOA material.
485 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 486 
 
2616 chandransh 487 
    Returns the id of the newly created order.
3431 rajveer 488 
 
2616 chandransh 489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 490 
 
2616 chandransh 491 
    Parameters:
492 
     - orderId
493 
    """
494 
    pass
2591 chandransh 495 
 
3226 chandransh 496 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 497 
    """
498 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a refund request for batch processing.
500 
    	2. Creates a return order for the warehouse executive to return the shipped material.
501 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 502 
 
2616 chandransh 503 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
504 
    	1. Creates a refund request for batch processing.
3226 chandransh 505 
    	2. Cancels the reservation of the item in the warehouse.
506 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 507 
 
3226 chandransh 508 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
509 
    	1. Cancels the reservation of the item in the warehouse.
510 
    	2. Marks the current order as CANCELED.
511 
 
512 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
513 
 
2616 chandransh 514 
    Returns True if it is successful, False otherwise.
3431 rajveer 515 
 
2616 chandransh 516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2616 chandransh 518 
    Parameters:
519 
     - orderId
3226 chandransh 520 
     - refundedBy
521 
     - reason
2616 chandransh 522 
    """
523 
    pass
524 
 
2690 chandransh 525 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
526 
    """
527 
    Get all return orders created between the from and to dates for the given warehouse.
528 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 529 
 
2690 chandransh 530 
    Parameters:
531 
     - warehouseId
532 
     - fromDate
533 
     - toDate
534 
    """
535 
    pass
2616 chandransh 536 
 
2700 chandransh 537 
  def getReturnOrder(self, id):
538 
    """
539 
    Returns the ReturnOrder corresponding to the given id.
540 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 541 
 
2700 chandransh 542 
    Parameters:
543 
     - id
544 
    """
545 
    pass
546 
 
2690 chandransh 547 
  def processReturn(self, returnOrderId):
548 
    """
549 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 550 
 
2690 chandransh 551 
    Parameters:
552 
     - returnOrderId
553 
    """
554 
    pass
555 
 
2819 chandransh 556 
  def createPurchaseOrder(self, warehouseId):
557 
    """
558 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 559 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 560 
 
2819 chandransh 561 
    Parameters:
562 
     - warehouseId
563 
    """
564 
    pass
2690 chandransh 565 
 
3451 chandransh 566 
  def updateWeight(self, orderId, weight):
567 
    """
568 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 569 
 
3451 chandransh 570 
    Parameters:
571 
     - orderId
572 
     - weight
573 
    """
574 
    pass
575 
 
3469 chandransh 576 
  def changeItem(self, orderId, itemId):
577 
    """
578 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
579 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 580 
 
3469 chandransh 581 
    Parameters:
582 
     - orderId
583 
     - itemId
584 
    """
585 
    pass
586 
 
587 
  def shiftToWarehouse(self, orderId, warehouseId):
588 
    """
589 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
590 
 
591 
    Parameters:
592 
     - orderId
593 
     - warehouseId
594 
    """
595 
    pass
596 
 
3986 chandransh 597 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 598 
    """
599 
    Adds the given delay reason to the given order.
3986 chandransh 600 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 601 
    Raises an exception if no order with the given id can be found.
3469 chandransh 602 
 
3553 chandransh 603 
    Parameters:
604 
     - orderId
605 
     - delayReason
3986 chandransh 606 
     - furtherDelay
3553 chandransh 607 
    """
608 
    pass
609 
 
3956 chandransh 610 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
611 
    """
612 
    Marks the COD orders with given AWB nos. as having been processed.
613 
    Updates the captured amount for the corresponding payment.
3553 chandransh 614 
 
3956 chandransh 615 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
616 
    1. There is no order corresponding to an AWB number.
617 
    2. The captured amount for a payment exceeds the total payment.
618 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
619 
 
620 
    Parameters:
621 
     - collectedAmountMap
622 
     - xferBy
623 
     - xferTxnId
624 
     - xferDate
625 
    """
626 
    pass
627 
 
4008 mandeep.dh 628 
  def getTransactionsRequiringExtraProcessing(self, category):
629 
    """
4065 mandeep.dh 630 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 631 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 632 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 633 
 
4008 mandeep.dh 634 
    Parameters:
635 
     - category
636 
    """
637 
    pass
638 
 
639 
  def markTransactionAsProcessed(self, transactionId, category):
640 
    """
641 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 642 
    It essentially deletes the transaction id record for a particular
643 
    processing type category (if present) from DB.
644 
    This is currently used by CRM application.
4008 mandeep.dh 645 
 
646 
    Parameters:
647 
     - transactionId
648 
     - category
649 
    """
650 
    pass
651 
 
4018 chandransh 652 
  def getItemWiseRiskyOrdersCount(self, ):
653 
    """
654 
    Returns a map containing the number of risky orders keyed by item id. A risky order
655 
    is defined as one whose shipping date is about to expire.
656 
    """
657 
    pass
4008 mandeep.dh 658 
 
4295 varun.gupt 659 
  def getOrdersForItemIds(self, itemIds):
660 
    """
661 
    Returns a list of all orders which have items with given id
662 
 
663 
    Parameters:
664 
     - itemIds
665 
    """
666 
    pass
667 
 
4247 rajveer 668 
  def markOrderCancellationRequestReceived(self, orderId):
669 
    """
670 
    Mark order as cancellation request received. If customer sends request of cancellation of
671 
    a particular order, this method will be called. It will just change status of the order
672 
    depending on its current status. It also records the previous status, so that we can move
673 
    back to that status if cancellation request is denied.
4018 chandransh 674 
 
4247 rajveer 675 
    Parameters:
676 
     - orderId
677 
    """
678 
    pass
679 
 
680 
  def markOrderCancellationRequestConfirmed(self, orderId):
681 
    """
682 
    If we decide to to cancel order, CRM will call this method to move the status of order to
683 
    cancellation request confirmed. After this OM will be able to cancel the order.
684 
 
685 
    Parameters:
686 
     - orderId
687 
    """
688 
    pass
689 
 
690 
  def markOrderCancellationRequestDenied(self, orderId):
691 
    """
692 
    If we decide to not to cancel order, we will move the order ro previous status.
693 
 
694 
    Parameters:
695 
     - orderId
696 
    """
697 
    pass
698 
 
4258 rajveer 699 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 700 
    """
4258 rajveer 701 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
702 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 703 
 
704 
    Parameters:
4258 rajveer 705 
     - transactionId
4247 rajveer 706 
    """
707 
    pass
708 
 
4259 anupam.sin 709 
  def refundTransaction(self, transactionId, refundedBy, reason):
710 
    """
711 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
712 
    need to be cancelled
4247 rajveer 713 
 
4259 anupam.sin 714 
    Parameters:
715 
     - transactionId
716 
     - refundedBy
717 
     - reason
718 
    """
719 
    pass
720 
 
4285 rajveer 721 
  def acceptOrdersForItemId(self, itemId, inventory):
722 
    """
723 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
724 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 725 
 
4285 rajveer 726 
    Parameters:
727 
     - itemId
728 
     - inventory
729 
    """
730 
    pass
731 
 
732 
 
3376 rajveer 733 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 734 
  def __init__(self, iprot, oprot=None):
3376 rajveer 735 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 736 
 
737 
  def createTransaction(self, transaction):
738 
    """
739 
    Parameters:
740 
     - transaction
741 
    """
742 
    self.send_createTransaction(transaction)
132 ashish 743 
    return self.recv_createTransaction()
94 ashish 744 
 
745 
  def send_createTransaction(self, transaction):
746 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
747 
    args = createTransaction_args()
748 
    args.transaction = transaction
749 
    args.write(self._oprot)
750 
    self._oprot.writeMessageEnd()
751 
    self._oprot.trans.flush()
752 
 
753 
  def recv_createTransaction(self, ):
754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
755 
    if mtype == TMessageType.EXCEPTION:
756 
      x = TApplicationException()
757 
      x.read(self._iprot)
758 
      self._iprot.readMessageEnd()
759 
      raise x
760 
    result = createTransaction_result()
761 
    result.read(self._iprot)
762 
    self._iprot.readMessageEnd()
3431 rajveer 763 
    if result.success is not None:
132 ashish 764 
      return result.success
3431 rajveer 765 
    if result.ex is not None:
94 ashish 766 
      raise result.ex
132 ashish 767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 768 
 
769 
  def getTransaction(self, id):
770 
    """
771 
    Parameters:
772 
     - id
773 
    """
774 
    self.send_getTransaction(id)
775 
    return self.recv_getTransaction()
776 
 
777 
  def send_getTransaction(self, id):
778 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
779 
    args = getTransaction_args()
780 
    args.id = id
781 
    args.write(self._oprot)
782 
    self._oprot.writeMessageEnd()
783 
    self._oprot.trans.flush()
784 
 
785 
  def recv_getTransaction(self, ):
786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
787 
    if mtype == TMessageType.EXCEPTION:
788 
      x = TApplicationException()
789 
      x.read(self._iprot)
790 
      self._iprot.readMessageEnd()
791 
      raise x
792 
    result = getTransaction_result()
793 
    result.read(self._iprot)
794 
    self._iprot.readMessageEnd()
3431 rajveer 795 
    if result.success is not None:
94 ashish 796 
      return result.success
3431 rajveer 797 
    if result.ex is not None:
94 ashish 798 
      raise result.ex
799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
800 
 
801 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
802 
    """
803 
    Parameters:
804 
     - customerId
805 
     - from_date
806 
     - to_date
807 
     - status
808 
    """
809 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
810 
    return self.recv_getTransactionsForCustomer()
811 
 
812 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
813 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
814 
    args = getTransactionsForCustomer_args()
815 
    args.customerId = customerId
816 
    args.from_date = from_date
817 
    args.to_date = to_date
818 
    args.status = status
819 
    args.write(self._oprot)
820 
    self._oprot.writeMessageEnd()
821 
    self._oprot.trans.flush()
822 
 
823 
  def recv_getTransactionsForCustomer(self, ):
824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
825 
    if mtype == TMessageType.EXCEPTION:
826 
      x = TApplicationException()
827 
      x.read(self._iprot)
828 
      self._iprot.readMessageEnd()
829 
      raise x
830 
    result = getTransactionsForCustomer_result()
831 
    result.read(self._iprot)
832 
    self._iprot.readMessageEnd()
3431 rajveer 833 
    if result.success is not None:
94 ashish 834 
      return result.success
3431 rajveer 835 
    if result.ex is not None:
94 ashish 836 
      raise result.ex
837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
838 
 
132 ashish 839 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
840 
    """
841 
    Parameters:
842 
     - shoppingCartId
843 
    """
844 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
845 
    return self.recv_getTransactionsForShoppingCartId()
846 
 
847 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
848 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
849 
    args = getTransactionsForShoppingCartId_args()
850 
    args.shoppingCartId = shoppingCartId
851 
    args.write(self._oprot)
852 
    self._oprot.writeMessageEnd()
853 
    self._oprot.trans.flush()
854 
 
855 
  def recv_getTransactionsForShoppingCartId(self, ):
856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
857 
    if mtype == TMessageType.EXCEPTION:
858 
      x = TApplicationException()
859 
      x.read(self._iprot)
860 
      self._iprot.readMessageEnd()
861 
      raise x
862 
    result = getTransactionsForShoppingCartId_result()
863 
    result.read(self._iprot)
864 
    self._iprot.readMessageEnd()
3431 rajveer 865 
    if result.success is not None:
132 ashish 866 
      return result.success
3431 rajveer 867 
    if result.ex is not None:
132 ashish 868 
      raise result.ex
869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
870 
 
94 ashish 871 
  def getTransactionStatus(self, transactionId):
872 
    """
873 
    Parameters:
874 
     - transactionId
875 
    """
876 
    self.send_getTransactionStatus(transactionId)
877 
    return self.recv_getTransactionStatus()
878 
 
879 
  def send_getTransactionStatus(self, transactionId):
880 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
881 
    args = getTransactionStatus_args()
882 
    args.transactionId = transactionId
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getTransactionStatus(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getTransactionStatus_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
3431 rajveer 897 
    if result.success is not None:
94 ashish 898 
      return result.success
3431 rajveer 899 
    if result.ex is not None:
94 ashish 900 
      raise result.ex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
902 
 
903 
  def changeTransactionStatus(self, transactionId, status, description):
904 
    """
905 
    Parameters:
906 
     - transactionId
907 
     - status
908 
     - description
909 
    """
910 
    self.send_changeTransactionStatus(transactionId, status, description)
911 
    return self.recv_changeTransactionStatus()
912 
 
913 
  def send_changeTransactionStatus(self, transactionId, status, description):
914 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
915 
    args = changeTransactionStatus_args()
916 
    args.transactionId = transactionId
917 
    args.status = status
918 
    args.description = description
919 
    args.write(self._oprot)
920 
    self._oprot.writeMessageEnd()
921 
    self._oprot.trans.flush()
922 
 
923 
  def recv_changeTransactionStatus(self, ):
924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
925 
    if mtype == TMessageType.EXCEPTION:
926 
      x = TApplicationException()
927 
      x.read(self._iprot)
928 
      self._iprot.readMessageEnd()
929 
      raise x
930 
    result = changeTransactionStatus_result()
931 
    result.read(self._iprot)
932 
    self._iprot.readMessageEnd()
3431 rajveer 933 
    if result.success is not None:
94 ashish 934 
      return result.success
3431 rajveer 935 
    if result.ex is not None:
94 ashish 936 
      raise result.ex
937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
938 
 
1398 varun.gupt 939 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 940 
    """
941 
    Parameters:
942 
     - transactionId
943 
    """
1398 varun.gupt 944 
    self.send_enqueueTransactionInfoEmail(transactionId)
945 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 946 
 
1398 varun.gupt 947 
  def send_enqueueTransactionInfoEmail(self, transactionId):
948 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
949 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 950 
    args.transactionId = transactionId
951 
    args.write(self._oprot)
952 
    self._oprot.writeMessageEnd()
953 
    self._oprot.trans.flush()
954 
 
1398 varun.gupt 955 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
957 
    if mtype == TMessageType.EXCEPTION:
958 
      x = TApplicationException()
959 
      x.read(self._iprot)
960 
      self._iprot.readMessageEnd()
961 
      raise x
1398 varun.gupt 962 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 963 
    result.read(self._iprot)
964 
    self._iprot.readMessageEnd()
3431 rajveer 965 
    if result.success is not None:
1382 varun.gupt 966 
      return result.success
3431 rajveer 967 
    if result.ex is not None:
1382 varun.gupt 968 
      raise result.ex
1398 varun.gupt 969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 970 
 
483 rajveer 971 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 972 
    """
973 
    Parameters:
483 rajveer 974 
     - status
975 
     - from_date
976 
     - to_date
977 
     - warehouse_id
94 ashish 978 
    """
483 rajveer 979 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
980 
    return self.recv_getAllOrders()
94 ashish 981 
 
483 rajveer 982 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
983 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
984 
    args = getAllOrders_args()
985 
    args.status = status
986 
    args.from_date = from_date
987 
    args.to_date = to_date
988 
    args.warehouse_id = warehouse_id
94 ashish 989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
483 rajveer 993 
  def recv_getAllOrders(self, ):
94 ashish 994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
483 rajveer 1000 
    result = getAllOrders_result()
94 ashish 1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
3431 rajveer 1003 
    if result.success is not None:
94 ashish 1004 
      return result.success
3431 rajveer 1005 
    if result.ex is not None:
94 ashish 1006 
      raise result.ex
483 rajveer 1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1008 
 
4133 chandransh 1009 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1010 
    """
1011 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1012 
    Pass the status as null and the limit as 0 to ignore them.
1013 
 
1014 
    Parameters:
1015 
     - statuses
1016 
     - offset
1017 
     - limit
1018 
     - warehouse_id
1019 
    """
1020 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1021 
    return self.recv_getOrdersInBatch()
1022 
 
1023 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1024 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1025 
    args = getOrdersInBatch_args()
1026 
    args.statuses = statuses
1027 
    args.offset = offset
1028 
    args.limit = limit
1029 
    args.warehouse_id = warehouse_id
1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
1034 
  def recv_getOrdersInBatch(self, ):
1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
1041 
    result = getOrdersInBatch_result()
1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
1044 
    if result.success is not None:
1045 
      return result.success
1046 
    if result.ex is not None:
1047 
      raise result.ex
1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1049 
 
1050 
  def getOrderCount(self, statuses, warehouseId):
1051 
    """
1052 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1053 
 
1054 
    Parameters:
1055 
     - statuses
1056 
     - warehouseId
1057 
    """
1058 
    self.send_getOrderCount(statuses, warehouseId)
1059 
    return self.recv_getOrderCount()
1060 
 
1061 
  def send_getOrderCount(self, statuses, warehouseId):
1062 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1063 
    args = getOrderCount_args()
1064 
    args.statuses = statuses
1065 
    args.warehouseId = warehouseId
1066 
    args.write(self._oprot)
1067 
    self._oprot.writeMessageEnd()
1068 
    self._oprot.trans.flush()
1069 
 
1070 
  def recv_getOrderCount(self, ):
1071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1072 
    if mtype == TMessageType.EXCEPTION:
1073 
      x = TApplicationException()
1074 
      x.read(self._iprot)
1075 
      self._iprot.readMessageEnd()
1076 
      raise x
1077 
    result = getOrderCount_result()
1078 
    result.read(self._iprot)
1079 
    self._iprot.readMessageEnd()
1080 
    if result.success is not None:
1081 
      return result.success
1082 
    if result.ex is not None:
1083 
      raise result.ex
1084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1085 
 
999 varun.gupt 1086 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1087 
    """
1132 chandransh 1088 
    Returns orders within a range of their billing dates
3431 rajveer 1089 
 
999 varun.gupt 1090 
    Parameters:
1091 
     - status
1092 
     - start_billing_date
1093 
     - end_billing_date
1094 
     - warehouse_id
1095 
    """
1096 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1097 
    return self.recv_getOrdersByBillingDate()
1098 
 
1099 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1100 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1101 
    args = getOrdersByBillingDate_args()
1102 
    args.status = status
1103 
    args.start_billing_date = start_billing_date
1104 
    args.end_billing_date = end_billing_date
1105 
    args.warehouse_id = warehouse_id
1106 
    args.write(self._oprot)
1107 
    self._oprot.writeMessageEnd()
1108 
    self._oprot.trans.flush()
1109 
 
1110 
  def recv_getOrdersByBillingDate(self, ):
1111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1112 
    if mtype == TMessageType.EXCEPTION:
1113 
      x = TApplicationException()
1114 
      x.read(self._iprot)
1115 
      self._iprot.readMessageEnd()
1116 
      raise x
1117 
    result = getOrdersByBillingDate_result()
1118 
    result.read(self._iprot)
1119 
    self._iprot.readMessageEnd()
3431 rajveer 1120 
    if result.success is not None:
999 varun.gupt 1121 
      return result.success
3431 rajveer 1122 
    if result.ex is not None:
999 varun.gupt 1123 
      raise result.ex
1124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1125 
 
3451 chandransh 1126 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1127 
    """
1128 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1129 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1130 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1131 
 
3427 chandransh 1132 
    Parameters:
1133 
     - fromShippingDate
1134 
     - toShippingDate
1135 
     - providerId
1136 
     - warehouseId
3451 chandransh 1137 
     - cod
3427 chandransh 1138 
    """
3451 chandransh 1139 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1140 
    return self.recv_getOrdersByShippingDate()
1141 
 
3451 chandransh 1142 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1143 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1144 
    args = getOrdersByShippingDate_args()
1145 
    args.fromShippingDate = fromShippingDate
1146 
    args.toShippingDate = toShippingDate
1147 
    args.providerId = providerId
1148 
    args.warehouseId = warehouseId
3451 chandransh 1149 
    args.cod = cod
3427 chandransh 1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_getOrdersByShippingDate(self, ):
1155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1156 
    if mtype == TMessageType.EXCEPTION:
1157 
      x = TApplicationException()
1158 
      x.read(self._iprot)
1159 
      self._iprot.readMessageEnd()
1160 
      raise x
1161 
    result = getOrdersByShippingDate_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
3431 rajveer 1164 
    if result.success is not None:
3427 chandransh 1165 
      return result.success
3431 rajveer 1166 
    if result.ex is not None:
3427 chandransh 1167 
      raise result.ex
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1169 
 
1382 varun.gupt 1170 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1171 
    """
1172 
    Returns order ids for orders which can be returned
3431 rajveer 1173 
 
1382 varun.gupt 1174 
    Parameters:
1175 
     - customer_id
1176 
     - limit
1177 
    """
1178 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1179 
    return self.recv_getReturnableOrdersForCustomer()
1180 
 
1181 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1182 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1183 
    args = getReturnableOrdersForCustomer_args()
1184 
    args.customer_id = customer_id
1185 
    args.limit = limit
1186 
    args.write(self._oprot)
1187 
    self._oprot.writeMessageEnd()
1188 
    self._oprot.trans.flush()
1189 
 
1190 
  def recv_getReturnableOrdersForCustomer(self, ):
1191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1192 
    if mtype == TMessageType.EXCEPTION:
1193 
      x = TApplicationException()
1194 
      x.read(self._iprot)
1195 
      self._iprot.readMessageEnd()
1196 
      raise x
1197 
    result = getReturnableOrdersForCustomer_result()
1198 
    result.read(self._iprot)
1199 
    self._iprot.readMessageEnd()
3431 rajveer 1200 
    if result.success is not None:
1382 varun.gupt 1201 
      return result.success
3431 rajveer 1202 
    if result.ex is not None:
1382 varun.gupt 1203 
      raise result.ex
1204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1205 
 
1206 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1207 
    """
1208 
    Returns order ids for orders which can be cancelled
3431 rajveer 1209 
 
1382 varun.gupt 1210 
    Parameters:
1211 
     - customer_id
1212 
     - limit
1213 
    """
1214 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1215 
    return self.recv_getCancellableOrdersForCustomer()
1216 
 
1217 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1218 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1219 
    args = getCancellableOrdersForCustomer_args()
1220 
    args.customer_id = customer_id
1221 
    args.limit = limit
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_getCancellableOrdersForCustomer(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = getCancellableOrdersForCustomer_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
3431 rajveer 1236 
    if result.success is not None:
1382 varun.gupt 1237 
      return result.success
3431 rajveer 1238 
    if result.ex is not None:
1382 varun.gupt 1239 
      raise result.ex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1241 
 
483 rajveer 1242 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1243 
    """
1244 
    Parameters:
483 rajveer 1245 
     - orderId
1246 
     - status
1247 
     - description
94 ashish 1248 
    """
483 rajveer 1249 
    self.send_changeOrderStatus(orderId, status, description)
1250 
    return self.recv_changeOrderStatus()
94 ashish 1251 
 
483 rajveer 1252 
  def send_changeOrderStatus(self, orderId, status, description):
1253 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1254 
    args = changeOrderStatus_args()
1255 
    args.orderId = orderId
1256 
    args.status = status
1257 
    args.description = description
94 ashish 1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
483 rajveer 1262 
  def recv_changeOrderStatus(self, ):
94 ashish 1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
483 rajveer 1269 
    result = changeOrderStatus_result()
94 ashish 1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
3431 rajveer 1272 
    if result.success is not None:
94 ashish 1273 
      return result.success
3431 rajveer 1274 
    if result.ex is not None:
94 ashish 1275 
      raise result.ex
483 rajveer 1276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1277 
 
1528 ankur.sing 1278 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1279 
    """
1528 ankur.sing 1280 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1281 
    only user who owns the transaction can view its order details.
3431 rajveer 1282 
 
94 ashish 1283 
    Parameters:
1284 
     - transactionId
1528 ankur.sing 1285 
     - customerId
94 ashish 1286 
    """
1528 ankur.sing 1287 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1288 
    return self.recv_getOrdersForTransaction()
94 ashish 1289 
 
1528 ankur.sing 1290 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1291 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1292 
    args = getOrdersForTransaction_args()
94 ashish 1293 
    args.transactionId = transactionId
1528 ankur.sing 1294 
    args.customerId = customerId
94 ashish 1295 
    args.write(self._oprot)
1296 
    self._oprot.writeMessageEnd()
1297 
    self._oprot.trans.flush()
1298 
 
483 rajveer 1299 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1301 
    if mtype == TMessageType.EXCEPTION:
1302 
      x = TApplicationException()
1303 
      x.read(self._iprot)
1304 
      self._iprot.readMessageEnd()
1305 
      raise x
483 rajveer 1306 
    result = getOrdersForTransaction_result()
94 ashish 1307 
    result.read(self._iprot)
1308 
    self._iprot.readMessageEnd()
3431 rajveer 1309 
    if result.success is not None:
94 ashish 1310 
      return result.success
3431 rajveer 1311 
    if result.ex is not None:
94 ashish 1312 
      raise result.ex
483 rajveer 1313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1314 
 
3014 chandransh 1315 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1316 
    """
3014 chandransh 1317 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1318 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1319 
 
94 ashish 1320 
    Parameters:
483 rajveer 1321 
     - customerId
1322 
     - from_date
1323 
     - to_date
3014 chandransh 1324 
     - statuses
94 ashish 1325 
    """
3014 chandransh 1326 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1327 
    return self.recv_getOrdersForCustomer()
94 ashish 1328 
 
3014 chandransh 1329 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1330 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1331 
    args = getOrdersForCustomer_args()
1332 
    args.customerId = customerId
1333 
    args.from_date = from_date
1334 
    args.to_date = to_date
3014 chandransh 1335 
    args.statuses = statuses
94 ashish 1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
483 rajveer 1340 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
483 rajveer 1347 
    result = getOrdersForCustomer_result()
94 ashish 1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
3431 rajveer 1350 
    if result.success is not None:
94 ashish 1351 
      return result.success
3431 rajveer 1352 
    if result.ex is not None:
94 ashish 1353 
      raise result.ex
483 rajveer 1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1355 
 
483 rajveer 1356 
  def createOrder(self, order):
94 ashish 1357 
    """
1358 
    Parameters:
483 rajveer 1359 
     - order
94 ashish 1360 
    """
483 rajveer 1361 
    self.send_createOrder(order)
1362 
    return self.recv_createOrder()
94 ashish 1363 
 
483 rajveer 1364 
  def send_createOrder(self, order):
1365 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1366 
    args = createOrder_args()
1367 
    args.order = order
94 ashish 1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
483 rajveer 1372 
  def recv_createOrder(self, ):
94 ashish 1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
483 rajveer 1379 
    result = createOrder_result()
94 ashish 1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
3431 rajveer 1382 
    if result.success is not None:
94 ashish 1383 
      return result.success
3431 rajveer 1384 
    if result.ex is not None:
94 ashish 1385 
      raise result.ex
483 rajveer 1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1387 
 
483 rajveer 1388 
  def getOrder(self, id):
94 ashish 1389 
    """
1390 
    Parameters:
483 rajveer 1391 
     - id
94 ashish 1392 
    """
483 rajveer 1393 
    self.send_getOrder(id)
1394 
    return self.recv_getOrder()
94 ashish 1395 
 
483 rajveer 1396 
  def send_getOrder(self, id):
1397 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1398 
    args = getOrder_args()
1399 
    args.id = id
94 ashish 1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
483 rajveer 1404 
  def recv_getOrder(self, ):
94 ashish 1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
483 rajveer 1411 
    result = getOrder_result()
94 ashish 1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
3431 rajveer 1414 
    if result.success is not None:
94 ashish 1415 
      return result.success
3431 rajveer 1416 
    if result.ex is not None:
94 ashish 1417 
      raise result.ex
483 rajveer 1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1419 
 
483 rajveer 1420 
  def getLineItemsForOrder(self, orderId):
94 ashish 1421 
    """
1422 
    Parameters:
483 rajveer 1423 
     - orderId
94 ashish 1424 
    """
483 rajveer 1425 
    self.send_getLineItemsForOrder(orderId)
1426 
    return self.recv_getLineItemsForOrder()
94 ashish 1427 
 
483 rajveer 1428 
  def send_getLineItemsForOrder(self, orderId):
1429 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1430 
    args = getLineItemsForOrder_args()
1431 
    args.orderId = orderId
94 ashish 1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
483 rajveer 1436 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
483 rajveer 1443 
    result = getLineItemsForOrder_result()
94 ashish 1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
3431 rajveer 1446 
    if result.success is not None:
94 ashish 1447 
      return result.success
3431 rajveer 1448 
    if result.ex is not None:
94 ashish 1449 
      raise result.ex
483 rajveer 1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1451 
 
1528 ankur.sing 1452 
  def getOrderForCustomer(self, orderId, customerId):
1453 
    """
1454 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1455 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1456 
 
1528 ankur.sing 1457 
    Parameters:
1458 
     - orderId
1459 
     - customerId
1460 
    """
1461 
    self.send_getOrderForCustomer(orderId, customerId)
1462 
    return self.recv_getOrderForCustomer()
1463 
 
1464 
  def send_getOrderForCustomer(self, orderId, customerId):
1465 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1466 
    args = getOrderForCustomer_args()
1467 
    args.orderId = orderId
1468 
    args.customerId = customerId
1469 
    args.write(self._oprot)
1470 
    self._oprot.writeMessageEnd()
1471 
    self._oprot.trans.flush()
1472 
 
1473 
  def recv_getOrderForCustomer(self, ):
1474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1475 
    if mtype == TMessageType.EXCEPTION:
1476 
      x = TApplicationException()
1477 
      x.read(self._iprot)
1478 
      self._iprot.readMessageEnd()
1479 
      raise x
1480 
    result = getOrderForCustomer_result()
1481 
    result.read(self._iprot)
1482 
    self._iprot.readMessageEnd()
3431 rajveer 1483 
    if result.success is not None:
1528 ankur.sing 1484 
      return result.success
3431 rajveer 1485 
    if result.ex is not None:
1528 ankur.sing 1486 
      raise result.ex
1487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1488 
 
3064 chandransh 1489 
  def getAlerts(self, orderId, valid):
1490 
    """
1491 
    Parameters:
1492 
     - orderId
1493 
     - valid
1494 
    """
1495 
    self.send_getAlerts(orderId, valid)
1496 
    return self.recv_getAlerts()
1497 
 
1498 
  def send_getAlerts(self, orderId, valid):
1499 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1500 
    args = getAlerts_args()
1501 
    args.orderId = orderId
1502 
    args.valid = valid
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_getAlerts(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = getAlerts_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
3431 rajveer 1517 
    if result.success is not None:
3064 chandransh 1518 
      return result.success
1519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1520 
 
1521 
  def setAlert(self, orderId, unset, type, comment):
1522 
    """
1523 
    Parameters:
1524 
     - orderId
1525 
     - unset
1526 
     - type
1527 
     - comment
1528 
    """
1529 
    self.send_setAlert(orderId, unset, type, comment)
1530 
    self.recv_setAlert()
1531 
 
1532 
  def send_setAlert(self, orderId, unset, type, comment):
1533 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1534 
    args = setAlert_args()
1535 
    args.orderId = orderId
1536 
    args.unset = unset
1537 
    args.type = type
1538 
    args.comment = comment
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_setAlert(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = setAlert_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    return
1554 
 
1555 
  def getValidOrderCount(self, ):
1556 
    """
1557 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1558 
    """
1559 
    self.send_getValidOrderCount()
1560 
    return self.recv_getValidOrderCount()
1561 
 
1562 
  def send_getValidOrderCount(self, ):
1563 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1564 
    args = getValidOrderCount_args()
1565 
    args.write(self._oprot)
1566 
    self._oprot.writeMessageEnd()
1567 
    self._oprot.trans.flush()
1568 
 
1569 
  def recv_getValidOrderCount(self, ):
1570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1571 
    if mtype == TMessageType.EXCEPTION:
1572 
      x = TApplicationException()
1573 
      x.read(self._iprot)
1574 
      self._iprot.readMessageEnd()
1575 
      raise x
1576 
    result = getValidOrderCount_result()
1577 
    result.read(self._iprot)
1578 
    self._iprot.readMessageEnd()
3431 rajveer 1579 
    if result.success is not None:
3064 chandransh 1580 
      return result.success
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1582 
 
1583 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1584 
    """
1585 
    Returns the number of distinct customers who have done successful transactions
1586 
    """
1587 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1588 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1589 
 
1590 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1591 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1592 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1593 
    args.write(self._oprot)
1594 
    self._oprot.writeMessageEnd()
1595 
    self._oprot.trans.flush()
1596 
 
1597 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1599 
    if mtype == TMessageType.EXCEPTION:
1600 
      x = TApplicationException()
1601 
      x.read(self._iprot)
1602 
      self._iprot.readMessageEnd()
1603 
      raise x
1604 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1605 
    result.read(self._iprot)
1606 
    self._iprot.readMessageEnd()
3431 rajveer 1607 
    if result.success is not None:
3064 chandransh 1608 
      return result.success
1609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1610 
 
1611 
  def getValidOrdersAmountRange(self, ):
1612 
    """
1613 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1614 
    List contains two values, first minimum amount and second maximum amount.
1615 
    """
1616 
    self.send_getValidOrdersAmountRange()
1617 
    return self.recv_getValidOrdersAmountRange()
1618 
 
1619 
  def send_getValidOrdersAmountRange(self, ):
1620 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1621 
    args = getValidOrdersAmountRange_args()
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getValidOrdersAmountRange(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getValidOrdersAmountRange_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
3431 rajveer 1636 
    if result.success is not None:
3064 chandransh 1637 
      return result.success
1638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1639 
 
1640 
  def getValidOrders(self, limit):
1641 
    """
1642 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1643 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1644 
 
3064 chandransh 1645 
    Parameters:
1646 
     - limit
1647 
    """
1648 
    self.send_getValidOrders(limit)
1649 
    return self.recv_getValidOrders()
1650 
 
1651 
  def send_getValidOrders(self, limit):
1652 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1653 
    args = getValidOrders_args()
1654 
    args.limit = limit
1655 
    args.write(self._oprot)
1656 
    self._oprot.writeMessageEnd()
1657 
    self._oprot.trans.flush()
1658 
 
1659 
  def recv_getValidOrders(self, ):
1660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1661 
    if mtype == TMessageType.EXCEPTION:
1662 
      x = TApplicationException()
1663 
      x.read(self._iprot)
1664 
      self._iprot.readMessageEnd()
1665 
      raise x
1666 
    result = getValidOrders_result()
1667 
    result.read(self._iprot)
1668 
    self._iprot.readMessageEnd()
3431 rajveer 1669 
    if result.success is not None:
3064 chandransh 1670 
      return result.success
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1672 
 
1220 chandransh 1673 
  def batchOrders(self, warehouseId):
1674 
    """
1675 
    Create a batch of all the pending orders for the given warehouse.
1676 
    The returned list is orderd by created_timestamp.
1677 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1678 
 
1220 chandransh 1679 
    Parameters:
1680 
     - warehouseId
1681 
    """
1682 
    self.send_batchOrders(warehouseId)
1683 
    return self.recv_batchOrders()
1684 
 
1685 
  def send_batchOrders(self, warehouseId):
1686 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1687 
    args = batchOrders_args()
1688 
    args.warehouseId = warehouseId
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_batchOrders(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = batchOrders_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
3431 rajveer 1703 
    if result.success is not None:
1220 chandransh 1704 
      return result.success
3431 rajveer 1705 
    if result.ex is not None:
1220 chandransh 1706 
      raise result.ex
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1708 
 
1208 chandransh 1709 
  def markOrderAsOutOfStock(self, orderId):
1710 
    """
1711 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1712 
 
1208 chandransh 1713 
    Parameters:
1714 
     - orderId
1715 
    """
1716 
    self.send_markOrderAsOutOfStock(orderId)
1717 
    return self.recv_markOrderAsOutOfStock()
1718 
 
1719 
  def send_markOrderAsOutOfStock(self, orderId):
1720 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1721 
    args = markOrderAsOutOfStock_args()
1722 
    args.orderId = orderId
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_markOrderAsOutOfStock(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = markOrderAsOutOfStock_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
3431 rajveer 1737 
    if result.success is not None:
1208 chandransh 1738 
      return result.success
3431 rajveer 1739 
    if result.ex is not None:
1208 chandransh 1740 
      raise result.ex
1741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1742 
 
3064 chandransh 1743 
  def verifyOrder(self, orderId):
759 chandransh 1744 
    """
3064 chandransh 1745 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1746 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1747 
    used for all other orders as well.
1748 
    Throws an exception if no such order exists.
3431 rajveer 1749 
 
759 chandransh 1750 
    Parameters:
3064 chandransh 1751 
     - orderId
759 chandransh 1752 
    """
3064 chandransh 1753 
    self.send_verifyOrder(orderId)
1754 
    return self.recv_verifyOrder()
759 chandransh 1755 
 
3064 chandransh 1756 
  def send_verifyOrder(self, orderId):
1757 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1758 
    args = verifyOrder_args()
1759 
    args.orderId = orderId
759 chandransh 1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
3064 chandransh 1764 
  def recv_verifyOrder(self, ):
759 chandransh 1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
3064 chandransh 1771 
    result = verifyOrder_result()
759 chandransh 1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
3431 rajveer 1774 
    if result.success is not None:
759 chandransh 1775 
      return result.success
3431 rajveer 1776 
    if result.ex is not None:
759 chandransh 1777 
      raise result.ex
3064 chandransh 1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1779 
 
3064 chandransh 1780 
  def acceptOrder(self, orderId):
1113 chandransh 1781 
    """
3064 chandransh 1782 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1783 
    given order is not a COD order, it also captures the payment if the same has
1784 
    not been captured.
1785 
    Throws an exception if no such order exists.
3431 rajveer 1786 
 
1113 chandransh 1787 
    Parameters:
3064 chandransh 1788 
     - orderId
1113 chandransh 1789 
    """
3064 chandransh 1790 
    self.send_acceptOrder(orderId)
1791 
    return self.recv_acceptOrder()
1113 chandransh 1792 
 
3064 chandransh 1793 
  def send_acceptOrder(self, orderId):
1794 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1795 
    args = acceptOrder_args()
1796 
    args.orderId = orderId
1113 chandransh 1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
3064 chandransh 1801 
  def recv_acceptOrder(self, ):
1113 chandransh 1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
3064 chandransh 1808 
    result = acceptOrder_result()
1113 chandransh 1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
3431 rajveer 1811 
    if result.success is not None:
1113 chandransh 1812 
      return result.success
3431 rajveer 1813 
    if result.ex is not None:
1113 chandransh 1814 
      raise result.ex
3064 chandransh 1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1816 
 
4283 anupam.sin 1817 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1818 
    """
3064 chandransh 1819 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1820 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1821 
    the IMEI no. if a -1 is supplied.
1822 
    Also, it generates an invoice number for the order, marks the order as
1823 
    BILLED and sets the billing timestamp.
1824 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1825 
 
1135 chandransh 1826 
    Parameters:
3064 chandransh 1827 
     - orderId
1828 
     - invoice_number
4283 anupam.sin 1829 
     - imeiNumber
1830 
     - itemNumber
3064 chandransh 1831 
     - billed_by
4264 rajveer 1832 
     - jacketNumber
4283 anupam.sin 1833 
     - billingType
1834 
     - vendorId
1135 chandransh 1835 
    """
4283 anupam.sin 1836 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1837 
    return self.recv_addBillingDetails()
1135 chandransh 1838 
 
4283 anupam.sin 1839 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1840 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1841 
    args = addBillingDetails_args()
1842 
    args.orderId = orderId
1843 
    args.invoice_number = invoice_number
4283 anupam.sin 1844 
    args.imeiNumber = imeiNumber
1845 
    args.itemNumber = itemNumber
3064 chandransh 1846 
    args.billed_by = billed_by
4264 rajveer 1847 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1848 
    args.billingType = billingType
1849 
    args.vendorId = vendorId
1135 chandransh 1850 
    args.write(self._oprot)
1851 
    self._oprot.writeMessageEnd()
1852 
    self._oprot.trans.flush()
1853 
 
3064 chandransh 1854 
  def recv_addBillingDetails(self, ):
1135 chandransh 1855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1856 
    if mtype == TMessageType.EXCEPTION:
1857 
      x = TApplicationException()
1858 
      x.read(self._iprot)
1859 
      self._iprot.readMessageEnd()
1860 
      raise x
3064 chandransh 1861 
    result = addBillingDetails_result()
1135 chandransh 1862 
    result.read(self._iprot)
1863 
    self._iprot.readMessageEnd()
3431 rajveer 1864 
    if result.success is not None:
3064 chandransh 1865 
      return result.success
3431 rajveer 1866 
    if result.ex is not None:
1135 chandransh 1867 
      raise result.ex
3064 chandransh 1868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1869 
 
3064 chandransh 1870 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1871 
    """
3064 chandransh 1872 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
1873 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 1874 
 
1408 ankur.sing 1875 
    Parameters:
3064 chandransh 1876 
     - warehouseId
1408 ankur.sing 1877 
     - providerId
3064 chandransh 1878 
     - cod
1408 ankur.sing 1879 
    """
3064 chandransh 1880 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1881 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1882 
 
3064 chandransh 1883 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1884 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1885 
    args = markOrdersAsManifested_args()
1886 
    args.warehouseId = warehouseId
1408 ankur.sing 1887 
    args.providerId = providerId
3064 chandransh 1888 
    args.cod = cod
1408 ankur.sing 1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
3064 chandransh 1893 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
3064 chandransh 1900 
    result = markOrdersAsManifested_result()
1408 ankur.sing 1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
3431 rajveer 1903 
    if result.success is not None:
1408 ankur.sing 1904 
      return result.success
3431 rajveer 1905 
    if result.ex is not None:
3064 chandransh 1906 
      raise result.ex
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 1908 
 
3064 chandransh 1909 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 1910 
    """
3064 chandransh 1911 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1912 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1913 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1914 
 
94 ashish 1915 
    Parameters:
3064 chandransh 1916 
     - providerId
1917 
     - pickupDetails
304 ashish 1918 
    """
3064 chandransh 1919 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1920 
    return self.recv_markOrdersAsPickedUp()
94 ashish 1921 
 
3064 chandransh 1922 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1923 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1924 
    args = markOrdersAsPickedUp_args()
1925 
    args.providerId = providerId
1926 
    args.pickupDetails = pickupDetails
304 ashish 1927 
    args.write(self._oprot)
1928 
    self._oprot.writeMessageEnd()
1929 
    self._oprot.trans.flush()
1930 
 
3064 chandransh 1931 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 1932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1933 
    if mtype == TMessageType.EXCEPTION:
1934 
      x = TApplicationException()
1935 
      x.read(self._iprot)
1936 
      self._iprot.readMessageEnd()
1937 
      raise x
3064 chandransh 1938 
    result = markOrdersAsPickedUp_result()
304 ashish 1939 
    result.read(self._iprot)
1940 
    self._iprot.readMessageEnd()
3431 rajveer 1941 
    if result.success is not None:
304 ashish 1942 
      return result.success
3431 rajveer 1943 
    if result.ex is not None:
3064 chandransh 1944 
      raise result.ex
1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 1946 
 
3064 chandransh 1947 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 1948 
    """
3064 chandransh 1949 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1950 
    the name of the receiver.
1951 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1952 
 
304 ashish 1953 
    Parameters:
3064 chandransh 1954 
     - providerId
1955 
     - deliveredOrders
304 ashish 1956 
    """
3064 chandransh 1957 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1958 
    self.recv_markOrdersAsDelivered()
304 ashish 1959 
 
3064 chandransh 1960 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1961 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1962 
    args = markOrdersAsDelivered_args()
1963 
    args.providerId = providerId
1964 
    args.deliveredOrders = deliveredOrders
304 ashish 1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
3064 chandransh 1969 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
3064 chandransh 1976 
    result = markOrdersAsDelivered_result()
304 ashish 1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
3431 rajveer 1979 
    if result.ex is not None:
3064 chandransh 1980 
      raise result.ex
304 ashish 1981 
    return
1982 
 
3064 chandransh 1983 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 1984 
    """
3064 chandransh 1985 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1986 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 1987 
 
3064 chandransh 1988 
    Parameters:
1989 
     - providerId
1990 
     - returnedOrders
1596 ankur.sing 1991 
    """
3064 chandransh 1992 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1993 
    self.recv_markOrdersAsFailed()
304 ashish 1994 
 
3064 chandransh 1995 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1996 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1997 
    args = markOrdersAsFailed_args()
1998 
    args.providerId = providerId
1999 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
3064 chandransh 2004 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
3064 chandransh 2011 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
3431 rajveer 2014 
    if result.ex is not None:
3064 chandransh 2015 
      raise result.ex
2016 
    return
1596 ankur.sing 2017 
 
3064 chandransh 2018 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2019 
    """
3064 chandransh 2020 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2021 
 
3064 chandransh 2022 
    Parameters:
2023 
     - providerId
2024 
     - undeliveredOrders
1627 ankur.sing 2025 
    """
3064 chandransh 2026 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2027 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2028 
 
3064 chandransh 2029 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2030 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2031 
    args = updateNonDeliveryReason_args()
2032 
    args.providerId = providerId
2033 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
3064 chandransh 2038 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
3064 chandransh 2045 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
3431 rajveer 2048 
    if result.ex is not None:
3064 chandransh 2049 
      raise result.ex
2050 
    return
1627 ankur.sing 2051 
 
3064 chandransh 2052 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2053 
    """
3064 chandransh 2054 
    Returns the list of orders whose delivery time has passed but have not been
2055 
    delivered yet for the given provider and warehouse. To get a complete list of
2056 
    undelivered orders, pass them as -1.
2057 
    Returns an empty list if no such orders exist.
3431 rajveer 2058 
 
1886 ankur.sing 2059 
    Parameters:
3064 chandransh 2060 
     - providerId
2061 
     - warehouseId
1886 ankur.sing 2062 
    """
3064 chandransh 2063 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2064 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2065 
 
3064 chandransh 2066 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2067 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2068 
    args = getUndeliveredOrders_args()
2069 
    args.providerId = providerId
2070 
    args.warehouseId = warehouseId
1886 ankur.sing 2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
3064 chandransh 2075 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
3064 chandransh 2082 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.success is not None:
1886 ankur.sing 2086 
      return result.success
3064 chandransh 2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2088 
 
2536 chandransh 2089 
  def toggleDOAFlag(self, orderId):
2090 
    """
2091 
    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.
2092 
    Returns the final flag status.
2093 
    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 2094 
 
2536 chandransh 2095 
    Parameters:
2096 
     - orderId
2097 
    """
2098 
    self.send_toggleDOAFlag(orderId)
2099 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2100 
 
2536 chandransh 2101 
  def send_toggleDOAFlag(self, orderId):
2102 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2103 
    args = toggleDOAFlag_args()
2104 
    args.orderId = orderId
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_toggleDOAFlag(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = toggleDOAFlag_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
3431 rajveer 2119 
    if result.success is not None:
2536 chandransh 2120 
      return result.success
3431 rajveer 2121 
    if result.ex is not None:
2536 chandransh 2122 
      raise result.ex
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2124 
 
2125 
  def requestPickupNumber(self, orderId):
2126 
    """
2127 
    Sends out an email to the account manager of the original courier provider used to ship the order.
2128 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
2129 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
2130 
    For any other status, it returns false.
2131 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2132 
 
2536 chandransh 2133 
    Parameters:
2134 
     - orderId
2135 
    """
2136 
    self.send_requestPickupNumber(orderId)
2137 
    return self.recv_requestPickupNumber()
2138 
 
2139 
  def send_requestPickupNumber(self, orderId):
2140 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2141 
    args = requestPickupNumber_args()
2142 
    args.orderId = orderId
2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
2147 
  def recv_requestPickupNumber(self, ):
2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
2154 
    result = requestPickupNumber_result()
2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
3431 rajveer 2157 
    if result.success is not None:
2536 chandransh 2158 
      return result.success
3431 rajveer 2159 
    if result.ex is not None:
2536 chandransh 2160 
      raise result.ex
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2162 
 
2163 
  def authorizePickup(self, orderId, pickupNumber):
2164 
    """
2165 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
2166 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2167 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2168 
    	3. Returns true
2591 chandransh 2169 
    If the order is in any other status, it returns false.
2536 chandransh 2170 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2171 
 
2536 chandransh 2172 
    Parameters:
2173 
     - orderId
2174 
     - pickupNumber
2175 
    """
2176 
    self.send_authorizePickup(orderId, pickupNumber)
2177 
    return self.recv_authorizePickup()
2178 
 
2179 
  def send_authorizePickup(self, orderId, pickupNumber):
2180 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2181 
    args = authorizePickup_args()
2182 
    args.orderId = orderId
2183 
    args.pickupNumber = pickupNumber
2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
2188 
  def recv_authorizePickup(self, ):
2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
2195 
    result = authorizePickup_result()
2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
3431 rajveer 2198 
    if result.success is not None:
2536 chandransh 2199 
      return result.success
3431 rajveer 2200 
    if result.ex is not None:
2536 chandransh 2201 
      raise result.ex
2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2203 
 
2764 chandransh 2204 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2205 
    """
2206 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2207 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2208 
 
2764 chandransh 2209 
    Parameters:
2210 
     - providerId
2211 
     - pickupDetails
2212 
    """
2213 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2214 
    return self.recv_markDoasAsPickedUp()
2215 
 
2216 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2217 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2218 
    args = markDoasAsPickedUp_args()
2219 
    args.providerId = providerId
2220 
    args.pickupDetails = pickupDetails
2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
2225 
  def recv_markDoasAsPickedUp(self, ):
2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
2232 
    result = markDoasAsPickedUp_result()
2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
3431 rajveer 2235 
    if result.success is not None:
2764 chandransh 2236 
      return result.success
2237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2238 
 
2616 chandransh 2239 
  def receiveReturn(self, orderId):
2591 chandransh 2240 
    """
2599 chandransh 2241 
    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 2242 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2243 
    If the order is in any other state, it returns false.
2244 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2245 
 
2591 chandransh 2246 
    Parameters:
2247 
     - orderId
2248 
    """
2616 chandransh 2249 
    self.send_receiveReturn(orderId)
2250 
    return self.recv_receiveReturn()
2536 chandransh 2251 
 
2616 chandransh 2252 
  def send_receiveReturn(self, orderId):
2253 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2254 
    args = receiveReturn_args()
2591 chandransh 2255 
    args.orderId = orderId
2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
2616 chandransh 2260 
  def recv_receiveReturn(self, ):
2591 chandransh 2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
2616 chandransh 2267 
    result = receiveReturn_result()
2591 chandransh 2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
2591 chandransh 2271 
      return result.success
3431 rajveer 2272 
    if result.ex is not None:
2591 chandransh 2273 
      raise result.ex
2616 chandransh 2274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2275 
 
2276 
  def validateDoa(self, orderId, isValid):
2277 
    """
2599 chandransh 2278 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 2279 
    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 2280 
    If the order is in any other state, it returns false.
2281 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2282 
 
2591 chandransh 2283 
    Parameters:
2284 
     - orderId
2285 
     - isValid
2286 
    """
2287 
    self.send_validateDoa(orderId, isValid)
2288 
    return self.recv_validateDoa()
2289 
 
2290 
  def send_validateDoa(self, orderId, isValid):
2291 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2292 
    args = validateDoa_args()
2293 
    args.orderId = orderId
2294 
    args.isValid = isValid
2295 
    args.write(self._oprot)
2296 
    self._oprot.writeMessageEnd()
2297 
    self._oprot.trans.flush()
2298 
 
2299 
  def recv_validateDoa(self, ):
2300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2301 
    if mtype == TMessageType.EXCEPTION:
2302 
      x = TApplicationException()
2303 
      x.read(self._iprot)
2304 
      self._iprot.readMessageEnd()
2305 
      raise x
2306 
    result = validateDoa_result()
2307 
    result.read(self._iprot)
2308 
    self._iprot.readMessageEnd()
3431 rajveer 2309 
    if result.success is not None:
2591 chandransh 2310 
      return result.success
3431 rajveer 2311 
    if result.ex is not None:
2591 chandransh 2312 
      raise result.ex
2313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2314 
 
2616 chandransh 2315 
  def reshipOrder(self, orderId):
2316 
    """
2317 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2318 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2319 
    	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.
2320 
 
2321 
    If the order is in DOA_CERT_VALID state, it does the following:
2322 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2323 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2324 
    	3. Marks the current order as the final DOA_RESHIPPED state.
3431 rajveer 2325 
 
2616 chandransh 2326 
    Returns the id of the newly created order.
3431 rajveer 2327 
 
2616 chandransh 2328 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2329 
 
2616 chandransh 2330 
    Parameters:
2331 
     - orderId
2332 
    """
2333 
    self.send_reshipOrder(orderId)
2334 
    return self.recv_reshipOrder()
2591 chandransh 2335 
 
2616 chandransh 2336 
  def send_reshipOrder(self, orderId):
2337 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2338 
    args = reshipOrder_args()
2339 
    args.orderId = orderId
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_reshipOrder(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = reshipOrder_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
3431 rajveer 2354 
    if result.success is not None:
2616 chandransh 2355 
      return result.success
3431 rajveer 2356 
    if result.ex is not None:
2616 chandransh 2357 
      raise result.ex
2358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2359 
 
3226 chandransh 2360 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2361 
    """
2362 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2363 
    	1. Creates a refund request for batch processing.
2364 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2365 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2366 
 
2616 chandransh 2367 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2368 
    	1. Creates a refund request for batch processing.
3226 chandransh 2369 
    	2. Cancels the reservation of the item in the warehouse.
2370 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2371 
 
3226 chandransh 2372 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2373 
    	1. Cancels the reservation of the item in the warehouse.
2374 
    	2. Marks the current order as CANCELED.
2375 
 
2376 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2377 
 
2616 chandransh 2378 
    Returns True if it is successful, False otherwise.
3431 rajveer 2379 
 
2616 chandransh 2380 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2381 
 
2616 chandransh 2382 
    Parameters:
2383 
     - orderId
3226 chandransh 2384 
     - refundedBy
2385 
     - reason
2616 chandransh 2386 
    """
3226 chandransh 2387 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2388 
    return self.recv_refundOrder()
2389 
 
3226 chandransh 2390 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2391 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2392 
    args = refundOrder_args()
2393 
    args.orderId = orderId
3226 chandransh 2394 
    args.refundedBy = refundedBy
2395 
    args.reason = reason
2616 chandransh 2396 
    args.write(self._oprot)
2397 
    self._oprot.writeMessageEnd()
2398 
    self._oprot.trans.flush()
2399 
 
2400 
  def recv_refundOrder(self, ):
2401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2402 
    if mtype == TMessageType.EXCEPTION:
2403 
      x = TApplicationException()
2404 
      x.read(self._iprot)
2405 
      self._iprot.readMessageEnd()
2406 
      raise x
2407 
    result = refundOrder_result()
2408 
    result.read(self._iprot)
2409 
    self._iprot.readMessageEnd()
3431 rajveer 2410 
    if result.success is not None:
2616 chandransh 2411 
      return result.success
3431 rajveer 2412 
    if result.ex is not None:
2616 chandransh 2413 
      raise result.ex
2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2415 
 
2690 chandransh 2416 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2417 
    """
2418 
    Get all return orders created between the from and to dates for the given warehouse.
2419 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2420 
 
2690 chandransh 2421 
    Parameters:
2422 
     - warehouseId
2423 
     - fromDate
2424 
     - toDate
2425 
    """
2426 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2427 
    return self.recv_getReturnOrders()
2616 chandransh 2428 
 
2690 chandransh 2429 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2430 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2431 
    args = getReturnOrders_args()
2432 
    args.warehouseId = warehouseId
2433 
    args.fromDate = fromDate
2434 
    args.toDate = toDate
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_getReturnOrders(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = getReturnOrders_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
3431 rajveer 2449 
    if result.success is not None:
2690 chandransh 2450 
      return result.success
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2452 
 
2700 chandransh 2453 
  def getReturnOrder(self, id):
2454 
    """
2455 
    Returns the ReturnOrder corresponding to the given id.
2456 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2457 
 
2700 chandransh 2458 
    Parameters:
2459 
     - id
2460 
    """
2461 
    self.send_getReturnOrder(id)
2462 
    return self.recv_getReturnOrder()
2463 
 
2464 
  def send_getReturnOrder(self, id):
2465 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2466 
    args = getReturnOrder_args()
2467 
    args.id = id
2468 
    args.write(self._oprot)
2469 
    self._oprot.writeMessageEnd()
2470 
    self._oprot.trans.flush()
2471 
 
2472 
  def recv_getReturnOrder(self, ):
2473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2474 
    if mtype == TMessageType.EXCEPTION:
2475 
      x = TApplicationException()
2476 
      x.read(self._iprot)
2477 
      self._iprot.readMessageEnd()
2478 
      raise x
2479 
    result = getReturnOrder_result()
2480 
    result.read(self._iprot)
2481 
    self._iprot.readMessageEnd()
3431 rajveer 2482 
    if result.success is not None:
2700 chandransh 2483 
      return result.success
3431 rajveer 2484 
    if result.ex is not None:
2700 chandransh 2485 
      raise result.ex
2486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2487 
 
2690 chandransh 2488 
  def processReturn(self, returnOrderId):
2489 
    """
2490 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2491 
 
2690 chandransh 2492 
    Parameters:
2493 
     - returnOrderId
2494 
    """
2495 
    self.send_processReturn(returnOrderId)
2496 
    self.recv_processReturn()
2497 
 
2498 
  def send_processReturn(self, returnOrderId):
2499 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2500 
    args = processReturn_args()
2501 
    args.returnOrderId = returnOrderId
2502 
    args.write(self._oprot)
2503 
    self._oprot.writeMessageEnd()
2504 
    self._oprot.trans.flush()
2505 
 
2506 
  def recv_processReturn(self, ):
2507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2508 
    if mtype == TMessageType.EXCEPTION:
2509 
      x = TApplicationException()
2510 
      x.read(self._iprot)
2511 
      self._iprot.readMessageEnd()
2512 
      raise x
2513 
    result = processReturn_result()
2514 
    result.read(self._iprot)
2515 
    self._iprot.readMessageEnd()
3431 rajveer 2516 
    if result.ex is not None:
2690 chandransh 2517 
      raise result.ex
2518 
    return
2519 
 
2819 chandransh 2520 
  def createPurchaseOrder(self, warehouseId):
2521 
    """
2522 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2523 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2524 
 
2819 chandransh 2525 
    Parameters:
2526 
     - warehouseId
2527 
    """
2528 
    self.send_createPurchaseOrder(warehouseId)
2529 
    return self.recv_createPurchaseOrder()
2690 chandransh 2530 
 
2819 chandransh 2531 
  def send_createPurchaseOrder(self, warehouseId):
2532 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2533 
    args = createPurchaseOrder_args()
2534 
    args.warehouseId = warehouseId
2535 
    args.write(self._oprot)
2536 
    self._oprot.writeMessageEnd()
2537 
    self._oprot.trans.flush()
2538 
 
2539 
  def recv_createPurchaseOrder(self, ):
2540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2541 
    if mtype == TMessageType.EXCEPTION:
2542 
      x = TApplicationException()
2543 
      x.read(self._iprot)
2544 
      self._iprot.readMessageEnd()
2545 
      raise x
2546 
    result = createPurchaseOrder_result()
2547 
    result.read(self._iprot)
2548 
    self._iprot.readMessageEnd()
3431 rajveer 2549 
    if result.success is not None:
2819 chandransh 2550 
      return result.success
3431 rajveer 2551 
    if result.ex is not None:
2819 chandransh 2552 
      raise result.ex
2553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2554 
 
3451 chandransh 2555 
  def updateWeight(self, orderId, weight):
2556 
    """
2557 
    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 2558 
 
3451 chandransh 2559 
    Parameters:
2560 
     - orderId
2561 
     - weight
2562 
    """
2563 
    self.send_updateWeight(orderId, weight)
2564 
    return self.recv_updateWeight()
2565 
 
2566 
  def send_updateWeight(self, orderId, weight):
2567 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2568 
    args = updateWeight_args()
2569 
    args.orderId = orderId
2570 
    args.weight = weight
2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2575 
  def recv_updateWeight(self, ):
2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2582 
    result = updateWeight_result()
2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
2585 
    if result.success is not None:
2586 
      return result.success
2587 
    if result.ex is not None:
2588 
      raise result.ex
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2590 
 
3469 chandransh 2591 
  def changeItem(self, orderId, itemId):
2592 
    """
2593 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2594 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2595 
 
3469 chandransh 2596 
    Parameters:
2597 
     - orderId
2598 
     - itemId
2599 
    """
2600 
    self.send_changeItem(orderId, itemId)
2601 
    return self.recv_changeItem()
2602 
 
2603 
  def send_changeItem(self, orderId, itemId):
2604 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2605 
    args = changeItem_args()
2606 
    args.orderId = orderId
2607 
    args.itemId = itemId
2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
2612 
  def recv_changeItem(self, ):
2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
2619 
    result = changeItem_result()
2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
2622 
    if result.success is not None:
2623 
      return result.success
2624 
    if result.ex is not None:
2625 
      raise result.ex
2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2627 
 
2628 
  def shiftToWarehouse(self, orderId, warehouseId):
2629 
    """
2630 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2631 
 
2632 
    Parameters:
2633 
     - orderId
2634 
     - warehouseId
2635 
    """
2636 
    self.send_shiftToWarehouse(orderId, warehouseId)
2637 
    return self.recv_shiftToWarehouse()
2638 
 
2639 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2640 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2641 
    args = shiftToWarehouse_args()
2642 
    args.orderId = orderId
2643 
    args.warehouseId = warehouseId
2644 
    args.write(self._oprot)
2645 
    self._oprot.writeMessageEnd()
2646 
    self._oprot.trans.flush()
2647 
 
2648 
  def recv_shiftToWarehouse(self, ):
2649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2650 
    if mtype == TMessageType.EXCEPTION:
2651 
      x = TApplicationException()
2652 
      x.read(self._iprot)
2653 
      self._iprot.readMessageEnd()
2654 
      raise x
2655 
    result = shiftToWarehouse_result()
2656 
    result.read(self._iprot)
2657 
    self._iprot.readMessageEnd()
2658 
    if result.success is not None:
2659 
      return result.success
2660 
    if result.ex is not None:
2661 
      raise result.ex
2662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2663 
 
3986 chandransh 2664 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2665 
    """
2666 
    Adds the given delay reason to the given order.
3986 chandransh 2667 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2668 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2669 
 
3553 chandransh 2670 
    Parameters:
2671 
     - orderId
2672 
     - delayReason
3986 chandransh 2673 
     - furtherDelay
3553 chandransh 2674 
    """
3986 chandransh 2675 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2676 
    return self.recv_addDelayReason()
2677 
 
3986 chandransh 2678 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2679 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2680 
    args = addDelayReason_args()
2681 
    args.orderId = orderId
2682 
    args.delayReason = delayReason
3986 chandransh 2683 
    args.furtherDelay = furtherDelay
3553 chandransh 2684 
    args.write(self._oprot)
2685 
    self._oprot.writeMessageEnd()
2686 
    self._oprot.trans.flush()
2687 
 
2688 
  def recv_addDelayReason(self, ):
2689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2690 
    if mtype == TMessageType.EXCEPTION:
2691 
      x = TApplicationException()
2692 
      x.read(self._iprot)
2693 
      self._iprot.readMessageEnd()
2694 
      raise x
2695 
    result = addDelayReason_result()
2696 
    result.read(self._iprot)
2697 
    self._iprot.readMessageEnd()
2698 
    if result.success is not None:
2699 
      return result.success
2700 
    if result.ex is not None:
2701 
      raise result.ex
2702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2703 
 
3956 chandransh 2704 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2705 
    """
2706 
    Marks the COD orders with given AWB nos. as having been processed.
2707 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2708 
 
3956 chandransh 2709 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2710 
    1. There is no order corresponding to an AWB number.
2711 
    2. The captured amount for a payment exceeds the total payment.
2712 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2713 
 
2714 
    Parameters:
2715 
     - collectedAmountMap
2716 
     - xferBy
2717 
     - xferTxnId
2718 
     - xferDate
2719 
    """
2720 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2721 
    return self.recv_reconcileCodCollection()
2722 
 
2723 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2724 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2725 
    args = reconcileCodCollection_args()
2726 
    args.collectedAmountMap = collectedAmountMap
2727 
    args.xferBy = xferBy
2728 
    args.xferTxnId = xferTxnId
2729 
    args.xferDate = xferDate
2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
2734 
  def recv_reconcileCodCollection(self, ):
2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
2741 
    result = reconcileCodCollection_result()
2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
2744 
    if result.success is not None:
2745 
      return result.success
2746 
    if result.ex is not None:
2747 
      raise result.ex
2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2749 
 
4008 mandeep.dh 2750 
  def getTransactionsRequiringExtraProcessing(self, category):
2751 
    """
4065 mandeep.dh 2752 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2753 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2754 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2755 
 
4008 mandeep.dh 2756 
    Parameters:
2757 
     - category
2758 
    """
2759 
    self.send_getTransactionsRequiringExtraProcessing(category)
2760 
    return self.recv_getTransactionsRequiringExtraProcessing()
2761 
 
2762 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2763 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2764 
    args = getTransactionsRequiringExtraProcessing_args()
2765 
    args.category = category
2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
2770 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
2777 
    result = getTransactionsRequiringExtraProcessing_result()
2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
2780 
    if result.success is not None:
2781 
      return result.success
2782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2783 
 
2784 
  def markTransactionAsProcessed(self, transactionId, category):
2785 
    """
2786 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2787 
    It essentially deletes the transaction id record for a particular
2788 
    processing type category (if present) from DB.
2789 
    This is currently used by CRM application.
4008 mandeep.dh 2790 
 
2791 
    Parameters:
2792 
     - transactionId
2793 
     - category
2794 
    """
2795 
    self.send_markTransactionAsProcessed(transactionId, category)
2796 
    self.recv_markTransactionAsProcessed()
2797 
 
2798 
  def send_markTransactionAsProcessed(self, transactionId, category):
2799 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2800 
    args = markTransactionAsProcessed_args()
2801 
    args.transactionId = transactionId
2802 
    args.category = category
2803 
    args.write(self._oprot)
2804 
    self._oprot.writeMessageEnd()
2805 
    self._oprot.trans.flush()
2806 
 
2807 
  def recv_markTransactionAsProcessed(self, ):
2808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2809 
    if mtype == TMessageType.EXCEPTION:
2810 
      x = TApplicationException()
2811 
      x.read(self._iprot)
2812 
      self._iprot.readMessageEnd()
2813 
      raise x
2814 
    result = markTransactionAsProcessed_result()
2815 
    result.read(self._iprot)
2816 
    self._iprot.readMessageEnd()
2817 
    return
2818 
 
4018 chandransh 2819 
  def getItemWiseRiskyOrdersCount(self, ):
2820 
    """
2821 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2822 
    is defined as one whose shipping date is about to expire.
2823 
    """
2824 
    self.send_getItemWiseRiskyOrdersCount()
2825 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2826 
 
4018 chandransh 2827 
  def send_getItemWiseRiskyOrdersCount(self, ):
2828 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2829 
    args = getItemWiseRiskyOrdersCount_args()
2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2834 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2841 
    result = getItemWiseRiskyOrdersCount_result()
2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    if result.success is not None:
2845 
      return result.success
2846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
2847 
 
4295 varun.gupt 2848 
  def getOrdersForItemIds(self, itemIds):
2849 
    """
2850 
    Returns a list of all orders which have items with given id
2851 
 
2852 
    Parameters:
2853 
     - itemIds
2854 
    """
2855 
    self.send_getOrdersForItemIds(itemIds)
2856 
    return self.recv_getOrdersForItemIds()
2857 
 
2858 
  def send_getOrdersForItemIds(self, itemIds):
2859 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
2860 
    args = getOrdersForItemIds_args()
2861 
    args.itemIds = itemIds
2862 
    args.write(self._oprot)
2863 
    self._oprot.writeMessageEnd()
2864 
    self._oprot.trans.flush()
2865 
 
2866 
  def recv_getOrdersForItemIds(self, ):
2867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2868 
    if mtype == TMessageType.EXCEPTION:
2869 
      x = TApplicationException()
2870 
      x.read(self._iprot)
2871 
      self._iprot.readMessageEnd()
2872 
      raise x
2873 
    result = getOrdersForItemIds_result()
2874 
    result.read(self._iprot)
2875 
    self._iprot.readMessageEnd()
2876 
    if result.success is not None:
2877 
      return result.success
2878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
2879 
 
4247 rajveer 2880 
  def markOrderCancellationRequestReceived(self, orderId):
2881 
    """
2882 
    Mark order as cancellation request received. If customer sends request of cancellation of
2883 
    a particular order, this method will be called. It will just change status of the order
2884 
    depending on its current status. It also records the previous status, so that we can move
2885 
    back to that status if cancellation request is denied.
4018 chandransh 2886 
 
4247 rajveer 2887 
    Parameters:
2888 
     - orderId
2889 
    """
2890 
    self.send_markOrderCancellationRequestReceived(orderId)
2891 
    self.recv_markOrderCancellationRequestReceived()
2892 
 
2893 
  def send_markOrderCancellationRequestReceived(self, orderId):
2894 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
2895 
    args = markOrderCancellationRequestReceived_args()
2896 
    args.orderId = orderId
2897 
    args.write(self._oprot)
2898 
    self._oprot.writeMessageEnd()
2899 
    self._oprot.trans.flush()
2900 
 
2901 
  def recv_markOrderCancellationRequestReceived(self, ):
2902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2903 
    if mtype == TMessageType.EXCEPTION:
2904 
      x = TApplicationException()
2905 
      x.read(self._iprot)
2906 
      self._iprot.readMessageEnd()
2907 
      raise x
2908 
    result = markOrderCancellationRequestReceived_result()
2909 
    result.read(self._iprot)
2910 
    self._iprot.readMessageEnd()
2911 
    if result.ex is not None:
2912 
      raise result.ex
2913 
    return
2914 
 
2915 
  def markOrderCancellationRequestConfirmed(self, orderId):
2916 
    """
2917 
    If we decide to to cancel order, CRM will call this method to move the status of order to
2918 
    cancellation request confirmed. After this OM will be able to cancel the order.
2919 
 
2920 
    Parameters:
2921 
     - orderId
2922 
    """
2923 
    self.send_markOrderCancellationRequestConfirmed(orderId)
2924 
    self.recv_markOrderCancellationRequestConfirmed()
2925 
 
2926 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
2927 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
2928 
    args = markOrderCancellationRequestConfirmed_args()
2929 
    args.orderId = orderId
2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
2934 
  def recv_markOrderCancellationRequestConfirmed(self, ):
2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
2941 
    result = markOrderCancellationRequestConfirmed_result()
2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
2944 
    if result.ex is not None:
2945 
      raise result.ex
2946 
    return
2947 
 
2948 
  def markOrderCancellationRequestDenied(self, orderId):
2949 
    """
2950 
    If we decide to not to cancel order, we will move the order ro previous status.
2951 
 
2952 
    Parameters:
2953 
     - orderId
2954 
    """
2955 
    self.send_markOrderCancellationRequestDenied(orderId)
2956 
    self.recv_markOrderCancellationRequestDenied()
2957 
 
2958 
  def send_markOrderCancellationRequestDenied(self, orderId):
2959 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
2960 
    args = markOrderCancellationRequestDenied_args()
2961 
    args.orderId = orderId
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
2965 
 
2966 
  def recv_markOrderCancellationRequestDenied(self, ):
2967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2968 
    if mtype == TMessageType.EXCEPTION:
2969 
      x = TApplicationException()
2970 
      x.read(self._iprot)
2971 
      self._iprot.readMessageEnd()
2972 
      raise x
2973 
    result = markOrderCancellationRequestDenied_result()
2974 
    result.read(self._iprot)
2975 
    self._iprot.readMessageEnd()
2976 
    if result.ex is not None:
2977 
      raise result.ex
2978 
    return
2979 
 
4258 rajveer 2980 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 2981 
    """
4258 rajveer 2982 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
2983 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 2984 
 
2985 
    Parameters:
4258 rajveer 2986 
     - transactionId
4247 rajveer 2987 
    """
4258 rajveer 2988 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
2989 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 2990 
 
4258 rajveer 2991 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
2992 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
2993 
    args = markTransactionAsPaymentFlagRemoved_args()
2994 
    args.transactionId = transactionId
4247 rajveer 2995 
    args.write(self._oprot)
2996 
    self._oprot.writeMessageEnd()
2997 
    self._oprot.trans.flush()
2998 
 
4258 rajveer 2999 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3001 
    if mtype == TMessageType.EXCEPTION:
3002 
      x = TApplicationException()
3003 
      x.read(self._iprot)
3004 
      self._iprot.readMessageEnd()
3005 
      raise x
4258 rajveer 3006 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3007 
    result.read(self._iprot)
3008 
    self._iprot.readMessageEnd()
3009 
    if result.ex is not None:
3010 
      raise result.ex
3011 
    return
3012 
 
4259 anupam.sin 3013 
  def refundTransaction(self, transactionId, refundedBy, reason):
3014 
    """
3015 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3016 
    need to be cancelled
4247 rajveer 3017 
 
4259 anupam.sin 3018 
    Parameters:
3019 
     - transactionId
3020 
     - refundedBy
3021 
     - reason
3022 
    """
3023 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3024 
    self.recv_refundTransaction()
3025 
 
3026 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3027 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3028 
    args = refundTransaction_args()
3029 
    args.transactionId = transactionId
3030 
    args.refundedBy = refundedBy
3031 
    args.reason = reason
3032 
    args.write(self._oprot)
3033 
    self._oprot.writeMessageEnd()
3034 
    self._oprot.trans.flush()
3035 
 
3036 
  def recv_refundTransaction(self, ):
3037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3038 
    if mtype == TMessageType.EXCEPTION:
3039 
      x = TApplicationException()
3040 
      x.read(self._iprot)
3041 
      self._iprot.readMessageEnd()
3042 
      raise x
3043 
    result = refundTransaction_result()
3044 
    result.read(self._iprot)
3045 
    self._iprot.readMessageEnd()
3046 
    if result.ex is not None:
3047 
      raise result.ex
3048 
    return
3049 
 
4285 rajveer 3050 
  def acceptOrdersForItemId(self, itemId, inventory):
3051 
    """
3052 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3053 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3054 
 
4285 rajveer 3055 
    Parameters:
3056 
     - itemId
3057 
     - inventory
3058 
    """
3059 
    self.send_acceptOrdersForItemId(itemId, inventory)
3060 
    return self.recv_acceptOrdersForItemId()
3061 
 
3062 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3063 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3064 
    args = acceptOrdersForItemId_args()
3065 
    args.itemId = itemId
3066 
    args.inventory = inventory
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_acceptOrdersForItemId(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = acceptOrdersForItemId_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    if result.success is not None:
3082 
      return result.success
3083 
    if result.ex is not None:
3084 
      raise result.ex
3085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3086 
 
3087 
 
3376 rajveer 3088 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3089 
  def __init__(self, handler):
3376 rajveer 3090 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3091 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3092 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3093 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3094 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3095 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3096 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3097 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3098 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3099 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3100 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3101 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3102 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3103 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3104 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3105 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3106 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3107 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3108 
    self._processMap["createOrder"] = Processor.process_createOrder
3109 
    self._processMap["getOrder"] = Processor.process_getOrder
3110 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3111 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3112 
    self._processMap["getAlerts"] = Processor.process_getAlerts
3113 
    self._processMap["setAlert"] = Processor.process_setAlert
3114 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3115 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3116 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3117 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3118 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3119 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3120 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3121 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3122 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3123 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 3124 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3125 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3126 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3127 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3128 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3129 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3130 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3131 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3132 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3133 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3134 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3135 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3136 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3137 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3138 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3139 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3140 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3141 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3142 
    self._processMap["changeItem"] = Processor.process_changeItem
3143 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3144 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3145 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3146 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3147 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3148 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3149 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3150 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3151 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3152 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3153 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3154 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4285 rajveer 3155 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
94 ashish 3156 
 
3157 
  def process(self, iprot, oprot):
3158 
    (name, type, seqid) = iprot.readMessageBegin()
3159 
    if name not in self._processMap:
3160 
      iprot.skip(TType.STRUCT)
3161 
      iprot.readMessageEnd()
3162 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3163 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3164 
      x.write(oprot)
3165 
      oprot.writeMessageEnd()
3166 
      oprot.trans.flush()
3167 
      return
3168 
    else:
3169 
      self._processMap[name](self, seqid, iprot, oprot)
3170 
    return True
3171 
 
3172 
  def process_createTransaction(self, seqid, iprot, oprot):
3173 
    args = createTransaction_args()
3174 
    args.read(iprot)
3175 
    iprot.readMessageEnd()
3176 
    result = createTransaction_result()
3177 
    try:
132 ashish 3178 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3179 
    except TransactionServiceException, ex:
3180 
      result.ex = ex
3181 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3182 
    result.write(oprot)
3183 
    oprot.writeMessageEnd()
3184 
    oprot.trans.flush()
3185 
 
3186 
  def process_getTransaction(self, seqid, iprot, oprot):
3187 
    args = getTransaction_args()
3188 
    args.read(iprot)
3189 
    iprot.readMessageEnd()
3190 
    result = getTransaction_result()
3191 
    try:
3192 
      result.success = self._handler.getTransaction(args.id)
3193 
    except TransactionServiceException, ex:
3194 
      result.ex = ex
3195 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3196 
    result.write(oprot)
3197 
    oprot.writeMessageEnd()
3198 
    oprot.trans.flush()
3199 
 
3200 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3201 
    args = getTransactionsForCustomer_args()
3202 
    args.read(iprot)
3203 
    iprot.readMessageEnd()
3204 
    result = getTransactionsForCustomer_result()
3205 
    try:
3206 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3207 
    except TransactionServiceException, ex:
3208 
      result.ex = ex
3209 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3210 
    result.write(oprot)
3211 
    oprot.writeMessageEnd()
3212 
    oprot.trans.flush()
3213 
 
132 ashish 3214 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3215 
    args = getTransactionsForShoppingCartId_args()
3216 
    args.read(iprot)
3217 
    iprot.readMessageEnd()
3218 
    result = getTransactionsForShoppingCartId_result()
3219 
    try:
3220 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3221 
    except TransactionServiceException, ex:
3222 
      result.ex = ex
3223 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3224 
    result.write(oprot)
3225 
    oprot.writeMessageEnd()
3226 
    oprot.trans.flush()
3227 
 
94 ashish 3228 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3229 
    args = getTransactionStatus_args()
3230 
    args.read(iprot)
3231 
    iprot.readMessageEnd()
3232 
    result = getTransactionStatus_result()
3233 
    try:
3234 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3235 
    except TransactionServiceException, ex:
3236 
      result.ex = ex
3237 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3238 
    result.write(oprot)
3239 
    oprot.writeMessageEnd()
3240 
    oprot.trans.flush()
3241 
 
3242 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3243 
    args = changeTransactionStatus_args()
3244 
    args.read(iprot)
3245 
    iprot.readMessageEnd()
3246 
    result = changeTransactionStatus_result()
3247 
    try:
3248 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3249 
    except TransactionServiceException, ex:
3250 
      result.ex = ex
3251 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3252 
    result.write(oprot)
3253 
    oprot.writeMessageEnd()
3254 
    oprot.trans.flush()
3255 
 
1398 varun.gupt 3256 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3257 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3258 
    args.read(iprot)
3259 
    iprot.readMessageEnd()
1398 varun.gupt 3260 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3261 
    try:
1398 varun.gupt 3262 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3263 
    except TransactionServiceException, ex:
3264 
      result.ex = ex
1398 varun.gupt 3265 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3266 
    result.write(oprot)
3267 
    oprot.writeMessageEnd()
3268 
    oprot.trans.flush()
3269 
 
483 rajveer 3270 
  def process_getAllOrders(self, seqid, iprot, oprot):
3271 
    args = getAllOrders_args()
94 ashish 3272 
    args.read(iprot)
3273 
    iprot.readMessageEnd()
483 rajveer 3274 
    result = getAllOrders_result()
94 ashish 3275 
    try:
483 rajveer 3276 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3277 
    except TransactionServiceException, ex:
3278 
      result.ex = ex
483 rajveer 3279 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3280 
    result.write(oprot)
3281 
    oprot.writeMessageEnd()
3282 
    oprot.trans.flush()
3283 
 
4133 chandransh 3284 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3285 
    args = getOrdersInBatch_args()
3286 
    args.read(iprot)
3287 
    iprot.readMessageEnd()
3288 
    result = getOrdersInBatch_result()
3289 
    try:
3290 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3291 
    except TransactionServiceException, ex:
3292 
      result.ex = ex
3293 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3294 
    result.write(oprot)
3295 
    oprot.writeMessageEnd()
3296 
    oprot.trans.flush()
3297 
 
3298 
  def process_getOrderCount(self, seqid, iprot, oprot):
3299 
    args = getOrderCount_args()
3300 
    args.read(iprot)
3301 
    iprot.readMessageEnd()
3302 
    result = getOrderCount_result()
3303 
    try:
3304 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3305 
    except TransactionServiceException, ex:
3306 
      result.ex = ex
3307 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3308 
    result.write(oprot)
3309 
    oprot.writeMessageEnd()
3310 
    oprot.trans.flush()
3311 
 
999 varun.gupt 3312 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3313 
    args = getOrdersByBillingDate_args()
3314 
    args.read(iprot)
3315 
    iprot.readMessageEnd()
3316 
    result = getOrdersByBillingDate_result()
3317 
    try:
3318 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3319 
    except TransactionServiceException, ex:
3320 
      result.ex = ex
3321 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3322 
    result.write(oprot)
3323 
    oprot.writeMessageEnd()
3324 
    oprot.trans.flush()
3325 
 
3427 chandransh 3326 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3327 
    args = getOrdersByShippingDate_args()
3328 
    args.read(iprot)
3329 
    iprot.readMessageEnd()
3330 
    result = getOrdersByShippingDate_result()
3331 
    try:
3451 chandransh 3332 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3333 
    except TransactionServiceException, ex:
3334 
      result.ex = ex
3335 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3336 
    result.write(oprot)
3337 
    oprot.writeMessageEnd()
3338 
    oprot.trans.flush()
3339 
 
1382 varun.gupt 3340 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3341 
    args = getReturnableOrdersForCustomer_args()
3342 
    args.read(iprot)
3343 
    iprot.readMessageEnd()
3344 
    result = getReturnableOrdersForCustomer_result()
3345 
    try:
3346 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3347 
    except TransactionServiceException, ex:
3348 
      result.ex = ex
3349 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3350 
    result.write(oprot)
3351 
    oprot.writeMessageEnd()
3352 
    oprot.trans.flush()
3353 
 
3354 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3355 
    args = getCancellableOrdersForCustomer_args()
3356 
    args.read(iprot)
3357 
    iprot.readMessageEnd()
3358 
    result = getCancellableOrdersForCustomer_result()
3359 
    try:
3360 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3361 
    except TransactionServiceException, ex:
3362 
      result.ex = ex
3363 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3364 
    result.write(oprot)
3365 
    oprot.writeMessageEnd()
3366 
    oprot.trans.flush()
3367 
 
483 rajveer 3368 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3369 
    args = changeOrderStatus_args()
94 ashish 3370 
    args.read(iprot)
3371 
    iprot.readMessageEnd()
483 rajveer 3372 
    result = changeOrderStatus_result()
94 ashish 3373 
    try:
483 rajveer 3374 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3375 
    except TransactionServiceException, ex:
3376 
      result.ex = ex
483 rajveer 3377 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3378 
    result.write(oprot)
3379 
    oprot.writeMessageEnd()
3380 
    oprot.trans.flush()
3381 
 
483 rajveer 3382 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3383 
    args = getOrdersForTransaction_args()
94 ashish 3384 
    args.read(iprot)
3385 
    iprot.readMessageEnd()
483 rajveer 3386 
    result = getOrdersForTransaction_result()
94 ashish 3387 
    try:
1528 ankur.sing 3388 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3389 
    except TransactionServiceException, ex:
3390 
      result.ex = ex
483 rajveer 3391 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3392 
    result.write(oprot)
3393 
    oprot.writeMessageEnd()
3394 
    oprot.trans.flush()
3395 
 
483 rajveer 3396 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3397 
    args = getOrdersForCustomer_args()
94 ashish 3398 
    args.read(iprot)
3399 
    iprot.readMessageEnd()
483 rajveer 3400 
    result = getOrdersForCustomer_result()
94 ashish 3401 
    try:
3014 chandransh 3402 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3403 
    except TransactionServiceException, ex:
3404 
      result.ex = ex
483 rajveer 3405 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3406 
    result.write(oprot)
3407 
    oprot.writeMessageEnd()
3408 
    oprot.trans.flush()
3409 
 
483 rajveer 3410 
  def process_createOrder(self, seqid, iprot, oprot):
3411 
    args = createOrder_args()
94 ashish 3412 
    args.read(iprot)
3413 
    iprot.readMessageEnd()
483 rajveer 3414 
    result = createOrder_result()
94 ashish 3415 
    try:
483 rajveer 3416 
      result.success = self._handler.createOrder(args.order)
94 ashish 3417 
    except TransactionServiceException, ex:
3418 
      result.ex = ex
483 rajveer 3419 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3420 
    result.write(oprot)
3421 
    oprot.writeMessageEnd()
3422 
    oprot.trans.flush()
3423 
 
483 rajveer 3424 
  def process_getOrder(self, seqid, iprot, oprot):
3425 
    args = getOrder_args()
94 ashish 3426 
    args.read(iprot)
3427 
    iprot.readMessageEnd()
483 rajveer 3428 
    result = getOrder_result()
94 ashish 3429 
    try:
483 rajveer 3430 
      result.success = self._handler.getOrder(args.id)
94 ashish 3431 
    except TransactionServiceException, ex:
3432 
      result.ex = ex
483 rajveer 3433 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3434 
    result.write(oprot)
3435 
    oprot.writeMessageEnd()
3436 
    oprot.trans.flush()
3437 
 
483 rajveer 3438 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3439 
    args = getLineItemsForOrder_args()
94 ashish 3440 
    args.read(iprot)
3441 
    iprot.readMessageEnd()
483 rajveer 3442 
    result = getLineItemsForOrder_result()
94 ashish 3443 
    try:
483 rajveer 3444 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3445 
    except TransactionServiceException, ex:
3446 
      result.ex = ex
483 rajveer 3447 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3448 
    result.write(oprot)
3449 
    oprot.writeMessageEnd()
3450 
    oprot.trans.flush()
3451 
 
1528 ankur.sing 3452 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3453 
    args = getOrderForCustomer_args()
3454 
    args.read(iprot)
3455 
    iprot.readMessageEnd()
3456 
    result = getOrderForCustomer_result()
3457 
    try:
3458 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3459 
    except TransactionServiceException, ex:
3460 
      result.ex = ex
3461 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3462 
    result.write(oprot)
3463 
    oprot.writeMessageEnd()
3464 
    oprot.trans.flush()
3465 
 
3064 chandransh 3466 
  def process_getAlerts(self, seqid, iprot, oprot):
3467 
    args = getAlerts_args()
3468 
    args.read(iprot)
3469 
    iprot.readMessageEnd()
3470 
    result = getAlerts_result()
3471 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
3472 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3473 
    result.write(oprot)
3474 
    oprot.writeMessageEnd()
3475 
    oprot.trans.flush()
3476 
 
3477 
  def process_setAlert(self, seqid, iprot, oprot):
3478 
    args = setAlert_args()
3479 
    args.read(iprot)
3480 
    iprot.readMessageEnd()
3481 
    result = setAlert_result()
3482 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
3483 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
3484 
    result.write(oprot)
3485 
    oprot.writeMessageEnd()
3486 
    oprot.trans.flush()
3487 
 
3488 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3489 
    args = getValidOrderCount_args()
3490 
    args.read(iprot)
3491 
    iprot.readMessageEnd()
3492 
    result = getValidOrderCount_result()
3493 
    result.success = self._handler.getValidOrderCount()
3494 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3495 
    result.write(oprot)
3496 
    oprot.writeMessageEnd()
3497 
    oprot.trans.flush()
3498 
 
3499 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3500 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3501 
    args.read(iprot)
3502 
    iprot.readMessageEnd()
3503 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3504 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3505 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3506 
    result.write(oprot)
3507 
    oprot.writeMessageEnd()
3508 
    oprot.trans.flush()
3509 
 
3510 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3511 
    args = getValidOrdersAmountRange_args()
3512 
    args.read(iprot)
3513 
    iprot.readMessageEnd()
3514 
    result = getValidOrdersAmountRange_result()
3515 
    result.success = self._handler.getValidOrdersAmountRange()
3516 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3517 
    result.write(oprot)
3518 
    oprot.writeMessageEnd()
3519 
    oprot.trans.flush()
3520 
 
3521 
  def process_getValidOrders(self, seqid, iprot, oprot):
3522 
    args = getValidOrders_args()
3523 
    args.read(iprot)
3524 
    iprot.readMessageEnd()
3525 
    result = getValidOrders_result()
3526 
    result.success = self._handler.getValidOrders(args.limit)
3527 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3528 
    result.write(oprot)
3529 
    oprot.writeMessageEnd()
3530 
    oprot.trans.flush()
3531 
 
1220 chandransh 3532 
  def process_batchOrders(self, seqid, iprot, oprot):
3533 
    args = batchOrders_args()
3534 
    args.read(iprot)
3535 
    iprot.readMessageEnd()
3536 
    result = batchOrders_result()
3537 
    try:
3538 
      result.success = self._handler.batchOrders(args.warehouseId)
3539 
    except TransactionServiceException, ex:
3540 
      result.ex = ex
3541 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3542 
    result.write(oprot)
3543 
    oprot.writeMessageEnd()
3544 
    oprot.trans.flush()
3545 
 
1208 chandransh 3546 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3547 
    args = markOrderAsOutOfStock_args()
3548 
    args.read(iprot)
3549 
    iprot.readMessageEnd()
3550 
    result = markOrderAsOutOfStock_result()
3551 
    try:
3552 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3553 
    except TransactionServiceException, ex:
3554 
      result.ex = ex
3555 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3556 
    result.write(oprot)
3557 
    oprot.writeMessageEnd()
3558 
    oprot.trans.flush()
3559 
 
3064 chandransh 3560 
  def process_verifyOrder(self, seqid, iprot, oprot):
3561 
    args = verifyOrder_args()
759 chandransh 3562 
    args.read(iprot)
3563 
    iprot.readMessageEnd()
3064 chandransh 3564 
    result = verifyOrder_result()
759 chandransh 3565 
    try:
3064 chandransh 3566 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3567 
    except TransactionServiceException, ex:
3568 
      result.ex = ex
3064 chandransh 3569 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3570 
    result.write(oprot)
3571 
    oprot.writeMessageEnd()
3572 
    oprot.trans.flush()
3573 
 
3064 chandransh 3574 
  def process_acceptOrder(self, seqid, iprot, oprot):
3575 
    args = acceptOrder_args()
1113 chandransh 3576 
    args.read(iprot)
3577 
    iprot.readMessageEnd()
3064 chandransh 3578 
    result = acceptOrder_result()
1113 chandransh 3579 
    try:
3064 chandransh 3580 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3581 
    except TransactionServiceException, ex:
3582 
      result.ex = ex
3064 chandransh 3583 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3584 
    result.write(oprot)
3585 
    oprot.writeMessageEnd()
3586 
    oprot.trans.flush()
3587 
 
3064 chandransh 3588 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3589 
    args = addBillingDetails_args()
1135 chandransh 3590 
    args.read(iprot)
3591 
    iprot.readMessageEnd()
3064 chandransh 3592 
    result = addBillingDetails_result()
1135 chandransh 3593 
    try:
4283 anupam.sin 3594 
      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 3595 
    except TransactionServiceException, ex:
3596 
      result.ex = ex
3064 chandransh 3597 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3598 
    result.write(oprot)
3599 
    oprot.writeMessageEnd()
3600 
    oprot.trans.flush()
3601 
 
3064 chandransh 3602 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3603 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3604 
    args.read(iprot)
3605 
    iprot.readMessageEnd()
3064 chandransh 3606 
    result = markOrdersAsManifested_result()
3607 
    try:
3608 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
3609 
    except TransactionServiceException, ex:
3610 
      result.ex = ex
3611 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 3612 
    result.write(oprot)
3613 
    oprot.writeMessageEnd()
3614 
    oprot.trans.flush()
3615 
 
3064 chandransh 3616 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
3617 
    args = markOrdersAsPickedUp_args()
304 ashish 3618 
    args.read(iprot)
3619 
    iprot.readMessageEnd()
3064 chandransh 3620 
    result = markOrdersAsPickedUp_result()
3621 
    try:
3622 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3623 
    except TransactionServiceException, ex:
3624 
      result.ex = ex
3625 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 3626 
    result.write(oprot)
3627 
    oprot.writeMessageEnd()
3628 
    oprot.trans.flush()
94 ashish 3629 
 
3064 chandransh 3630 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
3631 
    args = markOrdersAsDelivered_args()
304 ashish 3632 
    args.read(iprot)
3633 
    iprot.readMessageEnd()
3064 chandransh 3634 
    result = markOrdersAsDelivered_result()
3635 
    try:
3636 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
3637 
    except TransactionServiceException, ex:
3638 
      result.ex = ex
3639 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 3640 
    result.write(oprot)
3641 
    oprot.writeMessageEnd()
3642 
    oprot.trans.flush()
3643 
 
3064 chandransh 3644 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
3645 
    args = markOrdersAsFailed_args()
1596 ankur.sing 3646 
    args.read(iprot)
3647 
    iprot.readMessageEnd()
3064 chandransh 3648 
    result = markOrdersAsFailed_result()
3649 
    try:
3650 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
3651 
    except TransactionServiceException, ex:
3652 
      result.ex = ex
3653 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 3654 
    result.write(oprot)
3655 
    oprot.writeMessageEnd()
3656 
    oprot.trans.flush()
304 ashish 3657 
 
3064 chandransh 3658 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
3659 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 3660 
    args.read(iprot)
3661 
    iprot.readMessageEnd()
3064 chandransh 3662 
    result = updateNonDeliveryReason_result()
3663 
    try:
3664 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3665 
    except TransactionServiceException, ex:
3666 
      result.ex = ex
3667 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 3668 
    result.write(oprot)
3669 
    oprot.writeMessageEnd()
3670 
    oprot.trans.flush()
1596 ankur.sing 3671 
 
3064 chandransh 3672 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
3673 
    args = getUndeliveredOrders_args()
1627 ankur.sing 3674 
    args.read(iprot)
3675 
    iprot.readMessageEnd()
3064 chandransh 3676 
    result = getUndeliveredOrders_result()
3677 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
3678 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 3679 
    result.write(oprot)
3680 
    oprot.writeMessageEnd()
3681 
    oprot.trans.flush()
3682 
 
2536 chandransh 3683 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
3684 
    args = toggleDOAFlag_args()
3685 
    args.read(iprot)
3686 
    iprot.readMessageEnd()
3687 
    result = toggleDOAFlag_result()
3688 
    try:
3689 
      result.success = self._handler.toggleDOAFlag(args.orderId)
3690 
    except TransactionServiceException, ex:
3691 
      result.ex = ex
3692 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
3693 
    result.write(oprot)
3694 
    oprot.writeMessageEnd()
3695 
    oprot.trans.flush()
1886 ankur.sing 3696 
 
2536 chandransh 3697 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
3698 
    args = requestPickupNumber_args()
3699 
    args.read(iprot)
3700 
    iprot.readMessageEnd()
3701 
    result = requestPickupNumber_result()
3702 
    try:
3703 
      result.success = self._handler.requestPickupNumber(args.orderId)
3704 
    except TransactionServiceException, ex:
3705 
      result.ex = ex
3706 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
3707 
    result.write(oprot)
3708 
    oprot.writeMessageEnd()
3709 
    oprot.trans.flush()
3710 
 
3711 
  def process_authorizePickup(self, seqid, iprot, oprot):
3712 
    args = authorizePickup_args()
3713 
    args.read(iprot)
3714 
    iprot.readMessageEnd()
3715 
    result = authorizePickup_result()
3716 
    try:
3717 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
3718 
    except TransactionServiceException, ex:
3719 
      result.ex = ex
3720 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
3721 
    result.write(oprot)
3722 
    oprot.writeMessageEnd()
3723 
    oprot.trans.flush()
3724 
 
2764 chandransh 3725 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
3726 
    args = markDoasAsPickedUp_args()
3727 
    args.read(iprot)
3728 
    iprot.readMessageEnd()
3729 
    result = markDoasAsPickedUp_result()
3730 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
3731 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
3732 
    result.write(oprot)
3733 
    oprot.writeMessageEnd()
3734 
    oprot.trans.flush()
3735 
 
2616 chandransh 3736 
  def process_receiveReturn(self, seqid, iprot, oprot):
3737 
    args = receiveReturn_args()
2591 chandransh 3738 
    args.read(iprot)
3739 
    iprot.readMessageEnd()
2616 chandransh 3740 
    result = receiveReturn_result()
2591 chandransh 3741 
    try:
2616 chandransh 3742 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 3743 
    except TransactionServiceException, ex:
3744 
      result.ex = ex
2616 chandransh 3745 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 3746 
    result.write(oprot)
3747 
    oprot.writeMessageEnd()
3748 
    oprot.trans.flush()
2536 chandransh 3749 
 
2591 chandransh 3750 
  def process_validateDoa(self, seqid, iprot, oprot):
3751 
    args = validateDoa_args()
3752 
    args.read(iprot)
3753 
    iprot.readMessageEnd()
3754 
    result = validateDoa_result()
3755 
    try:
3756 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
3757 
    except TransactionServiceException, ex:
3758 
      result.ex = ex
3759 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
3760 
    result.write(oprot)
3761 
    oprot.writeMessageEnd()
3762 
    oprot.trans.flush()
3763 
 
2616 chandransh 3764 
  def process_reshipOrder(self, seqid, iprot, oprot):
3765 
    args = reshipOrder_args()
3766 
    args.read(iprot)
3767 
    iprot.readMessageEnd()
3768 
    result = reshipOrder_result()
3769 
    try:
3770 
      result.success = self._handler.reshipOrder(args.orderId)
3771 
    except TransactionServiceException, ex:
3772 
      result.ex = ex
3773 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
3774 
    result.write(oprot)
3775 
    oprot.writeMessageEnd()
3776 
    oprot.trans.flush()
2591 chandransh 3777 
 
2616 chandransh 3778 
  def process_refundOrder(self, seqid, iprot, oprot):
3779 
    args = refundOrder_args()
3780 
    args.read(iprot)
3781 
    iprot.readMessageEnd()
3782 
    result = refundOrder_result()
3783 
    try:
3226 chandransh 3784 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 3785 
    except TransactionServiceException, ex:
3786 
      result.ex = ex
3787 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
3788 
    result.write(oprot)
3789 
    oprot.writeMessageEnd()
3790 
    oprot.trans.flush()
3791 
 
2690 chandransh 3792 
  def process_getReturnOrders(self, seqid, iprot, oprot):
3793 
    args = getReturnOrders_args()
3794 
    args.read(iprot)
3795 
    iprot.readMessageEnd()
3796 
    result = getReturnOrders_result()
3797 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
3798 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
3799 
    result.write(oprot)
3800 
    oprot.writeMessageEnd()
3801 
    oprot.trans.flush()
2616 chandransh 3802 
 
2700 chandransh 3803 
  def process_getReturnOrder(self, seqid, iprot, oprot):
3804 
    args = getReturnOrder_args()
3805 
    args.read(iprot)
3806 
    iprot.readMessageEnd()
3807 
    result = getReturnOrder_result()
3808 
    try:
3809 
      result.success = self._handler.getReturnOrder(args.id)
3810 
    except TransactionServiceException, ex:
3811 
      result.ex = ex
3812 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
3813 
    result.write(oprot)
3814 
    oprot.writeMessageEnd()
3815 
    oprot.trans.flush()
3816 
 
2690 chandransh 3817 
  def process_processReturn(self, seqid, iprot, oprot):
3818 
    args = processReturn_args()
3819 
    args.read(iprot)
3820 
    iprot.readMessageEnd()
3821 
    result = processReturn_result()
3822 
    try:
3823 
      self._handler.processReturn(args.returnOrderId)
3824 
    except TransactionServiceException, ex:
3825 
      result.ex = ex
3826 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
3827 
    result.write(oprot)
3828 
    oprot.writeMessageEnd()
3829 
    oprot.trans.flush()
3830 
 
2819 chandransh 3831 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
3832 
    args = createPurchaseOrder_args()
3833 
    args.read(iprot)
3834 
    iprot.readMessageEnd()
3835 
    result = createPurchaseOrder_result()
3836 
    try:
3837 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
3838 
    except TransactionServiceException, ex:
3839 
      result.ex = ex
3840 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
3841 
    result.write(oprot)
3842 
    oprot.writeMessageEnd()
3843 
    oprot.trans.flush()
2690 chandransh 3844 
 
3451 chandransh 3845 
  def process_updateWeight(self, seqid, iprot, oprot):
3846 
    args = updateWeight_args()
3847 
    args.read(iprot)
3848 
    iprot.readMessageEnd()
3849 
    result = updateWeight_result()
3850 
    try:
3851 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
3852 
    except TransactionServiceException, ex:
3853 
      result.ex = ex
3854 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
2819 chandransh 3858 
 
3469 chandransh 3859 
  def process_changeItem(self, seqid, iprot, oprot):
3860 
    args = changeItem_args()
3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
3863 
    result = changeItem_result()
3864 
    try:
3865 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
3866 
    except TransactionServiceException, ex:
3867 
      result.ex = ex
3868 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
3869 
    result.write(oprot)
3870 
    oprot.writeMessageEnd()
3871 
    oprot.trans.flush()
3451 chandransh 3872 
 
3469 chandransh 3873 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
3874 
    args = shiftToWarehouse_args()
3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
3877 
    result = shiftToWarehouse_result()
3878 
    try:
3879 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
3880 
    except TransactionServiceException, ex:
3881 
      result.ex = ex
3882 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
3883 
    result.write(oprot)
3884 
    oprot.writeMessageEnd()
3885 
    oprot.trans.flush()
3886 
 
3553 chandransh 3887 
  def process_addDelayReason(self, seqid, iprot, oprot):
3888 
    args = addDelayReason_args()
3889 
    args.read(iprot)
3890 
    iprot.readMessageEnd()
3891 
    result = addDelayReason_result()
3892 
    try:
3986 chandransh 3893 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 3894 
    except TransactionServiceException, ex:
3895 
      result.ex = ex
3896 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3469 chandransh 3900 
 
3956 chandransh 3901 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
3902 
    args = reconcileCodCollection_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = reconcileCodCollection_result()
3906 
    try:
3907 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
3908 
    except TransactionServiceException, ex:
3909 
      result.ex = ex
3910 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
3911 
    result.write(oprot)
3912 
    oprot.writeMessageEnd()
3913 
    oprot.trans.flush()
3553 chandransh 3914 
 
4008 mandeep.dh 3915 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
3916 
    args = getTransactionsRequiringExtraProcessing_args()
3917 
    args.read(iprot)
3918 
    iprot.readMessageEnd()
3919 
    result = getTransactionsRequiringExtraProcessing_result()
3920 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
3921 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
3922 
    result.write(oprot)
3923 
    oprot.writeMessageEnd()
3924 
    oprot.trans.flush()
3956 chandransh 3925 
 
4008 mandeep.dh 3926 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
3927 
    args = markTransactionAsProcessed_args()
3928 
    args.read(iprot)
3929 
    iprot.readMessageEnd()
3930 
    result = markTransactionAsProcessed_result()
3931 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
3932 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
3933 
    result.write(oprot)
3934 
    oprot.writeMessageEnd()
3935 
    oprot.trans.flush()
3936 
 
4018 chandransh 3937 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
3938 
    args = getItemWiseRiskyOrdersCount_args()
3939 
    args.read(iprot)
3940 
    iprot.readMessageEnd()
3941 
    result = getItemWiseRiskyOrdersCount_result()
3942 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
3943 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
3944 
    result.write(oprot)
3945 
    oprot.writeMessageEnd()
3946 
    oprot.trans.flush()
4008 mandeep.dh 3947 
 
4295 varun.gupt 3948 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
3949 
    args = getOrdersForItemIds_args()
3950 
    args.read(iprot)
3951 
    iprot.readMessageEnd()
3952 
    result = getOrdersForItemIds_result()
3953 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
3954 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
3955 
    result.write(oprot)
3956 
    oprot.writeMessageEnd()
3957 
    oprot.trans.flush()
3958 
 
4247 rajveer 3959 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
3960 
    args = markOrderCancellationRequestReceived_args()
3961 
    args.read(iprot)
3962 
    iprot.readMessageEnd()
3963 
    result = markOrderCancellationRequestReceived_result()
3964 
    try:
3965 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
3966 
    except TransactionServiceException, ex:
3967 
      result.ex = ex
3968 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
3969 
    result.write(oprot)
3970 
    oprot.writeMessageEnd()
3971 
    oprot.trans.flush()
4018 chandransh 3972 
 
4247 rajveer 3973 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
3974 
    args = markOrderCancellationRequestConfirmed_args()
3975 
    args.read(iprot)
3976 
    iprot.readMessageEnd()
3977 
    result = markOrderCancellationRequestConfirmed_result()
3978 
    try:
3979 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
3980 
    except TransactionServiceException, ex:
3981 
      result.ex = ex
3982 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
3983 
    result.write(oprot)
3984 
    oprot.writeMessageEnd()
3985 
    oprot.trans.flush()
3986 
 
3987 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
3988 
    args = markOrderCancellationRequestDenied_args()
3989 
    args.read(iprot)
3990 
    iprot.readMessageEnd()
3991 
    result = markOrderCancellationRequestDenied_result()
3992 
    try:
3993 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
3994 
    except TransactionServiceException, ex:
3995 
      result.ex = ex
3996 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
3997 
    result.write(oprot)
3998 
    oprot.writeMessageEnd()
3999 
    oprot.trans.flush()
4000 
 
4258 rajveer 4001 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4002 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4003 
    args.read(iprot)
4004 
    iprot.readMessageEnd()
4258 rajveer 4005 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4006 
    try:
4258 rajveer 4007 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4008 
    except TransactionServiceException, ex:
4009 
      result.ex = ex
4258 rajveer 4010 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4011 
    result.write(oprot)
4012 
    oprot.writeMessageEnd()
4013 
    oprot.trans.flush()
4014 
 
4259 anupam.sin 4015 
  def process_refundTransaction(self, seqid, iprot, oprot):
4016 
    args = refundTransaction_args()
4017 
    args.read(iprot)
4018 
    iprot.readMessageEnd()
4019 
    result = refundTransaction_result()
4020 
    try:
4021 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4022 
    except TransactionServiceException, ex:
4023 
      result.ex = ex
4024 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4025 
    result.write(oprot)
4026 
    oprot.writeMessageEnd()
4027 
    oprot.trans.flush()
4247 rajveer 4028 
 
4285 rajveer 4029 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4030 
    args = acceptOrdersForItemId_args()
4031 
    args.read(iprot)
4032 
    iprot.readMessageEnd()
4033 
    result = acceptOrdersForItemId_result()
4034 
    try:
4035 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4036 
    except TransactionServiceException, ex:
4037 
      result.ex = ex
4038 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4039 
    result.write(oprot)
4040 
    oprot.writeMessageEnd()
4041 
    oprot.trans.flush()
4259 anupam.sin 4042 
 
4285 rajveer 4043 
 
94 ashish 4044 
# HELPER FUNCTIONS AND STRUCTURES
4045 
 
4046 
class createTransaction_args:
4047 
  """
4048 
  Attributes:
4049 
   - transaction
4050 
  """
4051 
 
4052 
  thrift_spec = (
4053 
    None, # 0
4054 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4055 
  )
4056 
 
4057 
  def __init__(self, transaction=None,):
4058 
    self.transaction = transaction
4059 
 
4060 
  def read(self, iprot):
4061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4063 
      return
4064 
    iprot.readStructBegin()
4065 
    while True:
4066 
      (fname, ftype, fid) = iprot.readFieldBegin()
4067 
      if ftype == TType.STOP:
4068 
        break
4069 
      if fid == 1:
4070 
        if ftype == TType.STRUCT:
4071 
          self.transaction = Transaction()
4072 
          self.transaction.read(iprot)
4073 
        else:
4074 
          iprot.skip(ftype)
4075 
      else:
4076 
        iprot.skip(ftype)
4077 
      iprot.readFieldEnd()
4078 
    iprot.readStructEnd()
4079 
 
4080 
  def write(self, oprot):
4081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4083 
      return
4084 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4085 
    if self.transaction is not None:
94 ashish 4086 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4087 
      self.transaction.write(oprot)
4088 
      oprot.writeFieldEnd()
4089 
    oprot.writeFieldStop()
4090 
    oprot.writeStructEnd()
4091 
 
3431 rajveer 4092 
  def validate(self):
4093 
    return
4094 
 
4095 
 
94 ashish 4096 
  def __repr__(self):
4097 
    L = ['%s=%r' % (key, value)
4098 
      for key, value in self.__dict__.iteritems()]
4099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4100 
 
4101 
  def __eq__(self, other):
4102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4103 
 
4104 
  def __ne__(self, other):
4105 
    return not (self == other)
4106 
 
4107 
class createTransaction_result:
4108 
  """
4109 
  Attributes:
132 ashish 4110 
   - success
94 ashish 4111 
   - ex
4112 
  """
4113 
 
4114 
  thrift_spec = (
132 ashish 4115 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4117 
  )
4118 
 
132 ashish 4119 
  def __init__(self, success=None, ex=None,):
4120 
    self.success = success
94 ashish 4121 
    self.ex = ex
4122 
 
4123 
  def read(self, iprot):
4124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4126 
      return
4127 
    iprot.readStructBegin()
4128 
    while True:
4129 
      (fname, ftype, fid) = iprot.readFieldBegin()
4130 
      if ftype == TType.STOP:
4131 
        break
132 ashish 4132 
      if fid == 0:
4133 
        if ftype == TType.I64:
4134 
          self.success = iprot.readI64();
4135 
        else:
4136 
          iprot.skip(ftype)
4137 
      elif fid == 1:
94 ashish 4138 
        if ftype == TType.STRUCT:
4139 
          self.ex = TransactionServiceException()
4140 
          self.ex.read(iprot)
4141 
        else:
4142 
          iprot.skip(ftype)
4143 
      else:
4144 
        iprot.skip(ftype)
4145 
      iprot.readFieldEnd()
4146 
    iprot.readStructEnd()
4147 
 
4148 
  def write(self, oprot):
4149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4151 
      return
4152 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4153 
    if self.success is not None:
132 ashish 4154 
      oprot.writeFieldBegin('success', TType.I64, 0)
4155 
      oprot.writeI64(self.success)
4156 
      oprot.writeFieldEnd()
3431 rajveer 4157 
    if self.ex is not None:
94 ashish 4158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4159 
      self.ex.write(oprot)
4160 
      oprot.writeFieldEnd()
4161 
    oprot.writeFieldStop()
4162 
    oprot.writeStructEnd()
4163 
 
3431 rajveer 4164 
  def validate(self):
4165 
    return
4166 
 
4167 
 
94 ashish 4168 
  def __repr__(self):
4169 
    L = ['%s=%r' % (key, value)
4170 
      for key, value in self.__dict__.iteritems()]
4171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4172 
 
4173 
  def __eq__(self, other):
4174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4175 
 
4176 
  def __ne__(self, other):
4177 
    return not (self == other)
4178 
 
4179 
class getTransaction_args:
4180 
  """
4181 
  Attributes:
4182 
   - id
4183 
  """
4184 
 
4185 
  thrift_spec = (
4186 
    None, # 0
4187 
    (1, TType.I64, 'id', None, None, ), # 1
4188 
  )
4189 
 
4190 
  def __init__(self, id=None,):
4191 
    self.id = id
4192 
 
4193 
  def read(self, iprot):
4194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4196 
      return
4197 
    iprot.readStructBegin()
4198 
    while True:
4199 
      (fname, ftype, fid) = iprot.readFieldBegin()
4200 
      if ftype == TType.STOP:
4201 
        break
4202 
      if fid == 1:
4203 
        if ftype == TType.I64:
4204 
          self.id = iprot.readI64();
4205 
        else:
4206 
          iprot.skip(ftype)
4207 
      else:
4208 
        iprot.skip(ftype)
4209 
      iprot.readFieldEnd()
4210 
    iprot.readStructEnd()
4211 
 
4212 
  def write(self, oprot):
4213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4215 
      return
4216 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4217 
    if self.id is not None:
94 ashish 4218 
      oprot.writeFieldBegin('id', TType.I64, 1)
4219 
      oprot.writeI64(self.id)
4220 
      oprot.writeFieldEnd()
4221 
    oprot.writeFieldStop()
4222 
    oprot.writeStructEnd()
4223 
 
3431 rajveer 4224 
  def validate(self):
4225 
    return
4226 
 
4227 
 
94 ashish 4228 
  def __repr__(self):
4229 
    L = ['%s=%r' % (key, value)
4230 
      for key, value in self.__dict__.iteritems()]
4231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4232 
 
4233 
  def __eq__(self, other):
4234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4235 
 
4236 
  def __ne__(self, other):
4237 
    return not (self == other)
4238 
 
4239 
class getTransaction_result:
4240 
  """
4241 
  Attributes:
4242 
   - success
4243 
   - ex
4244 
  """
4245 
 
4246 
  thrift_spec = (
4247 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4249 
  )
4250 
 
4251 
  def __init__(self, success=None, ex=None,):
4252 
    self.success = success
4253 
    self.ex = ex
4254 
 
4255 
  def read(self, iprot):
4256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4258 
      return
4259 
    iprot.readStructBegin()
4260 
    while True:
4261 
      (fname, ftype, fid) = iprot.readFieldBegin()
4262 
      if ftype == TType.STOP:
4263 
        break
4264 
      if fid == 0:
4265 
        if ftype == TType.STRUCT:
4266 
          self.success = Transaction()
4267 
          self.success.read(iprot)
4268 
        else:
4269 
          iprot.skip(ftype)
4270 
      elif fid == 1:
4271 
        if ftype == TType.STRUCT:
4272 
          self.ex = TransactionServiceException()
4273 
          self.ex.read(iprot)
4274 
        else:
4275 
          iprot.skip(ftype)
4276 
      else:
4277 
        iprot.skip(ftype)
4278 
      iprot.readFieldEnd()
4279 
    iprot.readStructEnd()
4280 
 
4281 
  def write(self, oprot):
4282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4284 
      return
4285 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4286 
    if self.success is not None:
94 ashish 4287 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4288 
      self.success.write(oprot)
4289 
      oprot.writeFieldEnd()
3431 rajveer 4290 
    if self.ex is not None:
94 ashish 4291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4292 
      self.ex.write(oprot)
4293 
      oprot.writeFieldEnd()
4294 
    oprot.writeFieldStop()
4295 
    oprot.writeStructEnd()
4296 
 
3431 rajveer 4297 
  def validate(self):
4298 
    return
4299 
 
4300 
 
94 ashish 4301 
  def __repr__(self):
4302 
    L = ['%s=%r' % (key, value)
4303 
      for key, value in self.__dict__.iteritems()]
4304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4305 
 
4306 
  def __eq__(self, other):
4307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4308 
 
4309 
  def __ne__(self, other):
4310 
    return not (self == other)
4311 
 
4312 
class getTransactionsForCustomer_args:
4313 
  """
4314 
  Attributes:
4315 
   - customerId
4316 
   - from_date
4317 
   - to_date
4318 
   - status
4319 
  """
4320 
 
4321 
  thrift_spec = (
4322 
    None, # 0
4323 
    (1, TType.I64, 'customerId', None, None, ), # 1
4324 
    (2, TType.I64, 'from_date', None, None, ), # 2
4325 
    (3, TType.I64, 'to_date', None, None, ), # 3
4326 
    (4, TType.I32, 'status', None, None, ), # 4
4327 
  )
4328 
 
4329 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4330 
    self.customerId = customerId
4331 
    self.from_date = from_date
4332 
    self.to_date = to_date
4333 
    self.status = status
4334 
 
4335 
  def read(self, iprot):
4336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4338 
      return
4339 
    iprot.readStructBegin()
4340 
    while True:
4341 
      (fname, ftype, fid) = iprot.readFieldBegin()
4342 
      if ftype == TType.STOP:
4343 
        break
4344 
      if fid == 1:
4345 
        if ftype == TType.I64:
4346 
          self.customerId = iprot.readI64();
4347 
        else:
4348 
          iprot.skip(ftype)
4349 
      elif fid == 2:
4350 
        if ftype == TType.I64:
4351 
          self.from_date = iprot.readI64();
4352 
        else:
4353 
          iprot.skip(ftype)
4354 
      elif fid == 3:
4355 
        if ftype == TType.I64:
4356 
          self.to_date = iprot.readI64();
4357 
        else:
4358 
          iprot.skip(ftype)
4359 
      elif fid == 4:
4360 
        if ftype == TType.I32:
4361 
          self.status = iprot.readI32();
4362 
        else:
4363 
          iprot.skip(ftype)
4364 
      else:
4365 
        iprot.skip(ftype)
4366 
      iprot.readFieldEnd()
4367 
    iprot.readStructEnd()
4368 
 
4369 
  def write(self, oprot):
4370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4372 
      return
4373 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4374 
    if self.customerId is not None:
94 ashish 4375 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4376 
      oprot.writeI64(self.customerId)
4377 
      oprot.writeFieldEnd()
3431 rajveer 4378 
    if self.from_date is not None:
94 ashish 4379 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4380 
      oprot.writeI64(self.from_date)
4381 
      oprot.writeFieldEnd()
3431 rajveer 4382 
    if self.to_date is not None:
94 ashish 4383 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4384 
      oprot.writeI64(self.to_date)
4385 
      oprot.writeFieldEnd()
3431 rajveer 4386 
    if self.status is not None:
94 ashish 4387 
      oprot.writeFieldBegin('status', TType.I32, 4)
4388 
      oprot.writeI32(self.status)
4389 
      oprot.writeFieldEnd()
4390 
    oprot.writeFieldStop()
4391 
    oprot.writeStructEnd()
4392 
 
3431 rajveer 4393 
  def validate(self):
4394 
    return
4395 
 
4396 
 
94 ashish 4397 
  def __repr__(self):
4398 
    L = ['%s=%r' % (key, value)
4399 
      for key, value in self.__dict__.iteritems()]
4400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4401 
 
4402 
  def __eq__(self, other):
4403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4404 
 
4405 
  def __ne__(self, other):
4406 
    return not (self == other)
4407 
 
4408 
class getTransactionsForCustomer_result:
4409 
  """
4410 
  Attributes:
4411 
   - success
4412 
   - ex
4413 
  """
4414 
 
4415 
  thrift_spec = (
4416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4418 
  )
4419 
 
4420 
  def __init__(self, success=None, ex=None,):
4421 
    self.success = success
4422 
    self.ex = ex
4423 
 
4424 
  def read(self, iprot):
4425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4427 
      return
4428 
    iprot.readStructBegin()
4429 
    while True:
4430 
      (fname, ftype, fid) = iprot.readFieldBegin()
4431 
      if ftype == TType.STOP:
4432 
        break
4433 
      if fid == 0:
4434 
        if ftype == TType.LIST:
4435 
          self.success = []
685 chandransh 4436 
          (_etype17, _size14) = iprot.readListBegin()
4437 
          for _i18 in xrange(_size14):
4438 
            _elem19 = Transaction()
4439 
            _elem19.read(iprot)
4440 
            self.success.append(_elem19)
94 ashish 4441 
          iprot.readListEnd()
4442 
        else:
4443 
          iprot.skip(ftype)
4444 
      elif fid == 1:
4445 
        if ftype == TType.STRUCT:
4446 
          self.ex = TransactionServiceException()
4447 
          self.ex.read(iprot)
4448 
        else:
4449 
          iprot.skip(ftype)
4450 
      else:
4451 
        iprot.skip(ftype)
4452 
      iprot.readFieldEnd()
4453 
    iprot.readStructEnd()
4454 
 
4455 
  def write(self, oprot):
4456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4458 
      return
4459 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4460 
    if self.success is not None:
94 ashish 4461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4463 
      for iter20 in self.success:
4464 
        iter20.write(oprot)
94 ashish 4465 
      oprot.writeListEnd()
4466 
      oprot.writeFieldEnd()
3431 rajveer 4467 
    if self.ex is not None:
94 ashish 4468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4469 
      self.ex.write(oprot)
4470 
      oprot.writeFieldEnd()
4471 
    oprot.writeFieldStop()
4472 
    oprot.writeStructEnd()
4473 
 
3431 rajveer 4474 
  def validate(self):
4475 
    return
4476 
 
4477 
 
94 ashish 4478 
  def __repr__(self):
4479 
    L = ['%s=%r' % (key, value)
4480 
      for key, value in self.__dict__.iteritems()]
4481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4482 
 
4483 
  def __eq__(self, other):
4484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4485 
 
4486 
  def __ne__(self, other):
4487 
    return not (self == other)
4488 
 
132 ashish 4489 
class getTransactionsForShoppingCartId_args:
4490 
  """
4491 
  Attributes:
4492 
   - shoppingCartId
4493 
  """
4494 
 
4495 
  thrift_spec = (
4496 
    None, # 0
4497 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4498 
  )
4499 
 
4500 
  def __init__(self, shoppingCartId=None,):
4501 
    self.shoppingCartId = shoppingCartId
4502 
 
4503 
  def read(self, iprot):
4504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4506 
      return
4507 
    iprot.readStructBegin()
4508 
    while True:
4509 
      (fname, ftype, fid) = iprot.readFieldBegin()
4510 
      if ftype == TType.STOP:
4511 
        break
4512 
      if fid == 1:
4513 
        if ftype == TType.I64:
4514 
          self.shoppingCartId = iprot.readI64();
4515 
        else:
4516 
          iprot.skip(ftype)
4517 
      else:
4518 
        iprot.skip(ftype)
4519 
      iprot.readFieldEnd()
4520 
    iprot.readStructEnd()
4521 
 
4522 
  def write(self, oprot):
4523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4525 
      return
4526 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 4527 
    if self.shoppingCartId is not None:
132 ashish 4528 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
4529 
      oprot.writeI64(self.shoppingCartId)
4530 
      oprot.writeFieldEnd()
4531 
    oprot.writeFieldStop()
4532 
    oprot.writeStructEnd()
4533 
 
3431 rajveer 4534 
  def validate(self):
4535 
    return
4536 
 
4537 
 
132 ashish 4538 
  def __repr__(self):
4539 
    L = ['%s=%r' % (key, value)
4540 
      for key, value in self.__dict__.iteritems()]
4541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4542 
 
4543 
  def __eq__(self, other):
4544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4545 
 
4546 
  def __ne__(self, other):
4547 
    return not (self == other)
4548 
 
4549 
class getTransactionsForShoppingCartId_result:
4550 
  """
4551 
  Attributes:
4552 
   - success
4553 
   - ex
4554 
  """
4555 
 
4556 
  thrift_spec = (
4557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4559 
  )
4560 
 
4561 
  def __init__(self, success=None, ex=None,):
4562 
    self.success = success
4563 
    self.ex = ex
4564 
 
4565 
  def read(self, iprot):
4566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4568 
      return
4569 
    iprot.readStructBegin()
4570 
    while True:
4571 
      (fname, ftype, fid) = iprot.readFieldBegin()
4572 
      if ftype == TType.STOP:
4573 
        break
4574 
      if fid == 0:
4575 
        if ftype == TType.LIST:
4576 
          self.success = []
685 chandransh 4577 
          (_etype24, _size21) = iprot.readListBegin()
4578 
          for _i25 in xrange(_size21):
4579 
            _elem26 = Transaction()
4580 
            _elem26.read(iprot)
4581 
            self.success.append(_elem26)
132 ashish 4582 
          iprot.readListEnd()
4583 
        else:
4584 
          iprot.skip(ftype)
4585 
      elif fid == 1:
4586 
        if ftype == TType.STRUCT:
4587 
          self.ex = TransactionServiceException()
4588 
          self.ex.read(iprot)
4589 
        else:
4590 
          iprot.skip(ftype)
4591 
      else:
4592 
        iprot.skip(ftype)
4593 
      iprot.readFieldEnd()
4594 
    iprot.readStructEnd()
4595 
 
4596 
  def write(self, oprot):
4597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4599 
      return
4600 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 4601 
    if self.success is not None:
132 ashish 4602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4604 
      for iter27 in self.success:
4605 
        iter27.write(oprot)
132 ashish 4606 
      oprot.writeListEnd()
4607 
      oprot.writeFieldEnd()
3431 rajveer 4608 
    if self.ex is not None:
132 ashish 4609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4610 
      self.ex.write(oprot)
4611 
      oprot.writeFieldEnd()
4612 
    oprot.writeFieldStop()
4613 
    oprot.writeStructEnd()
4614 
 
3431 rajveer 4615 
  def validate(self):
4616 
    return
4617 
 
4618 
 
132 ashish 4619 
  def __repr__(self):
4620 
    L = ['%s=%r' % (key, value)
4621 
      for key, value in self.__dict__.iteritems()]
4622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4623 
 
4624 
  def __eq__(self, other):
4625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4626 
 
4627 
  def __ne__(self, other):
4628 
    return not (self == other)
4629 
 
94 ashish 4630 
class getTransactionStatus_args:
4631 
  """
4632 
  Attributes:
4633 
   - transactionId
4634 
  """
4635 
 
4636 
  thrift_spec = (
4637 
    None, # 0
4638 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4639 
  )
4640 
 
4641 
  def __init__(self, transactionId=None,):
4642 
    self.transactionId = transactionId
4643 
 
4644 
  def read(self, iprot):
4645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4647 
      return
4648 
    iprot.readStructBegin()
4649 
    while True:
4650 
      (fname, ftype, fid) = iprot.readFieldBegin()
4651 
      if ftype == TType.STOP:
4652 
        break
4653 
      if fid == 1:
4654 
        if ftype == TType.I64:
4655 
          self.transactionId = iprot.readI64();
4656 
        else:
4657 
          iprot.skip(ftype)
4658 
      else:
4659 
        iprot.skip(ftype)
4660 
      iprot.readFieldEnd()
4661 
    iprot.readStructEnd()
4662 
 
4663 
  def write(self, oprot):
4664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4666 
      return
4667 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 4668 
    if self.transactionId is not None:
94 ashish 4669 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4670 
      oprot.writeI64(self.transactionId)
4671 
      oprot.writeFieldEnd()
4672 
    oprot.writeFieldStop()
4673 
    oprot.writeStructEnd()
4674 
 
3431 rajveer 4675 
  def validate(self):
4676 
    return
4677 
 
4678 
 
94 ashish 4679 
  def __repr__(self):
4680 
    L = ['%s=%r' % (key, value)
4681 
      for key, value in self.__dict__.iteritems()]
4682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4683 
 
4684 
  def __eq__(self, other):
4685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4686 
 
4687 
  def __ne__(self, other):
4688 
    return not (self == other)
4689 
 
4690 
class getTransactionStatus_result:
4691 
  """
4692 
  Attributes:
4693 
   - success
4694 
   - ex
4695 
  """
4696 
 
4697 
  thrift_spec = (
4698 
    (0, TType.I32, 'success', None, None, ), # 0
4699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4700 
  )
4701 
 
4702 
  def __init__(self, success=None, ex=None,):
4703 
    self.success = success
4704 
    self.ex = ex
4705 
 
4706 
  def read(self, iprot):
4707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4709 
      return
4710 
    iprot.readStructBegin()
4711 
    while True:
4712 
      (fname, ftype, fid) = iprot.readFieldBegin()
4713 
      if ftype == TType.STOP:
4714 
        break
4715 
      if fid == 0:
4716 
        if ftype == TType.I32:
4717 
          self.success = iprot.readI32();
4718 
        else:
4719 
          iprot.skip(ftype)
4720 
      elif fid == 1:
4721 
        if ftype == TType.STRUCT:
4722 
          self.ex = TransactionServiceException()
4723 
          self.ex.read(iprot)
4724 
        else:
4725 
          iprot.skip(ftype)
4726 
      else:
4727 
        iprot.skip(ftype)
4728 
      iprot.readFieldEnd()
4729 
    iprot.readStructEnd()
4730 
 
4731 
  def write(self, oprot):
4732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4734 
      return
4735 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 4736 
    if self.success is not None:
94 ashish 4737 
      oprot.writeFieldBegin('success', TType.I32, 0)
4738 
      oprot.writeI32(self.success)
4739 
      oprot.writeFieldEnd()
3431 rajveer 4740 
    if self.ex is not None:
94 ashish 4741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4742 
      self.ex.write(oprot)
4743 
      oprot.writeFieldEnd()
4744 
    oprot.writeFieldStop()
4745 
    oprot.writeStructEnd()
4746 
 
3431 rajveer 4747 
  def validate(self):
4748 
    return
4749 
 
4750 
 
94 ashish 4751 
  def __repr__(self):
4752 
    L = ['%s=%r' % (key, value)
4753 
      for key, value in self.__dict__.iteritems()]
4754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4755 
 
4756 
  def __eq__(self, other):
4757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4758 
 
4759 
  def __ne__(self, other):
4760 
    return not (self == other)
4761 
 
4762 
class changeTransactionStatus_args:
4763 
  """
4764 
  Attributes:
4765 
   - transactionId
4766 
   - status
4767 
   - description
4768 
  """
4769 
 
4770 
  thrift_spec = (
4771 
    None, # 0
4772 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4773 
    (2, TType.I32, 'status', None, None, ), # 2
4774 
    (3, TType.STRING, 'description', None, None, ), # 3
4775 
  )
4776 
 
4777 
  def __init__(self, transactionId=None, status=None, description=None,):
4778 
    self.transactionId = transactionId
4779 
    self.status = status
4780 
    self.description = description
4781 
 
4782 
  def read(self, iprot):
4783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4785 
      return
4786 
    iprot.readStructBegin()
4787 
    while True:
4788 
      (fname, ftype, fid) = iprot.readFieldBegin()
4789 
      if ftype == TType.STOP:
4790 
        break
4791 
      if fid == 1:
4792 
        if ftype == TType.I64:
4793 
          self.transactionId = iprot.readI64();
4794 
        else:
4795 
          iprot.skip(ftype)
4796 
      elif fid == 2:
4797 
        if ftype == TType.I32:
4798 
          self.status = iprot.readI32();
4799 
        else:
4800 
          iprot.skip(ftype)
4801 
      elif fid == 3:
4802 
        if ftype == TType.STRING:
4803 
          self.description = iprot.readString();
4804 
        else:
4805 
          iprot.skip(ftype)
4806 
      else:
4807 
        iprot.skip(ftype)
4808 
      iprot.readFieldEnd()
4809 
    iprot.readStructEnd()
4810 
 
4811 
  def write(self, oprot):
4812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4814 
      return
4815 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 4816 
    if self.transactionId is not None:
94 ashish 4817 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4818 
      oprot.writeI64(self.transactionId)
4819 
      oprot.writeFieldEnd()
3431 rajveer 4820 
    if self.status is not None:
94 ashish 4821 
      oprot.writeFieldBegin('status', TType.I32, 2)
4822 
      oprot.writeI32(self.status)
4823 
      oprot.writeFieldEnd()
3431 rajveer 4824 
    if self.description is not None:
94 ashish 4825 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4826 
      oprot.writeString(self.description)
4827 
      oprot.writeFieldEnd()
4828 
    oprot.writeFieldStop()
4829 
    oprot.writeStructEnd()
4830 
 
3431 rajveer 4831 
  def validate(self):
4832 
    return
4833 
 
4834 
 
94 ashish 4835 
  def __repr__(self):
4836 
    L = ['%s=%r' % (key, value)
4837 
      for key, value in self.__dict__.iteritems()]
4838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4839 
 
4840 
  def __eq__(self, other):
4841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4842 
 
4843 
  def __ne__(self, other):
4844 
    return not (self == other)
4845 
 
4846 
class changeTransactionStatus_result:
4847 
  """
4848 
  Attributes:
4849 
   - success
4850 
   - ex
4851 
  """
4852 
 
4853 
  thrift_spec = (
4854 
    (0, TType.BOOL, 'success', None, None, ), # 0
4855 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4856 
  )
4857 
 
4858 
  def __init__(self, success=None, ex=None,):
4859 
    self.success = success
4860 
    self.ex = ex
4861 
 
4862 
  def read(self, iprot):
4863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4865 
      return
4866 
    iprot.readStructBegin()
4867 
    while True:
4868 
      (fname, ftype, fid) = iprot.readFieldBegin()
4869 
      if ftype == TType.STOP:
4870 
        break
4871 
      if fid == 0:
4872 
        if ftype == TType.BOOL:
4873 
          self.success = iprot.readBool();
4874 
        else:
4875 
          iprot.skip(ftype)
4876 
      elif fid == 1:
4877 
        if ftype == TType.STRUCT:
4878 
          self.ex = TransactionServiceException()
4879 
          self.ex.read(iprot)
4880 
        else:
4881 
          iprot.skip(ftype)
4882 
      else:
4883 
        iprot.skip(ftype)
4884 
      iprot.readFieldEnd()
4885 
    iprot.readStructEnd()
4886 
 
4887 
  def write(self, oprot):
4888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4890 
      return
4891 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 4892 
    if self.success is not None:
94 ashish 4893 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4894 
      oprot.writeBool(self.success)
4895 
      oprot.writeFieldEnd()
3431 rajveer 4896 
    if self.ex is not None:
94 ashish 4897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4898 
      self.ex.write(oprot)
4899 
      oprot.writeFieldEnd()
4900 
    oprot.writeFieldStop()
4901 
    oprot.writeStructEnd()
4902 
 
3431 rajveer 4903 
  def validate(self):
4904 
    return
4905 
 
4906 
 
94 ashish 4907 
  def __repr__(self):
4908 
    L = ['%s=%r' % (key, value)
4909 
      for key, value in self.__dict__.iteritems()]
4910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4911 
 
4912 
  def __eq__(self, other):
4913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4914 
 
4915 
  def __ne__(self, other):
4916 
    return not (self == other)
4917 
 
1398 varun.gupt 4918 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 4919 
  """
4920 
  Attributes:
4921 
   - transactionId
4922 
  """
4923 
 
4924 
  thrift_spec = (
4925 
    None, # 0
4926 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4927 
  )
4928 
 
4929 
  def __init__(self, transactionId=None,):
4930 
    self.transactionId = transactionId
4931 
 
4932 
  def read(self, iprot):
4933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4935 
      return
4936 
    iprot.readStructBegin()
4937 
    while True:
4938 
      (fname, ftype, fid) = iprot.readFieldBegin()
4939 
      if ftype == TType.STOP:
4940 
        break
4941 
      if fid == 1:
4942 
        if ftype == TType.I64:
4943 
          self.transactionId = iprot.readI64();
4944 
        else:
4945 
          iprot.skip(ftype)
4946 
      else:
4947 
        iprot.skip(ftype)
4948 
      iprot.readFieldEnd()
4949 
    iprot.readStructEnd()
4950 
 
4951 
  def write(self, oprot):
4952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4954 
      return
1398 varun.gupt 4955 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 4956 
    if self.transactionId is not None:
1382 varun.gupt 4957 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4958 
      oprot.writeI64(self.transactionId)
4959 
      oprot.writeFieldEnd()
4960 
    oprot.writeFieldStop()
4961 
    oprot.writeStructEnd()
4962 
 
3431 rajveer 4963 
  def validate(self):
4964 
    return
4965 
 
4966 
 
1382 varun.gupt 4967 
  def __repr__(self):
4968 
    L = ['%s=%r' % (key, value)
4969 
      for key, value in self.__dict__.iteritems()]
4970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4971 
 
4972 
  def __eq__(self, other):
4973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4974 
 
4975 
  def __ne__(self, other):
4976 
    return not (self == other)
4977 
 
1398 varun.gupt 4978 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 4979 
  """
4980 
  Attributes:
4981 
   - success
4982 
   - ex
4983 
  """
4984 
 
4985 
  thrift_spec = (
4986 
    (0, TType.BOOL, 'success', None, None, ), # 0
4987 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4988 
  )
4989 
 
4990 
  def __init__(self, success=None, ex=None,):
4991 
    self.success = success
4992 
    self.ex = ex
4993 
 
4994 
  def read(self, iprot):
4995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4997 
      return
4998 
    iprot.readStructBegin()
4999 
    while True:
5000 
      (fname, ftype, fid) = iprot.readFieldBegin()
5001 
      if ftype == TType.STOP:
5002 
        break
5003 
      if fid == 0:
5004 
        if ftype == TType.BOOL:
5005 
          self.success = iprot.readBool();
5006 
        else:
5007 
          iprot.skip(ftype)
5008 
      elif fid == 1:
5009 
        if ftype == TType.STRUCT:
5010 
          self.ex = TransactionServiceException()
5011 
          self.ex.read(iprot)
5012 
        else:
5013 
          iprot.skip(ftype)
5014 
      else:
5015 
        iprot.skip(ftype)
5016 
      iprot.readFieldEnd()
5017 
    iprot.readStructEnd()
5018 
 
5019 
  def write(self, oprot):
5020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5022 
      return
1398 varun.gupt 5023 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5024 
    if self.success is not None:
1382 varun.gupt 5025 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5026 
      oprot.writeBool(self.success)
5027 
      oprot.writeFieldEnd()
3431 rajveer 5028 
    if self.ex is not None:
1382 varun.gupt 5029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5030 
      self.ex.write(oprot)
5031 
      oprot.writeFieldEnd()
5032 
    oprot.writeFieldStop()
5033 
    oprot.writeStructEnd()
5034 
 
3431 rajveer 5035 
  def validate(self):
5036 
    return
5037 
 
5038 
 
1382 varun.gupt 5039 
  def __repr__(self):
5040 
    L = ['%s=%r' % (key, value)
5041 
      for key, value in self.__dict__.iteritems()]
5042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5043 
 
5044 
  def __eq__(self, other):
5045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5046 
 
5047 
  def __ne__(self, other):
5048 
    return not (self == other)
5049 
 
483 rajveer 5050 
class getAllOrders_args:
94 ashish 5051 
  """
5052 
  Attributes:
483 rajveer 5053 
   - status
5054 
   - from_date
5055 
   - to_date
5056 
   - warehouse_id
94 ashish 5057 
  """
5058 
 
5059 
  thrift_spec = (
5060 
    None, # 0
483 rajveer 5061 
    (1, TType.I32, 'status', None, None, ), # 1
5062 
    (2, TType.I64, 'from_date', None, None, ), # 2
5063 
    (3, TType.I64, 'to_date', None, None, ), # 3
5064 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5065 
  )
5066 
 
483 rajveer 5067 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5068 
    self.status = status
5069 
    self.from_date = from_date
5070 
    self.to_date = to_date
5071 
    self.warehouse_id = warehouse_id
94 ashish 5072 
 
5073 
  def read(self, iprot):
5074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5076 
      return
5077 
    iprot.readStructBegin()
5078 
    while True:
5079 
      (fname, ftype, fid) = iprot.readFieldBegin()
5080 
      if ftype == TType.STOP:
5081 
        break
5082 
      if fid == 1:
483 rajveer 5083 
        if ftype == TType.I32:
5084 
          self.status = iprot.readI32();
94 ashish 5085 
        else:
5086 
          iprot.skip(ftype)
483 rajveer 5087 
      elif fid == 2:
5088 
        if ftype == TType.I64:
5089 
          self.from_date = iprot.readI64();
94 ashish 5090 
        else:
5091 
          iprot.skip(ftype)
483 rajveer 5092 
      elif fid == 3:
5093 
        if ftype == TType.I64:
5094 
          self.to_date = iprot.readI64();
94 ashish 5095 
        else:
5096 
          iprot.skip(ftype)
483 rajveer 5097 
      elif fid == 4:
94 ashish 5098 
        if ftype == TType.I64:
483 rajveer 5099 
          self.warehouse_id = iprot.readI64();
94 ashish 5100 
        else:
5101 
          iprot.skip(ftype)
5102 
      else:
5103 
        iprot.skip(ftype)
5104 
      iprot.readFieldEnd()
5105 
    iprot.readStructEnd()
5106 
 
5107 
  def write(self, oprot):
5108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5110 
      return
483 rajveer 5111 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5112 
    if self.status is not None:
483 rajveer 5113 
      oprot.writeFieldBegin('status', TType.I32, 1)
5114 
      oprot.writeI32(self.status)
94 ashish 5115 
      oprot.writeFieldEnd()
3431 rajveer 5116 
    if self.from_date is not None:
483 rajveer 5117 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5118 
      oprot.writeI64(self.from_date)
94 ashish 5119 
      oprot.writeFieldEnd()
3431 rajveer 5120 
    if self.to_date is not None:
483 rajveer 5121 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5122 
      oprot.writeI64(self.to_date)
94 ashish 5123 
      oprot.writeFieldEnd()
3431 rajveer 5124 
    if self.warehouse_id is not None:
483 rajveer 5125 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5126 
      oprot.writeI64(self.warehouse_id)
94 ashish 5127 
      oprot.writeFieldEnd()
5128 
    oprot.writeFieldStop()
5129 
    oprot.writeStructEnd()
5130 
 
3431 rajveer 5131 
  def validate(self):
5132 
    return
5133 
 
5134 
 
94 ashish 5135 
  def __repr__(self):
5136 
    L = ['%s=%r' % (key, value)
5137 
      for key, value in self.__dict__.iteritems()]
5138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5139 
 
5140 
  def __eq__(self, other):
5141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5142 
 
5143 
  def __ne__(self, other):
5144 
    return not (self == other)
5145 
 
483 rajveer 5146 
class getAllOrders_result:
94 ashish 5147 
  """
5148 
  Attributes:
5149 
   - success
5150 
   - ex
5151 
  """
5152 
 
5153 
  thrift_spec = (
483 rajveer 5154 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5156 
  )
5157 
 
5158 
  def __init__(self, success=None, ex=None,):
5159 
    self.success = success
5160 
    self.ex = ex
5161 
 
5162 
  def read(self, iprot):
5163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5165 
      return
5166 
    iprot.readStructBegin()
5167 
    while True:
5168 
      (fname, ftype, fid) = iprot.readFieldBegin()
5169 
      if ftype == TType.STOP:
5170 
        break
5171 
      if fid == 0:
483 rajveer 5172 
        if ftype == TType.LIST:
5173 
          self.success = []
685 chandransh 5174 
          (_etype31, _size28) = iprot.readListBegin()
5175 
          for _i32 in xrange(_size28):
5176 
            _elem33 = Order()
5177 
            _elem33.read(iprot)
5178 
            self.success.append(_elem33)
483 rajveer 5179 
          iprot.readListEnd()
94 ashish 5180 
        else:
5181 
          iprot.skip(ftype)
5182 
      elif fid == 1:
5183 
        if ftype == TType.STRUCT:
5184 
          self.ex = TransactionServiceException()
5185 
          self.ex.read(iprot)
5186 
        else:
5187 
          iprot.skip(ftype)
5188 
      else:
5189 
        iprot.skip(ftype)
5190 
      iprot.readFieldEnd()
5191 
    iprot.readStructEnd()
5192 
 
5193 
  def write(self, oprot):
5194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5196 
      return
483 rajveer 5197 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5198 
    if self.success is not None:
483 rajveer 5199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5201 
      for iter34 in self.success:
5202 
        iter34.write(oprot)
483 rajveer 5203 
      oprot.writeListEnd()
94 ashish 5204 
      oprot.writeFieldEnd()
3431 rajveer 5205 
    if self.ex is not None:
94 ashish 5206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5207 
      self.ex.write(oprot)
5208 
      oprot.writeFieldEnd()
5209 
    oprot.writeFieldStop()
5210 
    oprot.writeStructEnd()
5211 
 
3431 rajveer 5212 
  def validate(self):
5213 
    return
5214 
 
5215 
 
94 ashish 5216 
  def __repr__(self):
5217 
    L = ['%s=%r' % (key, value)
5218 
      for key, value in self.__dict__.iteritems()]
5219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5220 
 
5221 
  def __eq__(self, other):
5222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5223 
 
5224 
  def __ne__(self, other):
5225 
    return not (self == other)
5226 
 
4133 chandransh 5227 
class getOrdersInBatch_args:
5228 
  """
5229 
  Attributes:
5230 
   - statuses
5231 
   - offset
5232 
   - limit
5233 
   - warehouse_id
5234 
  """
5235 
 
5236 
  thrift_spec = (
5237 
    None, # 0
5238 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5239 
    (2, TType.I64, 'offset', None, None, ), # 2
5240 
    (3, TType.I64, 'limit', None, None, ), # 3
5241 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5242 
  )
5243 
 
5244 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5245 
    self.statuses = statuses
5246 
    self.offset = offset
5247 
    self.limit = limit
5248 
    self.warehouse_id = warehouse_id
5249 
 
5250 
  def read(self, iprot):
5251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5253 
      return
5254 
    iprot.readStructBegin()
5255 
    while True:
5256 
      (fname, ftype, fid) = iprot.readFieldBegin()
5257 
      if ftype == TType.STOP:
5258 
        break
5259 
      if fid == 1:
5260 
        if ftype == TType.LIST:
5261 
          self.statuses = []
5262 
          (_etype38, _size35) = iprot.readListBegin()
5263 
          for _i39 in xrange(_size35):
5264 
            _elem40 = iprot.readI32();
5265 
            self.statuses.append(_elem40)
5266 
          iprot.readListEnd()
5267 
        else:
5268 
          iprot.skip(ftype)
5269 
      elif fid == 2:
5270 
        if ftype == TType.I64:
5271 
          self.offset = iprot.readI64();
5272 
        else:
5273 
          iprot.skip(ftype)
5274 
      elif fid == 3:
5275 
        if ftype == TType.I64:
5276 
          self.limit = iprot.readI64();
5277 
        else:
5278 
          iprot.skip(ftype)
5279 
      elif fid == 4:
5280 
        if ftype == TType.I64:
5281 
          self.warehouse_id = iprot.readI64();
5282 
        else:
5283 
          iprot.skip(ftype)
5284 
      else:
5285 
        iprot.skip(ftype)
5286 
      iprot.readFieldEnd()
5287 
    iprot.readStructEnd()
5288 
 
5289 
  def write(self, oprot):
5290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5292 
      return
5293 
    oprot.writeStructBegin('getOrdersInBatch_args')
5294 
    if self.statuses is not None:
5295 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5296 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5297 
      for iter41 in self.statuses:
5298 
        oprot.writeI32(iter41)
5299 
      oprot.writeListEnd()
5300 
      oprot.writeFieldEnd()
5301 
    if self.offset is not None:
5302 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5303 
      oprot.writeI64(self.offset)
5304 
      oprot.writeFieldEnd()
5305 
    if self.limit is not None:
5306 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5307 
      oprot.writeI64(self.limit)
5308 
      oprot.writeFieldEnd()
5309 
    if self.warehouse_id is not None:
5310 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5311 
      oprot.writeI64(self.warehouse_id)
5312 
      oprot.writeFieldEnd()
5313 
    oprot.writeFieldStop()
5314 
    oprot.writeStructEnd()
5315 
 
5316 
  def validate(self):
5317 
    return
5318 
 
5319 
 
5320 
  def __repr__(self):
5321 
    L = ['%s=%r' % (key, value)
5322 
      for key, value in self.__dict__.iteritems()]
5323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5324 
 
5325 
  def __eq__(self, other):
5326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5327 
 
5328 
  def __ne__(self, other):
5329 
    return not (self == other)
5330 
 
5331 
class getOrdersInBatch_result:
5332 
  """
5333 
  Attributes:
5334 
   - success
5335 
   - ex
5336 
  """
5337 
 
5338 
  thrift_spec = (
5339 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5341 
  )
5342 
 
5343 
  def __init__(self, success=None, ex=None,):
5344 
    self.success = success
5345 
    self.ex = ex
5346 
 
5347 
  def read(self, iprot):
5348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5350 
      return
5351 
    iprot.readStructBegin()
5352 
    while True:
5353 
      (fname, ftype, fid) = iprot.readFieldBegin()
5354 
      if ftype == TType.STOP:
5355 
        break
5356 
      if fid == 0:
5357 
        if ftype == TType.LIST:
5358 
          self.success = []
5359 
          (_etype45, _size42) = iprot.readListBegin()
5360 
          for _i46 in xrange(_size42):
5361 
            _elem47 = Order()
5362 
            _elem47.read(iprot)
5363 
            self.success.append(_elem47)
5364 
          iprot.readListEnd()
5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      elif fid == 1:
5368 
        if ftype == TType.STRUCT:
5369 
          self.ex = TransactionServiceException()
5370 
          self.ex.read(iprot)
5371 
        else:
5372 
          iprot.skip(ftype)
5373 
      else:
5374 
        iprot.skip(ftype)
5375 
      iprot.readFieldEnd()
5376 
    iprot.readStructEnd()
5377 
 
5378 
  def write(self, oprot):
5379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5381 
      return
5382 
    oprot.writeStructBegin('getOrdersInBatch_result')
5383 
    if self.success is not None:
5384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 
      for iter48 in self.success:
5387 
        iter48.write(oprot)
5388 
      oprot.writeListEnd()
5389 
      oprot.writeFieldEnd()
5390 
    if self.ex is not None:
5391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5392 
      self.ex.write(oprot)
5393 
      oprot.writeFieldEnd()
5394 
    oprot.writeFieldStop()
5395 
    oprot.writeStructEnd()
5396 
 
5397 
  def validate(self):
5398 
    return
5399 
 
5400 
 
5401 
  def __repr__(self):
5402 
    L = ['%s=%r' % (key, value)
5403 
      for key, value in self.__dict__.iteritems()]
5404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5405 
 
5406 
  def __eq__(self, other):
5407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5408 
 
5409 
  def __ne__(self, other):
5410 
    return not (self == other)
5411 
 
5412 
class getOrderCount_args:
5413 
  """
5414 
  Attributes:
5415 
   - statuses
5416 
   - warehouseId
5417 
  """
5418 
 
5419 
  thrift_spec = (
5420 
    None, # 0
5421 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5422 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5423 
  )
5424 
 
5425 
  def __init__(self, statuses=None, warehouseId=None,):
5426 
    self.statuses = statuses
5427 
    self.warehouseId = warehouseId
5428 
 
5429 
  def read(self, iprot):
5430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5432 
      return
5433 
    iprot.readStructBegin()
5434 
    while True:
5435 
      (fname, ftype, fid) = iprot.readFieldBegin()
5436 
      if ftype == TType.STOP:
5437 
        break
5438 
      if fid == 1:
5439 
        if ftype == TType.LIST:
5440 
          self.statuses = []
5441 
          (_etype52, _size49) = iprot.readListBegin()
5442 
          for _i53 in xrange(_size49):
5443 
            _elem54 = iprot.readI32();
5444 
            self.statuses.append(_elem54)
5445 
          iprot.readListEnd()
5446 
        else:
5447 
          iprot.skip(ftype)
5448 
      elif fid == 2:
5449 
        if ftype == TType.I64:
5450 
          self.warehouseId = iprot.readI64();
5451 
        else:
5452 
          iprot.skip(ftype)
5453 
      else:
5454 
        iprot.skip(ftype)
5455 
      iprot.readFieldEnd()
5456 
    iprot.readStructEnd()
5457 
 
5458 
  def write(self, oprot):
5459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5461 
      return
5462 
    oprot.writeStructBegin('getOrderCount_args')
5463 
    if self.statuses is not None:
5464 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5465 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5466 
      for iter55 in self.statuses:
5467 
        oprot.writeI32(iter55)
5468 
      oprot.writeListEnd()
5469 
      oprot.writeFieldEnd()
5470 
    if self.warehouseId is not None:
5471 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5472 
      oprot.writeI64(self.warehouseId)
5473 
      oprot.writeFieldEnd()
5474 
    oprot.writeFieldStop()
5475 
    oprot.writeStructEnd()
5476 
 
5477 
  def validate(self):
5478 
    return
5479 
 
5480 
 
5481 
  def __repr__(self):
5482 
    L = ['%s=%r' % (key, value)
5483 
      for key, value in self.__dict__.iteritems()]
5484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5485 
 
5486 
  def __eq__(self, other):
5487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5488 
 
5489 
  def __ne__(self, other):
5490 
    return not (self == other)
5491 
 
5492 
class getOrderCount_result:
5493 
  """
5494 
  Attributes:
5495 
   - success
5496 
   - ex
5497 
  """
5498 
 
5499 
  thrift_spec = (
5500 
    (0, TType.I32, 'success', None, None, ), # 0
5501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5502 
  )
5503 
 
5504 
  def __init__(self, success=None, ex=None,):
5505 
    self.success = success
5506 
    self.ex = ex
5507 
 
5508 
  def read(self, iprot):
5509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5511 
      return
5512 
    iprot.readStructBegin()
5513 
    while True:
5514 
      (fname, ftype, fid) = iprot.readFieldBegin()
5515 
      if ftype == TType.STOP:
5516 
        break
5517 
      if fid == 0:
5518 
        if ftype == TType.I32:
5519 
          self.success = iprot.readI32();
5520 
        else:
5521 
          iprot.skip(ftype)
5522 
      elif fid == 1:
5523 
        if ftype == TType.STRUCT:
5524 
          self.ex = TransactionServiceException()
5525 
          self.ex.read(iprot)
5526 
        else:
5527 
          iprot.skip(ftype)
5528 
      else:
5529 
        iprot.skip(ftype)
5530 
      iprot.readFieldEnd()
5531 
    iprot.readStructEnd()
5532 
 
5533 
  def write(self, oprot):
5534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5536 
      return
5537 
    oprot.writeStructBegin('getOrderCount_result')
5538 
    if self.success is not None:
5539 
      oprot.writeFieldBegin('success', TType.I32, 0)
5540 
      oprot.writeI32(self.success)
5541 
      oprot.writeFieldEnd()
5542 
    if self.ex is not None:
5543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5544 
      self.ex.write(oprot)
5545 
      oprot.writeFieldEnd()
5546 
    oprot.writeFieldStop()
5547 
    oprot.writeStructEnd()
5548 
 
5549 
  def validate(self):
5550 
    return
5551 
 
5552 
 
5553 
  def __repr__(self):
5554 
    L = ['%s=%r' % (key, value)
5555 
      for key, value in self.__dict__.iteritems()]
5556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5557 
 
5558 
  def __eq__(self, other):
5559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5560 
 
5561 
  def __ne__(self, other):
5562 
    return not (self == other)
5563 
 
999 varun.gupt 5564 
class getOrdersByBillingDate_args:
5565 
  """
5566 
  Attributes:
5567 
   - status
5568 
   - start_billing_date
5569 
   - end_billing_date
5570 
   - warehouse_id
5571 
  """
5572 
 
5573 
  thrift_spec = (
5574 
    None, # 0
5575 
    (1, TType.I32, 'status', None, None, ), # 1
5576 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
5577 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
5578 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5579 
  )
5580 
 
5581 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
5582 
    self.status = status
5583 
    self.start_billing_date = start_billing_date
5584 
    self.end_billing_date = end_billing_date
5585 
    self.warehouse_id = warehouse_id
5586 
 
5587 
  def read(self, iprot):
5588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5590 
      return
5591 
    iprot.readStructBegin()
5592 
    while True:
5593 
      (fname, ftype, fid) = iprot.readFieldBegin()
5594 
      if ftype == TType.STOP:
5595 
        break
5596 
      if fid == 1:
5597 
        if ftype == TType.I32:
5598 
          self.status = iprot.readI32();
5599 
        else:
5600 
          iprot.skip(ftype)
5601 
      elif fid == 2:
5602 
        if ftype == TType.I64:
5603 
          self.start_billing_date = iprot.readI64();
5604 
        else:
5605 
          iprot.skip(ftype)
5606 
      elif fid == 3:
5607 
        if ftype == TType.I64:
5608 
          self.end_billing_date = iprot.readI64();
5609 
        else:
5610 
          iprot.skip(ftype)
5611 
      elif fid == 4:
5612 
        if ftype == TType.I64:
5613 
          self.warehouse_id = iprot.readI64();
5614 
        else:
5615 
          iprot.skip(ftype)
5616 
      else:
5617 
        iprot.skip(ftype)
5618 
      iprot.readFieldEnd()
5619 
    iprot.readStructEnd()
5620 
 
5621 
  def write(self, oprot):
5622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5624 
      return
5625 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 5626 
    if self.status is not None:
999 varun.gupt 5627 
      oprot.writeFieldBegin('status', TType.I32, 1)
5628 
      oprot.writeI32(self.status)
5629 
      oprot.writeFieldEnd()
3431 rajveer 5630 
    if self.start_billing_date is not None:
999 varun.gupt 5631 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
5632 
      oprot.writeI64(self.start_billing_date)
5633 
      oprot.writeFieldEnd()
3431 rajveer 5634 
    if self.end_billing_date is not None:
999 varun.gupt 5635 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
5636 
      oprot.writeI64(self.end_billing_date)
5637 
      oprot.writeFieldEnd()
3431 rajveer 5638 
    if self.warehouse_id is not None:
999 varun.gupt 5639 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5640 
      oprot.writeI64(self.warehouse_id)
5641 
      oprot.writeFieldEnd()
5642 
    oprot.writeFieldStop()
5643 
    oprot.writeStructEnd()
5644 
 
3431 rajveer 5645 
  def validate(self):
5646 
    return
5647 
 
5648 
 
999 varun.gupt 5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
5660 
class getOrdersByBillingDate_result:
5661 
  """
5662 
  Attributes:
5663 
   - success
5664 
   - ex
5665 
  """
5666 
 
5667 
  thrift_spec = (
5668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5670 
  )
5671 
 
5672 
  def __init__(self, success=None, ex=None,):
5673 
    self.success = success
5674 
    self.ex = ex
5675 
 
5676 
  def read(self, iprot):
5677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5679 
      return
5680 
    iprot.readStructBegin()
5681 
    while True:
5682 
      (fname, ftype, fid) = iprot.readFieldBegin()
5683 
      if ftype == TType.STOP:
5684 
        break
5685 
      if fid == 0:
5686 
        if ftype == TType.LIST:
5687 
          self.success = []
4133 chandransh 5688 
          (_etype59, _size56) = iprot.readListBegin()
5689 
          for _i60 in xrange(_size56):
5690 
            _elem61 = Order()
5691 
            _elem61.read(iprot)
5692 
            self.success.append(_elem61)
999 varun.gupt 5693 
          iprot.readListEnd()
5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      elif fid == 1:
5697 
        if ftype == TType.STRUCT:
5698 
          self.ex = TransactionServiceException()
5699 
          self.ex.read(iprot)
5700 
        else:
5701 
          iprot.skip(ftype)
5702 
      else:
5703 
        iprot.skip(ftype)
5704 
      iprot.readFieldEnd()
5705 
    iprot.readStructEnd()
5706 
 
5707 
  def write(self, oprot):
5708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5710 
      return
5711 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 5712 
    if self.success is not None:
999 varun.gupt 5713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5715 
      for iter62 in self.success:
5716 
        iter62.write(oprot)
999 varun.gupt 5717 
      oprot.writeListEnd()
5718 
      oprot.writeFieldEnd()
3431 rajveer 5719 
    if self.ex is not None:
999 varun.gupt 5720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5721 
      self.ex.write(oprot)
5722 
      oprot.writeFieldEnd()
5723 
    oprot.writeFieldStop()
5724 
    oprot.writeStructEnd()
5725 
 
3431 rajveer 5726 
  def validate(self):
5727 
    return
5728 
 
5729 
 
999 varun.gupt 5730 
  def __repr__(self):
5731 
    L = ['%s=%r' % (key, value)
5732 
      for key, value in self.__dict__.iteritems()]
5733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5734 
 
5735 
  def __eq__(self, other):
5736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5737 
 
5738 
  def __ne__(self, other):
5739 
    return not (self == other)
5740 
 
3427 chandransh 5741 
class getOrdersByShippingDate_args:
5742 
  """
5743 
  Attributes:
5744 
   - fromShippingDate
5745 
   - toShippingDate
5746 
   - providerId
5747 
   - warehouseId
3451 chandransh 5748 
   - cod
3427 chandransh 5749 
  """
5750 
 
5751 
  thrift_spec = (
5752 
    None, # 0
5753 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
5754 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
5755 
    (3, TType.I64, 'providerId', None, None, ), # 3
5756 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 5757 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 5758 
  )
5759 
 
3451 chandransh 5760 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 5761 
    self.fromShippingDate = fromShippingDate
5762 
    self.toShippingDate = toShippingDate
5763 
    self.providerId = providerId
5764 
    self.warehouseId = warehouseId
3451 chandransh 5765 
    self.cod = cod
3427 chandransh 5766 
 
5767 
  def read(self, iprot):
5768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5770 
      return
5771 
    iprot.readStructBegin()
5772 
    while True:
5773 
      (fname, ftype, fid) = iprot.readFieldBegin()
5774 
      if ftype == TType.STOP:
5775 
        break
5776 
      if fid == 1:
5777 
        if ftype == TType.I64:
5778 
          self.fromShippingDate = iprot.readI64();
5779 
        else:
5780 
          iprot.skip(ftype)
5781 
      elif fid == 2:
5782 
        if ftype == TType.I64:
5783 
          self.toShippingDate = iprot.readI64();
5784 
        else:
5785 
          iprot.skip(ftype)
5786 
      elif fid == 3:
5787 
        if ftype == TType.I64:
5788 
          self.providerId = iprot.readI64();
5789 
        else:
5790 
          iprot.skip(ftype)
5791 
      elif fid == 4:
5792 
        if ftype == TType.I64:
5793 
          self.warehouseId = iprot.readI64();
5794 
        else:
5795 
          iprot.skip(ftype)
3451 chandransh 5796 
      elif fid == 5:
5797 
        if ftype == TType.BOOL:
5798 
          self.cod = iprot.readBool();
5799 
        else:
5800 
          iprot.skip(ftype)
3427 chandransh 5801 
      else:
5802 
        iprot.skip(ftype)
5803 
      iprot.readFieldEnd()
5804 
    iprot.readStructEnd()
5805 
 
5806 
  def write(self, oprot):
5807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5809 
      return
5810 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 5811 
    if self.fromShippingDate is not None:
3427 chandransh 5812 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
5813 
      oprot.writeI64(self.fromShippingDate)
5814 
      oprot.writeFieldEnd()
3431 rajveer 5815 
    if self.toShippingDate is not None:
3427 chandransh 5816 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
5817 
      oprot.writeI64(self.toShippingDate)
5818 
      oprot.writeFieldEnd()
3431 rajveer 5819 
    if self.providerId is not None:
3427 chandransh 5820 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
5821 
      oprot.writeI64(self.providerId)
5822 
      oprot.writeFieldEnd()
3431 rajveer 5823 
    if self.warehouseId is not None:
3427 chandransh 5824 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
5825 
      oprot.writeI64(self.warehouseId)
5826 
      oprot.writeFieldEnd()
3451 chandransh 5827 
    if self.cod is not None:
5828 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
5829 
      oprot.writeBool(self.cod)
5830 
      oprot.writeFieldEnd()
3427 chandransh 5831 
    oprot.writeFieldStop()
5832 
    oprot.writeStructEnd()
5833 
 
3431 rajveer 5834 
  def validate(self):
5835 
    return
5836 
 
5837 
 
3427 chandransh 5838 
  def __repr__(self):
5839 
    L = ['%s=%r' % (key, value)
5840 
      for key, value in self.__dict__.iteritems()]
5841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5842 
 
5843 
  def __eq__(self, other):
5844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5845 
 
5846 
  def __ne__(self, other):
5847 
    return not (self == other)
5848 
 
5849 
class getOrdersByShippingDate_result:
5850 
  """
5851 
  Attributes:
5852 
   - success
5853 
   - ex
5854 
  """
5855 
 
5856 
  thrift_spec = (
5857 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5859 
  )
5860 
 
5861 
  def __init__(self, success=None, ex=None,):
5862 
    self.success = success
5863 
    self.ex = ex
5864 
 
5865 
  def read(self, iprot):
5866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5868 
      return
5869 
    iprot.readStructBegin()
5870 
    while True:
5871 
      (fname, ftype, fid) = iprot.readFieldBegin()
5872 
      if ftype == TType.STOP:
5873 
        break
5874 
      if fid == 0:
5875 
        if ftype == TType.LIST:
5876 
          self.success = []
4133 chandransh 5877 
          (_etype66, _size63) = iprot.readListBegin()
5878 
          for _i67 in xrange(_size63):
5879 
            _elem68 = Order()
5880 
            _elem68.read(iprot)
5881 
            self.success.append(_elem68)
3427 chandransh 5882 
          iprot.readListEnd()
5883 
        else:
5884 
          iprot.skip(ftype)
5885 
      elif fid == 1:
5886 
        if ftype == TType.STRUCT:
5887 
          self.ex = TransactionServiceException()
5888 
          self.ex.read(iprot)
5889 
        else:
5890 
          iprot.skip(ftype)
5891 
      else:
5892 
        iprot.skip(ftype)
5893 
      iprot.readFieldEnd()
5894 
    iprot.readStructEnd()
5895 
 
5896 
  def write(self, oprot):
5897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5899 
      return
5900 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 5901 
    if self.success is not None:
3427 chandransh 5902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 5904 
      for iter69 in self.success:
5905 
        iter69.write(oprot)
3427 chandransh 5906 
      oprot.writeListEnd()
5907 
      oprot.writeFieldEnd()
3431 rajveer 5908 
    if self.ex is not None:
3427 chandransh 5909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5910 
      self.ex.write(oprot)
5911 
      oprot.writeFieldEnd()
5912 
    oprot.writeFieldStop()
5913 
    oprot.writeStructEnd()
5914 
 
3431 rajveer 5915 
  def validate(self):
5916 
    return
5917 
 
5918 
 
3427 chandransh 5919 
  def __repr__(self):
5920 
    L = ['%s=%r' % (key, value)
5921 
      for key, value in self.__dict__.iteritems()]
5922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5923 
 
5924 
  def __eq__(self, other):
5925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5926 
 
5927 
  def __ne__(self, other):
5928 
    return not (self == other)
5929 
 
1382 varun.gupt 5930 
class getReturnableOrdersForCustomer_args:
5931 
  """
5932 
  Attributes:
5933 
   - customer_id
5934 
   - limit
5935 
  """
5936 
 
5937 
  thrift_spec = (
5938 
    None, # 0
5939 
    (1, TType.I64, 'customer_id', None, None, ), # 1
5940 
    (2, TType.I64, 'limit', None, None, ), # 2
5941 
  )
5942 
 
5943 
  def __init__(self, customer_id=None, limit=None,):
5944 
    self.customer_id = customer_id
5945 
    self.limit = limit
5946 
 
5947 
  def read(self, iprot):
5948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5950 
      return
5951 
    iprot.readStructBegin()
5952 
    while True:
5953 
      (fname, ftype, fid) = iprot.readFieldBegin()
5954 
      if ftype == TType.STOP:
5955 
        break
5956 
      if fid == 1:
5957 
        if ftype == TType.I64:
5958 
          self.customer_id = iprot.readI64();
5959 
        else:
5960 
          iprot.skip(ftype)
5961 
      elif fid == 2:
5962 
        if ftype == TType.I64:
5963 
          self.limit = iprot.readI64();
5964 
        else:
5965 
          iprot.skip(ftype)
5966 
      else:
5967 
        iprot.skip(ftype)
5968 
      iprot.readFieldEnd()
5969 
    iprot.readStructEnd()
5970 
 
5971 
  def write(self, oprot):
5972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5974 
      return
5975 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 5976 
    if self.customer_id is not None:
1382 varun.gupt 5977 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
5978 
      oprot.writeI64(self.customer_id)
5979 
      oprot.writeFieldEnd()
3431 rajveer 5980 
    if self.limit is not None:
1382 varun.gupt 5981 
      oprot.writeFieldBegin('limit', TType.I64, 2)
5982 
      oprot.writeI64(self.limit)
5983 
      oprot.writeFieldEnd()
5984 
    oprot.writeFieldStop()
5985 
    oprot.writeStructEnd()
5986 
 
3431 rajveer 5987 
  def validate(self):
5988 
    return
5989 
 
5990 
 
1382 varun.gupt 5991 
  def __repr__(self):
5992 
    L = ['%s=%r' % (key, value)
5993 
      for key, value in self.__dict__.iteritems()]
5994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5995 
 
5996 
  def __eq__(self, other):
5997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5998 
 
5999 
  def __ne__(self, other):
6000 
    return not (self == other)
6001 
 
6002 
class getReturnableOrdersForCustomer_result:
6003 
  """
6004 
  Attributes:
6005 
   - success
6006 
   - ex
6007 
  """
6008 
 
6009 
  thrift_spec = (
6010 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6012 
  )
6013 
 
6014 
  def __init__(self, success=None, ex=None,):
6015 
    self.success = success
6016 
    self.ex = ex
6017 
 
6018 
  def read(self, iprot):
6019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6021 
      return
6022 
    iprot.readStructBegin()
6023 
    while True:
6024 
      (fname, ftype, fid) = iprot.readFieldBegin()
6025 
      if ftype == TType.STOP:
6026 
        break
6027 
      if fid == 0:
6028 
        if ftype == TType.LIST:
6029 
          self.success = []
4133 chandransh 6030 
          (_etype73, _size70) = iprot.readListBegin()
6031 
          for _i74 in xrange(_size70):
6032 
            _elem75 = iprot.readI64();
6033 
            self.success.append(_elem75)
1382 varun.gupt 6034 
          iprot.readListEnd()
6035 
        else:
6036 
          iprot.skip(ftype)
6037 
      elif fid == 1:
6038 
        if ftype == TType.STRUCT:
6039 
          self.ex = TransactionServiceException()
6040 
          self.ex.read(iprot)
6041 
        else:
6042 
          iprot.skip(ftype)
6043 
      else:
6044 
        iprot.skip(ftype)
6045 
      iprot.readFieldEnd()
6046 
    iprot.readStructEnd()
6047 
 
6048 
  def write(self, oprot):
6049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6051 
      return
6052 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6053 
    if self.success is not None:
1382 varun.gupt 6054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6055 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6056 
      for iter76 in self.success:
6057 
        oprot.writeI64(iter76)
1382 varun.gupt 6058 
      oprot.writeListEnd()
6059 
      oprot.writeFieldEnd()
3431 rajveer 6060 
    if self.ex is not None:
1382 varun.gupt 6061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6062 
      self.ex.write(oprot)
6063 
      oprot.writeFieldEnd()
6064 
    oprot.writeFieldStop()
6065 
    oprot.writeStructEnd()
6066 
 
3431 rajveer 6067 
  def validate(self):
6068 
    return
6069 
 
6070 
 
1382 varun.gupt 6071 
  def __repr__(self):
6072 
    L = ['%s=%r' % (key, value)
6073 
      for key, value in self.__dict__.iteritems()]
6074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6075 
 
6076 
  def __eq__(self, other):
6077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6078 
 
6079 
  def __ne__(self, other):
6080 
    return not (self == other)
6081 
 
6082 
class getCancellableOrdersForCustomer_args:
6083 
  """
6084 
  Attributes:
6085 
   - customer_id
6086 
   - limit
6087 
  """
6088 
 
6089 
  thrift_spec = (
6090 
    None, # 0
6091 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6092 
    (2, TType.I64, 'limit', None, None, ), # 2
6093 
  )
6094 
 
6095 
  def __init__(self, customer_id=None, limit=None,):
6096 
    self.customer_id = customer_id
6097 
    self.limit = limit
6098 
 
6099 
  def read(self, iprot):
6100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6102 
      return
6103 
    iprot.readStructBegin()
6104 
    while True:
6105 
      (fname, ftype, fid) = iprot.readFieldBegin()
6106 
      if ftype == TType.STOP:
6107 
        break
6108 
      if fid == 1:
6109 
        if ftype == TType.I64:
6110 
          self.customer_id = iprot.readI64();
6111 
        else:
6112 
          iprot.skip(ftype)
6113 
      elif fid == 2:
6114 
        if ftype == TType.I64:
6115 
          self.limit = iprot.readI64();
6116 
        else:
6117 
          iprot.skip(ftype)
6118 
      else:
6119 
        iprot.skip(ftype)
6120 
      iprot.readFieldEnd()
6121 
    iprot.readStructEnd()
6122 
 
6123 
  def write(self, oprot):
6124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6126 
      return
6127 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6128 
    if self.customer_id is not None:
1382 varun.gupt 6129 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6130 
      oprot.writeI64(self.customer_id)
6131 
      oprot.writeFieldEnd()
3431 rajveer 6132 
    if self.limit is not None:
1382 varun.gupt 6133 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6134 
      oprot.writeI64(self.limit)
6135 
      oprot.writeFieldEnd()
6136 
    oprot.writeFieldStop()
6137 
    oprot.writeStructEnd()
6138 
 
3431 rajveer 6139 
  def validate(self):
6140 
    return
6141 
 
6142 
 
1382 varun.gupt 6143 
  def __repr__(self):
6144 
    L = ['%s=%r' % (key, value)
6145 
      for key, value in self.__dict__.iteritems()]
6146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6147 
 
6148 
  def __eq__(self, other):
6149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6150 
 
6151 
  def __ne__(self, other):
6152 
    return not (self == other)
6153 
 
6154 
class getCancellableOrdersForCustomer_result:
6155 
  """
6156 
  Attributes:
6157 
   - success
6158 
   - ex
6159 
  """
6160 
 
6161 
  thrift_spec = (
6162 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6164 
  )
6165 
 
6166 
  def __init__(self, success=None, ex=None,):
6167 
    self.success = success
6168 
    self.ex = ex
6169 
 
6170 
  def read(self, iprot):
6171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6173 
      return
6174 
    iprot.readStructBegin()
6175 
    while True:
6176 
      (fname, ftype, fid) = iprot.readFieldBegin()
6177 
      if ftype == TType.STOP:
6178 
        break
6179 
      if fid == 0:
6180 
        if ftype == TType.LIST:
6181 
          self.success = []
4133 chandransh 6182 
          (_etype80, _size77) = iprot.readListBegin()
6183 
          for _i81 in xrange(_size77):
6184 
            _elem82 = iprot.readI64();
6185 
            self.success.append(_elem82)
1382 varun.gupt 6186 
          iprot.readListEnd()
6187 
        else:
6188 
          iprot.skip(ftype)
6189 
      elif fid == 1:
6190 
        if ftype == TType.STRUCT:
6191 
          self.ex = TransactionServiceException()
6192 
          self.ex.read(iprot)
6193 
        else:
6194 
          iprot.skip(ftype)
6195 
      else:
6196 
        iprot.skip(ftype)
6197 
      iprot.readFieldEnd()
6198 
    iprot.readStructEnd()
6199 
 
6200 
  def write(self, oprot):
6201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6203 
      return
6204 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6205 
    if self.success is not None:
1382 varun.gupt 6206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6207 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6208 
      for iter83 in self.success:
6209 
        oprot.writeI64(iter83)
1382 varun.gupt 6210 
      oprot.writeListEnd()
6211 
      oprot.writeFieldEnd()
3431 rajveer 6212 
    if self.ex is not None:
1382 varun.gupt 6213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6214 
      self.ex.write(oprot)
6215 
      oprot.writeFieldEnd()
6216 
    oprot.writeFieldStop()
6217 
    oprot.writeStructEnd()
6218 
 
3431 rajveer 6219 
  def validate(self):
6220 
    return
6221 
 
6222 
 
1382 varun.gupt 6223 
  def __repr__(self):
6224 
    L = ['%s=%r' % (key, value)
6225 
      for key, value in self.__dict__.iteritems()]
6226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6227 
 
6228 
  def __eq__(self, other):
6229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6230 
 
6231 
  def __ne__(self, other):
6232 
    return not (self == other)
6233 
 
483 rajveer 6234 
class changeOrderStatus_args:
94 ashish 6235 
  """
6236 
  Attributes:
483 rajveer 6237 
   - orderId
6238 
   - status
6239 
   - description
94 ashish 6240 
  """
6241 
 
6242 
  thrift_spec = (
6243 
    None, # 0
483 rajveer 6244 
    (1, TType.I64, 'orderId', None, None, ), # 1
6245 
    (2, TType.I32, 'status', None, None, ), # 2
6246 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6247 
  )
6248 
 
483 rajveer 6249 
  def __init__(self, orderId=None, status=None, description=None,):
6250 
    self.orderId = orderId
6251 
    self.status = status
6252 
    self.description = description
94 ashish 6253 
 
6254 
  def read(self, iprot):
6255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6257 
      return
6258 
    iprot.readStructBegin()
6259 
    while True:
6260 
      (fname, ftype, fid) = iprot.readFieldBegin()
6261 
      if ftype == TType.STOP:
6262 
        break
6263 
      if fid == 1:
6264 
        if ftype == TType.I64:
483 rajveer 6265 
          self.orderId = iprot.readI64();
94 ashish 6266 
        else:
6267 
          iprot.skip(ftype)
6268 
      elif fid == 2:
483 rajveer 6269 
        if ftype == TType.I32:
6270 
          self.status = iprot.readI32();
94 ashish 6271 
        else:
6272 
          iprot.skip(ftype)
483 rajveer 6273 
      elif fid == 3:
6274 
        if ftype == TType.STRING:
6275 
          self.description = iprot.readString();
6276 
        else:
6277 
          iprot.skip(ftype)
94 ashish 6278 
      else:
6279 
        iprot.skip(ftype)
6280 
      iprot.readFieldEnd()
6281 
    iprot.readStructEnd()
6282 
 
6283 
  def write(self, oprot):
6284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6286 
      return
483 rajveer 6287 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6288 
    if self.orderId is not None:
483 rajveer 6289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6290 
      oprot.writeI64(self.orderId)
94 ashish 6291 
      oprot.writeFieldEnd()
3431 rajveer 6292 
    if self.status is not None:
483 rajveer 6293 
      oprot.writeFieldBegin('status', TType.I32, 2)
6294 
      oprot.writeI32(self.status)
94 ashish 6295 
      oprot.writeFieldEnd()
3431 rajveer 6296 
    if self.description is not None:
483 rajveer 6297 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6298 
      oprot.writeString(self.description)
6299 
      oprot.writeFieldEnd()
94 ashish 6300 
    oprot.writeFieldStop()
6301 
    oprot.writeStructEnd()
6302 
 
3431 rajveer 6303 
  def validate(self):
6304 
    return
6305 
 
6306 
 
94 ashish 6307 
  def __repr__(self):
6308 
    L = ['%s=%r' % (key, value)
6309 
      for key, value in self.__dict__.iteritems()]
6310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6311 
 
6312 
  def __eq__(self, other):
6313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6314 
 
6315 
  def __ne__(self, other):
6316 
    return not (self == other)
6317 
 
483 rajveer 6318 
class changeOrderStatus_result:
94 ashish 6319 
  """
6320 
  Attributes:
6321 
   - success
6322 
   - ex
6323 
  """
6324 
 
6325 
  thrift_spec = (
6326 
    (0, TType.BOOL, 'success', None, None, ), # 0
6327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6328 
  )
6329 
 
6330 
  def __init__(self, success=None, ex=None,):
6331 
    self.success = success
6332 
    self.ex = ex
6333 
 
6334 
  def read(self, iprot):
6335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6337 
      return
6338 
    iprot.readStructBegin()
6339 
    while True:
6340 
      (fname, ftype, fid) = iprot.readFieldBegin()
6341 
      if ftype == TType.STOP:
6342 
        break
6343 
      if fid == 0:
6344 
        if ftype == TType.BOOL:
6345 
          self.success = iprot.readBool();
6346 
        else:
6347 
          iprot.skip(ftype)
6348 
      elif fid == 1:
6349 
        if ftype == TType.STRUCT:
6350 
          self.ex = TransactionServiceException()
6351 
          self.ex.read(iprot)
6352 
        else:
6353 
          iprot.skip(ftype)
6354 
      else:
6355 
        iprot.skip(ftype)
6356 
      iprot.readFieldEnd()
6357 
    iprot.readStructEnd()
6358 
 
6359 
  def write(self, oprot):
6360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6362 
      return
483 rajveer 6363 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6364 
    if self.success is not None:
94 ashish 6365 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6366 
      oprot.writeBool(self.success)
6367 
      oprot.writeFieldEnd()
3431 rajveer 6368 
    if self.ex is not None:
94 ashish 6369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6370 
      self.ex.write(oprot)
6371 
      oprot.writeFieldEnd()
6372 
    oprot.writeFieldStop()
6373 
    oprot.writeStructEnd()
6374 
 
3431 rajveer 6375 
  def validate(self):
6376 
    return
6377 
 
6378 
 
94 ashish 6379 
  def __repr__(self):
6380 
    L = ['%s=%r' % (key, value)
6381 
      for key, value in self.__dict__.iteritems()]
6382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6383 
 
6384 
  def __eq__(self, other):
6385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6386 
 
6387 
  def __ne__(self, other):
6388 
    return not (self == other)
6389 
 
3064 chandransh 6390 
class getOrdersForTransaction_args:
494 rajveer 6391 
  """
6392 
  Attributes:
3064 chandransh 6393 
   - transactionId
6394 
   - customerId
494 rajveer 6395 
  """
6396 
 
6397 
  thrift_spec = (
6398 
    None, # 0
3064 chandransh 6399 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6400 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6401 
  )
6402 
 
3064 chandransh 6403 
  def __init__(self, transactionId=None, customerId=None,):
6404 
    self.transactionId = transactionId
6405 
    self.customerId = customerId
494 rajveer 6406 
 
6407 
  def read(self, iprot):
6408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6410 
      return
6411 
    iprot.readStructBegin()
6412 
    while True:
6413 
      (fname, ftype, fid) = iprot.readFieldBegin()
6414 
      if ftype == TType.STOP:
6415 
        break
6416 
      if fid == 1:
6417 
        if ftype == TType.I64:
3064 chandransh 6418 
          self.transactionId = iprot.readI64();
494 rajveer 6419 
        else:
6420 
          iprot.skip(ftype)
6421 
      elif fid == 2:
3064 chandransh 6422 
        if ftype == TType.I64:
6423 
          self.customerId = iprot.readI64();
494 rajveer 6424 
        else:
6425 
          iprot.skip(ftype)
6426 
      else:
6427 
        iprot.skip(ftype)
6428 
      iprot.readFieldEnd()
6429 
    iprot.readStructEnd()
6430 
 
6431 
  def write(self, oprot):
6432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6434 
      return
3064 chandransh 6435 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6436 
    if self.transactionId is not None:
3064 chandransh 6437 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6438 
      oprot.writeI64(self.transactionId)
494 rajveer 6439 
      oprot.writeFieldEnd()
3431 rajveer 6440 
    if self.customerId is not None:
3064 chandransh 6441 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6442 
      oprot.writeI64(self.customerId)
494 rajveer 6443 
      oprot.writeFieldEnd()
6444 
    oprot.writeFieldStop()
6445 
    oprot.writeStructEnd()
6446 
 
3431 rajveer 6447 
  def validate(self):
6448 
    return
6449 
 
6450 
 
494 rajveer 6451 
  def __repr__(self):
6452 
    L = ['%s=%r' % (key, value)
6453 
      for key, value in self.__dict__.iteritems()]
6454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6455 
 
6456 
  def __eq__(self, other):
6457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6458 
 
6459 
  def __ne__(self, other):
6460 
    return not (self == other)
6461 
 
3064 chandransh 6462 
class getOrdersForTransaction_result:
494 rajveer 6463 
  """
6464 
  Attributes:
6465 
   - success
6466 
   - ex
6467 
  """
6468 
 
6469 
  thrift_spec = (
3064 chandransh 6470 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6472 
  )
6473 
 
6474 
  def __init__(self, success=None, ex=None,):
6475 
    self.success = success
6476 
    self.ex = ex
6477 
 
6478 
  def read(self, iprot):
6479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6481 
      return
6482 
    iprot.readStructBegin()
6483 
    while True:
6484 
      (fname, ftype, fid) = iprot.readFieldBegin()
6485 
      if ftype == TType.STOP:
6486 
        break
6487 
      if fid == 0:
3064 chandransh 6488 
        if ftype == TType.LIST:
6489 
          self.success = []
4133 chandransh 6490 
          (_etype87, _size84) = iprot.readListBegin()
6491 
          for _i88 in xrange(_size84):
6492 
            _elem89 = Order()
6493 
            _elem89.read(iprot)
6494 
            self.success.append(_elem89)
3064 chandransh 6495 
          iprot.readListEnd()
494 rajveer 6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      elif fid == 1:
6499 
        if ftype == TType.STRUCT:
6500 
          self.ex = TransactionServiceException()
6501 
          self.ex.read(iprot)
6502 
        else:
6503 
          iprot.skip(ftype)
6504 
      else:
6505 
        iprot.skip(ftype)
6506 
      iprot.readFieldEnd()
6507 
    iprot.readStructEnd()
6508 
 
6509 
  def write(self, oprot):
6510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6512 
      return
3064 chandransh 6513 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 6514 
    if self.success is not None:
3064 chandransh 6515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6517 
      for iter90 in self.success:
6518 
        iter90.write(oprot)
3064 chandransh 6519 
      oprot.writeListEnd()
494 rajveer 6520 
      oprot.writeFieldEnd()
3431 rajveer 6521 
    if self.ex is not None:
494 rajveer 6522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6523 
      self.ex.write(oprot)
6524 
      oprot.writeFieldEnd()
6525 
    oprot.writeFieldStop()
6526 
    oprot.writeStructEnd()
6527 
 
3431 rajveer 6528 
  def validate(self):
6529 
    return
6530 
 
6531 
 
494 rajveer 6532 
  def __repr__(self):
6533 
    L = ['%s=%r' % (key, value)
6534 
      for key, value in self.__dict__.iteritems()]
6535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6536 
 
6537 
  def __eq__(self, other):
6538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6539 
 
6540 
  def __ne__(self, other):
6541 
    return not (self == other)
6542 
 
3064 chandransh 6543 
class getOrdersForCustomer_args:
1149 chandransh 6544 
  """
6545 
  Attributes:
3064 chandransh 6546 
   - customerId
6547 
   - from_date
6548 
   - to_date
6549 
   - statuses
1149 chandransh 6550 
  """
6551 
 
6552 
  thrift_spec = (
6553 
    None, # 0
3064 chandransh 6554 
    (1, TType.I64, 'customerId', None, None, ), # 1
6555 
    (2, TType.I64, 'from_date', None, None, ), # 2
6556 
    (3, TType.I64, 'to_date', None, None, ), # 3
6557 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 6558 
  )
6559 
 
3064 chandransh 6560 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
6561 
    self.customerId = customerId
6562 
    self.from_date = from_date
6563 
    self.to_date = to_date
6564 
    self.statuses = statuses
1149 chandransh 6565 
 
6566 
  def read(self, iprot):
6567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6569 
      return
6570 
    iprot.readStructBegin()
6571 
    while True:
6572 
      (fname, ftype, fid) = iprot.readFieldBegin()
6573 
      if ftype == TType.STOP:
6574 
        break
6575 
      if fid == 1:
6576 
        if ftype == TType.I64:
3064 chandransh 6577 
          self.customerId = iprot.readI64();
1149 chandransh 6578 
        else:
6579 
          iprot.skip(ftype)
6580 
      elif fid == 2:
6581 
        if ftype == TType.I64:
3064 chandransh 6582 
          self.from_date = iprot.readI64();
1149 chandransh 6583 
        else:
6584 
          iprot.skip(ftype)
2783 chandransh 6585 
      elif fid == 3:
6586 
        if ftype == TType.I64:
3064 chandransh 6587 
          self.to_date = iprot.readI64();
2783 chandransh 6588 
        else:
6589 
          iprot.skip(ftype)
6590 
      elif fid == 4:
3064 chandransh 6591 
        if ftype == TType.LIST:
6592 
          self.statuses = []
4133 chandransh 6593 
          (_etype94, _size91) = iprot.readListBegin()
6594 
          for _i95 in xrange(_size91):
6595 
            _elem96 = iprot.readI32();
6596 
            self.statuses.append(_elem96)
3064 chandransh 6597 
          iprot.readListEnd()
2783 chandransh 6598 
        else:
6599 
          iprot.skip(ftype)
1149 chandransh 6600 
      else:
6601 
        iprot.skip(ftype)
6602 
      iprot.readFieldEnd()
6603 
    iprot.readStructEnd()
6604 
 
6605 
  def write(self, oprot):
6606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6608 
      return
3064 chandransh 6609 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 6610 
    if self.customerId is not None:
3064 chandransh 6611 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6612 
      oprot.writeI64(self.customerId)
1149 chandransh 6613 
      oprot.writeFieldEnd()
3431 rajveer 6614 
    if self.from_date is not None:
3064 chandransh 6615 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6616 
      oprot.writeI64(self.from_date)
1149 chandransh 6617 
      oprot.writeFieldEnd()
3431 rajveer 6618 
    if self.to_date is not None:
3064 chandransh 6619 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6620 
      oprot.writeI64(self.to_date)
2783 chandransh 6621 
      oprot.writeFieldEnd()
3431 rajveer 6622 
    if self.statuses is not None:
3064 chandransh 6623 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
6624 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 6625 
      for iter97 in self.statuses:
6626 
        oprot.writeI32(iter97)
3064 chandransh 6627 
      oprot.writeListEnd()
2783 chandransh 6628 
      oprot.writeFieldEnd()
1149 chandransh 6629 
    oprot.writeFieldStop()
6630 
    oprot.writeStructEnd()
6631 
 
3431 rajveer 6632 
  def validate(self):
6633 
    return
6634 
 
6635 
 
1149 chandransh 6636 
  def __repr__(self):
6637 
    L = ['%s=%r' % (key, value)
6638 
      for key, value in self.__dict__.iteritems()]
6639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6640 
 
6641 
  def __eq__(self, other):
6642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6643 
 
6644 
  def __ne__(self, other):
6645 
    return not (self == other)
6646 
 
3064 chandransh 6647 
class getOrdersForCustomer_result:
1149 chandransh 6648 
  """
6649 
  Attributes:
6650 
   - success
6651 
   - ex
6652 
  """
6653 
 
6654 
  thrift_spec = (
3064 chandransh 6655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 6656 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6657 
  )
6658 
 
6659 
  def __init__(self, success=None, ex=None,):
6660 
    self.success = success
6661 
    self.ex = ex
6662 
 
6663 
  def read(self, iprot):
6664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6666 
      return
6667 
    iprot.readStructBegin()
6668 
    while True:
6669 
      (fname, ftype, fid) = iprot.readFieldBegin()
6670 
      if ftype == TType.STOP:
6671 
        break
6672 
      if fid == 0:
3064 chandransh 6673 
        if ftype == TType.LIST:
6674 
          self.success = []
4133 chandransh 6675 
          (_etype101, _size98) = iprot.readListBegin()
6676 
          for _i102 in xrange(_size98):
6677 
            _elem103 = Order()
6678 
            _elem103.read(iprot)
6679 
            self.success.append(_elem103)
3064 chandransh 6680 
          iprot.readListEnd()
1149 chandransh 6681 
        else:
6682 
          iprot.skip(ftype)
6683 
      elif fid == 1:
6684 
        if ftype == TType.STRUCT:
6685 
          self.ex = TransactionServiceException()
6686 
          self.ex.read(iprot)
6687 
        else:
6688 
          iprot.skip(ftype)
6689 
      else:
6690 
        iprot.skip(ftype)
6691 
      iprot.readFieldEnd()
6692 
    iprot.readStructEnd()
6693 
 
6694 
  def write(self, oprot):
6695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6697 
      return
3064 chandransh 6698 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 6699 
    if self.success is not None:
3064 chandransh 6700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6702 
      for iter104 in self.success:
6703 
        iter104.write(oprot)
3064 chandransh 6704 
      oprot.writeListEnd()
1149 chandransh 6705 
      oprot.writeFieldEnd()
3431 rajveer 6706 
    if self.ex is not None:
1149 chandransh 6707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6708 
      self.ex.write(oprot)
6709 
      oprot.writeFieldEnd()
6710 
    oprot.writeFieldStop()
6711 
    oprot.writeStructEnd()
6712 
 
3431 rajveer 6713 
  def validate(self):
6714 
    return
6715 
 
6716 
 
1149 chandransh 6717 
  def __repr__(self):
6718 
    L = ['%s=%r' % (key, value)
6719 
      for key, value in self.__dict__.iteritems()]
6720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6721 
 
6722 
  def __eq__(self, other):
6723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6724 
 
6725 
  def __ne__(self, other):
6726 
    return not (self == other)
6727 
 
3064 chandransh 6728 
class createOrder_args:
921 rajveer 6729 
  """
6730 
  Attributes:
3064 chandransh 6731 
   - order
921 rajveer 6732 
  """
6733 
 
6734 
  thrift_spec = (
6735 
    None, # 0
3064 chandransh 6736 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 6737 
  )
6738 
 
3064 chandransh 6739 
  def __init__(self, order=None,):
6740 
    self.order = order
921 rajveer 6741 
 
6742 
  def read(self, iprot):
6743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6745 
      return
6746 
    iprot.readStructBegin()
6747 
    while True:
6748 
      (fname, ftype, fid) = iprot.readFieldBegin()
6749 
      if ftype == TType.STOP:
6750 
        break
6751 
      if fid == 1:
3064 chandransh 6752 
        if ftype == TType.STRUCT:
6753 
          self.order = Order()
6754 
          self.order.read(iprot)
921 rajveer 6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      else:
6758 
        iprot.skip(ftype)
6759 
      iprot.readFieldEnd()
6760 
    iprot.readStructEnd()
6761 
 
6762 
  def write(self, oprot):
6763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6765 
      return
3064 chandransh 6766 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 6767 
    if self.order is not None:
3064 chandransh 6768 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
6769 
      self.order.write(oprot)
921 rajveer 6770 
      oprot.writeFieldEnd()
6771 
    oprot.writeFieldStop()
6772 
    oprot.writeStructEnd()
6773 
 
3431 rajveer 6774 
  def validate(self):
6775 
    return
6776 
 
6777 
 
921 rajveer 6778 
  def __repr__(self):
6779 
    L = ['%s=%r' % (key, value)
6780 
      for key, value in self.__dict__.iteritems()]
6781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6782 
 
6783 
  def __eq__(self, other):
6784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6785 
 
6786 
  def __ne__(self, other):
6787 
    return not (self == other)
6788 
 
3064 chandransh 6789 
class createOrder_result:
921 rajveer 6790 
  """
6791 
  Attributes:
6792 
   - success
6793 
   - ex
6794 
  """
6795 
 
6796 
  thrift_spec = (
3064 chandransh 6797 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 6798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6799 
  )
6800 
 
6801 
  def __init__(self, success=None, ex=None,):
6802 
    self.success = success
6803 
    self.ex = ex
6804 
 
6805 
  def read(self, iprot):
6806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6808 
      return
6809 
    iprot.readStructBegin()
6810 
    while True:
6811 
      (fname, ftype, fid) = iprot.readFieldBegin()
6812 
      if ftype == TType.STOP:
6813 
        break
6814 
      if fid == 0:
3064 chandransh 6815 
        if ftype == TType.I64:
6816 
          self.success = iprot.readI64();
921 rajveer 6817 
        else:
6818 
          iprot.skip(ftype)
6819 
      elif fid == 1:
6820 
        if ftype == TType.STRUCT:
6821 
          self.ex = TransactionServiceException()
6822 
          self.ex.read(iprot)
6823 
        else:
6824 
          iprot.skip(ftype)
6825 
      else:
6826 
        iprot.skip(ftype)
6827 
      iprot.readFieldEnd()
6828 
    iprot.readStructEnd()
6829 
 
6830 
  def write(self, oprot):
6831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6833 
      return
3064 chandransh 6834 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 6835 
    if self.success is not None:
3064 chandransh 6836 
      oprot.writeFieldBegin('success', TType.I64, 0)
6837 
      oprot.writeI64(self.success)
921 rajveer 6838 
      oprot.writeFieldEnd()
3431 rajveer 6839 
    if self.ex is not None:
921 rajveer 6840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6841 
      self.ex.write(oprot)
6842 
      oprot.writeFieldEnd()
6843 
    oprot.writeFieldStop()
6844 
    oprot.writeStructEnd()
6845 
 
3431 rajveer 6846 
  def validate(self):
6847 
    return
6848 
 
6849 
 
921 rajveer 6850 
  def __repr__(self):
6851 
    L = ['%s=%r' % (key, value)
6852 
      for key, value in self.__dict__.iteritems()]
6853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6854 
 
6855 
  def __eq__(self, other):
6856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6857 
 
6858 
  def __ne__(self, other):
6859 
    return not (self == other)
6860 
 
3064 chandransh 6861 
class getOrder_args:
921 rajveer 6862 
  """
6863 
  Attributes:
3064 chandransh 6864 
   - id
921 rajveer 6865 
  """
6866 
 
6867 
  thrift_spec = (
6868 
    None, # 0
3064 chandransh 6869 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 6870 
  )
6871 
 
3064 chandransh 6872 
  def __init__(self, id=None,):
6873 
    self.id = id
921 rajveer 6874 
 
6875 
  def read(self, iprot):
6876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6878 
      return
6879 
    iprot.readStructBegin()
6880 
    while True:
6881 
      (fname, ftype, fid) = iprot.readFieldBegin()
6882 
      if ftype == TType.STOP:
6883 
        break
6884 
      if fid == 1:
6885 
        if ftype == TType.I64:
3064 chandransh 6886 
          self.id = iprot.readI64();
921 rajveer 6887 
        else:
6888 
          iprot.skip(ftype)
6889 
      else:
6890 
        iprot.skip(ftype)
6891 
      iprot.readFieldEnd()
6892 
    iprot.readStructEnd()
6893 
 
6894 
  def write(self, oprot):
6895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6897 
      return
3064 chandransh 6898 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 6899 
    if self.id is not None:
3064 chandransh 6900 
      oprot.writeFieldBegin('id', TType.I64, 1)
6901 
      oprot.writeI64(self.id)
921 rajveer 6902 
      oprot.writeFieldEnd()
6903 
    oprot.writeFieldStop()
6904 
    oprot.writeStructEnd()
6905 
 
3431 rajveer 6906 
  def validate(self):
6907 
    return
6908 
 
6909 
 
921 rajveer 6910 
  def __repr__(self):
6911 
    L = ['%s=%r' % (key, value)
6912 
      for key, value in self.__dict__.iteritems()]
6913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6914 
 
6915 
  def __eq__(self, other):
6916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6917 
 
6918 
  def __ne__(self, other):
6919 
    return not (self == other)
6920 
 
3064 chandransh 6921 
class getOrder_result:
921 rajveer 6922 
  """
6923 
  Attributes:
6924 
   - success
6925 
   - ex
6926 
  """
6927 
 
6928 
  thrift_spec = (
3064 chandransh 6929 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 6930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6931 
  )
6932 
 
6933 
  def __init__(self, success=None, ex=None,):
6934 
    self.success = success
6935 
    self.ex = ex
6936 
 
6937 
  def read(self, iprot):
6938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6940 
      return
6941 
    iprot.readStructBegin()
6942 
    while True:
6943 
      (fname, ftype, fid) = iprot.readFieldBegin()
6944 
      if ftype == TType.STOP:
6945 
        break
6946 
      if fid == 0:
3064 chandransh 6947 
        if ftype == TType.STRUCT:
6948 
          self.success = Order()
6949 
          self.success.read(iprot)
921 rajveer 6950 
        else:
6951 
          iprot.skip(ftype)
6952 
      elif fid == 1:
6953 
        if ftype == TType.STRUCT:
6954 
          self.ex = TransactionServiceException()
6955 
          self.ex.read(iprot)
6956 
        else:
6957 
          iprot.skip(ftype)
6958 
      else:
6959 
        iprot.skip(ftype)
6960 
      iprot.readFieldEnd()
6961 
    iprot.readStructEnd()
6962 
 
6963 
  def write(self, oprot):
6964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6966 
      return
3064 chandransh 6967 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 6968 
    if self.success is not None:
3064 chandransh 6969 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6970 
      self.success.write(oprot)
921 rajveer 6971 
      oprot.writeFieldEnd()
3431 rajveer 6972 
    if self.ex is not None:
921 rajveer 6973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6974 
      self.ex.write(oprot)
6975 
      oprot.writeFieldEnd()
6976 
    oprot.writeFieldStop()
6977 
    oprot.writeStructEnd()
6978 
 
3431 rajveer 6979 
  def validate(self):
6980 
    return
6981 
 
6982 
 
921 rajveer 6983 
  def __repr__(self):
6984 
    L = ['%s=%r' % (key, value)
6985 
      for key, value in self.__dict__.iteritems()]
6986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6987 
 
6988 
  def __eq__(self, other):
6989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6990 
 
6991 
  def __ne__(self, other):
6992 
    return not (self == other)
6993 
 
3064 chandransh 6994 
class getLineItemsForOrder_args:
94 ashish 6995 
  """
6996 
  Attributes:
3064 chandransh 6997 
   - orderId
94 ashish 6998 
  """
6999 
 
7000 
  thrift_spec = (
7001 
    None, # 0
3064 chandransh 7002 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7003 
  )
7004 
 
3064 chandransh 7005 
  def __init__(self, orderId=None,):
7006 
    self.orderId = orderId
94 ashish 7007 
 
7008 
  def read(self, iprot):
7009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7011 
      return
7012 
    iprot.readStructBegin()
7013 
    while True:
7014 
      (fname, ftype, fid) = iprot.readFieldBegin()
7015 
      if ftype == TType.STOP:
7016 
        break
7017 
      if fid == 1:
7018 
        if ftype == TType.I64:
3064 chandransh 7019 
          self.orderId = iprot.readI64();
94 ashish 7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      else:
7023 
        iprot.skip(ftype)
7024 
      iprot.readFieldEnd()
7025 
    iprot.readStructEnd()
7026 
 
7027 
  def write(self, oprot):
7028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7030 
      return
3064 chandransh 7031 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7032 
    if self.orderId is not None:
3064 chandransh 7033 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7034 
      oprot.writeI64(self.orderId)
94 ashish 7035 
      oprot.writeFieldEnd()
7036 
    oprot.writeFieldStop()
7037 
    oprot.writeStructEnd()
7038 
 
3431 rajveer 7039 
  def validate(self):
7040 
    return
7041 
 
7042 
 
94 ashish 7043 
  def __repr__(self):
7044 
    L = ['%s=%r' % (key, value)
7045 
      for key, value in self.__dict__.iteritems()]
7046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7047 
 
7048 
  def __eq__(self, other):
7049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7050 
 
7051 
  def __ne__(self, other):
7052 
    return not (self == other)
7053 
 
3064 chandransh 7054 
class getLineItemsForOrder_result:
94 ashish 7055 
  """
7056 
  Attributes:
7057 
   - success
7058 
   - ex
7059 
  """
7060 
 
7061 
  thrift_spec = (
3064 chandransh 7062 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7064 
  )
7065 
 
7066 
  def __init__(self, success=None, ex=None,):
7067 
    self.success = success
7068 
    self.ex = ex
7069 
 
7070 
  def read(self, iprot):
7071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7073 
      return
7074 
    iprot.readStructBegin()
7075 
    while True:
7076 
      (fname, ftype, fid) = iprot.readFieldBegin()
7077 
      if ftype == TType.STOP:
7078 
        break
7079 
      if fid == 0:
483 rajveer 7080 
        if ftype == TType.LIST:
7081 
          self.success = []
4133 chandransh 7082 
          (_etype108, _size105) = iprot.readListBegin()
7083 
          for _i109 in xrange(_size105):
7084 
            _elem110 = LineItem()
7085 
            _elem110.read(iprot)
7086 
            self.success.append(_elem110)
483 rajveer 7087 
          iprot.readListEnd()
94 ashish 7088 
        else:
7089 
          iprot.skip(ftype)
7090 
      elif fid == 1:
7091 
        if ftype == TType.STRUCT:
7092 
          self.ex = TransactionServiceException()
7093 
          self.ex.read(iprot)
7094 
        else:
7095 
          iprot.skip(ftype)
7096 
      else:
7097 
        iprot.skip(ftype)
7098 
      iprot.readFieldEnd()
7099 
    iprot.readStructEnd()
7100 
 
7101 
  def write(self, oprot):
7102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7104 
      return
3064 chandransh 7105 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7106 
    if self.success is not None:
483 rajveer 7107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7109 
      for iter111 in self.success:
7110 
        iter111.write(oprot)
483 rajveer 7111 
      oprot.writeListEnd()
94 ashish 7112 
      oprot.writeFieldEnd()
3431 rajveer 7113 
    if self.ex is not None:
94 ashish 7114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7115 
      self.ex.write(oprot)
7116 
      oprot.writeFieldEnd()
7117 
    oprot.writeFieldStop()
7118 
    oprot.writeStructEnd()
7119 
 
3431 rajveer 7120 
  def validate(self):
7121 
    return
7122 
 
7123 
 
94 ashish 7124 
  def __repr__(self):
7125 
    L = ['%s=%r' % (key, value)
7126 
      for key, value in self.__dict__.iteritems()]
7127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7128 
 
7129 
  def __eq__(self, other):
7130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7131 
 
7132 
  def __ne__(self, other):
7133 
    return not (self == other)
7134 
 
3064 chandransh 7135 
class getOrderForCustomer_args:
94 ashish 7136 
  """
7137 
  Attributes:
3064 chandransh 7138 
   - orderId
483 rajveer 7139 
   - customerId
94 ashish 7140 
  """
7141 
 
7142 
  thrift_spec = (
7143 
    None, # 0
3064 chandransh 7144 
    (1, TType.I64, 'orderId', None, None, ), # 1
7145 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7146 
  )
7147 
 
3064 chandransh 7148 
  def __init__(self, orderId=None, customerId=None,):
7149 
    self.orderId = orderId
483 rajveer 7150 
    self.customerId = customerId
94 ashish 7151 
 
7152 
  def read(self, iprot):
7153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7155 
      return
7156 
    iprot.readStructBegin()
7157 
    while True:
7158 
      (fname, ftype, fid) = iprot.readFieldBegin()
7159 
      if ftype == TType.STOP:
7160 
        break
7161 
      if fid == 1:
7162 
        if ftype == TType.I64:
3064 chandransh 7163 
          self.orderId = iprot.readI64();
94 ashish 7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      elif fid == 2:
7167 
        if ftype == TType.I64:
3064 chandransh 7168 
          self.customerId = iprot.readI64();
94 ashish 7169 
        else:
7170 
          iprot.skip(ftype)
7171 
      else:
7172 
        iprot.skip(ftype)
7173 
      iprot.readFieldEnd()
7174 
    iprot.readStructEnd()
7175 
 
7176 
  def write(self, oprot):
7177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7179 
      return
3064 chandransh 7180 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7181 
    if self.orderId is not None:
3064 chandransh 7182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7183 
      oprot.writeI64(self.orderId)
7184 
      oprot.writeFieldEnd()
3431 rajveer 7185 
    if self.customerId is not None:
3064 chandransh 7186 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7187 
      oprot.writeI64(self.customerId)
94 ashish 7188 
      oprot.writeFieldEnd()
7189 
    oprot.writeFieldStop()
7190 
    oprot.writeStructEnd()
7191 
 
3431 rajveer 7192 
  def validate(self):
7193 
    return
7194 
 
7195 
 
94 ashish 7196 
  def __repr__(self):
7197 
    L = ['%s=%r' % (key, value)
7198 
      for key, value in self.__dict__.iteritems()]
7199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7200 
 
7201 
  def __eq__(self, other):
7202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7203 
 
7204 
  def __ne__(self, other):
7205 
    return not (self == other)
7206 
 
3064 chandransh 7207 
class getOrderForCustomer_result:
94 ashish 7208 
  """
7209 
  Attributes:
7210 
   - success
7211 
   - ex
7212 
  """
7213 
 
7214 
  thrift_spec = (
3064 chandransh 7215 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7217 
  )
7218 
 
7219 
  def __init__(self, success=None, ex=None,):
7220 
    self.success = success
7221 
    self.ex = ex
7222 
 
7223 
  def read(self, iprot):
7224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7226 
      return
7227 
    iprot.readStructBegin()
7228 
    while True:
7229 
      (fname, ftype, fid) = iprot.readFieldBegin()
7230 
      if ftype == TType.STOP:
7231 
        break
7232 
      if fid == 0:
3064 chandransh 7233 
        if ftype == TType.STRUCT:
7234 
          self.success = Order()
7235 
          self.success.read(iprot)
94 ashish 7236 
        else:
7237 
          iprot.skip(ftype)
7238 
      elif fid == 1:
7239 
        if ftype == TType.STRUCT:
7240 
          self.ex = TransactionServiceException()
7241 
          self.ex.read(iprot)
7242 
        else:
7243 
          iprot.skip(ftype)
7244 
      else:
7245 
        iprot.skip(ftype)
7246 
      iprot.readFieldEnd()
7247 
    iprot.readStructEnd()
7248 
 
7249 
  def write(self, oprot):
7250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7252 
      return
3064 chandransh 7253 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7254 
    if self.success is not None:
3064 chandransh 7255 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7256 
      self.success.write(oprot)
94 ashish 7257 
      oprot.writeFieldEnd()
3431 rajveer 7258 
    if self.ex is not None:
94 ashish 7259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7260 
      self.ex.write(oprot)
7261 
      oprot.writeFieldEnd()
7262 
    oprot.writeFieldStop()
7263 
    oprot.writeStructEnd()
7264 
 
3431 rajveer 7265 
  def validate(self):
7266 
    return
7267 
 
7268 
 
94 ashish 7269 
  def __repr__(self):
7270 
    L = ['%s=%r' % (key, value)
7271 
      for key, value in self.__dict__.iteritems()]
7272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7273 
 
7274 
  def __eq__(self, other):
7275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7276 
 
7277 
  def __ne__(self, other):
7278 
    return not (self == other)
7279 
 
3064 chandransh 7280 
class getAlerts_args:
94 ashish 7281 
  """
7282 
  Attributes:
3064 chandransh 7283 
   - orderId
7284 
   - valid
94 ashish 7285 
  """
7286 
 
7287 
  thrift_spec = (
7288 
    None, # 0
3064 chandransh 7289 
    (1, TType.I64, 'orderId', None, None, ), # 1
7290 
    (2, TType.BOOL, 'valid', None, None, ), # 2
94 ashish 7291 
  )
7292 
 
3064 chandransh 7293 
  def __init__(self, orderId=None, valid=None,):
7294 
    self.orderId = orderId
7295 
    self.valid = valid
94 ashish 7296 
 
7297 
  def read(self, iprot):
7298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7300 
      return
7301 
    iprot.readStructBegin()
7302 
    while True:
7303 
      (fname, ftype, fid) = iprot.readFieldBegin()
7304 
      if ftype == TType.STOP:
7305 
        break
7306 
      if fid == 1:
3064 chandransh 7307 
        if ftype == TType.I64:
7308 
          self.orderId = iprot.readI64();
94 ashish 7309 
        else:
7310 
          iprot.skip(ftype)
3064 chandransh 7311 
      elif fid == 2:
7312 
        if ftype == TType.BOOL:
7313 
          self.valid = iprot.readBool();
7314 
        else:
7315 
          iprot.skip(ftype)
94 ashish 7316 
      else:
7317 
        iprot.skip(ftype)
7318 
      iprot.readFieldEnd()
7319 
    iprot.readStructEnd()
7320 
 
7321 
  def write(self, oprot):
7322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7324 
      return
3064 chandransh 7325 
    oprot.writeStructBegin('getAlerts_args')
3431 rajveer 7326 
    if self.orderId is not None:
3064 chandransh 7327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7328 
      oprot.writeI64(self.orderId)
94 ashish 7329 
      oprot.writeFieldEnd()
3431 rajveer 7330 
    if self.valid is not None:
3064 chandransh 7331 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7332 
      oprot.writeBool(self.valid)
7333 
      oprot.writeFieldEnd()
94 ashish 7334 
    oprot.writeFieldStop()
7335 
    oprot.writeStructEnd()
7336 
 
3431 rajveer 7337 
  def validate(self):
7338 
    return
7339 
 
7340 
 
94 ashish 7341 
  def __repr__(self):
7342 
    L = ['%s=%r' % (key, value)
7343 
      for key, value in self.__dict__.iteritems()]
7344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7345 
 
7346 
  def __eq__(self, other):
7347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7348 
 
7349 
  def __ne__(self, other):
7350 
    return not (self == other)
7351 
 
3064 chandransh 7352 
class getAlerts_result:
94 ashish 7353 
  """
7354 
  Attributes:
7355 
   - success
7356 
  """
7357 
 
7358 
  thrift_spec = (
3064 chandransh 7359 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7360 
  )
7361 
 
3064 chandransh 7362 
  def __init__(self, success=None,):
94 ashish 7363 
    self.success = success
7364 
 
7365 
  def read(self, iprot):
7366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7368 
      return
7369 
    iprot.readStructBegin()
7370 
    while True:
7371 
      (fname, ftype, fid) = iprot.readFieldBegin()
7372 
      if ftype == TType.STOP:
7373 
        break
7374 
      if fid == 0:
3064 chandransh 7375 
        if ftype == TType.LIST:
7376 
          self.success = []
4133 chandransh 7377 
          (_etype115, _size112) = iprot.readListBegin()
7378 
          for _i116 in xrange(_size112):
7379 
            _elem117 = Alert()
7380 
            _elem117.read(iprot)
7381 
            self.success.append(_elem117)
3064 chandransh 7382 
          iprot.readListEnd()
94 ashish 7383 
        else:
7384 
          iprot.skip(ftype)
7385 
      else:
7386 
        iprot.skip(ftype)
7387 
      iprot.readFieldEnd()
7388 
    iprot.readStructEnd()
7389 
 
7390 
  def write(self, oprot):
7391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7393 
      return
3064 chandransh 7394 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7395 
    if self.success is not None:
3064 chandransh 7396 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7397 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7398 
      for iter118 in self.success:
7399 
        iter118.write(oprot)
3064 chandransh 7400 
      oprot.writeListEnd()
94 ashish 7401 
      oprot.writeFieldEnd()
7402 
    oprot.writeFieldStop()
7403 
    oprot.writeStructEnd()
7404 
 
3431 rajveer 7405 
  def validate(self):
7406 
    return
7407 
 
7408 
 
94 ashish 7409 
  def __repr__(self):
7410 
    L = ['%s=%r' % (key, value)
7411 
      for key, value in self.__dict__.iteritems()]
7412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7413 
 
7414 
  def __eq__(self, other):
7415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7416 
 
7417 
  def __ne__(self, other):
7418 
    return not (self == other)
7419 
 
3064 chandransh 7420 
class setAlert_args:
94 ashish 7421 
  """
7422 
  Attributes:
3064 chandransh 7423 
   - orderId
7424 
   - unset
7425 
   - type
7426 
   - comment
94 ashish 7427 
  """
7428 
 
7429 
  thrift_spec = (
7430 
    None, # 0
3064 chandransh 7431 
    (1, TType.I64, 'orderId', None, None, ), # 1
7432 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7433 
    (3, TType.I64, 'type', None, None, ), # 3
7434 
    (4, TType.STRING, 'comment', None, None, ), # 4
94 ashish 7435 
  )
7436 
 
3064 chandransh 7437 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7438 
    self.orderId = orderId
7439 
    self.unset = unset
7440 
    self.type = type
7441 
    self.comment = comment
94 ashish 7442 
 
7443 
  def read(self, iprot):
7444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7446 
      return
7447 
    iprot.readStructBegin()
7448 
    while True:
7449 
      (fname, ftype, fid) = iprot.readFieldBegin()
7450 
      if ftype == TType.STOP:
7451 
        break
7452 
      if fid == 1:
7453 
        if ftype == TType.I64:
3064 chandransh 7454 
          self.orderId = iprot.readI64();
94 ashish 7455 
        else:
7456 
          iprot.skip(ftype)
3064 chandransh 7457 
      elif fid == 2:
7458 
        if ftype == TType.BOOL:
7459 
          self.unset = iprot.readBool();
7460 
        else:
7461 
          iprot.skip(ftype)
7462 
      elif fid == 3:
7463 
        if ftype == TType.I64:
7464 
          self.type = iprot.readI64();
7465 
        else:
7466 
          iprot.skip(ftype)
7467 
      elif fid == 4:
7468 
        if ftype == TType.STRING:
7469 
          self.comment = iprot.readString();
7470 
        else:
7471 
          iprot.skip(ftype)
94 ashish 7472 
      else:
7473 
        iprot.skip(ftype)
7474 
      iprot.readFieldEnd()
7475 
    iprot.readStructEnd()
7476 
 
7477 
  def write(self, oprot):
7478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7480 
      return
3064 chandransh 7481 
    oprot.writeStructBegin('setAlert_args')
3431 rajveer 7482 
    if self.orderId is not None:
3064 chandransh 7483 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7484 
      oprot.writeI64(self.orderId)
94 ashish 7485 
      oprot.writeFieldEnd()
3431 rajveer 7486 
    if self.unset is not None:
3064 chandransh 7487 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7488 
      oprot.writeBool(self.unset)
7489 
      oprot.writeFieldEnd()
3431 rajveer 7490 
    if self.type is not None:
3064 chandransh 7491 
      oprot.writeFieldBegin('type', TType.I64, 3)
7492 
      oprot.writeI64(self.type)
7493 
      oprot.writeFieldEnd()
3431 rajveer 7494 
    if self.comment is not None:
3064 chandransh 7495 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7496 
      oprot.writeString(self.comment)
7497 
      oprot.writeFieldEnd()
94 ashish 7498 
    oprot.writeFieldStop()
7499 
    oprot.writeStructEnd()
7500 
 
3431 rajveer 7501 
  def validate(self):
7502 
    return
7503 
 
7504 
 
94 ashish 7505 
  def __repr__(self):
7506 
    L = ['%s=%r' % (key, value)
7507 
      for key, value in self.__dict__.iteritems()]
7508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7509 
 
7510 
  def __eq__(self, other):
7511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7512 
 
7513 
  def __ne__(self, other):
7514 
    return not (self == other)
7515 
 
3064 chandransh 7516 
class setAlert_result:
7517 
 
7518 
  thrift_spec = (
7519 
  )
7520 
 
7521 
  def read(self, iprot):
7522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7524 
      return
7525 
    iprot.readStructBegin()
7526 
    while True:
7527 
      (fname, ftype, fid) = iprot.readFieldBegin()
7528 
      if ftype == TType.STOP:
7529 
        break
7530 
      else:
7531 
        iprot.skip(ftype)
7532 
      iprot.readFieldEnd()
7533 
    iprot.readStructEnd()
7534 
 
7535 
  def write(self, oprot):
7536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7538 
      return
7539 
    oprot.writeStructBegin('setAlert_result')
7540 
    oprot.writeFieldStop()
7541 
    oprot.writeStructEnd()
7542 
 
3431 rajveer 7543 
  def validate(self):
7544 
    return
7545 
 
7546 
 
3064 chandransh 7547 
  def __repr__(self):
7548 
    L = ['%s=%r' % (key, value)
7549 
      for key, value in self.__dict__.iteritems()]
7550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7551 
 
7552 
  def __eq__(self, other):
7553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7554 
 
7555 
  def __ne__(self, other):
7556 
    return not (self == other)
7557 
 
7558 
class getValidOrderCount_args:
7559 
 
7560 
  thrift_spec = (
7561 
  )
7562 
 
7563 
  def read(self, iprot):
7564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7566 
      return
7567 
    iprot.readStructBegin()
7568 
    while True:
7569 
      (fname, ftype, fid) = iprot.readFieldBegin()
7570 
      if ftype == TType.STOP:
7571 
        break
7572 
      else:
7573 
        iprot.skip(ftype)
7574 
      iprot.readFieldEnd()
7575 
    iprot.readStructEnd()
7576 
 
7577 
  def write(self, oprot):
7578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7580 
      return
7581 
    oprot.writeStructBegin('getValidOrderCount_args')
7582 
    oprot.writeFieldStop()
7583 
    oprot.writeStructEnd()
7584 
 
3431 rajveer 7585 
  def validate(self):
7586 
    return
7587 
 
7588 
 
3064 chandransh 7589 
  def __repr__(self):
7590 
    L = ['%s=%r' % (key, value)
7591 
      for key, value in self.__dict__.iteritems()]
7592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7593 
 
7594 
  def __eq__(self, other):
7595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7596 
 
7597 
  def __ne__(self, other):
7598 
    return not (self == other)
7599 
 
7600 
class getValidOrderCount_result:
94 ashish 7601 
  """
7602 
  Attributes:
7603 
   - success
7604 
  """
7605 
 
7606 
  thrift_spec = (
3064 chandransh 7607 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7608 
  )
7609 
 
3064 chandransh 7610 
  def __init__(self, success=None,):
94 ashish 7611 
    self.success = success
7612 
 
7613 
  def read(self, iprot):
7614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7616 
      return
7617 
    iprot.readStructBegin()
7618 
    while True:
7619 
      (fname, ftype, fid) = iprot.readFieldBegin()
7620 
      if ftype == TType.STOP:
7621 
        break
7622 
      if fid == 0:
3064 chandransh 7623 
        if ftype == TType.I64:
7624 
          self.success = iprot.readI64();
94 ashish 7625 
        else:
7626 
          iprot.skip(ftype)
7627 
      else:
7628 
        iprot.skip(ftype)
7629 
      iprot.readFieldEnd()
7630 
    iprot.readStructEnd()
7631 
 
7632 
  def write(self, oprot):
7633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7635 
      return
3064 chandransh 7636 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 7637 
    if self.success is not None:
3064 chandransh 7638 
      oprot.writeFieldBegin('success', TType.I64, 0)
7639 
      oprot.writeI64(self.success)
94 ashish 7640 
      oprot.writeFieldEnd()
7641 
    oprot.writeFieldStop()
7642 
    oprot.writeStructEnd()
7643 
 
3431 rajveer 7644 
  def validate(self):
7645 
    return
7646 
 
7647 
 
94 ashish 7648 
  def __repr__(self):
7649 
    L = ['%s=%r' % (key, value)
7650 
      for key, value in self.__dict__.iteritems()]
7651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7652 
 
7653 
  def __eq__(self, other):
7654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7655 
 
7656 
  def __ne__(self, other):
7657 
    return not (self == other)
7658 
 
3064 chandransh 7659 
class getNoOfCustomersWithSuccessfulTransaction_args:
7660 
 
7661 
  thrift_spec = (
7662 
  )
7663 
 
7664 
  def read(self, iprot):
7665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7667 
      return
7668 
    iprot.readStructBegin()
7669 
    while True:
7670 
      (fname, ftype, fid) = iprot.readFieldBegin()
7671 
      if ftype == TType.STOP:
7672 
        break
7673 
      else:
7674 
        iprot.skip(ftype)
7675 
      iprot.readFieldEnd()
7676 
    iprot.readStructEnd()
7677 
 
7678 
  def write(self, oprot):
7679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7681 
      return
7682 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7683 
    oprot.writeFieldStop()
7684 
    oprot.writeStructEnd()
7685 
 
3431 rajveer 7686 
  def validate(self):
7687 
    return
7688 
 
7689 
 
3064 chandransh 7690 
  def __repr__(self):
7691 
    L = ['%s=%r' % (key, value)
7692 
      for key, value in self.__dict__.iteritems()]
7693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7694 
 
7695 
  def __eq__(self, other):
7696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7697 
 
7698 
  def __ne__(self, other):
7699 
    return not (self == other)
7700 
 
7701 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 7702 
  """
7703 
  Attributes:
3064 chandransh 7704 
   - success
94 ashish 7705 
  """
7706 
 
7707 
  thrift_spec = (
3064 chandransh 7708 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7709 
  )
7710 
 
3064 chandransh 7711 
  def __init__(self, success=None,):
7712 
    self.success = success
94 ashish 7713 
 
7714 
  def read(self, iprot):
7715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7717 
      return
7718 
    iprot.readStructBegin()
7719 
    while True:
7720 
      (fname, ftype, fid) = iprot.readFieldBegin()
7721 
      if ftype == TType.STOP:
7722 
        break
3064 chandransh 7723 
      if fid == 0:
94 ashish 7724 
        if ftype == TType.I64:
3064 chandransh 7725 
          self.success = iprot.readI64();
94 ashish 7726 
        else:
7727 
          iprot.skip(ftype)
7728 
      else:
7729 
        iprot.skip(ftype)
7730 
      iprot.readFieldEnd()
7731 
    iprot.readStructEnd()
7732 
 
7733 
  def write(self, oprot):
7734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7736 
      return
3064 chandransh 7737 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 7738 
    if self.success is not None:
3064 chandransh 7739 
      oprot.writeFieldBegin('success', TType.I64, 0)
7740 
      oprot.writeI64(self.success)
94 ashish 7741 
      oprot.writeFieldEnd()
7742 
    oprot.writeFieldStop()
7743 
    oprot.writeStructEnd()
7744 
 
3431 rajveer 7745 
  def validate(self):
7746 
    return
7747 
 
7748 
 
94 ashish 7749 
  def __repr__(self):
7750 
    L = ['%s=%r' % (key, value)
7751 
      for key, value in self.__dict__.iteritems()]
7752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7753 
 
7754 
  def __eq__(self, other):
7755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7756 
 
7757 
  def __ne__(self, other):
7758 
    return not (self == other)
7759 
 
3064 chandransh 7760 
class getValidOrdersAmountRange_args:
7761 
 
7762 
  thrift_spec = (
7763 
  )
7764 
 
7765 
  def read(self, iprot):
7766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7768 
      return
7769 
    iprot.readStructBegin()
7770 
    while True:
7771 
      (fname, ftype, fid) = iprot.readFieldBegin()
7772 
      if ftype == TType.STOP:
7773 
        break
7774 
      else:
7775 
        iprot.skip(ftype)
7776 
      iprot.readFieldEnd()
7777 
    iprot.readStructEnd()
7778 
 
7779 
  def write(self, oprot):
7780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7782 
      return
7783 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
7784 
    oprot.writeFieldStop()
7785 
    oprot.writeStructEnd()
7786 
 
3431 rajveer 7787 
  def validate(self):
7788 
    return
7789 
 
7790 
 
3064 chandransh 7791 
  def __repr__(self):
7792 
    L = ['%s=%r' % (key, value)
7793 
      for key, value in self.__dict__.iteritems()]
7794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7795 
 
7796 
  def __eq__(self, other):
7797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7798 
 
7799 
  def __ne__(self, other):
7800 
    return not (self == other)
7801 
 
7802 
class getValidOrdersAmountRange_result:
94 ashish 7803 
  """
7804 
  Attributes:
7805 
   - success
7806 
  """
7807 
 
7808 
  thrift_spec = (
3064 chandransh 7809 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 7810 
  )
7811 
 
3064 chandransh 7812 
  def __init__(self, success=None,):
94 ashish 7813 
    self.success = success
7814 
 
7815 
  def read(self, iprot):
7816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7818 
      return
7819 
    iprot.readStructBegin()
7820 
    while True:
7821 
      (fname, ftype, fid) = iprot.readFieldBegin()
7822 
      if ftype == TType.STOP:
7823 
        break
7824 
      if fid == 0:
483 rajveer 7825 
        if ftype == TType.LIST:
7826 
          self.success = []
4133 chandransh 7827 
          (_etype122, _size119) = iprot.readListBegin()
7828 
          for _i123 in xrange(_size119):
7829 
            _elem124 = iprot.readDouble();
7830 
            self.success.append(_elem124)
483 rajveer 7831 
          iprot.readListEnd()
94 ashish 7832 
        else:
7833 
          iprot.skip(ftype)
7834 
      else:
7835 
        iprot.skip(ftype)
7836 
      iprot.readFieldEnd()
7837 
    iprot.readStructEnd()
7838 
 
7839 
  def write(self, oprot):
7840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7842 
      return
3064 chandransh 7843 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 7844 
    if self.success is not None:
483 rajveer 7845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 7846 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 7847 
      for iter125 in self.success:
7848 
        oprot.writeDouble(iter125)
483 rajveer 7849 
      oprot.writeListEnd()
94 ashish 7850 
      oprot.writeFieldEnd()
7851 
    oprot.writeFieldStop()
7852 
    oprot.writeStructEnd()
7853 
 
3431 rajveer 7854 
  def validate(self):
7855 
    return
7856 
 
7857 
 
94 ashish 7858 
  def __repr__(self):
7859 
    L = ['%s=%r' % (key, value)
7860 
      for key, value in self.__dict__.iteritems()]
7861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7862 
 
7863 
  def __eq__(self, other):
7864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7865 
 
7866 
  def __ne__(self, other):
7867 
    return not (self == other)
7868 
 
3064 chandransh 7869 
class getValidOrders_args:
1528 ankur.sing 7870 
  """
7871 
  Attributes:
3064 chandransh 7872 
   - limit
1528 ankur.sing 7873 
  """
7874 
 
7875 
  thrift_spec = (
7876 
    None, # 0
3064 chandransh 7877 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 7878 
  )
7879 
 
3064 chandransh 7880 
  def __init__(self, limit=None,):
7881 
    self.limit = limit
1528 ankur.sing 7882 
 
7883 
  def read(self, iprot):
7884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7886 
      return
7887 
    iprot.readStructBegin()
7888 
    while True:
7889 
      (fname, ftype, fid) = iprot.readFieldBegin()
7890 
      if ftype == TType.STOP:
7891 
        break
7892 
      if fid == 1:
7893 
        if ftype == TType.I64:
3064 chandransh 7894 
          self.limit = iprot.readI64();
1528 ankur.sing 7895 
        else:
7896 
          iprot.skip(ftype)
7897 
      else:
7898 
        iprot.skip(ftype)
7899 
      iprot.readFieldEnd()
7900 
    iprot.readStructEnd()
7901 
 
7902 
  def write(self, oprot):
7903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7905 
      return
3064 chandransh 7906 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 7907 
    if self.limit is not None:
3064 chandransh 7908 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7909 
      oprot.writeI64(self.limit)
1528 ankur.sing 7910 
      oprot.writeFieldEnd()
7911 
    oprot.writeFieldStop()
7912 
    oprot.writeStructEnd()
7913 
 
3431 rajveer 7914 
  def validate(self):
7915 
    return
7916 
 
7917 
 
1528 ankur.sing 7918 
  def __repr__(self):
7919 
    L = ['%s=%r' % (key, value)
7920 
      for key, value in self.__dict__.iteritems()]
7921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7922 
 
7923 
  def __eq__(self, other):
7924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7925 
 
7926 
  def __ne__(self, other):
7927 
    return not (self == other)
7928 
 
3064 chandransh 7929 
class getValidOrders_result:
1528 ankur.sing 7930 
  """
7931 
  Attributes:
7932 
   - success
7933 
  """
7934 
 
7935 
  thrift_spec = (
3064 chandransh 7936 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 7937 
  )
7938 
 
3064 chandransh 7939 
  def __init__(self, success=None,):
1528 ankur.sing 7940 
    self.success = success
7941 
 
7942 
  def read(self, iprot):
7943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7945 
      return
7946 
    iprot.readStructBegin()
7947 
    while True:
7948 
      (fname, ftype, fid) = iprot.readFieldBegin()
7949 
      if ftype == TType.STOP:
7950 
        break
7951 
      if fid == 0:
3064 chandransh 7952 
        if ftype == TType.LIST:
7953 
          self.success = []
4133 chandransh 7954 
          (_etype129, _size126) = iprot.readListBegin()
7955 
          for _i130 in xrange(_size126):
7956 
            _elem131 = Order()
7957 
            _elem131.read(iprot)
7958 
            self.success.append(_elem131)
3064 chandransh 7959 
          iprot.readListEnd()
1528 ankur.sing 7960 
        else:
7961 
          iprot.skip(ftype)
7962 
      else:
7963 
        iprot.skip(ftype)
7964 
      iprot.readFieldEnd()
7965 
    iprot.readStructEnd()
7966 
 
7967 
  def write(self, oprot):
7968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7970 
      return
3064 chandransh 7971 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 7972 
    if self.success is not None:
3064 chandransh 7973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7975 
      for iter132 in self.success:
7976 
        iter132.write(oprot)
3064 chandransh 7977 
      oprot.writeListEnd()
1528 ankur.sing 7978 
      oprot.writeFieldEnd()
7979 
    oprot.writeFieldStop()
7980 
    oprot.writeStructEnd()
7981 
 
3431 rajveer 7982 
  def validate(self):
7983 
    return
7984 
 
7985 
 
1528 ankur.sing 7986 
  def __repr__(self):
7987 
    L = ['%s=%r' % (key, value)
7988 
      for key, value in self.__dict__.iteritems()]
7989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7990 
 
7991 
  def __eq__(self, other):
7992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7993 
 
7994 
  def __ne__(self, other):
7995 
    return not (self == other)
7996 
 
1220 chandransh 7997 
class batchOrders_args:
7998 
  """
7999 
  Attributes:
8000 
   - warehouseId
8001 
  """
8002 
 
8003 
  thrift_spec = (
8004 
    None, # 0
8005 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8006 
  )
8007 
 
8008 
  def __init__(self, warehouseId=None,):
8009 
    self.warehouseId = warehouseId
8010 
 
8011 
  def read(self, iprot):
8012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8014 
      return
8015 
    iprot.readStructBegin()
8016 
    while True:
8017 
      (fname, ftype, fid) = iprot.readFieldBegin()
8018 
      if ftype == TType.STOP:
8019 
        break
8020 
      if fid == 1:
8021 
        if ftype == TType.I64:
8022 
          self.warehouseId = iprot.readI64();
8023 
        else:
8024 
          iprot.skip(ftype)
8025 
      else:
8026 
        iprot.skip(ftype)
8027 
      iprot.readFieldEnd()
8028 
    iprot.readStructEnd()
8029 
 
8030 
  def write(self, oprot):
8031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8033 
      return
8034 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8035 
    if self.warehouseId is not None:
1220 chandransh 8036 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8037 
      oprot.writeI64(self.warehouseId)
8038 
      oprot.writeFieldEnd()
8039 
    oprot.writeFieldStop()
8040 
    oprot.writeStructEnd()
8041 
 
3431 rajveer 8042 
  def validate(self):
8043 
    return
8044 
 
8045 
 
1220 chandransh 8046 
  def __repr__(self):
8047 
    L = ['%s=%r' % (key, value)
8048 
      for key, value in self.__dict__.iteritems()]
8049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8050 
 
8051 
  def __eq__(self, other):
8052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8053 
 
8054 
  def __ne__(self, other):
8055 
    return not (self == other)
8056 
 
8057 
class batchOrders_result:
8058 
  """
8059 
  Attributes:
8060 
   - success
8061 
   - ex
8062 
  """
8063 
 
8064 
  thrift_spec = (
8065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8067 
  )
8068 
 
8069 
  def __init__(self, success=None, ex=None,):
8070 
    self.success = success
8071 
    self.ex = ex
8072 
 
8073 
  def read(self, iprot):
8074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8076 
      return
8077 
    iprot.readStructBegin()
8078 
    while True:
8079 
      (fname, ftype, fid) = iprot.readFieldBegin()
8080 
      if ftype == TType.STOP:
8081 
        break
8082 
      if fid == 0:
8083 
        if ftype == TType.LIST:
8084 
          self.success = []
4133 chandransh 8085 
          (_etype136, _size133) = iprot.readListBegin()
8086 
          for _i137 in xrange(_size133):
8087 
            _elem138 = Order()
8088 
            _elem138.read(iprot)
8089 
            self.success.append(_elem138)
1220 chandransh 8090 
          iprot.readListEnd()
8091 
        else:
8092 
          iprot.skip(ftype)
8093 
      elif fid == 1:
8094 
        if ftype == TType.STRUCT:
8095 
          self.ex = TransactionServiceException()
8096 
          self.ex.read(iprot)
8097 
        else:
8098 
          iprot.skip(ftype)
8099 
      else:
8100 
        iprot.skip(ftype)
8101 
      iprot.readFieldEnd()
8102 
    iprot.readStructEnd()
8103 
 
8104 
  def write(self, oprot):
8105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8107 
      return
8108 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8109 
    if self.success is not None:
1220 chandransh 8110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8112 
      for iter139 in self.success:
8113 
        iter139.write(oprot)
1220 chandransh 8114 
      oprot.writeListEnd()
8115 
      oprot.writeFieldEnd()
3431 rajveer 8116 
    if self.ex is not None:
1220 chandransh 8117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8118 
      self.ex.write(oprot)
8119 
      oprot.writeFieldEnd()
8120 
    oprot.writeFieldStop()
8121 
    oprot.writeStructEnd()
8122 
 
3431 rajveer 8123 
  def validate(self):
8124 
    return
8125 
 
8126 
 
1220 chandransh 8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
1208 chandransh 8138 
class markOrderAsOutOfStock_args:
8139 
  """
8140 
  Attributes:
8141 
   - orderId
8142 
  """
8143 
 
8144 
  thrift_spec = (
8145 
    None, # 0
8146 
    (1, TType.I64, 'orderId', None, None, ), # 1
8147 
  )
8148 
 
8149 
  def __init__(self, orderId=None,):
8150 
    self.orderId = orderId
8151 
 
8152 
  def read(self, iprot):
8153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8155 
      return
8156 
    iprot.readStructBegin()
8157 
    while True:
8158 
      (fname, ftype, fid) = iprot.readFieldBegin()
8159 
      if ftype == TType.STOP:
8160 
        break
8161 
      if fid == 1:
8162 
        if ftype == TType.I64:
8163 
          self.orderId = iprot.readI64();
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      else:
8167 
        iprot.skip(ftype)
8168 
      iprot.readFieldEnd()
8169 
    iprot.readStructEnd()
8170 
 
8171 
  def write(self, oprot):
8172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8174 
      return
8175 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8176 
    if self.orderId is not None:
1208 chandransh 8177 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8178 
      oprot.writeI64(self.orderId)
8179 
      oprot.writeFieldEnd()
8180 
    oprot.writeFieldStop()
8181 
    oprot.writeStructEnd()
8182 
 
3431 rajveer 8183 
  def validate(self):
8184 
    return
8185 
 
8186 
 
1208 chandransh 8187 
  def __repr__(self):
8188 
    L = ['%s=%r' % (key, value)
8189 
      for key, value in self.__dict__.iteritems()]
8190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8191 
 
8192 
  def __eq__(self, other):
8193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8194 
 
8195 
  def __ne__(self, other):
8196 
    return not (self == other)
8197 
 
8198 
class markOrderAsOutOfStock_result:
8199 
  """
8200 
  Attributes:
8201 
   - success
8202 
   - ex
8203 
  """
8204 
 
8205 
  thrift_spec = (
8206 
    (0, TType.BOOL, 'success', None, None, ), # 0
8207 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8208 
  )
8209 
 
8210 
  def __init__(self, success=None, ex=None,):
8211 
    self.success = success
8212 
    self.ex = ex
8213 
 
8214 
  def read(self, iprot):
8215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8217 
      return
8218 
    iprot.readStructBegin()
8219 
    while True:
8220 
      (fname, ftype, fid) = iprot.readFieldBegin()
8221 
      if ftype == TType.STOP:
8222 
        break
8223 
      if fid == 0:
8224 
        if ftype == TType.BOOL:
8225 
          self.success = iprot.readBool();
8226 
        else:
8227 
          iprot.skip(ftype)
8228 
      elif fid == 1:
8229 
        if ftype == TType.STRUCT:
8230 
          self.ex = TransactionServiceException()
8231 
          self.ex.read(iprot)
8232 
        else:
8233 
          iprot.skip(ftype)
8234 
      else:
8235 
        iprot.skip(ftype)
8236 
      iprot.readFieldEnd()
8237 
    iprot.readStructEnd()
8238 
 
8239 
  def write(self, oprot):
8240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8242 
      return
8243 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8244 
    if self.success is not None:
1208 chandransh 8245 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8246 
      oprot.writeBool(self.success)
8247 
      oprot.writeFieldEnd()
3431 rajveer 8248 
    if self.ex is not None:
1208 chandransh 8249 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8250 
      self.ex.write(oprot)
8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
1208 chandransh 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
3064 chandransh 8270 
class verifyOrder_args:
759 chandransh 8271 
  """
8272 
  Attributes:
3064 chandransh 8273 
   - orderId
759 chandransh 8274 
  """
8275 
 
8276 
  thrift_spec = (
8277 
    None, # 0
3064 chandransh 8278 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8279 
  )
8280 
 
3064 chandransh 8281 
  def __init__(self, orderId=None,):
8282 
    self.orderId = orderId
759 chandransh 8283 
 
8284 
  def read(self, iprot):
8285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8287 
      return
8288 
    iprot.readStructBegin()
8289 
    while True:
8290 
      (fname, ftype, fid) = iprot.readFieldBegin()
8291 
      if ftype == TType.STOP:
8292 
        break
8293 
      if fid == 1:
8294 
        if ftype == TType.I64:
3064 chandransh 8295 
          self.orderId = iprot.readI64();
759 chandransh 8296 
        else:
8297 
          iprot.skip(ftype)
8298 
      else:
8299 
        iprot.skip(ftype)
8300 
      iprot.readFieldEnd()
8301 
    iprot.readStructEnd()
8302 
 
8303 
  def write(self, oprot):
8304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8306 
      return
3064 chandransh 8307 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8308 
    if self.orderId is not None:
3064 chandransh 8309 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8310 
      oprot.writeI64(self.orderId)
759 chandransh 8311 
      oprot.writeFieldEnd()
8312 
    oprot.writeFieldStop()
8313 
    oprot.writeStructEnd()
8314 
 
3431 rajveer 8315 
  def validate(self):
8316 
    return
8317 
 
8318 
 
759 chandransh 8319 
  def __repr__(self):
8320 
    L = ['%s=%r' % (key, value)
8321 
      for key, value in self.__dict__.iteritems()]
8322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8323 
 
8324 
  def __eq__(self, other):
8325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8326 
 
8327 
  def __ne__(self, other):
8328 
    return not (self == other)
8329 
 
3064 chandransh 8330 
class verifyOrder_result:
759 chandransh 8331 
  """
8332 
  Attributes:
8333 
   - success
8334 
   - ex
8335 
  """
8336 
 
8337 
  thrift_spec = (
8338 
    (0, TType.BOOL, 'success', None, None, ), # 0
8339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8340 
  )
8341 
 
8342 
  def __init__(self, success=None, ex=None,):
8343 
    self.success = success
8344 
    self.ex = ex
8345 
 
8346 
  def read(self, iprot):
8347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8349 
      return
8350 
    iprot.readStructBegin()
8351 
    while True:
8352 
      (fname, ftype, fid) = iprot.readFieldBegin()
8353 
      if ftype == TType.STOP:
8354 
        break
8355 
      if fid == 0:
8356 
        if ftype == TType.BOOL:
8357 
          self.success = iprot.readBool();
8358 
        else:
8359 
          iprot.skip(ftype)
8360 
      elif fid == 1:
8361 
        if ftype == TType.STRUCT:
8362 
          self.ex = TransactionServiceException()
8363 
          self.ex.read(iprot)
8364 
        else:
8365 
          iprot.skip(ftype)
8366 
      else:
8367 
        iprot.skip(ftype)
8368 
      iprot.readFieldEnd()
8369 
    iprot.readStructEnd()
8370 
 
8371 
  def write(self, oprot):
8372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8374 
      return
3064 chandransh 8375 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8376 
    if self.success is not None:
759 chandransh 8377 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8378 
      oprot.writeBool(self.success)
8379 
      oprot.writeFieldEnd()
3431 rajveer 8380 
    if self.ex is not None:
759 chandransh 8381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8382 
      self.ex.write(oprot)
8383 
      oprot.writeFieldEnd()
8384 
    oprot.writeFieldStop()
8385 
    oprot.writeStructEnd()
8386 
 
3431 rajveer 8387 
  def validate(self):
8388 
    return
8389 
 
8390 
 
759 chandransh 8391 
  def __repr__(self):
8392 
    L = ['%s=%r' % (key, value)
8393 
      for key, value in self.__dict__.iteritems()]
8394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8395 
 
8396 
  def __eq__(self, other):
8397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8398 
 
8399 
  def __ne__(self, other):
8400 
    return not (self == other)
8401 
 
3064 chandransh 8402 
class acceptOrder_args:
1113 chandransh 8403 
  """
8404 
  Attributes:
3064 chandransh 8405 
   - orderId
1113 chandransh 8406 
  """
8407 
 
8408 
  thrift_spec = (
8409 
    None, # 0
3064 chandransh 8410 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 8411 
  )
8412 
 
3064 chandransh 8413 
  def __init__(self, orderId=None,):
8414 
    self.orderId = orderId
1113 chandransh 8415 
 
8416 
  def read(self, iprot):
8417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8419 
      return
8420 
    iprot.readStructBegin()
8421 
    while True:
8422 
      (fname, ftype, fid) = iprot.readFieldBegin()
8423 
      if ftype == TType.STOP:
8424 
        break
8425 
      if fid == 1:
8426 
        if ftype == TType.I64:
3064 chandransh 8427 
          self.orderId = iprot.readI64();
1113 chandransh 8428 
        else:
8429 
          iprot.skip(ftype)
8430 
      else:
8431 
        iprot.skip(ftype)
8432 
      iprot.readFieldEnd()
8433 
    iprot.readStructEnd()
8434 
 
8435 
  def write(self, oprot):
8436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8438 
      return
3064 chandransh 8439 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 8440 
    if self.orderId is not None:
3064 chandransh 8441 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8442 
      oprot.writeI64(self.orderId)
1113 chandransh 8443 
      oprot.writeFieldEnd()
8444 
    oprot.writeFieldStop()
8445 
    oprot.writeStructEnd()
8446 
 
3431 rajveer 8447 
  def validate(self):
8448 
    return
8449 
 
8450 
 
1113 chandransh 8451 
  def __repr__(self):
8452 
    L = ['%s=%r' % (key, value)
8453 
      for key, value in self.__dict__.iteritems()]
8454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8455 
 
8456 
  def __eq__(self, other):
8457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8458 
 
8459 
  def __ne__(self, other):
8460 
    return not (self == other)
8461 
 
3064 chandransh 8462 
class acceptOrder_result:
1113 chandransh 8463 
  """
8464 
  Attributes:
8465 
   - success
8466 
   - ex
8467 
  """
8468 
 
8469 
  thrift_spec = (
3064 chandransh 8470 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 8471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8472 
  )
8473 
 
8474 
  def __init__(self, success=None, ex=None,):
8475 
    self.success = success
8476 
    self.ex = ex
8477 
 
8478 
  def read(self, iprot):
8479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8481 
      return
8482 
    iprot.readStructBegin()
8483 
    while True:
8484 
      (fname, ftype, fid) = iprot.readFieldBegin()
8485 
      if ftype == TType.STOP:
8486 
        break
8487 
      if fid == 0:
3064 chandransh 8488 
        if ftype == TType.BOOL:
8489 
          self.success = iprot.readBool();
1113 chandransh 8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      elif fid == 1:
8493 
        if ftype == TType.STRUCT:
8494 
          self.ex = TransactionServiceException()
8495 
          self.ex.read(iprot)
8496 
        else:
8497 
          iprot.skip(ftype)
8498 
      else:
8499 
        iprot.skip(ftype)
8500 
      iprot.readFieldEnd()
8501 
    iprot.readStructEnd()
8502 
 
8503 
  def write(self, oprot):
8504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8506 
      return
3064 chandransh 8507 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 8508 
    if self.success is not None:
3064 chandransh 8509 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8510 
      oprot.writeBool(self.success)
1113 chandransh 8511 
      oprot.writeFieldEnd()
3431 rajveer 8512 
    if self.ex is not None:
1113 chandransh 8513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8514 
      self.ex.write(oprot)
8515 
      oprot.writeFieldEnd()
8516 
    oprot.writeFieldStop()
8517 
    oprot.writeStructEnd()
8518 
 
3431 rajveer 8519 
  def validate(self):
8520 
    return
8521 
 
8522 
 
1113 chandransh 8523 
  def __repr__(self):
8524 
    L = ['%s=%r' % (key, value)
8525 
      for key, value in self.__dict__.iteritems()]
8526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8527 
 
8528 
  def __eq__(self, other):
8529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8530 
 
8531 
  def __ne__(self, other):
8532 
    return not (self == other)
8533 
 
3064 chandransh 8534 
class addBillingDetails_args:
1135 chandransh 8535 
  """
8536 
  Attributes:
3064 chandransh 8537 
   - orderId
8538 
   - invoice_number
4283 anupam.sin 8539 
   - imeiNumber
8540 
   - itemNumber
3064 chandransh 8541 
   - billed_by
4264 rajveer 8542 
   - jacketNumber
4283 anupam.sin 8543 
   - billingType
8544 
   - vendorId
1135 chandransh 8545 
  """
8546 
 
8547 
  thrift_spec = (
8548 
    None, # 0
3064 chandransh 8549 
    (1, TType.I64, 'orderId', None, None, ), # 1
8550 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 8551 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
8552 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
8553 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
8554 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
8555 
    (7, TType.I64, 'billingType', None, None, ), # 7
8556 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 8557 
  )
8558 
 
4283 anupam.sin 8559 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 8560 
    self.orderId = orderId
8561 
    self.invoice_number = invoice_number
4283 anupam.sin 8562 
    self.imeiNumber = imeiNumber
8563 
    self.itemNumber = itemNumber
3064 chandransh 8564 
    self.billed_by = billed_by
4264 rajveer 8565 
    self.jacketNumber = jacketNumber
4283 anupam.sin 8566 
    self.billingType = billingType
8567 
    self.vendorId = vendorId
1135 chandransh 8568 
 
8569 
  def read(self, iprot):
8570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8572 
      return
8573 
    iprot.readStructBegin()
8574 
    while True:
8575 
      (fname, ftype, fid) = iprot.readFieldBegin()
8576 
      if ftype == TType.STOP:
8577 
        break
8578 
      if fid == 1:
8579 
        if ftype == TType.I64:
3064 chandransh 8580 
          self.orderId = iprot.readI64();
1135 chandransh 8581 
        else:
8582 
          iprot.skip(ftype)
8583 
      elif fid == 2:
3064 chandransh 8584 
        if ftype == TType.STRING:
8585 
          self.invoice_number = iprot.readString();
1135 chandransh 8586 
        else:
8587 
          iprot.skip(ftype)
3064 chandransh 8588 
      elif fid == 3:
4264 rajveer 8589 
        if ftype == TType.I64:
3064 chandransh 8590 
          self.imeiNumber = iprot.readI64();
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      elif fid == 4:
8594 
        if ftype == TType.STRING:
8595 
          self.itemNumber = iprot.readString();
8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      elif fid == 5:
8599 
        if ftype == TType.STRING:
4283 anupam.sin 8600 
          self.billed_by = iprot.readString();
3064 chandransh 8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      elif fid == 6:
8604 
        if ftype == TType.I64:
4283 anupam.sin 8605 
          self.jacketNumber = iprot.readI64();
8606 
        else:
8607 
          iprot.skip(ftype)
8608 
      elif fid == 7:
8609 
        if ftype == TType.I64:
3064 chandransh 8610 
          self.billingType = iprot.readI64();
8611 
        else:
8612 
          iprot.skip(ftype)
4283 anupam.sin 8613 
      elif fid == 8:
8614 
        if ftype == TType.I64:
8615 
          self.vendorId = iprot.readI64();
8616 
        else:
8617 
          iprot.skip(ftype)
1246 chandransh 8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
4283 anupam.sin 8627 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 8628 
    if self.orderId is not None:
3064 chandransh 8629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8630 
      oprot.writeI64(self.orderId)
1246 chandransh 8631 
      oprot.writeFieldEnd()
4283 anupam.sin 8632 
    if self.invoice_number is not None:
8633 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
8634 
      oprot.writeString(self.invoice_number)
1246 chandransh 8635 
      oprot.writeFieldEnd()
3431 rajveer 8636 
    if self.imeiNumber is not None:
3064 chandransh 8637 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
8638 
      oprot.writeI64(self.imeiNumber)
8639 
      oprot.writeFieldEnd()
3431 rajveer 8640 
    if self.itemNumber is not None:
3064 chandransh 8641 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
8642 
      oprot.writeString(self.itemNumber)
8643 
      oprot.writeFieldEnd()
4283 anupam.sin 8644 
    if self.billed_by is not None:
8645 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
8646 
      oprot.writeString(self.billed_by)
3064 chandransh 8647 
      oprot.writeFieldEnd()
4283 anupam.sin 8648 
    if self.jacketNumber is not None:
8649 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
8650 
      oprot.writeI64(self.jacketNumber)
8651 
      oprot.writeFieldEnd()
3431 rajveer 8652 
    if self.billingType is not None:
4283 anupam.sin 8653 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 8654 
      oprot.writeI64(self.billingType)
8655 
      oprot.writeFieldEnd()
4283 anupam.sin 8656 
    if self.vendorId is not None:
8657 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
8658 
      oprot.writeI64(self.vendorId)
8659 
      oprot.writeFieldEnd()
1246 chandransh 8660 
    oprot.writeFieldStop()
8661 
    oprot.writeStructEnd()
8662 
 
3431 rajveer 8663 
  def validate(self):
8664 
    return
8665 
 
8666 
 
1246 chandransh 8667 
  def __repr__(self):
8668 
    L = ['%s=%r' % (key, value)
8669 
      for key, value in self.__dict__.iteritems()]
8670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8671 
 
8672 
  def __eq__(self, other):
8673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8674 
 
8675 
  def __ne__(self, other):
8676 
    return not (self == other)
8677 
 
4283 anupam.sin 8678 
class addBillingDetails_result:
1246 chandransh 8679 
  """
8680 
  Attributes:
3064 chandransh 8681 
   - success
1246 chandransh 8682 
   - ex
8683 
  """
8684 
 
8685 
  thrift_spec = (
3064 chandransh 8686 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 8687 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8688 
  )
8689 
 
3064 chandransh 8690 
  def __init__(self, success=None, ex=None,):
8691 
    self.success = success
1246 chandransh 8692 
    self.ex = ex
8693 
 
8694 
  def read(self, iprot):
8695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8697 
      return
8698 
    iprot.readStructBegin()
8699 
    while True:
8700 
      (fname, ftype, fid) = iprot.readFieldBegin()
8701 
      if ftype == TType.STOP:
8702 
        break
3064 chandransh 8703 
      if fid == 0:
8704 
        if ftype == TType.BOOL:
8705 
          self.success = iprot.readBool();
8706 
        else:
8707 
          iprot.skip(ftype)
8708 
      elif fid == 1:
1246 chandransh 8709 
        if ftype == TType.STRUCT:
8710 
          self.ex = TransactionServiceException()
8711 
          self.ex.read(iprot)
8712 
        else:
8713 
          iprot.skip(ftype)
8714 
      else:
8715 
        iprot.skip(ftype)
8716 
      iprot.readFieldEnd()
8717 
    iprot.readStructEnd()
8718 
 
8719 
  def write(self, oprot):
8720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8722 
      return
4283 anupam.sin 8723 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 8724 
    if self.success is not None:
3064 chandransh 8725 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8726 
      oprot.writeBool(self.success)
8727 
      oprot.writeFieldEnd()
3431 rajveer 8728 
    if self.ex is not None:
1246 chandransh 8729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8730 
      self.ex.write(oprot)
8731 
      oprot.writeFieldEnd()
8732 
    oprot.writeFieldStop()
8733 
    oprot.writeStructEnd()
8734 
 
3431 rajveer 8735 
  def validate(self):
8736 
    return
8737 
 
8738 
 
1246 chandransh 8739 
  def __repr__(self):
8740 
    L = ['%s=%r' % (key, value)
8741 
      for key, value in self.__dict__.iteritems()]
8742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8743 
 
8744 
  def __eq__(self, other):
8745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8746 
 
8747 
  def __ne__(self, other):
8748 
    return not (self == other)
8749 
 
3064 chandransh 8750 
class markOrdersAsManifested_args:
1408 ankur.sing 8751 
  """
8752 
  Attributes:
3064 chandransh 8753 
   - warehouseId
1408 ankur.sing 8754 
   - providerId
3064 chandransh 8755 
   - cod
1408 ankur.sing 8756 
  """
8757 
 
8758 
  thrift_spec = (
8759 
    None, # 0
3064 chandransh 8760 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8761 
    (2, TType.I64, 'providerId', None, None, ), # 2
8762 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 8763 
  )
8764 
 
3064 chandransh 8765 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
8766 
    self.warehouseId = warehouseId
1408 ankur.sing 8767 
    self.providerId = providerId
3064 chandransh 8768 
    self.cod = cod
1408 ankur.sing 8769 
 
8770 
  def read(self, iprot):
8771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8773 
      return
8774 
    iprot.readStructBegin()
8775 
    while True:
8776 
      (fname, ftype, fid) = iprot.readFieldBegin()
8777 
      if ftype == TType.STOP:
8778 
        break
8779 
      if fid == 1:
8780 
        if ftype == TType.I64:
3064 chandransh 8781 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 8782 
        else:
8783 
          iprot.skip(ftype)
8784 
      elif fid == 2:
8785 
        if ftype == TType.I64:
3064 chandransh 8786 
          self.providerId = iprot.readI64();
1408 ankur.sing 8787 
        else:
8788 
          iprot.skip(ftype)
3064 chandransh 8789 
      elif fid == 3:
8790 
        if ftype == TType.BOOL:
8791 
          self.cod = iprot.readBool();
8792 
        else:
8793 
          iprot.skip(ftype)
1408 ankur.sing 8794 
      else:
8795 
        iprot.skip(ftype)
8796 
      iprot.readFieldEnd()
8797 
    iprot.readStructEnd()
8798 
 
8799 
  def write(self, oprot):
8800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8802 
      return
3064 chandransh 8803 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 8804 
    if self.warehouseId is not None:
3064 chandransh 8805 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8806 
      oprot.writeI64(self.warehouseId)
8807 
      oprot.writeFieldEnd()
3431 rajveer 8808 
    if self.providerId is not None:
3064 chandransh 8809 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 8810 
      oprot.writeI64(self.providerId)
8811 
      oprot.writeFieldEnd()
3431 rajveer 8812 
    if self.cod is not None:
3064 chandransh 8813 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
8814 
      oprot.writeBool(self.cod)
1408 ankur.sing 8815 
      oprot.writeFieldEnd()
8816 
    oprot.writeFieldStop()
8817 
    oprot.writeStructEnd()
8818 
 
3431 rajveer 8819 
  def validate(self):
8820 
    return
8821 
 
8822 
 
1408 ankur.sing 8823 
  def __repr__(self):
8824 
    L = ['%s=%r' % (key, value)
8825 
      for key, value in self.__dict__.iteritems()]
8826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8827 
 
8828 
  def __eq__(self, other):
8829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8830 
 
8831 
  def __ne__(self, other):
8832 
    return not (self == other)
8833 
 
3064 chandransh 8834 
class markOrdersAsManifested_result:
1408 ankur.sing 8835 
  """
8836 
  Attributes:
8837 
   - success
3064 chandransh 8838 
   - ex
1408 ankur.sing 8839 
  """
8840 
 
8841 
  thrift_spec = (
3064 chandransh 8842 
    (0, TType.BOOL, 'success', None, None, ), # 0
8843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 8844 
  )
8845 
 
3064 chandransh 8846 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 8847 
    self.success = success
3064 chandransh 8848 
    self.ex = ex
1408 ankur.sing 8849 
 
8850 
  def read(self, iprot):
8851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8853 
      return
8854 
    iprot.readStructBegin()
8855 
    while True:
8856 
      (fname, ftype, fid) = iprot.readFieldBegin()
8857 
      if ftype == TType.STOP:
8858 
        break
8859 
      if fid == 0:
3064 chandransh 8860 
        if ftype == TType.BOOL:
8861 
          self.success = iprot.readBool();
1408 ankur.sing 8862 
        else:
8863 
          iprot.skip(ftype)
3064 chandransh 8864 
      elif fid == 1:
8865 
        if ftype == TType.STRUCT:
8866 
          self.ex = TransactionServiceException()
8867 
          self.ex.read(iprot)
8868 
        else:
8869 
          iprot.skip(ftype)
1408 ankur.sing 8870 
      else:
8871 
        iprot.skip(ftype)
8872 
      iprot.readFieldEnd()
8873 
    iprot.readStructEnd()
8874 
 
8875 
  def write(self, oprot):
8876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8878 
      return
3064 chandransh 8879 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 8880 
    if self.success is not None:
3064 chandransh 8881 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8882 
      oprot.writeBool(self.success)
1408 ankur.sing 8883 
      oprot.writeFieldEnd()
3431 rajveer 8884 
    if self.ex is not None:
3064 chandransh 8885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8886 
      self.ex.write(oprot)
8887 
      oprot.writeFieldEnd()
1408 ankur.sing 8888 
    oprot.writeFieldStop()
8889 
    oprot.writeStructEnd()
8890 
 
3431 rajveer 8891 
  def validate(self):
8892 
    return
8893 
 
8894 
 
1408 ankur.sing 8895 
  def __repr__(self):
8896 
    L = ['%s=%r' % (key, value)
8897 
      for key, value in self.__dict__.iteritems()]
8898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8899 
 
8900 
  def __eq__(self, other):
8901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8902 
 
8903 
  def __ne__(self, other):
8904 
    return not (self == other)
8905 
 
3064 chandransh 8906 
class markOrdersAsPickedUp_args:
304 ashish 8907 
  """
8908 
  Attributes:
3064 chandransh 8909 
   - providerId
8910 
   - pickupDetails
304 ashish 8911 
  """
94 ashish 8912 
 
304 ashish 8913 
  thrift_spec = (
8914 
    None, # 0
3064 chandransh 8915 
    (1, TType.I64, 'providerId', None, None, ), # 1
8916 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 8917 
  )
8918 
 
3064 chandransh 8919 
  def __init__(self, providerId=None, pickupDetails=None,):
8920 
    self.providerId = providerId
8921 
    self.pickupDetails = pickupDetails
304 ashish 8922 
 
8923 
  def read(self, iprot):
8924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8926 
      return
8927 
    iprot.readStructBegin()
8928 
    while True:
8929 
      (fname, ftype, fid) = iprot.readFieldBegin()
8930 
      if ftype == TType.STOP:
8931 
        break
8932 
      if fid == 1:
8933 
        if ftype == TType.I64:
3064 chandransh 8934 
          self.providerId = iprot.readI64();
304 ashish 8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      elif fid == 2:
3064 chandransh 8938 
        if ftype == TType.MAP:
8939 
          self.pickupDetails = {}
4133 chandransh 8940 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
8941 
          for _i144 in xrange(_size140):
8942 
            _key145 = iprot.readString();
8943 
            _val146 = iprot.readString();
8944 
            self.pickupDetails[_key145] = _val146
3064 chandransh 8945 
          iprot.readMapEnd()
304 ashish 8946 
        else:
8947 
          iprot.skip(ftype)
8948 
      else:
8949 
        iprot.skip(ftype)
8950 
      iprot.readFieldEnd()
8951 
    iprot.readStructEnd()
8952 
 
8953 
  def write(self, oprot):
8954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8956 
      return
3064 chandransh 8957 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 8958 
    if self.providerId is not None:
3064 chandransh 8959 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8960 
      oprot.writeI64(self.providerId)
304 ashish 8961 
      oprot.writeFieldEnd()
3431 rajveer 8962 
    if self.pickupDetails is not None:
3064 chandransh 8963 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
8964 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 8965 
      for kiter147,viter148 in self.pickupDetails.items():
8966 
        oprot.writeString(kiter147)
8967 
        oprot.writeString(viter148)
3064 chandransh 8968 
      oprot.writeMapEnd()
304 ashish 8969 
      oprot.writeFieldEnd()
8970 
    oprot.writeFieldStop()
8971 
    oprot.writeStructEnd()
8972 
 
3431 rajveer 8973 
  def validate(self):
8974 
    return
8975 
 
8976 
 
304 ashish 8977 
  def __repr__(self):
8978 
    L = ['%s=%r' % (key, value)
8979 
      for key, value in self.__dict__.iteritems()]
8980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8981 
 
8982 
  def __eq__(self, other):
8983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8984 
 
8985 
  def __ne__(self, other):
8986 
    return not (self == other)
8987 
 
3064 chandransh 8988 
class markOrdersAsPickedUp_result:
304 ashish 8989 
  """
8990 
  Attributes:
8991 
   - success
3064 chandransh 8992 
   - ex
304 ashish 8993 
  """
8994 
 
8995 
  thrift_spec = (
3064 chandransh 8996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 8998 
  )
8999 
 
3064 chandransh 9000 
  def __init__(self, success=None, ex=None,):
304 ashish 9001 
    self.success = success
3064 chandransh 9002 
    self.ex = ex
304 ashish 9003 
 
9004 
  def read(self, iprot):
9005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9007 
      return
9008 
    iprot.readStructBegin()
9009 
    while True:
9010 
      (fname, ftype, fid) = iprot.readFieldBegin()
9011 
      if ftype == TType.STOP:
9012 
        break
9013 
      if fid == 0:
9014 
        if ftype == TType.LIST:
9015 
          self.success = []
4133 chandransh 9016 
          (_etype152, _size149) = iprot.readListBegin()
9017 
          for _i153 in xrange(_size149):
9018 
            _elem154 = Order()
9019 
            _elem154.read(iprot)
9020 
            self.success.append(_elem154)
304 ashish 9021 
          iprot.readListEnd()
9022 
        else:
9023 
          iprot.skip(ftype)
3064 chandransh 9024 
      elif fid == 1:
9025 
        if ftype == TType.STRUCT:
9026 
          self.ex = TransactionServiceException()
9027 
          self.ex.read(iprot)
9028 
        else:
9029 
          iprot.skip(ftype)
304 ashish 9030 
      else:
9031 
        iprot.skip(ftype)
9032 
      iprot.readFieldEnd()
9033 
    iprot.readStructEnd()
9034 
 
9035 
  def write(self, oprot):
9036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9038 
      return
3064 chandransh 9039 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9040 
    if self.success is not None:
304 ashish 9041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9043 
      for iter155 in self.success:
9044 
        iter155.write(oprot)
304 ashish 9045 
      oprot.writeListEnd()
9046 
      oprot.writeFieldEnd()
3431 rajveer 9047 
    if self.ex is not None:
3064 chandransh 9048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9049 
      self.ex.write(oprot)
9050 
      oprot.writeFieldEnd()
304 ashish 9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
3431 rajveer 9054 
  def validate(self):
9055 
    return
9056 
 
9057 
 
304 ashish 9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
3064 chandransh 9069 
class markOrdersAsDelivered_args:
304 ashish 9070 
  """
9071 
  Attributes:
3064 chandransh 9072 
   - providerId
9073 
   - deliveredOrders
304 ashish 9074 
  """
9075 
 
9076 
  thrift_spec = (
9077 
    None, # 0
3064 chandransh 9078 
    (1, TType.I64, 'providerId', None, None, ), # 1
9079 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9080 
  )
9081 
 
3064 chandransh 9082 
  def __init__(self, providerId=None, deliveredOrders=None,):
9083 
    self.providerId = providerId
9084 
    self.deliveredOrders = deliveredOrders
304 ashish 9085 
 
9086 
  def read(self, iprot):
9087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9089 
      return
9090 
    iprot.readStructBegin()
9091 
    while True:
9092 
      (fname, ftype, fid) = iprot.readFieldBegin()
9093 
      if ftype == TType.STOP:
9094 
        break
9095 
      if fid == 1:
9096 
        if ftype == TType.I64:
3064 chandransh 9097 
          self.providerId = iprot.readI64();
304 ashish 9098 
        else:
9099 
          iprot.skip(ftype)
9100 
      elif fid == 2:
3064 chandransh 9101 
        if ftype == TType.MAP:
9102 
          self.deliveredOrders = {}
4133 chandransh 9103 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9104 
          for _i160 in xrange(_size156):
9105 
            _key161 = iprot.readString();
9106 
            _val162 = iprot.readString();
9107 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9108 
          iprot.readMapEnd()
304 ashish 9109 
        else:
9110 
          iprot.skip(ftype)
9111 
      else:
9112 
        iprot.skip(ftype)
9113 
      iprot.readFieldEnd()
9114 
    iprot.readStructEnd()
9115 
 
9116 
  def write(self, oprot):
9117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9119 
      return
3064 chandransh 9120 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9121 
    if self.providerId is not None:
3064 chandransh 9122 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9123 
      oprot.writeI64(self.providerId)
304 ashish 9124 
      oprot.writeFieldEnd()
3431 rajveer 9125 
    if self.deliveredOrders is not None:
3064 chandransh 9126 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9127 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9128 
      for kiter163,viter164 in self.deliveredOrders.items():
9129 
        oprot.writeString(kiter163)
9130 
        oprot.writeString(viter164)
3064 chandransh 9131 
      oprot.writeMapEnd()
304 ashish 9132 
      oprot.writeFieldEnd()
9133 
    oprot.writeFieldStop()
9134 
    oprot.writeStructEnd()
9135 
 
3431 rajveer 9136 
  def validate(self):
9137 
    return
9138 
 
9139 
 
304 ashish 9140 
  def __repr__(self):
9141 
    L = ['%s=%r' % (key, value)
9142 
      for key, value in self.__dict__.iteritems()]
9143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9144 
 
9145 
  def __eq__(self, other):
9146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9147 
 
9148 
  def __ne__(self, other):
9149 
    return not (self == other)
9150 
 
3064 chandransh 9151 
class markOrdersAsDelivered_result:
9152 
  """
9153 
  Attributes:
9154 
   - ex
9155 
  """
304 ashish 9156 
 
9157 
  thrift_spec = (
3064 chandransh 9158 
    None, # 0
9159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9160 
  )
9161 
 
3064 chandransh 9162 
  def __init__(self, ex=None,):
9163 
    self.ex = ex
304 ashish 9164 
 
1596 ankur.sing 9165 
  def read(self, iprot):
9166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9168 
      return
9169 
    iprot.readStructBegin()
9170 
    while True:
9171 
      (fname, ftype, fid) = iprot.readFieldBegin()
9172 
      if ftype == TType.STOP:
9173 
        break
3064 chandransh 9174 
      if fid == 1:
9175 
        if ftype == TType.STRUCT:
9176 
          self.ex = TransactionServiceException()
9177 
          self.ex.read(iprot)
9178 
        else:
9179 
          iprot.skip(ftype)
1596 ankur.sing 9180 
      else:
9181 
        iprot.skip(ftype)
9182 
      iprot.readFieldEnd()
9183 
    iprot.readStructEnd()
9184 
 
9185 
  def write(self, oprot):
9186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9188 
      return
3064 chandransh 9189 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9190 
    if self.ex is not None:
3064 chandransh 9191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9192 
      self.ex.write(oprot)
9193 
      oprot.writeFieldEnd()
1596 ankur.sing 9194 
    oprot.writeFieldStop()
9195 
    oprot.writeStructEnd()
9196 
 
3431 rajveer 9197 
  def validate(self):
9198 
    return
9199 
 
9200 
 
1596 ankur.sing 9201 
  def __repr__(self):
9202 
    L = ['%s=%r' % (key, value)
9203 
      for key, value in self.__dict__.iteritems()]
9204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9205 
 
9206 
  def __eq__(self, other):
9207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9208 
 
9209 
  def __ne__(self, other):
9210 
    return not (self == other)
9211 
 
3064 chandransh 9212 
class markOrdersAsFailed_args:
1596 ankur.sing 9213 
  """
9214 
  Attributes:
3064 chandransh 9215 
   - providerId
9216 
   - returnedOrders
1596 ankur.sing 9217 
  """
9218 
 
9219 
  thrift_spec = (
3064 chandransh 9220 
    None, # 0
9221 
    (1, TType.I64, 'providerId', None, None, ), # 1
9222 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9223 
  )
9224 
 
3064 chandransh 9225 
  def __init__(self, providerId=None, returnedOrders=None,):
9226 
    self.providerId = providerId
9227 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9228 
 
9229 
  def read(self, iprot):
9230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9232 
      return
9233 
    iprot.readStructBegin()
9234 
    while True:
9235 
      (fname, ftype, fid) = iprot.readFieldBegin()
9236 
      if ftype == TType.STOP:
9237 
        break
3064 chandransh 9238 
      if fid == 1:
1596 ankur.sing 9239 
        if ftype == TType.I64:
3064 chandransh 9240 
          self.providerId = iprot.readI64();
1596 ankur.sing 9241 
        else:
9242 
          iprot.skip(ftype)
3064 chandransh 9243 
      elif fid == 2:
9244 
        if ftype == TType.MAP:
9245 
          self.returnedOrders = {}
4133 chandransh 9246 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
9247 
          for _i169 in xrange(_size165):
9248 
            _key170 = iprot.readString();
9249 
            _val171 = iprot.readString();
9250 
            self.returnedOrders[_key170] = _val171
3064 chandransh 9251 
          iprot.readMapEnd()
9252 
        else:
9253 
          iprot.skip(ftype)
1596 ankur.sing 9254 
      else:
9255 
        iprot.skip(ftype)
9256 
      iprot.readFieldEnd()
9257 
    iprot.readStructEnd()
9258 
 
9259 
  def write(self, oprot):
9260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9262 
      return
3064 chandransh 9263 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 9264 
    if self.providerId is not None:
3064 chandransh 9265 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9266 
      oprot.writeI64(self.providerId)
1596 ankur.sing 9267 
      oprot.writeFieldEnd()
3431 rajveer 9268 
    if self.returnedOrders is not None:
3064 chandransh 9269 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
9270 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 9271 
      for kiter172,viter173 in self.returnedOrders.items():
9272 
        oprot.writeString(kiter172)
9273 
        oprot.writeString(viter173)
3064 chandransh 9274 
      oprot.writeMapEnd()
9275 
      oprot.writeFieldEnd()
1596 ankur.sing 9276 
    oprot.writeFieldStop()
9277 
    oprot.writeStructEnd()
9278 
 
3431 rajveer 9279 
  def validate(self):
9280 
    return
9281 
 
9282 
 
1596 ankur.sing 9283 
  def __repr__(self):
9284 
    L = ['%s=%r' % (key, value)
9285 
      for key, value in self.__dict__.iteritems()]
9286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9287 
 
9288 
  def __eq__(self, other):
9289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9290 
 
9291 
  def __ne__(self, other):
9292 
    return not (self == other)
9293 
 
3064 chandransh 9294 
class markOrdersAsFailed_result:
9295 
  """
9296 
  Attributes:
9297 
   - ex
9298 
  """
1596 ankur.sing 9299 
 
1627 ankur.sing 9300 
  thrift_spec = (
3064 chandransh 9301 
    None, # 0
9302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9303 
  )
9304 
 
3064 chandransh 9305 
  def __init__(self, ex=None,):
9306 
    self.ex = ex
9307 
 
1627 ankur.sing 9308 
  def read(self, iprot):
9309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9311 
      return
9312 
    iprot.readStructBegin()
9313 
    while True:
9314 
      (fname, ftype, fid) = iprot.readFieldBegin()
9315 
      if ftype == TType.STOP:
9316 
        break
3064 chandransh 9317 
      if fid == 1:
9318 
        if ftype == TType.STRUCT:
9319 
          self.ex = TransactionServiceException()
9320 
          self.ex.read(iprot)
9321 
        else:
9322 
          iprot.skip(ftype)
1627 ankur.sing 9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
3064 chandransh 9332 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 9333 
    if self.ex is not None:
3064 chandransh 9334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9335 
      self.ex.write(oprot)
9336 
      oprot.writeFieldEnd()
1627 ankur.sing 9337 
    oprot.writeFieldStop()
9338 
    oprot.writeStructEnd()
9339 
 
3431 rajveer 9340 
  def validate(self):
9341 
    return
9342 
 
9343 
 
1627 ankur.sing 9344 
  def __repr__(self):
9345 
    L = ['%s=%r' % (key, value)
9346 
      for key, value in self.__dict__.iteritems()]
9347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9348 
 
9349 
  def __eq__(self, other):
9350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9351 
 
9352 
  def __ne__(self, other):
9353 
    return not (self == other)
9354 
 
3064 chandransh 9355 
class updateNonDeliveryReason_args:
1627 ankur.sing 9356 
  """
9357 
  Attributes:
3064 chandransh 9358 
   - providerId
9359 
   - undeliveredOrders
1627 ankur.sing 9360 
  """
9361 
 
9362 
  thrift_spec = (
3064 chandransh 9363 
    None, # 0
9364 
    (1, TType.I64, 'providerId', None, None, ), # 1
9365 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 9366 
  )
9367 
 
3064 chandransh 9368 
  def __init__(self, providerId=None, undeliveredOrders=None,):
9369 
    self.providerId = providerId
9370 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 9371 
 
9372 
  def read(self, iprot):
9373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9375 
      return
9376 
    iprot.readStructBegin()
9377 
    while True:
9378 
      (fname, ftype, fid) = iprot.readFieldBegin()
9379 
      if ftype == TType.STOP:
9380 
        break
3064 chandransh 9381 
      if fid == 1:
1627 ankur.sing 9382 
        if ftype == TType.I64:
3064 chandransh 9383 
          self.providerId = iprot.readI64();
1627 ankur.sing 9384 
        else:
9385 
          iprot.skip(ftype)
3064 chandransh 9386 
      elif fid == 2:
9387 
        if ftype == TType.MAP:
9388 
          self.undeliveredOrders = {}
4133 chandransh 9389 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
9390 
          for _i178 in xrange(_size174):
9391 
            _key179 = iprot.readString();
9392 
            _val180 = iprot.readString();
9393 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 9394 
          iprot.readMapEnd()
9395 
        else:
9396 
          iprot.skip(ftype)
1627 ankur.sing 9397 
      else:
9398 
        iprot.skip(ftype)
9399 
      iprot.readFieldEnd()
9400 
    iprot.readStructEnd()
9401 
 
9402 
  def write(self, oprot):
9403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9405 
      return
3064 chandransh 9406 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 9407 
    if self.providerId is not None:
3064 chandransh 9408 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9409 
      oprot.writeI64(self.providerId)
1627 ankur.sing 9410 
      oprot.writeFieldEnd()
3431 rajveer 9411 
    if self.undeliveredOrders is not None:
3064 chandransh 9412 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
9413 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 9414 
      for kiter181,viter182 in self.undeliveredOrders.items():
9415 
        oprot.writeString(kiter181)
9416 
        oprot.writeString(viter182)
3064 chandransh 9417 
      oprot.writeMapEnd()
9418 
      oprot.writeFieldEnd()
1627 ankur.sing 9419 
    oprot.writeFieldStop()
9420 
    oprot.writeStructEnd()
9421 
 
3431 rajveer 9422 
  def validate(self):
9423 
    return
9424 
 
9425 
 
1627 ankur.sing 9426 
  def __repr__(self):
9427 
    L = ['%s=%r' % (key, value)
9428 
      for key, value in self.__dict__.iteritems()]
9429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9430 
 
9431 
  def __eq__(self, other):
9432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9433 
 
9434 
  def __ne__(self, other):
9435 
    return not (self == other)
9436 
 
3064 chandransh 9437 
class updateNonDeliveryReason_result:
1627 ankur.sing 9438 
  """
9439 
  Attributes:
3064 chandransh 9440 
   - ex
1627 ankur.sing 9441 
  """
9442 
 
9443 
  thrift_spec = (
3064 chandransh 9444 
    None, # 0
9445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 9446 
  )
9447 
 
3064 chandransh 9448 
  def __init__(self, ex=None,):
9449 
    self.ex = ex
1627 ankur.sing 9450 
 
9451 
  def read(self, iprot):
9452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9454 
      return
9455 
    iprot.readStructBegin()
9456 
    while True:
9457 
      (fname, ftype, fid) = iprot.readFieldBegin()
9458 
      if ftype == TType.STOP:
9459 
        break
3064 chandransh 9460 
      if fid == 1:
9461 
        if ftype == TType.STRUCT:
9462 
          self.ex = TransactionServiceException()
9463 
          self.ex.read(iprot)
1627 ankur.sing 9464 
        else:
9465 
          iprot.skip(ftype)
9466 
      else:
9467 
        iprot.skip(ftype)
9468 
      iprot.readFieldEnd()
9469 
    iprot.readStructEnd()
9470 
 
9471 
  def write(self, oprot):
9472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9474 
      return
3064 chandransh 9475 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 9476 
    if self.ex is not None:
3064 chandransh 9477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9478 
      self.ex.write(oprot)
1627 ankur.sing 9479 
      oprot.writeFieldEnd()
9480 
    oprot.writeFieldStop()
9481 
    oprot.writeStructEnd()
9482 
 
3431 rajveer 9483 
  def validate(self):
9484 
    return
9485 
 
9486 
 
1627 ankur.sing 9487 
  def __repr__(self):
9488 
    L = ['%s=%r' % (key, value)
9489 
      for key, value in self.__dict__.iteritems()]
9490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9491 
 
9492 
  def __eq__(self, other):
9493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9494 
 
9495 
  def __ne__(self, other):
9496 
    return not (self == other)
9497 
 
3064 chandransh 9498 
class getUndeliveredOrders_args:
1886 ankur.sing 9499 
  """
9500 
  Attributes:
3064 chandransh 9501 
   - providerId
9502 
   - warehouseId
1886 ankur.sing 9503 
  """
1627 ankur.sing 9504 
 
1886 ankur.sing 9505 
  thrift_spec = (
9506 
    None, # 0
3064 chandransh 9507 
    (1, TType.I64, 'providerId', None, None, ), # 1
9508 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 9509 
  )
9510 
 
3064 chandransh 9511 
  def __init__(self, providerId=None, warehouseId=None,):
9512 
    self.providerId = providerId
9513 
    self.warehouseId = warehouseId
1886 ankur.sing 9514 
 
9515 
  def read(self, iprot):
9516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9518 
      return
9519 
    iprot.readStructBegin()
9520 
    while True:
9521 
      (fname, ftype, fid) = iprot.readFieldBegin()
9522 
      if ftype == TType.STOP:
9523 
        break
9524 
      if fid == 1:
9525 
        if ftype == TType.I64:
3064 chandransh 9526 
          self.providerId = iprot.readI64();
1886 ankur.sing 9527 
        else:
9528 
          iprot.skip(ftype)
3064 chandransh 9529 
      elif fid == 2:
9530 
        if ftype == TType.I64:
9531 
          self.warehouseId = iprot.readI64();
9532 
        else:
9533 
          iprot.skip(ftype)
1886 ankur.sing 9534 
      else:
9535 
        iprot.skip(ftype)
9536 
      iprot.readFieldEnd()
9537 
    iprot.readStructEnd()
9538 
 
9539 
  def write(self, oprot):
9540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9542 
      return
3064 chandransh 9543 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 9544 
    if self.providerId is not None:
3064 chandransh 9545 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9546 
      oprot.writeI64(self.providerId)
1886 ankur.sing 9547 
      oprot.writeFieldEnd()
3431 rajveer 9548 
    if self.warehouseId is not None:
3064 chandransh 9549 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9550 
      oprot.writeI64(self.warehouseId)
9551 
      oprot.writeFieldEnd()
1886 ankur.sing 9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
3431 rajveer 9555 
  def validate(self):
9556 
    return
9557 
 
9558 
 
1886 ankur.sing 9559 
  def __repr__(self):
9560 
    L = ['%s=%r' % (key, value)
9561 
      for key, value in self.__dict__.iteritems()]
9562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9563 
 
9564 
  def __eq__(self, other):
9565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9566 
 
9567 
  def __ne__(self, other):
9568 
    return not (self == other)
9569 
 
3064 chandransh 9570 
class getUndeliveredOrders_result:
1886 ankur.sing 9571 
  """
9572 
  Attributes:
9573 
   - success
9574 
  """
9575 
 
9576 
  thrift_spec = (
9577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9578 
  )
9579 
 
9580 
  def __init__(self, success=None,):
9581 
    self.success = success
9582 
 
9583 
  def read(self, iprot):
9584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9586 
      return
9587 
    iprot.readStructBegin()
9588 
    while True:
9589 
      (fname, ftype, fid) = iprot.readFieldBegin()
9590 
      if ftype == TType.STOP:
9591 
        break
9592 
      if fid == 0:
9593 
        if ftype == TType.LIST:
9594 
          self.success = []
4133 chandransh 9595 
          (_etype186, _size183) = iprot.readListBegin()
9596 
          for _i187 in xrange(_size183):
9597 
            _elem188 = Order()
9598 
            _elem188.read(iprot)
9599 
            self.success.append(_elem188)
1886 ankur.sing 9600 
          iprot.readListEnd()
9601 
        else:
9602 
          iprot.skip(ftype)
9603 
      else:
9604 
        iprot.skip(ftype)
9605 
      iprot.readFieldEnd()
9606 
    iprot.readStructEnd()
9607 
 
9608 
  def write(self, oprot):
9609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9611 
      return
3064 chandransh 9612 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 9613 
    if self.success is not None:
1886 ankur.sing 9614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9616 
      for iter189 in self.success:
9617 
        iter189.write(oprot)
1886 ankur.sing 9618 
      oprot.writeListEnd()
9619 
      oprot.writeFieldEnd()
9620 
    oprot.writeFieldStop()
9621 
    oprot.writeStructEnd()
9622 
 
3431 rajveer 9623 
  def validate(self):
9624 
    return
9625 
 
9626 
 
1886 ankur.sing 9627 
  def __repr__(self):
9628 
    L = ['%s=%r' % (key, value)
9629 
      for key, value in self.__dict__.iteritems()]
9630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9631 
 
9632 
  def __eq__(self, other):
9633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9634 
 
9635 
  def __ne__(self, other):
9636 
    return not (self == other)
9637 
 
2536 chandransh 9638 
class toggleDOAFlag_args:
9639 
  """
9640 
  Attributes:
9641 
   - orderId
9642 
  """
1886 ankur.sing 9643 
 
2536 chandransh 9644 
  thrift_spec = (
9645 
    None, # 0
9646 
    (1, TType.I64, 'orderId', None, None, ), # 1
9647 
  )
9648 
 
9649 
  def __init__(self, orderId=None,):
9650 
    self.orderId = orderId
9651 
 
9652 
  def read(self, iprot):
9653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9655 
      return
9656 
    iprot.readStructBegin()
9657 
    while True:
9658 
      (fname, ftype, fid) = iprot.readFieldBegin()
9659 
      if ftype == TType.STOP:
9660 
        break
9661 
      if fid == 1:
9662 
        if ftype == TType.I64:
9663 
          self.orderId = iprot.readI64();
9664 
        else:
9665 
          iprot.skip(ftype)
9666 
      else:
9667 
        iprot.skip(ftype)
9668 
      iprot.readFieldEnd()
9669 
    iprot.readStructEnd()
9670 
 
9671 
  def write(self, oprot):
9672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9674 
      return
9675 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 9676 
    if self.orderId is not None:
2536 chandransh 9677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9678 
      oprot.writeI64(self.orderId)
9679 
      oprot.writeFieldEnd()
9680 
    oprot.writeFieldStop()
9681 
    oprot.writeStructEnd()
9682 
 
3431 rajveer 9683 
  def validate(self):
9684 
    return
9685 
 
9686 
 
2536 chandransh 9687 
  def __repr__(self):
9688 
    L = ['%s=%r' % (key, value)
9689 
      for key, value in self.__dict__.iteritems()]
9690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9691 
 
9692 
  def __eq__(self, other):
9693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9694 
 
9695 
  def __ne__(self, other):
9696 
    return not (self == other)
9697 
 
9698 
class toggleDOAFlag_result:
9699 
  """
9700 
  Attributes:
9701 
   - success
9702 
   - ex
9703 
  """
9704 
 
9705 
  thrift_spec = (
9706 
    (0, TType.BOOL, 'success', None, None, ), # 0
9707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9708 
  )
9709 
 
9710 
  def __init__(self, success=None, ex=None,):
9711 
    self.success = success
9712 
    self.ex = ex
9713 
 
9714 
  def read(self, iprot):
9715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9717 
      return
9718 
    iprot.readStructBegin()
9719 
    while True:
9720 
      (fname, ftype, fid) = iprot.readFieldBegin()
9721 
      if ftype == TType.STOP:
9722 
        break
9723 
      if fid == 0:
9724 
        if ftype == TType.BOOL:
9725 
          self.success = iprot.readBool();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      elif fid == 1:
9729 
        if ftype == TType.STRUCT:
9730 
          self.ex = TransactionServiceException()
9731 
          self.ex.read(iprot)
9732 
        else:
9733 
          iprot.skip(ftype)
9734 
      else:
9735 
        iprot.skip(ftype)
9736 
      iprot.readFieldEnd()
9737 
    iprot.readStructEnd()
9738 
 
9739 
  def write(self, oprot):
9740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9742 
      return
9743 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 9744 
    if self.success is not None:
2536 chandransh 9745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9746 
      oprot.writeBool(self.success)
9747 
      oprot.writeFieldEnd()
3431 rajveer 9748 
    if self.ex is not None:
2536 chandransh 9749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9750 
      self.ex.write(oprot)
9751 
      oprot.writeFieldEnd()
9752 
    oprot.writeFieldStop()
9753 
    oprot.writeStructEnd()
9754 
 
3431 rajveer 9755 
  def validate(self):
9756 
    return
9757 
 
9758 
 
2536 chandransh 9759 
  def __repr__(self):
9760 
    L = ['%s=%r' % (key, value)
9761 
      for key, value in self.__dict__.iteritems()]
9762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9763 
 
9764 
  def __eq__(self, other):
9765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9766 
 
9767 
  def __ne__(self, other):
9768 
    return not (self == other)
9769 
 
9770 
class requestPickupNumber_args:
9771 
  """
9772 
  Attributes:
9773 
   - orderId
9774 
  """
9775 
 
9776 
  thrift_spec = (
9777 
    None, # 0
9778 
    (1, TType.I64, 'orderId', None, None, ), # 1
9779 
  )
9780 
 
9781 
  def __init__(self, orderId=None,):
9782 
    self.orderId = orderId
9783 
 
9784 
  def read(self, iprot):
9785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9787 
      return
9788 
    iprot.readStructBegin()
9789 
    while True:
9790 
      (fname, ftype, fid) = iprot.readFieldBegin()
9791 
      if ftype == TType.STOP:
9792 
        break
9793 
      if fid == 1:
9794 
        if ftype == TType.I64:
9795 
          self.orderId = iprot.readI64();
9796 
        else:
9797 
          iprot.skip(ftype)
9798 
      else:
9799 
        iprot.skip(ftype)
9800 
      iprot.readFieldEnd()
9801 
    iprot.readStructEnd()
9802 
 
9803 
  def write(self, oprot):
9804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9806 
      return
9807 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 9808 
    if self.orderId is not None:
2536 chandransh 9809 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9810 
      oprot.writeI64(self.orderId)
9811 
      oprot.writeFieldEnd()
9812 
    oprot.writeFieldStop()
9813 
    oprot.writeStructEnd()
9814 
 
3431 rajveer 9815 
  def validate(self):
9816 
    return
9817 
 
9818 
 
2536 chandransh 9819 
  def __repr__(self):
9820 
    L = ['%s=%r' % (key, value)
9821 
      for key, value in self.__dict__.iteritems()]
9822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9823 
 
9824 
  def __eq__(self, other):
9825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9826 
 
9827 
  def __ne__(self, other):
9828 
    return not (self == other)
9829 
 
9830 
class requestPickupNumber_result:
9831 
  """
9832 
  Attributes:
9833 
   - success
9834 
   - ex
9835 
  """
9836 
 
9837 
  thrift_spec = (
9838 
    (0, TType.BOOL, 'success', None, None, ), # 0
9839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9840 
  )
9841 
 
9842 
  def __init__(self, success=None, ex=None,):
9843 
    self.success = success
9844 
    self.ex = ex
9845 
 
9846 
  def read(self, iprot):
9847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9849 
      return
9850 
    iprot.readStructBegin()
9851 
    while True:
9852 
      (fname, ftype, fid) = iprot.readFieldBegin()
9853 
      if ftype == TType.STOP:
9854 
        break
9855 
      if fid == 0:
9856 
        if ftype == TType.BOOL:
9857 
          self.success = iprot.readBool();
9858 
        else:
9859 
          iprot.skip(ftype)
9860 
      elif fid == 1:
9861 
        if ftype == TType.STRUCT:
9862 
          self.ex = TransactionServiceException()
9863 
          self.ex.read(iprot)
9864 
        else:
9865 
          iprot.skip(ftype)
9866 
      else:
9867 
        iprot.skip(ftype)
9868 
      iprot.readFieldEnd()
9869 
    iprot.readStructEnd()
9870 
 
9871 
  def write(self, oprot):
9872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9874 
      return
9875 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 9876 
    if self.success is not None:
2536 chandransh 9877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9878 
      oprot.writeBool(self.success)
9879 
      oprot.writeFieldEnd()
3431 rajveer 9880 
    if self.ex is not None:
2536 chandransh 9881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9882 
      self.ex.write(oprot)
9883 
      oprot.writeFieldEnd()
9884 
    oprot.writeFieldStop()
9885 
    oprot.writeStructEnd()
9886 
 
3431 rajveer 9887 
  def validate(self):
9888 
    return
9889 
 
9890 
 
2536 chandransh 9891 
  def __repr__(self):
9892 
    L = ['%s=%r' % (key, value)
9893 
      for key, value in self.__dict__.iteritems()]
9894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9895 
 
9896 
  def __eq__(self, other):
9897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9898 
 
9899 
  def __ne__(self, other):
9900 
    return not (self == other)
9901 
 
9902 
class authorizePickup_args:
9903 
  """
9904 
  Attributes:
9905 
   - orderId
9906 
   - pickupNumber
9907 
  """
9908 
 
9909 
  thrift_spec = (
9910 
    None, # 0
9911 
    (1, TType.I64, 'orderId', None, None, ), # 1
9912 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
9913 
  )
9914 
 
9915 
  def __init__(self, orderId=None, pickupNumber=None,):
9916 
    self.orderId = orderId
9917 
    self.pickupNumber = pickupNumber
9918 
 
9919 
  def read(self, iprot):
9920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9922 
      return
9923 
    iprot.readStructBegin()
9924 
    while True:
9925 
      (fname, ftype, fid) = iprot.readFieldBegin()
9926 
      if ftype == TType.STOP:
9927 
        break
9928 
      if fid == 1:
9929 
        if ftype == TType.I64:
9930 
          self.orderId = iprot.readI64();
9931 
        else:
9932 
          iprot.skip(ftype)
9933 
      elif fid == 2:
9934 
        if ftype == TType.STRING:
9935 
          self.pickupNumber = iprot.readString();
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      else:
9939 
        iprot.skip(ftype)
9940 
      iprot.readFieldEnd()
9941 
    iprot.readStructEnd()
9942 
 
9943 
  def write(self, oprot):
9944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9946 
      return
9947 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 9948 
    if self.orderId is not None:
2536 chandransh 9949 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9950 
      oprot.writeI64(self.orderId)
9951 
      oprot.writeFieldEnd()
3431 rajveer 9952 
    if self.pickupNumber is not None:
2536 chandransh 9953 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
9954 
      oprot.writeString(self.pickupNumber)
9955 
      oprot.writeFieldEnd()
9956 
    oprot.writeFieldStop()
9957 
    oprot.writeStructEnd()
9958 
 
3431 rajveer 9959 
  def validate(self):
9960 
    return
9961 
 
9962 
 
2536 chandransh 9963 
  def __repr__(self):
9964 
    L = ['%s=%r' % (key, value)
9965 
      for key, value in self.__dict__.iteritems()]
9966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9967 
 
9968 
  def __eq__(self, other):
9969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9970 
 
9971 
  def __ne__(self, other):
9972 
    return not (self == other)
9973 
 
9974 
class authorizePickup_result:
9975 
  """
9976 
  Attributes:
9977 
   - success
9978 
   - ex
9979 
  """
9980 
 
9981 
  thrift_spec = (
9982 
    (0, TType.BOOL, 'success', None, None, ), # 0
9983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9984 
  )
9985 
 
9986 
  def __init__(self, success=None, ex=None,):
9987 
    self.success = success
9988 
    self.ex = ex
9989 
 
9990 
  def read(self, iprot):
9991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9993 
      return
9994 
    iprot.readStructBegin()
9995 
    while True:
9996 
      (fname, ftype, fid) = iprot.readFieldBegin()
9997 
      if ftype == TType.STOP:
9998 
        break
9999 
      if fid == 0:
10000 
        if ftype == TType.BOOL:
10001 
          self.success = iprot.readBool();
10002 
        else:
10003 
          iprot.skip(ftype)
10004 
      elif fid == 1:
10005 
        if ftype == TType.STRUCT:
10006 
          self.ex = TransactionServiceException()
10007 
          self.ex.read(iprot)
10008 
        else:
10009 
          iprot.skip(ftype)
10010 
      else:
10011 
        iprot.skip(ftype)
10012 
      iprot.readFieldEnd()
10013 
    iprot.readStructEnd()
10014 
 
10015 
  def write(self, oprot):
10016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10018 
      return
10019 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10020 
    if self.success is not None:
2536 chandransh 10021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10022 
      oprot.writeBool(self.success)
10023 
      oprot.writeFieldEnd()
3431 rajveer 10024 
    if self.ex is not None:
2536 chandransh 10025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10026 
      self.ex.write(oprot)
10027 
      oprot.writeFieldEnd()
10028 
    oprot.writeFieldStop()
10029 
    oprot.writeStructEnd()
10030 
 
3431 rajveer 10031 
  def validate(self):
10032 
    return
10033 
 
10034 
 
2536 chandransh 10035 
  def __repr__(self):
10036 
    L = ['%s=%r' % (key, value)
10037 
      for key, value in self.__dict__.iteritems()]
10038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10039 
 
10040 
  def __eq__(self, other):
10041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10042 
 
10043 
  def __ne__(self, other):
10044 
    return not (self == other)
10045 
 
2764 chandransh 10046 
class markDoasAsPickedUp_args:
10047 
  """
10048 
  Attributes:
10049 
   - providerId
10050 
   - pickupDetails
10051 
  """
10052 
 
10053 
  thrift_spec = (
10054 
    None, # 0
10055 
    (1, TType.I64, 'providerId', None, None, ), # 1
10056 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10057 
  )
10058 
 
10059 
  def __init__(self, providerId=None, pickupDetails=None,):
10060 
    self.providerId = providerId
10061 
    self.pickupDetails = pickupDetails
10062 
 
10063 
  def read(self, iprot):
10064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10066 
      return
10067 
    iprot.readStructBegin()
10068 
    while True:
10069 
      (fname, ftype, fid) = iprot.readFieldBegin()
10070 
      if ftype == TType.STOP:
10071 
        break
10072 
      if fid == 1:
10073 
        if ftype == TType.I64:
10074 
          self.providerId = iprot.readI64();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      elif fid == 2:
10078 
        if ftype == TType.MAP:
10079 
          self.pickupDetails = {}
4133 chandransh 10080 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10081 
          for _i194 in xrange(_size190):
10082 
            _key195 = iprot.readString();
10083 
            _val196 = iprot.readString();
10084 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10085 
          iprot.readMapEnd()
10086 
        else:
10087 
          iprot.skip(ftype)
10088 
      else:
10089 
        iprot.skip(ftype)
10090 
      iprot.readFieldEnd()
10091 
    iprot.readStructEnd()
10092 
 
10093 
  def write(self, oprot):
10094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10096 
      return
10097 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10098 
    if self.providerId is not None:
2764 chandransh 10099 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10100 
      oprot.writeI64(self.providerId)
10101 
      oprot.writeFieldEnd()
3431 rajveer 10102 
    if self.pickupDetails is not None:
2764 chandransh 10103 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10104 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10105 
      for kiter197,viter198 in self.pickupDetails.items():
10106 
        oprot.writeString(kiter197)
10107 
        oprot.writeString(viter198)
2764 chandransh 10108 
      oprot.writeMapEnd()
10109 
      oprot.writeFieldEnd()
10110 
    oprot.writeFieldStop()
10111 
    oprot.writeStructEnd()
10112 
 
3431 rajveer 10113 
  def validate(self):
10114 
    return
10115 
 
10116 
 
2764 chandransh 10117 
  def __repr__(self):
10118 
    L = ['%s=%r' % (key, value)
10119 
      for key, value in self.__dict__.iteritems()]
10120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10121 
 
10122 
  def __eq__(self, other):
10123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10124 
 
10125 
  def __ne__(self, other):
10126 
    return not (self == other)
10127 
 
10128 
class markDoasAsPickedUp_result:
10129 
  """
10130 
  Attributes:
10131 
   - success
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10136 
  )
10137 
 
10138 
  def __init__(self, success=None,):
10139 
    self.success = success
10140 
 
10141 
  def read(self, iprot):
10142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10144 
      return
10145 
    iprot.readStructBegin()
10146 
    while True:
10147 
      (fname, ftype, fid) = iprot.readFieldBegin()
10148 
      if ftype == TType.STOP:
10149 
        break
10150 
      if fid == 0:
10151 
        if ftype == TType.LIST:
10152 
          self.success = []
4133 chandransh 10153 
          (_etype202, _size199) = iprot.readListBegin()
10154 
          for _i203 in xrange(_size199):
10155 
            _elem204 = Order()
10156 
            _elem204.read(iprot)
10157 
            self.success.append(_elem204)
2764 chandransh 10158 
          iprot.readListEnd()
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      else:
10162 
        iprot.skip(ftype)
10163 
      iprot.readFieldEnd()
10164 
    iprot.readStructEnd()
10165 
 
10166 
  def write(self, oprot):
10167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10169 
      return
10170 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10171 
    if self.success is not None:
2764 chandransh 10172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10174 
      for iter205 in self.success:
10175 
        iter205.write(oprot)
2764 chandransh 10176 
      oprot.writeListEnd()
10177 
      oprot.writeFieldEnd()
10178 
    oprot.writeFieldStop()
10179 
    oprot.writeStructEnd()
10180 
 
3431 rajveer 10181 
  def validate(self):
10182 
    return
10183 
 
10184 
 
2764 chandransh 10185 
  def __repr__(self):
10186 
    L = ['%s=%r' % (key, value)
10187 
      for key, value in self.__dict__.iteritems()]
10188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10189 
 
10190 
  def __eq__(self, other):
10191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10192 
 
10193 
  def __ne__(self, other):
10194 
    return not (self == other)
10195 
 
2616 chandransh 10196 
class receiveReturn_args:
2591 chandransh 10197 
  """
10198 
  Attributes:
10199 
   - orderId
10200 
  """
2536 chandransh 10201 
 
2591 chandransh 10202 
  thrift_spec = (
10203 
    None, # 0
10204 
    (1, TType.I64, 'orderId', None, None, ), # 1
10205 
  )
10206 
 
10207 
  def __init__(self, orderId=None,):
10208 
    self.orderId = orderId
10209 
 
10210 
  def read(self, iprot):
10211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10213 
      return
10214 
    iprot.readStructBegin()
10215 
    while True:
10216 
      (fname, ftype, fid) = iprot.readFieldBegin()
10217 
      if ftype == TType.STOP:
10218 
        break
10219 
      if fid == 1:
10220 
        if ftype == TType.I64:
10221 
          self.orderId = iprot.readI64();
10222 
        else:
10223 
          iprot.skip(ftype)
10224 
      else:
10225 
        iprot.skip(ftype)
10226 
      iprot.readFieldEnd()
10227 
    iprot.readStructEnd()
10228 
 
10229 
  def write(self, oprot):
10230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10232 
      return
2616 chandransh 10233 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10234 
    if self.orderId is not None:
2591 chandransh 10235 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10236 
      oprot.writeI64(self.orderId)
10237 
      oprot.writeFieldEnd()
10238 
    oprot.writeFieldStop()
10239 
    oprot.writeStructEnd()
10240 
 
3431 rajveer 10241 
  def validate(self):
10242 
    return
10243 
 
10244 
 
2591 chandransh 10245 
  def __repr__(self):
10246 
    L = ['%s=%r' % (key, value)
10247 
      for key, value in self.__dict__.iteritems()]
10248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10249 
 
10250 
  def __eq__(self, other):
10251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10252 
 
10253 
  def __ne__(self, other):
10254 
    return not (self == other)
10255 
 
2616 chandransh 10256 
class receiveReturn_result:
2591 chandransh 10257 
  """
10258 
  Attributes:
10259 
   - success
10260 
   - ex
10261 
  """
10262 
 
10263 
  thrift_spec = (
10264 
    (0, TType.BOOL, 'success', None, None, ), # 0
10265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10266 
  )
10267 
 
10268 
  def __init__(self, success=None, ex=None,):
10269 
    self.success = success
10270 
    self.ex = ex
10271 
 
10272 
  def read(self, iprot):
10273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10275 
      return
10276 
    iprot.readStructBegin()
10277 
    while True:
10278 
      (fname, ftype, fid) = iprot.readFieldBegin()
10279 
      if ftype == TType.STOP:
10280 
        break
10281 
      if fid == 0:
10282 
        if ftype == TType.BOOL:
10283 
          self.success = iprot.readBool();
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      elif fid == 1:
10287 
        if ftype == TType.STRUCT:
10288 
          self.ex = TransactionServiceException()
10289 
          self.ex.read(iprot)
10290 
        else:
10291 
          iprot.skip(ftype)
10292 
      else:
10293 
        iprot.skip(ftype)
10294 
      iprot.readFieldEnd()
10295 
    iprot.readStructEnd()
10296 
 
10297 
  def write(self, oprot):
10298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10300 
      return
2616 chandransh 10301 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 10302 
    if self.success is not None:
2591 chandransh 10303 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10304 
      oprot.writeBool(self.success)
10305 
      oprot.writeFieldEnd()
3431 rajveer 10306 
    if self.ex is not None:
2591 chandransh 10307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10308 
      self.ex.write(oprot)
10309 
      oprot.writeFieldEnd()
10310 
    oprot.writeFieldStop()
10311 
    oprot.writeStructEnd()
10312 
 
3431 rajveer 10313 
  def validate(self):
10314 
    return
10315 
 
10316 
 
2591 chandransh 10317 
  def __repr__(self):
10318 
    L = ['%s=%r' % (key, value)
10319 
      for key, value in self.__dict__.iteritems()]
10320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10321 
 
10322 
  def __eq__(self, other):
10323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10324 
 
10325 
  def __ne__(self, other):
10326 
    return not (self == other)
10327 
 
10328 
class validateDoa_args:
10329 
  """
10330 
  Attributes:
10331 
   - orderId
10332 
   - isValid
10333 
  """
10334 
 
10335 
  thrift_spec = (
10336 
    None, # 0
10337 
    (1, TType.I64, 'orderId', None, None, ), # 1
10338 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
10339 
  )
10340 
 
10341 
  def __init__(self, orderId=None, isValid=None,):
10342 
    self.orderId = orderId
10343 
    self.isValid = isValid
10344 
 
10345 
  def read(self, iprot):
10346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10348 
      return
10349 
    iprot.readStructBegin()
10350 
    while True:
10351 
      (fname, ftype, fid) = iprot.readFieldBegin()
10352 
      if ftype == TType.STOP:
10353 
        break
10354 
      if fid == 1:
10355 
        if ftype == TType.I64:
10356 
          self.orderId = iprot.readI64();
10357 
        else:
10358 
          iprot.skip(ftype)
10359 
      elif fid == 2:
10360 
        if ftype == TType.BOOL:
10361 
          self.isValid = iprot.readBool();
10362 
        else:
10363 
          iprot.skip(ftype)
10364 
      else:
10365 
        iprot.skip(ftype)
10366 
      iprot.readFieldEnd()
10367 
    iprot.readStructEnd()
10368 
 
10369 
  def write(self, oprot):
10370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10372 
      return
10373 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 10374 
    if self.orderId is not None:
2591 chandransh 10375 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10376 
      oprot.writeI64(self.orderId)
10377 
      oprot.writeFieldEnd()
3431 rajveer 10378 
    if self.isValid is not None:
2591 chandransh 10379 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
10380 
      oprot.writeBool(self.isValid)
10381 
      oprot.writeFieldEnd()
10382 
    oprot.writeFieldStop()
10383 
    oprot.writeStructEnd()
10384 
 
3431 rajveer 10385 
  def validate(self):
10386 
    return
10387 
 
10388 
 
2591 chandransh 10389 
  def __repr__(self):
10390 
    L = ['%s=%r' % (key, value)
10391 
      for key, value in self.__dict__.iteritems()]
10392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10393 
 
10394 
  def __eq__(self, other):
10395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10396 
 
10397 
  def __ne__(self, other):
10398 
    return not (self == other)
10399 
 
10400 
class validateDoa_result:
10401 
  """
10402 
  Attributes:
10403 
   - success
10404 
   - ex
10405 
  """
10406 
 
10407 
  thrift_spec = (
10408 
    (0, TType.BOOL, 'success', None, None, ), # 0
10409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10410 
  )
10411 
 
10412 
  def __init__(self, success=None, ex=None,):
10413 
    self.success = success
10414 
    self.ex = ex
10415 
 
10416 
  def read(self, iprot):
10417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10419 
      return
10420 
    iprot.readStructBegin()
10421 
    while True:
10422 
      (fname, ftype, fid) = iprot.readFieldBegin()
10423 
      if ftype == TType.STOP:
10424 
        break
10425 
      if fid == 0:
10426 
        if ftype == TType.BOOL:
10427 
          self.success = iprot.readBool();
10428 
        else:
10429 
          iprot.skip(ftype)
10430 
      elif fid == 1:
10431 
        if ftype == TType.STRUCT:
10432 
          self.ex = TransactionServiceException()
10433 
          self.ex.read(iprot)
10434 
        else:
10435 
          iprot.skip(ftype)
10436 
      else:
10437 
        iprot.skip(ftype)
10438 
      iprot.readFieldEnd()
10439 
    iprot.readStructEnd()
10440 
 
10441 
  def write(self, oprot):
10442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10444 
      return
10445 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 10446 
    if self.success is not None:
2591 chandransh 10447 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10448 
      oprot.writeBool(self.success)
10449 
      oprot.writeFieldEnd()
3431 rajveer 10450 
    if self.ex is not None:
2591 chandransh 10451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10452 
      self.ex.write(oprot)
10453 
      oprot.writeFieldEnd()
10454 
    oprot.writeFieldStop()
10455 
    oprot.writeStructEnd()
10456 
 
3431 rajveer 10457 
  def validate(self):
10458 
    return
10459 
 
10460 
 
2591 chandransh 10461 
  def __repr__(self):
10462 
    L = ['%s=%r' % (key, value)
10463 
      for key, value in self.__dict__.iteritems()]
10464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10465 
 
10466 
  def __eq__(self, other):
10467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10468 
 
10469 
  def __ne__(self, other):
10470 
    return not (self == other)
10471 
 
2616 chandransh 10472 
class reshipOrder_args:
10473 
  """
10474 
  Attributes:
10475 
   - orderId
10476 
  """
2591 chandransh 10477 
 
2616 chandransh 10478 
  thrift_spec = (
10479 
    None, # 0
10480 
    (1, TType.I64, 'orderId', None, None, ), # 1
10481 
  )
10482 
 
10483 
  def __init__(self, orderId=None,):
10484 
    self.orderId = orderId
10485 
 
10486 
  def read(self, iprot):
10487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10489 
      return
10490 
    iprot.readStructBegin()
10491 
    while True:
10492 
      (fname, ftype, fid) = iprot.readFieldBegin()
10493 
      if ftype == TType.STOP:
10494 
        break
10495 
      if fid == 1:
10496 
        if ftype == TType.I64:
10497 
          self.orderId = iprot.readI64();
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      else:
10501 
        iprot.skip(ftype)
10502 
      iprot.readFieldEnd()
10503 
    iprot.readStructEnd()
10504 
 
10505 
  def write(self, oprot):
10506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10508 
      return
10509 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 10510 
    if self.orderId is not None:
2616 chandransh 10511 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10512 
      oprot.writeI64(self.orderId)
10513 
      oprot.writeFieldEnd()
10514 
    oprot.writeFieldStop()
10515 
    oprot.writeStructEnd()
10516 
 
3431 rajveer 10517 
  def validate(self):
10518 
    return
10519 
 
10520 
 
2616 chandransh 10521 
  def __repr__(self):
10522 
    L = ['%s=%r' % (key, value)
10523 
      for key, value in self.__dict__.iteritems()]
10524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10525 
 
10526 
  def __eq__(self, other):
10527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10528 
 
10529 
  def __ne__(self, other):
10530 
    return not (self == other)
10531 
 
10532 
class reshipOrder_result:
10533 
  """
10534 
  Attributes:
10535 
   - success
10536 
   - ex
10537 
  """
10538 
 
10539 
  thrift_spec = (
10540 
    (0, TType.I64, 'success', None, None, ), # 0
10541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10542 
  )
10543 
 
10544 
  def __init__(self, success=None, ex=None,):
10545 
    self.success = success
10546 
    self.ex = ex
10547 
 
10548 
  def read(self, iprot):
10549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10551 
      return
10552 
    iprot.readStructBegin()
10553 
    while True:
10554 
      (fname, ftype, fid) = iprot.readFieldBegin()
10555 
      if ftype == TType.STOP:
10556 
        break
10557 
      if fid == 0:
10558 
        if ftype == TType.I64:
10559 
          self.success = iprot.readI64();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      elif fid == 1:
10563 
        if ftype == TType.STRUCT:
10564 
          self.ex = TransactionServiceException()
10565 
          self.ex.read(iprot)
10566 
        else:
10567 
          iprot.skip(ftype)
10568 
      else:
10569 
        iprot.skip(ftype)
10570 
      iprot.readFieldEnd()
10571 
    iprot.readStructEnd()
10572 
 
10573 
  def write(self, oprot):
10574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10576 
      return
10577 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 10578 
    if self.success is not None:
2616 chandransh 10579 
      oprot.writeFieldBegin('success', TType.I64, 0)
10580 
      oprot.writeI64(self.success)
10581 
      oprot.writeFieldEnd()
3431 rajveer 10582 
    if self.ex is not None:
2616 chandransh 10583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10584 
      self.ex.write(oprot)
10585 
      oprot.writeFieldEnd()
10586 
    oprot.writeFieldStop()
10587 
    oprot.writeStructEnd()
10588 
 
3431 rajveer 10589 
  def validate(self):
10590 
    return
10591 
 
10592 
 
2616 chandransh 10593 
  def __repr__(self):
10594 
    L = ['%s=%r' % (key, value)
10595 
      for key, value in self.__dict__.iteritems()]
10596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10597 
 
10598 
  def __eq__(self, other):
10599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10600 
 
10601 
  def __ne__(self, other):
10602 
    return not (self == other)
10603 
 
10604 
class refundOrder_args:
10605 
  """
10606 
  Attributes:
10607 
   - orderId
3226 chandransh 10608 
   - refundedBy
10609 
   - reason
2616 chandransh 10610 
  """
10611 
 
10612 
  thrift_spec = (
10613 
    None, # 0
10614 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 10615 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
10616 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 10617 
  )
10618 
 
3226 chandransh 10619 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 10620 
    self.orderId = orderId
3226 chandransh 10621 
    self.refundedBy = refundedBy
10622 
    self.reason = reason
2616 chandransh 10623 
 
10624 
  def read(self, iprot):
10625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10627 
      return
10628 
    iprot.readStructBegin()
10629 
    while True:
10630 
      (fname, ftype, fid) = iprot.readFieldBegin()
10631 
      if ftype == TType.STOP:
10632 
        break
10633 
      if fid == 1:
10634 
        if ftype == TType.I64:
10635 
          self.orderId = iprot.readI64();
10636 
        else:
10637 
          iprot.skip(ftype)
3226 chandransh 10638 
      elif fid == 2:
10639 
        if ftype == TType.STRING:
10640 
          self.refundedBy = iprot.readString();
10641 
        else:
10642 
          iprot.skip(ftype)
10643 
      elif fid == 3:
10644 
        if ftype == TType.STRING:
10645 
          self.reason = iprot.readString();
10646 
        else:
10647 
          iprot.skip(ftype)
2616 chandransh 10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 10658 
    if self.orderId is not None:
2616 chandransh 10659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10660 
      oprot.writeI64(self.orderId)
10661 
      oprot.writeFieldEnd()
3431 rajveer 10662 
    if self.refundedBy is not None:
3226 chandransh 10663 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
10664 
      oprot.writeString(self.refundedBy)
10665 
      oprot.writeFieldEnd()
3431 rajveer 10666 
    if self.reason is not None:
3226 chandransh 10667 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
10668 
      oprot.writeString(self.reason)
10669 
      oprot.writeFieldEnd()
2616 chandransh 10670 
    oprot.writeFieldStop()
10671 
    oprot.writeStructEnd()
10672 
 
3431 rajveer 10673 
  def validate(self):
10674 
    return
10675 
 
10676 
 
2616 chandransh 10677 
  def __repr__(self):
10678 
    L = ['%s=%r' % (key, value)
10679 
      for key, value in self.__dict__.iteritems()]
10680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10681 
 
10682 
  def __eq__(self, other):
10683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10684 
 
10685 
  def __ne__(self, other):
10686 
    return not (self == other)
10687 
 
10688 
class refundOrder_result:
10689 
  """
10690 
  Attributes:
10691 
   - success
10692 
   - ex
10693 
  """
10694 
 
10695 
  thrift_spec = (
10696 
    (0, TType.BOOL, 'success', None, None, ), # 0
10697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10698 
  )
10699 
 
10700 
  def __init__(self, success=None, ex=None,):
10701 
    self.success = success
10702 
    self.ex = ex
10703 
 
10704 
  def read(self, iprot):
10705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10707 
      return
10708 
    iprot.readStructBegin()
10709 
    while True:
10710 
      (fname, ftype, fid) = iprot.readFieldBegin()
10711 
      if ftype == TType.STOP:
10712 
        break
10713 
      if fid == 0:
10714 
        if ftype == TType.BOOL:
10715 
          self.success = iprot.readBool();
10716 
        else:
10717 
          iprot.skip(ftype)
10718 
      elif fid == 1:
10719 
        if ftype == TType.STRUCT:
10720 
          self.ex = TransactionServiceException()
10721 
          self.ex.read(iprot)
10722 
        else:
10723 
          iprot.skip(ftype)
10724 
      else:
10725 
        iprot.skip(ftype)
10726 
      iprot.readFieldEnd()
10727 
    iprot.readStructEnd()
10728 
 
10729 
  def write(self, oprot):
10730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10732 
      return
10733 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 10734 
    if self.success is not None:
2616 chandransh 10735 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10736 
      oprot.writeBool(self.success)
10737 
      oprot.writeFieldEnd()
3431 rajveer 10738 
    if self.ex is not None:
2616 chandransh 10739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10740 
      self.ex.write(oprot)
10741 
      oprot.writeFieldEnd()
10742 
    oprot.writeFieldStop()
10743 
    oprot.writeStructEnd()
10744 
 
3431 rajveer 10745 
  def validate(self):
10746 
    return
10747 
 
10748 
 
2616 chandransh 10749 
  def __repr__(self):
10750 
    L = ['%s=%r' % (key, value)
10751 
      for key, value in self.__dict__.iteritems()]
10752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10753 
 
10754 
  def __eq__(self, other):
10755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10756 
 
10757 
  def __ne__(self, other):
10758 
    return not (self == other)
10759 
 
2690 chandransh 10760 
class getReturnOrders_args:
10761 
  """
10762 
  Attributes:
10763 
   - warehouseId
10764 
   - fromDate
10765 
   - toDate
10766 
  """
2616 chandransh 10767 
 
2690 chandransh 10768 
  thrift_spec = (
10769 
    None, # 0
10770 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10771 
    (2, TType.I64, 'fromDate', None, None, ), # 2
10772 
    (3, TType.I64, 'toDate', None, None, ), # 3
10773 
  )
10774 
 
10775 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
10776 
    self.warehouseId = warehouseId
10777 
    self.fromDate = fromDate
10778 
    self.toDate = toDate
10779 
 
10780 
  def read(self, iprot):
10781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10783 
      return
10784 
    iprot.readStructBegin()
10785 
    while True:
10786 
      (fname, ftype, fid) = iprot.readFieldBegin()
10787 
      if ftype == TType.STOP:
10788 
        break
10789 
      if fid == 1:
10790 
        if ftype == TType.I64:
10791 
          self.warehouseId = iprot.readI64();
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      elif fid == 2:
10795 
        if ftype == TType.I64:
10796 
          self.fromDate = iprot.readI64();
10797 
        else:
10798 
          iprot.skip(ftype)
10799 
      elif fid == 3:
10800 
        if ftype == TType.I64:
10801 
          self.toDate = iprot.readI64();
10802 
        else:
10803 
          iprot.skip(ftype)
10804 
      else:
10805 
        iprot.skip(ftype)
10806 
      iprot.readFieldEnd()
10807 
    iprot.readStructEnd()
10808 
 
10809 
  def write(self, oprot):
10810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10812 
      return
10813 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 10814 
    if self.warehouseId is not None:
2690 chandransh 10815 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10816 
      oprot.writeI64(self.warehouseId)
10817 
      oprot.writeFieldEnd()
3431 rajveer 10818 
    if self.fromDate is not None:
2690 chandransh 10819 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
10820 
      oprot.writeI64(self.fromDate)
10821 
      oprot.writeFieldEnd()
3431 rajveer 10822 
    if self.toDate is not None:
2690 chandransh 10823 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
10824 
      oprot.writeI64(self.toDate)
10825 
      oprot.writeFieldEnd()
10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
3431 rajveer 10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
2690 chandransh 10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
10844 
class getReturnOrders_result:
10845 
  """
10846 
  Attributes:
10847 
   - success
10848 
  """
10849 
 
10850 
  thrift_spec = (
10851 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
10852 
  )
10853 
 
10854 
  def __init__(self, success=None,):
10855 
    self.success = success
10856 
 
10857 
  def read(self, iprot):
10858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10860 
      return
10861 
    iprot.readStructBegin()
10862 
    while True:
10863 
      (fname, ftype, fid) = iprot.readFieldBegin()
10864 
      if ftype == TType.STOP:
10865 
        break
10866 
      if fid == 0:
10867 
        if ftype == TType.LIST:
10868 
          self.success = []
4133 chandransh 10869 
          (_etype209, _size206) = iprot.readListBegin()
10870 
          for _i210 in xrange(_size206):
10871 
            _elem211 = ReturnOrder()
10872 
            _elem211.read(iprot)
10873 
            self.success.append(_elem211)
2690 chandransh 10874 
          iprot.readListEnd()
10875 
        else:
10876 
          iprot.skip(ftype)
10877 
      else:
10878 
        iprot.skip(ftype)
10879 
      iprot.readFieldEnd()
10880 
    iprot.readStructEnd()
10881 
 
10882 
  def write(self, oprot):
10883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10885 
      return
10886 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 10887 
    if self.success is not None:
2690 chandransh 10888 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10889 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10890 
      for iter212 in self.success:
10891 
        iter212.write(oprot)
2690 chandransh 10892 
      oprot.writeListEnd()
10893 
      oprot.writeFieldEnd()
10894 
    oprot.writeFieldStop()
10895 
    oprot.writeStructEnd()
10896 
 
3431 rajveer 10897 
  def validate(self):
10898 
    return
10899 
 
10900 
 
2690 chandransh 10901 
  def __repr__(self):
10902 
    L = ['%s=%r' % (key, value)
10903 
      for key, value in self.__dict__.iteritems()]
10904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10905 
 
10906 
  def __eq__(self, other):
10907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10908 
 
10909 
  def __ne__(self, other):
10910 
    return not (self == other)
10911 
 
2700 chandransh 10912 
class getReturnOrder_args:
10913 
  """
10914 
  Attributes:
10915 
   - id
10916 
  """
10917 
 
10918 
  thrift_spec = (
10919 
    None, # 0
10920 
    (1, TType.I64, 'id', None, None, ), # 1
10921 
  )
10922 
 
10923 
  def __init__(self, id=None,):
10924 
    self.id = id
10925 
 
10926 
  def read(self, iprot):
10927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10929 
      return
10930 
    iprot.readStructBegin()
10931 
    while True:
10932 
      (fname, ftype, fid) = iprot.readFieldBegin()
10933 
      if ftype == TType.STOP:
10934 
        break
10935 
      if fid == 1:
10936 
        if ftype == TType.I64:
10937 
          self.id = iprot.readI64();
10938 
        else:
10939 
          iprot.skip(ftype)
10940 
      else:
10941 
        iprot.skip(ftype)
10942 
      iprot.readFieldEnd()
10943 
    iprot.readStructEnd()
10944 
 
10945 
  def write(self, oprot):
10946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10948 
      return
10949 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 10950 
    if self.id is not None:
2700 chandransh 10951 
      oprot.writeFieldBegin('id', TType.I64, 1)
10952 
      oprot.writeI64(self.id)
10953 
      oprot.writeFieldEnd()
10954 
    oprot.writeFieldStop()
10955 
    oprot.writeStructEnd()
10956 
 
3431 rajveer 10957 
  def validate(self):
10958 
    return
10959 
 
10960 
 
2700 chandransh 10961 
  def __repr__(self):
10962 
    L = ['%s=%r' % (key, value)
10963 
      for key, value in self.__dict__.iteritems()]
10964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10965 
 
10966 
  def __eq__(self, other):
10967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10968 
 
10969 
  def __ne__(self, other):
10970 
    return not (self == other)
10971 
 
10972 
class getReturnOrder_result:
10973 
  """
10974 
  Attributes:
10975 
   - success
10976 
   - ex
10977 
  """
10978 
 
10979 
  thrift_spec = (
10980 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
10981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10982 
  )
10983 
 
10984 
  def __init__(self, success=None, ex=None,):
10985 
    self.success = success
10986 
    self.ex = ex
10987 
 
10988 
  def read(self, iprot):
10989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10991 
      return
10992 
    iprot.readStructBegin()
10993 
    while True:
10994 
      (fname, ftype, fid) = iprot.readFieldBegin()
10995 
      if ftype == TType.STOP:
10996 
        break
10997 
      if fid == 0:
10998 
        if ftype == TType.STRUCT:
10999 
          self.success = ReturnOrder()
11000 
          self.success.read(iprot)
11001 
        else:
11002 
          iprot.skip(ftype)
11003 
      elif fid == 1:
11004 
        if ftype == TType.STRUCT:
11005 
          self.ex = TransactionServiceException()
11006 
          self.ex.read(iprot)
11007 
        else:
11008 
          iprot.skip(ftype)
11009 
      else:
11010 
        iprot.skip(ftype)
11011 
      iprot.readFieldEnd()
11012 
    iprot.readStructEnd()
11013 
 
11014 
  def write(self, oprot):
11015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11017 
      return
11018 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11019 
    if self.success is not None:
2700 chandransh 11020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11021 
      self.success.write(oprot)
11022 
      oprot.writeFieldEnd()
3431 rajveer 11023 
    if self.ex is not None:
2700 chandransh 11024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11025 
      self.ex.write(oprot)
11026 
      oprot.writeFieldEnd()
11027 
    oprot.writeFieldStop()
11028 
    oprot.writeStructEnd()
11029 
 
3431 rajveer 11030 
  def validate(self):
11031 
    return
11032 
 
11033 
 
2700 chandransh 11034 
  def __repr__(self):
11035 
    L = ['%s=%r' % (key, value)
11036 
      for key, value in self.__dict__.iteritems()]
11037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11038 
 
11039 
  def __eq__(self, other):
11040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11041 
 
11042 
  def __ne__(self, other):
11043 
    return not (self == other)
11044 
 
2690 chandransh 11045 
class processReturn_args:
11046 
  """
11047 
  Attributes:
11048 
   - returnOrderId
11049 
  """
11050 
 
11051 
  thrift_spec = (
11052 
    None, # 0
11053 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11054 
  )
11055 
 
11056 
  def __init__(self, returnOrderId=None,):
11057 
    self.returnOrderId = returnOrderId
11058 
 
11059 
  def read(self, iprot):
11060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11062 
      return
11063 
    iprot.readStructBegin()
11064 
    while True:
11065 
      (fname, ftype, fid) = iprot.readFieldBegin()
11066 
      if ftype == TType.STOP:
11067 
        break
11068 
      if fid == 1:
11069 
        if ftype == TType.I64:
11070 
          self.returnOrderId = iprot.readI64();
11071 
        else:
11072 
          iprot.skip(ftype)
11073 
      else:
11074 
        iprot.skip(ftype)
11075 
      iprot.readFieldEnd()
11076 
    iprot.readStructEnd()
11077 
 
11078 
  def write(self, oprot):
11079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11081 
      return
11082 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11083 
    if self.returnOrderId is not None:
2690 chandransh 11084 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11085 
      oprot.writeI64(self.returnOrderId)
11086 
      oprot.writeFieldEnd()
11087 
    oprot.writeFieldStop()
11088 
    oprot.writeStructEnd()
11089 
 
3431 rajveer 11090 
  def validate(self):
11091 
    return
11092 
 
11093 
 
2690 chandransh 11094 
  def __repr__(self):
11095 
    L = ['%s=%r' % (key, value)
11096 
      for key, value in self.__dict__.iteritems()]
11097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11098 
 
11099 
  def __eq__(self, other):
11100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11101 
 
11102 
  def __ne__(self, other):
11103 
    return not (self == other)
11104 
 
11105 
class processReturn_result:
11106 
  """
11107 
  Attributes:
11108 
   - ex
11109 
  """
11110 
 
11111 
  thrift_spec = (
11112 
    None, # 0
11113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11114 
  )
11115 
 
11116 
  def __init__(self, ex=None,):
11117 
    self.ex = ex
11118 
 
11119 
  def read(self, iprot):
11120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11122 
      return
11123 
    iprot.readStructBegin()
11124 
    while True:
11125 
      (fname, ftype, fid) = iprot.readFieldBegin()
11126 
      if ftype == TType.STOP:
11127 
        break
11128 
      if fid == 1:
11129 
        if ftype == TType.STRUCT:
11130 
          self.ex = TransactionServiceException()
11131 
          self.ex.read(iprot)
11132 
        else:
11133 
          iprot.skip(ftype)
11134 
      else:
11135 
        iprot.skip(ftype)
11136 
      iprot.readFieldEnd()
11137 
    iprot.readStructEnd()
11138 
 
11139 
  def write(self, oprot):
11140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11142 
      return
11143 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11144 
    if self.ex is not None:
2690 chandransh 11145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11146 
      self.ex.write(oprot)
11147 
      oprot.writeFieldEnd()
11148 
    oprot.writeFieldStop()
11149 
    oprot.writeStructEnd()
11150 
 
3431 rajveer 11151 
  def validate(self):
11152 
    return
11153 
 
11154 
 
2690 chandransh 11155 
  def __repr__(self):
11156 
    L = ['%s=%r' % (key, value)
11157 
      for key, value in self.__dict__.iteritems()]
11158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11159 
 
11160 
  def __eq__(self, other):
11161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11162 
 
11163 
  def __ne__(self, other):
11164 
    return not (self == other)
11165 
 
2819 chandransh 11166 
class createPurchaseOrder_args:
11167 
  """
11168 
  Attributes:
11169 
   - warehouseId
11170 
  """
2690 chandransh 11171 
 
2819 chandransh 11172 
  thrift_spec = (
11173 
    None, # 0
11174 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11175 
  )
11176 
 
11177 
  def __init__(self, warehouseId=None,):
11178 
    self.warehouseId = warehouseId
11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      if fid == 1:
11190 
        if ftype == TType.I64:
11191 
          self.warehouseId = iprot.readI64();
11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      else:
11195 
        iprot.skip(ftype)
11196 
      iprot.readFieldEnd()
11197 
    iprot.readStructEnd()
11198 
 
11199 
  def write(self, oprot):
11200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11202 
      return
11203 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11204 
    if self.warehouseId is not None:
2819 chandransh 11205 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11206 
      oprot.writeI64(self.warehouseId)
11207 
      oprot.writeFieldEnd()
11208 
    oprot.writeFieldStop()
11209 
    oprot.writeStructEnd()
11210 
 
3431 rajveer 11211 
  def validate(self):
11212 
    return
11213 
 
11214 
 
2819 chandransh 11215 
  def __repr__(self):
11216 
    L = ['%s=%r' % (key, value)
11217 
      for key, value in self.__dict__.iteritems()]
11218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11219 
 
11220 
  def __eq__(self, other):
11221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11222 
 
11223 
  def __ne__(self, other):
11224 
    return not (self == other)
11225 
 
11226 
class createPurchaseOrder_result:
11227 
  """
11228 
  Attributes:
11229 
   - success
11230 
   - ex
11231 
  """
11232 
 
11233 
  thrift_spec = (
11234 
    (0, TType.I64, 'success', None, None, ), # 0
11235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11236 
  )
11237 
 
11238 
  def __init__(self, success=None, ex=None,):
11239 
    self.success = success
11240 
    self.ex = ex
11241 
 
11242 
  def read(self, iprot):
11243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11245 
      return
11246 
    iprot.readStructBegin()
11247 
    while True:
11248 
      (fname, ftype, fid) = iprot.readFieldBegin()
11249 
      if ftype == TType.STOP:
11250 
        break
11251 
      if fid == 0:
11252 
        if ftype == TType.I64:
11253 
          self.success = iprot.readI64();
11254 
        else:
11255 
          iprot.skip(ftype)
11256 
      elif fid == 1:
11257 
        if ftype == TType.STRUCT:
11258 
          self.ex = TransactionServiceException()
11259 
          self.ex.read(iprot)
11260 
        else:
11261 
          iprot.skip(ftype)
11262 
      else:
11263 
        iprot.skip(ftype)
11264 
      iprot.readFieldEnd()
11265 
    iprot.readStructEnd()
11266 
 
11267 
  def write(self, oprot):
11268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11270 
      return
11271 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 11272 
    if self.success is not None:
2819 chandransh 11273 
      oprot.writeFieldBegin('success', TType.I64, 0)
11274 
      oprot.writeI64(self.success)
11275 
      oprot.writeFieldEnd()
3431 rajveer 11276 
    if self.ex is not None:
2819 chandransh 11277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11278 
      self.ex.write(oprot)
11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
3431 rajveer 11283 
  def validate(self):
11284 
    return
11285 
 
11286 
 
2819 chandransh 11287 
  def __repr__(self):
11288 
    L = ['%s=%r' % (key, value)
11289 
      for key, value in self.__dict__.iteritems()]
11290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11291 
 
11292 
  def __eq__(self, other):
11293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11294 
 
11295 
  def __ne__(self, other):
11296 
    return not (self == other)
3451 chandransh 11297 
 
11298 
class updateWeight_args:
11299 
  """
11300 
  Attributes:
11301 
   - orderId
11302 
   - weight
11303 
  """
11304 
 
11305 
  thrift_spec = (
11306 
    None, # 0
11307 
    (1, TType.I64, 'orderId', None, None, ), # 1
11308 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
11309 
  )
11310 
 
11311 
  def __init__(self, orderId=None, weight=None,):
11312 
    self.orderId = orderId
11313 
    self.weight = weight
11314 
 
11315 
  def read(self, iprot):
11316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11318 
      return
11319 
    iprot.readStructBegin()
11320 
    while True:
11321 
      (fname, ftype, fid) = iprot.readFieldBegin()
11322 
      if ftype == TType.STOP:
11323 
        break
11324 
      if fid == 1:
11325 
        if ftype == TType.I64:
11326 
          self.orderId = iprot.readI64();
11327 
        else:
11328 
          iprot.skip(ftype)
11329 
      elif fid == 2:
11330 
        if ftype == TType.DOUBLE:
11331 
          self.weight = iprot.readDouble();
11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      else:
11335 
        iprot.skip(ftype)
11336 
      iprot.readFieldEnd()
11337 
    iprot.readStructEnd()
11338 
 
11339 
  def write(self, oprot):
11340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11342 
      return
11343 
    oprot.writeStructBegin('updateWeight_args')
11344 
    if self.orderId is not None:
11345 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11346 
      oprot.writeI64(self.orderId)
11347 
      oprot.writeFieldEnd()
11348 
    if self.weight is not None:
11349 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
11350 
      oprot.writeDouble(self.weight)
11351 
      oprot.writeFieldEnd()
11352 
    oprot.writeFieldStop()
11353 
    oprot.writeStructEnd()
11354 
 
11355 
  def validate(self):
11356 
    return
11357 
 
11358 
 
11359 
  def __repr__(self):
11360 
    L = ['%s=%r' % (key, value)
11361 
      for key, value in self.__dict__.iteritems()]
11362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11363 
 
11364 
  def __eq__(self, other):
11365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11366 
 
11367 
  def __ne__(self, other):
11368 
    return not (self == other)
11369 
 
11370 
class updateWeight_result:
11371 
  """
11372 
  Attributes:
11373 
   - success
11374 
   - ex
11375 
  """
11376 
 
11377 
  thrift_spec = (
11378 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11380 
  )
11381 
 
11382 
  def __init__(self, success=None, ex=None,):
11383 
    self.success = success
11384 
    self.ex = ex
11385 
 
11386 
  def read(self, iprot):
11387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11389 
      return
11390 
    iprot.readStructBegin()
11391 
    while True:
11392 
      (fname, ftype, fid) = iprot.readFieldBegin()
11393 
      if ftype == TType.STOP:
11394 
        break
11395 
      if fid == 0:
11396 
        if ftype == TType.STRUCT:
11397 
          self.success = Order()
11398 
          self.success.read(iprot)
11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      elif fid == 1:
11402 
        if ftype == TType.STRUCT:
11403 
          self.ex = TransactionServiceException()
11404 
          self.ex.read(iprot)
11405 
        else:
11406 
          iprot.skip(ftype)
11407 
      else:
11408 
        iprot.skip(ftype)
11409 
      iprot.readFieldEnd()
11410 
    iprot.readStructEnd()
11411 
 
11412 
  def write(self, oprot):
11413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11415 
      return
11416 
    oprot.writeStructBegin('updateWeight_result')
11417 
    if self.success is not None:
11418 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11419 
      self.success.write(oprot)
11420 
      oprot.writeFieldEnd()
11421 
    if self.ex is not None:
11422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11423 
      self.ex.write(oprot)
11424 
      oprot.writeFieldEnd()
11425 
    oprot.writeFieldStop()
11426 
    oprot.writeStructEnd()
11427 
 
11428 
  def validate(self):
11429 
    return
11430 
 
11431 
 
11432 
  def __repr__(self):
11433 
    L = ['%s=%r' % (key, value)
11434 
      for key, value in self.__dict__.iteritems()]
11435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11436 
 
11437 
  def __eq__(self, other):
11438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11439 
 
11440 
  def __ne__(self, other):
11441 
    return not (self == other)
3469 chandransh 11442 
 
11443 
class changeItem_args:
11444 
  """
11445 
  Attributes:
11446 
   - orderId
11447 
   - itemId
11448 
  """
11449 
 
11450 
  thrift_spec = (
11451 
    None, # 0
11452 
    (1, TType.I64, 'orderId', None, None, ), # 1
11453 
    (2, TType.I64, 'itemId', None, None, ), # 2
11454 
  )
11455 
 
11456 
  def __init__(self, orderId=None, itemId=None,):
11457 
    self.orderId = orderId
11458 
    self.itemId = itemId
11459 
 
11460 
  def read(self, iprot):
11461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11463 
      return
11464 
    iprot.readStructBegin()
11465 
    while True:
11466 
      (fname, ftype, fid) = iprot.readFieldBegin()
11467 
      if ftype == TType.STOP:
11468 
        break
11469 
      if fid == 1:
11470 
        if ftype == TType.I64:
11471 
          self.orderId = iprot.readI64();
11472 
        else:
11473 
          iprot.skip(ftype)
11474 
      elif fid == 2:
11475 
        if ftype == TType.I64:
11476 
          self.itemId = iprot.readI64();
11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      else:
11480 
        iprot.skip(ftype)
11481 
      iprot.readFieldEnd()
11482 
    iprot.readStructEnd()
11483 
 
11484 
  def write(self, oprot):
11485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11487 
      return
11488 
    oprot.writeStructBegin('changeItem_args')
11489 
    if self.orderId is not None:
11490 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11491 
      oprot.writeI64(self.orderId)
11492 
      oprot.writeFieldEnd()
11493 
    if self.itemId is not None:
11494 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11495 
      oprot.writeI64(self.itemId)
11496 
      oprot.writeFieldEnd()
11497 
    oprot.writeFieldStop()
11498 
    oprot.writeStructEnd()
11499 
 
11500 
  def validate(self):
11501 
    return
11502 
 
11503 
 
11504 
  def __repr__(self):
11505 
    L = ['%s=%r' % (key, value)
11506 
      for key, value in self.__dict__.iteritems()]
11507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11508 
 
11509 
  def __eq__(self, other):
11510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11511 
 
11512 
  def __ne__(self, other):
11513 
    return not (self == other)
11514 
 
11515 
class changeItem_result:
11516 
  """
11517 
  Attributes:
11518 
   - success
11519 
   - ex
11520 
  """
11521 
 
11522 
  thrift_spec = (
11523 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11525 
  )
11526 
 
11527 
  def __init__(self, success=None, ex=None,):
11528 
    self.success = success
11529 
    self.ex = ex
11530 
 
11531 
  def read(self, iprot):
11532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11534 
      return
11535 
    iprot.readStructBegin()
11536 
    while True:
11537 
      (fname, ftype, fid) = iprot.readFieldBegin()
11538 
      if ftype == TType.STOP:
11539 
        break
11540 
      if fid == 0:
11541 
        if ftype == TType.STRUCT:
11542 
          self.success = Order()
11543 
          self.success.read(iprot)
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      elif fid == 1:
11547 
        if ftype == TType.STRUCT:
11548 
          self.ex = TransactionServiceException()
11549 
          self.ex.read(iprot)
11550 
        else:
11551 
          iprot.skip(ftype)
11552 
      else:
11553 
        iprot.skip(ftype)
11554 
      iprot.readFieldEnd()
11555 
    iprot.readStructEnd()
11556 
 
11557 
  def write(self, oprot):
11558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11560 
      return
11561 
    oprot.writeStructBegin('changeItem_result')
11562 
    if self.success is not None:
11563 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11564 
      self.success.write(oprot)
11565 
      oprot.writeFieldEnd()
11566 
    if self.ex is not None:
11567 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11568 
      self.ex.write(oprot)
11569 
      oprot.writeFieldEnd()
11570 
    oprot.writeFieldStop()
11571 
    oprot.writeStructEnd()
11572 
 
11573 
  def validate(self):
11574 
    return
11575 
 
11576 
 
11577 
  def __repr__(self):
11578 
    L = ['%s=%r' % (key, value)
11579 
      for key, value in self.__dict__.iteritems()]
11580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11581 
 
11582 
  def __eq__(self, other):
11583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11584 
 
11585 
  def __ne__(self, other):
11586 
    return not (self == other)
11587 
 
11588 
class shiftToWarehouse_args:
11589 
  """
11590 
  Attributes:
11591 
   - orderId
11592 
   - warehouseId
11593 
  """
11594 
 
11595 
  thrift_spec = (
11596 
    None, # 0
11597 
    (1, TType.I64, 'orderId', None, None, ), # 1
11598 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11599 
  )
11600 
 
11601 
  def __init__(self, orderId=None, warehouseId=None,):
11602 
    self.orderId = orderId
11603 
    self.warehouseId = warehouseId
11604 
 
11605 
  def read(self, iprot):
11606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11608 
      return
11609 
    iprot.readStructBegin()
11610 
    while True:
11611 
      (fname, ftype, fid) = iprot.readFieldBegin()
11612 
      if ftype == TType.STOP:
11613 
        break
11614 
      if fid == 1:
11615 
        if ftype == TType.I64:
11616 
          self.orderId = iprot.readI64();
11617 
        else:
11618 
          iprot.skip(ftype)
11619 
      elif fid == 2:
11620 
        if ftype == TType.I64:
11621 
          self.warehouseId = iprot.readI64();
11622 
        else:
11623 
          iprot.skip(ftype)
11624 
      else:
11625 
        iprot.skip(ftype)
11626 
      iprot.readFieldEnd()
11627 
    iprot.readStructEnd()
11628 
 
11629 
  def write(self, oprot):
11630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11632 
      return
11633 
    oprot.writeStructBegin('shiftToWarehouse_args')
11634 
    if self.orderId is not None:
11635 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11636 
      oprot.writeI64(self.orderId)
11637 
      oprot.writeFieldEnd()
11638 
    if self.warehouseId is not None:
11639 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11640 
      oprot.writeI64(self.warehouseId)
11641 
      oprot.writeFieldEnd()
11642 
    oprot.writeFieldStop()
11643 
    oprot.writeStructEnd()
11644 
 
11645 
  def validate(self):
11646 
    return
11647 
 
11648 
 
11649 
  def __repr__(self):
11650 
    L = ['%s=%r' % (key, value)
11651 
      for key, value in self.__dict__.iteritems()]
11652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11653 
 
11654 
  def __eq__(self, other):
11655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11656 
 
11657 
  def __ne__(self, other):
11658 
    return not (self == other)
11659 
 
11660 
class shiftToWarehouse_result:
11661 
  """
11662 
  Attributes:
11663 
   - success
11664 
   - ex
11665 
  """
11666 
 
11667 
  thrift_spec = (
11668 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
11669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11670 
  )
11671 
 
11672 
  def __init__(self, success=None, ex=None,):
11673 
    self.success = success
11674 
    self.ex = ex
11675 
 
11676 
  def read(self, iprot):
11677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11679 
      return
11680 
    iprot.readStructBegin()
11681 
    while True:
11682 
      (fname, ftype, fid) = iprot.readFieldBegin()
11683 
      if ftype == TType.STOP:
11684 
        break
11685 
      if fid == 0:
11686 
        if ftype == TType.STRUCT:
11687 
          self.success = Order()
11688 
          self.success.read(iprot)
11689 
        else:
11690 
          iprot.skip(ftype)
11691 
      elif fid == 1:
11692 
        if ftype == TType.STRUCT:
11693 
          self.ex = TransactionServiceException()
11694 
          self.ex.read(iprot)
11695 
        else:
11696 
          iprot.skip(ftype)
11697 
      else:
11698 
        iprot.skip(ftype)
11699 
      iprot.readFieldEnd()
11700 
    iprot.readStructEnd()
11701 
 
11702 
  def write(self, oprot):
11703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11705 
      return
11706 
    oprot.writeStructBegin('shiftToWarehouse_result')
11707 
    if self.success is not None:
11708 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11709 
      self.success.write(oprot)
11710 
      oprot.writeFieldEnd()
11711 
    if self.ex is not None:
11712 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11713 
      self.ex.write(oprot)
11714 
      oprot.writeFieldEnd()
11715 
    oprot.writeFieldStop()
11716 
    oprot.writeStructEnd()
11717 
 
11718 
  def validate(self):
11719 
    return
11720 
 
11721 
 
11722 
  def __repr__(self):
11723 
    L = ['%s=%r' % (key, value)
11724 
      for key, value in self.__dict__.iteritems()]
11725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11726 
 
11727 
  def __eq__(self, other):
11728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11729 
 
11730 
  def __ne__(self, other):
11731 
    return not (self == other)
3553 chandransh 11732 
 
11733 
class addDelayReason_args:
11734 
  """
11735 
  Attributes:
11736 
   - orderId
11737 
   - delayReason
3986 chandransh 11738 
   - furtherDelay
3553 chandransh 11739 
  """
11740 
 
11741 
  thrift_spec = (
11742 
    None, # 0
11743 
    (1, TType.I64, 'orderId', None, None, ), # 1
11744 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 11745 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 11746 
  )
11747 
 
3986 chandransh 11748 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 11749 
    self.orderId = orderId
11750 
    self.delayReason = delayReason
3986 chandransh 11751 
    self.furtherDelay = furtherDelay
3553 chandransh 11752 
 
11753 
  def read(self, iprot):
11754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11756 
      return
11757 
    iprot.readStructBegin()
11758 
    while True:
11759 
      (fname, ftype, fid) = iprot.readFieldBegin()
11760 
      if ftype == TType.STOP:
11761 
        break
11762 
      if fid == 1:
11763 
        if ftype == TType.I64:
11764 
          self.orderId = iprot.readI64();
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      elif fid == 2:
11768 
        if ftype == TType.I32:
11769 
          self.delayReason = iprot.readI32();
11770 
        else:
11771 
          iprot.skip(ftype)
3986 chandransh 11772 
      elif fid == 3:
11773 
        if ftype == TType.I64:
11774 
          self.furtherDelay = iprot.readI64();
11775 
        else:
11776 
          iprot.skip(ftype)
3553 chandransh 11777 
      else:
11778 
        iprot.skip(ftype)
11779 
      iprot.readFieldEnd()
11780 
    iprot.readStructEnd()
11781 
 
11782 
  def write(self, oprot):
11783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11785 
      return
11786 
    oprot.writeStructBegin('addDelayReason_args')
11787 
    if self.orderId is not None:
11788 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11789 
      oprot.writeI64(self.orderId)
11790 
      oprot.writeFieldEnd()
11791 
    if self.delayReason is not None:
11792 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
11793 
      oprot.writeI32(self.delayReason)
11794 
      oprot.writeFieldEnd()
3986 chandransh 11795 
    if self.furtherDelay is not None:
11796 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
11797 
      oprot.writeI64(self.furtherDelay)
11798 
      oprot.writeFieldEnd()
3553 chandransh 11799 
    oprot.writeFieldStop()
11800 
    oprot.writeStructEnd()
11801 
 
11802 
  def validate(self):
11803 
    return
11804 
 
11805 
 
11806 
  def __repr__(self):
11807 
    L = ['%s=%r' % (key, value)
11808 
      for key, value in self.__dict__.iteritems()]
11809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11810 
 
11811 
  def __eq__(self, other):
11812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11813 
 
11814 
  def __ne__(self, other):
11815 
    return not (self == other)
11816 
 
11817 
class addDelayReason_result:
11818 
  """
11819 
  Attributes:
11820 
   - success
11821 
   - ex
11822 
  """
11823 
 
11824 
  thrift_spec = (
11825 
    (0, TType.BOOL, 'success', None, None, ), # 0
11826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11827 
  )
11828 
 
11829 
  def __init__(self, success=None, ex=None,):
11830 
    self.success = success
11831 
    self.ex = ex
11832 
 
11833 
  def read(self, iprot):
11834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11836 
      return
11837 
    iprot.readStructBegin()
11838 
    while True:
11839 
      (fname, ftype, fid) = iprot.readFieldBegin()
11840 
      if ftype == TType.STOP:
11841 
        break
11842 
      if fid == 0:
11843 
        if ftype == TType.BOOL:
11844 
          self.success = iprot.readBool();
11845 
        else:
11846 
          iprot.skip(ftype)
11847 
      elif fid == 1:
11848 
        if ftype == TType.STRUCT:
11849 
          self.ex = TransactionServiceException()
11850 
          self.ex.read(iprot)
11851 
        else:
11852 
          iprot.skip(ftype)
11853 
      else:
11854 
        iprot.skip(ftype)
11855 
      iprot.readFieldEnd()
11856 
    iprot.readStructEnd()
11857 
 
11858 
  def write(self, oprot):
11859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11861 
      return
11862 
    oprot.writeStructBegin('addDelayReason_result')
11863 
    if self.success is not None:
11864 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11865 
      oprot.writeBool(self.success)
11866 
      oprot.writeFieldEnd()
11867 
    if self.ex is not None:
11868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11869 
      self.ex.write(oprot)
11870 
      oprot.writeFieldEnd()
11871 
    oprot.writeFieldStop()
11872 
    oprot.writeStructEnd()
11873 
 
11874 
  def validate(self):
11875 
    return
11876 
 
11877 
 
11878 
  def __repr__(self):
11879 
    L = ['%s=%r' % (key, value)
11880 
      for key, value in self.__dict__.iteritems()]
11881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11882 
 
11883 
  def __eq__(self, other):
11884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11885 
 
11886 
  def __ne__(self, other):
11887 
    return not (self == other)
3956 chandransh 11888 
 
11889 
class reconcileCodCollection_args:
11890 
  """
11891 
  Attributes:
11892 
   - collectedAmountMap
11893 
   - xferBy
11894 
   - xferTxnId
11895 
   - xferDate
11896 
  """
11897 
 
11898 
  thrift_spec = (
11899 
    None, # 0
11900 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
11901 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
11902 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
11903 
    (4, TType.I64, 'xferDate', None, None, ), # 4
11904 
  )
11905 
 
11906 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
11907 
    self.collectedAmountMap = collectedAmountMap
11908 
    self.xferBy = xferBy
11909 
    self.xferTxnId = xferTxnId
11910 
    self.xferDate = xferDate
11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
11921 
      if fid == 1:
11922 
        if ftype == TType.MAP:
11923 
          self.collectedAmountMap = {}
4133 chandransh 11924 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
11925 
          for _i217 in xrange(_size213):
11926 
            _key218 = iprot.readString();
11927 
            _val219 = iprot.readDouble();
11928 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 11929 
          iprot.readMapEnd()
11930 
        else:
11931 
          iprot.skip(ftype)
11932 
      elif fid == 2:
11933 
        if ftype == TType.STRING:
11934 
          self.xferBy = iprot.readString();
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      elif fid == 3:
11938 
        if ftype == TType.STRING:
11939 
          self.xferTxnId = iprot.readString();
11940 
        else:
11941 
          iprot.skip(ftype)
11942 
      elif fid == 4:
11943 
        if ftype == TType.I64:
11944 
          self.xferDate = iprot.readI64();
11945 
        else:
11946 
          iprot.skip(ftype)
11947 
      else:
11948 
        iprot.skip(ftype)
11949 
      iprot.readFieldEnd()
11950 
    iprot.readStructEnd()
11951 
 
11952 
  def write(self, oprot):
11953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11955 
      return
11956 
    oprot.writeStructBegin('reconcileCodCollection_args')
11957 
    if self.collectedAmountMap is not None:
11958 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
11959 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 11960 
      for kiter220,viter221 in self.collectedAmountMap.items():
11961 
        oprot.writeString(kiter220)
11962 
        oprot.writeDouble(viter221)
3956 chandransh 11963 
      oprot.writeMapEnd()
11964 
      oprot.writeFieldEnd()
11965 
    if self.xferBy is not None:
11966 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
11967 
      oprot.writeString(self.xferBy)
11968 
      oprot.writeFieldEnd()
11969 
    if self.xferTxnId is not None:
11970 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
11971 
      oprot.writeString(self.xferTxnId)
11972 
      oprot.writeFieldEnd()
11973 
    if self.xferDate is not None:
11974 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
11975 
      oprot.writeI64(self.xferDate)
11976 
      oprot.writeFieldEnd()
11977 
    oprot.writeFieldStop()
11978 
    oprot.writeStructEnd()
11979 
 
11980 
  def validate(self):
11981 
    return
11982 
 
11983 
 
11984 
  def __repr__(self):
11985 
    L = ['%s=%r' % (key, value)
11986 
      for key, value in self.__dict__.iteritems()]
11987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11988 
 
11989 
  def __eq__(self, other):
11990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11991 
 
11992 
  def __ne__(self, other):
11993 
    return not (self == other)
11994 
 
11995 
class reconcileCodCollection_result:
11996 
  """
11997 
  Attributes:
11998 
   - success
11999 
   - ex
12000 
  """
12001 
 
12002 
  thrift_spec = (
12003 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12005 
  )
12006 
 
12007 
  def __init__(self, success=None, ex=None,):
12008 
    self.success = success
12009 
    self.ex = ex
12010 
 
12011 
  def read(self, iprot):
12012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12014 
      return
12015 
    iprot.readStructBegin()
12016 
    while True:
12017 
      (fname, ftype, fid) = iprot.readFieldBegin()
12018 
      if ftype == TType.STOP:
12019 
        break
12020 
      if fid == 0:
12021 
        if ftype == TType.MAP:
12022 
          self.success = {}
4133 chandransh 12023 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12024 
          for _i226 in xrange(_size222):
12025 
            _key227 = iprot.readString();
12026 
            _val228 = iprot.readString();
12027 
            self.success[_key227] = _val228
3956 chandransh 12028 
          iprot.readMapEnd()
12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      elif fid == 1:
12032 
        if ftype == TType.STRUCT:
12033 
          self.ex = TransactionServiceException()
12034 
          self.ex.read(iprot)
12035 
        else:
12036 
          iprot.skip(ftype)
12037 
      else:
12038 
        iprot.skip(ftype)
12039 
      iprot.readFieldEnd()
12040 
    iprot.readStructEnd()
12041 
 
12042 
  def write(self, oprot):
12043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12045 
      return
12046 
    oprot.writeStructBegin('reconcileCodCollection_result')
12047 
    if self.success is not None:
12048 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12049 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12050 
      for kiter229,viter230 in self.success.items():
12051 
        oprot.writeString(kiter229)
12052 
        oprot.writeString(viter230)
3956 chandransh 12053 
      oprot.writeMapEnd()
12054 
      oprot.writeFieldEnd()
12055 
    if self.ex is not None:
12056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12057 
      self.ex.write(oprot)
12058 
      oprot.writeFieldEnd()
12059 
    oprot.writeFieldStop()
12060 
    oprot.writeStructEnd()
12061 
 
12062 
  def validate(self):
12063 
    return
12064 
 
12065 
 
12066 
  def __repr__(self):
12067 
    L = ['%s=%r' % (key, value)
12068 
      for key, value in self.__dict__.iteritems()]
12069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12070 
 
12071 
  def __eq__(self, other):
12072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12073 
 
12074 
  def __ne__(self, other):
12075 
    return not (self == other)
4008 mandeep.dh 12076 
 
12077 
class getTransactionsRequiringExtraProcessing_args:
12078 
  """
12079 
  Attributes:
12080 
   - category
12081 
  """
12082 
 
12083 
  thrift_spec = (
12084 
    None, # 0
12085 
    (1, TType.I32, 'category', None, None, ), # 1
12086 
  )
12087 
 
12088 
  def __init__(self, category=None,):
12089 
    self.category = category
12090 
 
12091 
  def read(self, iprot):
12092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12094 
      return
12095 
    iprot.readStructBegin()
12096 
    while True:
12097 
      (fname, ftype, fid) = iprot.readFieldBegin()
12098 
      if ftype == TType.STOP:
12099 
        break
12100 
      if fid == 1:
12101 
        if ftype == TType.I32:
12102 
          self.category = iprot.readI32();
12103 
        else:
12104 
          iprot.skip(ftype)
12105 
      else:
12106 
        iprot.skip(ftype)
12107 
      iprot.readFieldEnd()
12108 
    iprot.readStructEnd()
12109 
 
12110 
  def write(self, oprot):
12111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12113 
      return
12114 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12115 
    if self.category is not None:
12116 
      oprot.writeFieldBegin('category', TType.I32, 1)
12117 
      oprot.writeI32(self.category)
12118 
      oprot.writeFieldEnd()
12119 
    oprot.writeFieldStop()
12120 
    oprot.writeStructEnd()
12121 
 
12122 
  def validate(self):
12123 
    return
12124 
 
12125 
 
12126 
  def __repr__(self):
12127 
    L = ['%s=%r' % (key, value)
12128 
      for key, value in self.__dict__.iteritems()]
12129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12130 
 
12131 
  def __eq__(self, other):
12132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12133 
 
12134 
  def __ne__(self, other):
12135 
    return not (self == other)
12136 
 
12137 
class getTransactionsRequiringExtraProcessing_result:
12138 
  """
12139 
  Attributes:
12140 
   - success
12141 
  """
12142 
 
12143 
  thrift_spec = (
12144 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12145 
  )
12146 
 
12147 
  def __init__(self, success=None,):
12148 
    self.success = success
12149 
 
12150 
  def read(self, iprot):
12151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12153 
      return
12154 
    iprot.readStructBegin()
12155 
    while True:
12156 
      (fname, ftype, fid) = iprot.readFieldBegin()
12157 
      if ftype == TType.STOP:
12158 
        break
12159 
      if fid == 0:
12160 
        if ftype == TType.LIST:
12161 
          self.success = []
4133 chandransh 12162 
          (_etype234, _size231) = iprot.readListBegin()
12163 
          for _i235 in xrange(_size231):
12164 
            _elem236 = iprot.readI64();
12165 
            self.success.append(_elem236)
4008 mandeep.dh 12166 
          iprot.readListEnd()
12167 
        else:
12168 
          iprot.skip(ftype)
12169 
      else:
12170 
        iprot.skip(ftype)
12171 
      iprot.readFieldEnd()
12172 
    iprot.readStructEnd()
12173 
 
12174 
  def write(self, oprot):
12175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12177 
      return
12178 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12179 
    if self.success is not None:
12180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12181 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12182 
      for iter237 in self.success:
12183 
        oprot.writeI64(iter237)
4008 mandeep.dh 12184 
      oprot.writeListEnd()
12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
12204 
class markTransactionAsProcessed_args:
12205 
  """
12206 
  Attributes:
12207 
   - transactionId
12208 
   - category
12209 
  """
12210 
 
12211 
  thrift_spec = (
12212 
    None, # 0
12213 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12214 
    (2, TType.I32, 'category', None, None, ), # 2
12215 
  )
12216 
 
12217 
  def __init__(self, transactionId=None, category=None,):
12218 
    self.transactionId = transactionId
12219 
    self.category = category
12220 
 
12221 
  def read(self, iprot):
12222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12224 
      return
12225 
    iprot.readStructBegin()
12226 
    while True:
12227 
      (fname, ftype, fid) = iprot.readFieldBegin()
12228 
      if ftype == TType.STOP:
12229 
        break
12230 
      if fid == 1:
12231 
        if ftype == TType.I64:
12232 
          self.transactionId = iprot.readI64();
12233 
        else:
12234 
          iprot.skip(ftype)
12235 
      elif fid == 2:
12236 
        if ftype == TType.I32:
12237 
          self.category = iprot.readI32();
12238 
        else:
12239 
          iprot.skip(ftype)
12240 
      else:
12241 
        iprot.skip(ftype)
12242 
      iprot.readFieldEnd()
12243 
    iprot.readStructEnd()
12244 
 
12245 
  def write(self, oprot):
12246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12248 
      return
12249 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
12250 
    if self.transactionId is not None:
12251 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12252 
      oprot.writeI64(self.transactionId)
12253 
      oprot.writeFieldEnd()
12254 
    if self.category is not None:
12255 
      oprot.writeFieldBegin('category', TType.I32, 2)
12256 
      oprot.writeI32(self.category)
12257 
      oprot.writeFieldEnd()
12258 
    oprot.writeFieldStop()
12259 
    oprot.writeStructEnd()
12260 
 
12261 
  def validate(self):
12262 
    return
12263 
 
12264 
 
12265 
  def __repr__(self):
12266 
    L = ['%s=%r' % (key, value)
12267 
      for key, value in self.__dict__.iteritems()]
12268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12269 
 
12270 
  def __eq__(self, other):
12271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12272 
 
12273 
  def __ne__(self, other):
12274 
    return not (self == other)
12275 
 
12276 
class markTransactionAsProcessed_result:
12277 
 
12278 
  thrift_spec = (
12279 
  )
12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      else:
12291 
        iprot.skip(ftype)
12292 
      iprot.readFieldEnd()
12293 
    iprot.readStructEnd()
12294 
 
12295 
  def write(self, oprot):
12296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12298 
      return
12299 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
12303 
  def validate(self):
12304 
    return
12305 
 
12306 
 
12307 
  def __repr__(self):
12308 
    L = ['%s=%r' % (key, value)
12309 
      for key, value in self.__dict__.iteritems()]
12310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12311 
 
12312 
  def __eq__(self, other):
12313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12314 
 
12315 
  def __ne__(self, other):
12316 
    return not (self == other)
4018 chandransh 12317 
 
12318 
class getItemWiseRiskyOrdersCount_args:
12319 
 
12320 
  thrift_spec = (
12321 
  )
12322 
 
12323 
  def read(self, iprot):
12324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12326 
      return
12327 
    iprot.readStructBegin()
12328 
    while True:
12329 
      (fname, ftype, fid) = iprot.readFieldBegin()
12330 
      if ftype == TType.STOP:
12331 
        break
12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
12341 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
12342 
    oprot.writeFieldStop()
12343 
    oprot.writeStructEnd()
12344 
 
12345 
  def validate(self):
12346 
    return
12347 
 
12348 
 
12349 
  def __repr__(self):
12350 
    L = ['%s=%r' % (key, value)
12351 
      for key, value in self.__dict__.iteritems()]
12352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12353 
 
12354 
  def __eq__(self, other):
12355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12356 
 
12357 
  def __ne__(self, other):
12358 
    return not (self == other)
12359 
 
12360 
class getItemWiseRiskyOrdersCount_result:
12361 
  """
12362 
  Attributes:
12363 
   - success
12364 
  """
12365 
 
12366 
  thrift_spec = (
12367 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12368 
  )
12369 
 
12370 
  def __init__(self, success=None,):
12371 
    self.success = success
12372 
 
12373 
  def read(self, iprot):
12374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12376 
      return
12377 
    iprot.readStructBegin()
12378 
    while True:
12379 
      (fname, ftype, fid) = iprot.readFieldBegin()
12380 
      if ftype == TType.STOP:
12381 
        break
12382 
      if fid == 0:
12383 
        if ftype == TType.MAP:
12384 
          self.success = {}
4133 chandransh 12385 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
12386 
          for _i242 in xrange(_size238):
12387 
            _key243 = iprot.readI64();
12388 
            _val244 = iprot.readI64();
12389 
            self.success[_key243] = _val244
4018 chandransh 12390 
          iprot.readMapEnd()
12391 
        else:
12392 
          iprot.skip(ftype)
12393 
      else:
12394 
        iprot.skip(ftype)
12395 
      iprot.readFieldEnd()
12396 
    iprot.readStructEnd()
12397 
 
12398 
  def write(self, oprot):
12399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12401 
      return
12402 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
12403 
    if self.success is not None:
12404 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12405 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 12406 
      for kiter245,viter246 in self.success.items():
12407 
        oprot.writeI64(kiter245)
12408 
        oprot.writeI64(viter246)
4018 chandransh 12409 
      oprot.writeMapEnd()
12410 
      oprot.writeFieldEnd()
12411 
    oprot.writeFieldStop()
12412 
    oprot.writeStructEnd()
12413 
 
12414 
  def validate(self):
12415 
    return
12416 
 
12417 
 
12418 
  def __repr__(self):
12419 
    L = ['%s=%r' % (key, value)
12420 
      for key, value in self.__dict__.iteritems()]
12421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12422 
 
12423 
  def __eq__(self, other):
12424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12425 
 
12426 
  def __ne__(self, other):
12427 
    return not (self == other)
4247 rajveer 12428 
 
4295 varun.gupt 12429 
class getOrdersForItemIds_args:
12430 
  """
12431 
  Attributes:
12432 
   - itemIds
12433 
  """
12434 
 
12435 
  thrift_spec = (
12436 
    None, # 0
12437 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
12438 
  )
12439 
 
12440 
  def __init__(self, itemIds=None,):
12441 
    self.itemIds = itemIds
12442 
 
12443 
  def read(self, iprot):
12444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12446 
      return
12447 
    iprot.readStructBegin()
12448 
    while True:
12449 
      (fname, ftype, fid) = iprot.readFieldBegin()
12450 
      if ftype == TType.STOP:
12451 
        break
12452 
      if fid == 1:
12453 
        if ftype == TType.LIST:
12454 
          self.itemIds = []
12455 
          (_etype250, _size247) = iprot.readListBegin()
12456 
          for _i251 in xrange(_size247):
12457 
            _elem252 = iprot.readI64();
12458 
            self.itemIds.append(_elem252)
12459 
          iprot.readListEnd()
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('getOrdersForItemIds_args')
12472 
    if self.itemIds is not None:
12473 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
12474 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
12475 
      for iter253 in self.itemIds:
12476 
        oprot.writeI64(iter253)
12477 
      oprot.writeListEnd()
12478 
      oprot.writeFieldEnd()
12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def validate(self):
12483 
    return
12484 
 
12485 
 
12486 
  def __repr__(self):
12487 
    L = ['%s=%r' % (key, value)
12488 
      for key, value in self.__dict__.iteritems()]
12489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12490 
 
12491 
  def __eq__(self, other):
12492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12493 
 
12494 
  def __ne__(self, other):
12495 
    return not (self == other)
12496 
 
12497 
class getOrdersForItemIds_result:
12498 
  """
12499 
  Attributes:
12500 
   - success
12501 
  """
12502 
 
12503 
  thrift_spec = (
12504 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12505 
  )
12506 
 
12507 
  def __init__(self, success=None,):
12508 
    self.success = success
12509 
 
12510 
  def read(self, iprot):
12511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12513 
      return
12514 
    iprot.readStructBegin()
12515 
    while True:
12516 
      (fname, ftype, fid) = iprot.readFieldBegin()
12517 
      if ftype == TType.STOP:
12518 
        break
12519 
      if fid == 0:
12520 
        if ftype == TType.LIST:
12521 
          self.success = []
12522 
          (_etype257, _size254) = iprot.readListBegin()
12523 
          for _i258 in xrange(_size254):
12524 
            _elem259 = Order()
12525 
            _elem259.read(iprot)
12526 
            self.success.append(_elem259)
12527 
          iprot.readListEnd()
12528 
        else:
12529 
          iprot.skip(ftype)
12530 
      else:
12531 
        iprot.skip(ftype)
12532 
      iprot.readFieldEnd()
12533 
    iprot.readStructEnd()
12534 
 
12535 
  def write(self, oprot):
12536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12538 
      return
12539 
    oprot.writeStructBegin('getOrdersForItemIds_result')
12540 
    if self.success is not None:
12541 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12542 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12543 
      for iter260 in self.success:
12544 
        iter260.write(oprot)
12545 
      oprot.writeListEnd()
12546 
      oprot.writeFieldEnd()
12547 
    oprot.writeFieldStop()
12548 
    oprot.writeStructEnd()
12549 
 
12550 
  def validate(self):
12551 
    return
12552 
 
12553 
 
12554 
  def __repr__(self):
12555 
    L = ['%s=%r' % (key, value)
12556 
      for key, value in self.__dict__.iteritems()]
12557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12558 
 
12559 
  def __eq__(self, other):
12560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12561 
 
12562 
  def __ne__(self, other):
12563 
    return not (self == other)
12564 
 
4247 rajveer 12565 
class markOrderCancellationRequestReceived_args:
12566 
  """
12567 
  Attributes:
12568 
   - orderId
12569 
  """
12570 
 
12571 
  thrift_spec = (
12572 
    None, # 0
12573 
    (1, TType.I64, 'orderId', None, None, ), # 1
12574 
  )
12575 
 
12576 
  def __init__(self, orderId=None,):
12577 
    self.orderId = orderId
12578 
 
12579 
  def read(self, iprot):
12580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12582 
      return
12583 
    iprot.readStructBegin()
12584 
    while True:
12585 
      (fname, ftype, fid) = iprot.readFieldBegin()
12586 
      if ftype == TType.STOP:
12587 
        break
12588 
      if fid == 1:
12589 
        if ftype == TType.I64:
12590 
          self.orderId = iprot.readI64();
12591 
        else:
12592 
          iprot.skip(ftype)
12593 
      else:
12594 
        iprot.skip(ftype)
12595 
      iprot.readFieldEnd()
12596 
    iprot.readStructEnd()
12597 
 
12598 
  def write(self, oprot):
12599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12601 
      return
12602 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
12603 
    if self.orderId is not None:
12604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12605 
      oprot.writeI64(self.orderId)
12606 
      oprot.writeFieldEnd()
12607 
    oprot.writeFieldStop()
12608 
    oprot.writeStructEnd()
12609 
 
12610 
  def validate(self):
12611 
    return
12612 
 
12613 
 
12614 
  def __repr__(self):
12615 
    L = ['%s=%r' % (key, value)
12616 
      for key, value in self.__dict__.iteritems()]
12617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12618 
 
12619 
  def __eq__(self, other):
12620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12621 
 
12622 
  def __ne__(self, other):
12623 
    return not (self == other)
12624 
 
12625 
class markOrderCancellationRequestReceived_result:
12626 
  """
12627 
  Attributes:
12628 
   - ex
12629 
  """
12630 
 
12631 
  thrift_spec = (
12632 
    None, # 0
12633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12634 
  )
12635 
 
12636 
  def __init__(self, ex=None,):
12637 
    self.ex = ex
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      if fid == 1:
12649 
        if ftype == TType.STRUCT:
12650 
          self.ex = TransactionServiceException()
12651 
          self.ex.read(iprot)
12652 
        else:
12653 
          iprot.skip(ftype)
12654 
      else:
12655 
        iprot.skip(ftype)
12656 
      iprot.readFieldEnd()
12657 
    iprot.readStructEnd()
12658 
 
12659 
  def write(self, oprot):
12660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12662 
      return
12663 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
12664 
    if self.ex is not None:
12665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12666 
      self.ex.write(oprot)
12667 
      oprot.writeFieldEnd()
12668 
    oprot.writeFieldStop()
12669 
    oprot.writeStructEnd()
12670 
 
12671 
  def validate(self):
12672 
    return
12673 
 
12674 
 
12675 
  def __repr__(self):
12676 
    L = ['%s=%r' % (key, value)
12677 
      for key, value in self.__dict__.iteritems()]
12678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12679 
 
12680 
  def __eq__(self, other):
12681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12682 
 
12683 
  def __ne__(self, other):
12684 
    return not (self == other)
12685 
 
12686 
class markOrderCancellationRequestConfirmed_args:
12687 
  """
12688 
  Attributes:
12689 
   - orderId
12690 
  """
12691 
 
12692 
  thrift_spec = (
12693 
    None, # 0
12694 
    (1, TType.I64, 'orderId', None, None, ), # 1
12695 
  )
12696 
 
12697 
  def __init__(self, orderId=None,):
12698 
    self.orderId = orderId
12699 
 
12700 
  def read(self, iprot):
12701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12703 
      return
12704 
    iprot.readStructBegin()
12705 
    while True:
12706 
      (fname, ftype, fid) = iprot.readFieldBegin()
12707 
      if ftype == TType.STOP:
12708 
        break
12709 
      if fid == 1:
12710 
        if ftype == TType.I64:
12711 
          self.orderId = iprot.readI64();
12712 
        else:
12713 
          iprot.skip(ftype)
12714 
      else:
12715 
        iprot.skip(ftype)
12716 
      iprot.readFieldEnd()
12717 
    iprot.readStructEnd()
12718 
 
12719 
  def write(self, oprot):
12720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12722 
      return
12723 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
12724 
    if self.orderId is not None:
12725 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12726 
      oprot.writeI64(self.orderId)
12727 
      oprot.writeFieldEnd()
12728 
    oprot.writeFieldStop()
12729 
    oprot.writeStructEnd()
12730 
 
12731 
  def validate(self):
12732 
    return
12733 
 
12734 
 
12735 
  def __repr__(self):
12736 
    L = ['%s=%r' % (key, value)
12737 
      for key, value in self.__dict__.iteritems()]
12738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12739 
 
12740 
  def __eq__(self, other):
12741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12742 
 
12743 
  def __ne__(self, other):
12744 
    return not (self == other)
12745 
 
12746 
class markOrderCancellationRequestConfirmed_result:
12747 
  """
12748 
  Attributes:
12749 
   - ex
12750 
  """
12751 
 
12752 
  thrift_spec = (
12753 
    None, # 0
12754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12755 
  )
12756 
 
12757 
  def __init__(self, ex=None,):
12758 
    self.ex = ex
12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 1:
12770 
        if ftype == TType.STRUCT:
12771 
          self.ex = TransactionServiceException()
12772 
          self.ex.read(iprot)
12773 
        else:
12774 
          iprot.skip(ftype)
12775 
      else:
12776 
        iprot.skip(ftype)
12777 
      iprot.readFieldEnd()
12778 
    iprot.readStructEnd()
12779 
 
12780 
  def write(self, oprot):
12781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12783 
      return
12784 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
12785 
    if self.ex is not None:
12786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12787 
      self.ex.write(oprot)
12788 
      oprot.writeFieldEnd()
12789 
    oprot.writeFieldStop()
12790 
    oprot.writeStructEnd()
12791 
 
12792 
  def validate(self):
12793 
    return
12794 
 
12795 
 
12796 
  def __repr__(self):
12797 
    L = ['%s=%r' % (key, value)
12798 
      for key, value in self.__dict__.iteritems()]
12799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12800 
 
12801 
  def __eq__(self, other):
12802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12803 
 
12804 
  def __ne__(self, other):
12805 
    return not (self == other)
12806 
 
12807 
class markOrderCancellationRequestDenied_args:
12808 
  """
12809 
  Attributes:
12810 
   - orderId
12811 
  """
12812 
 
12813 
  thrift_spec = (
12814 
    None, # 0
12815 
    (1, TType.I64, 'orderId', None, None, ), # 1
12816 
  )
12817 
 
12818 
  def __init__(self, orderId=None,):
12819 
    self.orderId = orderId
12820 
 
12821 
  def read(self, iprot):
12822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12824 
      return
12825 
    iprot.readStructBegin()
12826 
    while True:
12827 
      (fname, ftype, fid) = iprot.readFieldBegin()
12828 
      if ftype == TType.STOP:
12829 
        break
12830 
      if fid == 1:
12831 
        if ftype == TType.I64:
12832 
          self.orderId = iprot.readI64();
12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      else:
12836 
        iprot.skip(ftype)
12837 
      iprot.readFieldEnd()
12838 
    iprot.readStructEnd()
12839 
 
12840 
  def write(self, oprot):
12841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12843 
      return
12844 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
12845 
    if self.orderId is not None:
12846 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12847 
      oprot.writeI64(self.orderId)
12848 
      oprot.writeFieldEnd()
12849 
    oprot.writeFieldStop()
12850 
    oprot.writeStructEnd()
12851 
 
12852 
  def validate(self):
12853 
    return
12854 
 
12855 
 
12856 
  def __repr__(self):
12857 
    L = ['%s=%r' % (key, value)
12858 
      for key, value in self.__dict__.iteritems()]
12859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12860 
 
12861 
  def __eq__(self, other):
12862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12863 
 
12864 
  def __ne__(self, other):
12865 
    return not (self == other)
12866 
 
12867 
class markOrderCancellationRequestDenied_result:
12868 
  """
12869 
  Attributes:
12870 
   - ex
12871 
  """
12872 
 
12873 
  thrift_spec = (
12874 
    None, # 0
12875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12876 
  )
12877 
 
12878 
  def __init__(self, ex=None,):
12879 
    self.ex = ex
12880 
 
12881 
  def read(self, iprot):
12882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12884 
      return
12885 
    iprot.readStructBegin()
12886 
    while True:
12887 
      (fname, ftype, fid) = iprot.readFieldBegin()
12888 
      if ftype == TType.STOP:
12889 
        break
12890 
      if fid == 1:
12891 
        if ftype == TType.STRUCT:
12892 
          self.ex = TransactionServiceException()
12893 
          self.ex.read(iprot)
12894 
        else:
12895 
          iprot.skip(ftype)
12896 
      else:
12897 
        iprot.skip(ftype)
12898 
      iprot.readFieldEnd()
12899 
    iprot.readStructEnd()
12900 
 
12901 
  def write(self, oprot):
12902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12904 
      return
12905 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
12906 
    if self.ex is not None:
12907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12908 
      self.ex.write(oprot)
12909 
      oprot.writeFieldEnd()
12910 
    oprot.writeFieldStop()
12911 
    oprot.writeStructEnd()
12912 
 
12913 
  def validate(self):
12914 
    return
12915 
 
12916 
 
12917 
  def __repr__(self):
12918 
    L = ['%s=%r' % (key, value)
12919 
      for key, value in self.__dict__.iteritems()]
12920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12921 
 
12922 
  def __eq__(self, other):
12923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12924 
 
12925 
  def __ne__(self, other):
12926 
    return not (self == other)
12927 
 
4258 rajveer 12928 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 12929 
  """
12930 
  Attributes:
4258 rajveer 12931 
   - transactionId
4247 rajveer 12932 
  """
12933 
 
12934 
  thrift_spec = (
12935 
    None, # 0
4258 rajveer 12936 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 12937 
  )
12938 
 
4258 rajveer 12939 
  def __init__(self, transactionId=None,):
12940 
    self.transactionId = transactionId
4247 rajveer 12941 
 
12942 
  def read(self, iprot):
12943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12945 
      return
12946 
    iprot.readStructBegin()
12947 
    while True:
12948 
      (fname, ftype, fid) = iprot.readFieldBegin()
12949 
      if ftype == TType.STOP:
12950 
        break
12951 
      if fid == 1:
12952 
        if ftype == TType.I64:
4258 rajveer 12953 
          self.transactionId = iprot.readI64();
4247 rajveer 12954 
        else:
12955 
          iprot.skip(ftype)
12956 
      else:
12957 
        iprot.skip(ftype)
12958 
      iprot.readFieldEnd()
12959 
    iprot.readStructEnd()
12960 
 
12961 
  def write(self, oprot):
12962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12964 
      return
4258 rajveer 12965 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
12966 
    if self.transactionId is not None:
12967 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12968 
      oprot.writeI64(self.transactionId)
4247 rajveer 12969 
      oprot.writeFieldEnd()
12970 
    oprot.writeFieldStop()
12971 
    oprot.writeStructEnd()
12972 
 
12973 
  def validate(self):
12974 
    return
12975 
 
12976 
 
12977 
  def __repr__(self):
12978 
    L = ['%s=%r' % (key, value)
12979 
      for key, value in self.__dict__.iteritems()]
12980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12981 
 
12982 
  def __eq__(self, other):
12983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12984 
 
12985 
  def __ne__(self, other):
12986 
    return not (self == other)
12987 
 
4258 rajveer 12988 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 12989 
  """
12990 
  Attributes:
12991 
   - ex
12992 
  """
12993 
 
12994 
  thrift_spec = (
12995 
    None, # 0
12996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12997 
  )
12998 
 
12999 
  def __init__(self, ex=None,):
13000 
    self.ex = ex
13001 
 
13002 
  def read(self, iprot):
13003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13005 
      return
13006 
    iprot.readStructBegin()
13007 
    while True:
13008 
      (fname, ftype, fid) = iprot.readFieldBegin()
13009 
      if ftype == TType.STOP:
13010 
        break
13011 
      if fid == 1:
13012 
        if ftype == TType.STRUCT:
13013 
          self.ex = TransactionServiceException()
13014 
          self.ex.read(iprot)
13015 
        else:
13016 
          iprot.skip(ftype)
13017 
      else:
13018 
        iprot.skip(ftype)
13019 
      iprot.readFieldEnd()
13020 
    iprot.readStructEnd()
13021 
 
13022 
  def write(self, oprot):
13023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13025 
      return
4258 rajveer 13026 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13027 
    if self.ex is not None:
13028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13029 
      self.ex.write(oprot)
13030 
      oprot.writeFieldEnd()
13031 
    oprot.writeFieldStop()
13032 
    oprot.writeStructEnd()
13033 
 
13034 
  def validate(self):
13035 
    return
13036 
 
13037 
 
13038 
  def __repr__(self):
13039 
    L = ['%s=%r' % (key, value)
13040 
      for key, value in self.__dict__.iteritems()]
13041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13042 
 
13043 
  def __eq__(self, other):
13044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13045 
 
13046 
  def __ne__(self, other):
13047 
    return not (self == other)
4259 anupam.sin 13048 
 
13049 
class refundTransaction_args:
13050 
  """
13051 
  Attributes:
13052 
   - transactionId
13053 
   - refundedBy
13054 
   - reason
13055 
  """
13056 
 
13057 
  thrift_spec = (
13058 
    None, # 0
13059 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13060 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13061 
    (3, TType.STRING, 'reason', None, None, ), # 3
13062 
  )
13063 
 
13064 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13065 
    self.transactionId = transactionId
13066 
    self.refundedBy = refundedBy
13067 
    self.reason = reason
13068 
 
13069 
  def read(self, iprot):
13070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13072 
      return
13073 
    iprot.readStructBegin()
13074 
    while True:
13075 
      (fname, ftype, fid) = iprot.readFieldBegin()
13076 
      if ftype == TType.STOP:
13077 
        break
13078 
      if fid == 1:
13079 
        if ftype == TType.I64:
13080 
          self.transactionId = iprot.readI64();
13081 
        else:
13082 
          iprot.skip(ftype)
13083 
      elif fid == 2:
13084 
        if ftype == TType.STRING:
13085 
          self.refundedBy = iprot.readString();
13086 
        else:
13087 
          iprot.skip(ftype)
13088 
      elif fid == 3:
13089 
        if ftype == TType.STRING:
13090 
          self.reason = iprot.readString();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      else:
13094 
        iprot.skip(ftype)
13095 
      iprot.readFieldEnd()
13096 
    iprot.readStructEnd()
13097 
 
13098 
  def write(self, oprot):
13099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13101 
      return
13102 
    oprot.writeStructBegin('refundTransaction_args')
13103 
    if self.transactionId is not None:
13104 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13105 
      oprot.writeI64(self.transactionId)
13106 
      oprot.writeFieldEnd()
13107 
    if self.refundedBy is not None:
13108 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13109 
      oprot.writeString(self.refundedBy)
13110 
      oprot.writeFieldEnd()
13111 
    if self.reason is not None:
13112 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13113 
      oprot.writeString(self.reason)
13114 
      oprot.writeFieldEnd()
13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
13133 
class refundTransaction_result:
13134 
  """
13135 
  Attributes:
13136 
   - ex
13137 
  """
13138 
 
13139 
  thrift_spec = (
13140 
    None, # 0
13141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13142 
  )
13143 
 
13144 
  def __init__(self, ex=None,):
13145 
    self.ex = ex
13146 
 
13147 
  def read(self, iprot):
13148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13150 
      return
13151 
    iprot.readStructBegin()
13152 
    while True:
13153 
      (fname, ftype, fid) = iprot.readFieldBegin()
13154 
      if ftype == TType.STOP:
13155 
        break
13156 
      if fid == 1:
13157 
        if ftype == TType.STRUCT:
13158 
          self.ex = TransactionServiceException()
13159 
          self.ex.read(iprot)
13160 
        else:
13161 
          iprot.skip(ftype)
13162 
      else:
13163 
        iprot.skip(ftype)
13164 
      iprot.readFieldEnd()
13165 
    iprot.readStructEnd()
13166 
 
13167 
  def write(self, oprot):
13168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13170 
      return
13171 
    oprot.writeStructBegin('refundTransaction_result')
13172 
    if self.ex is not None:
13173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13174 
      self.ex.write(oprot)
13175 
      oprot.writeFieldEnd()
13176 
    oprot.writeFieldStop()
13177 
    oprot.writeStructEnd()
13178 
 
13179 
  def validate(self):
13180 
    return
13181 
 
13182 
 
13183 
  def __repr__(self):
13184 
    L = ['%s=%r' % (key, value)
13185 
      for key, value in self.__dict__.iteritems()]
13186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13187 
 
13188 
  def __eq__(self, other):
13189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13190 
 
13191 
  def __ne__(self, other):
13192 
    return not (self == other)
4285 rajveer 13193 
 
13194 
class acceptOrdersForItemId_args:
13195 
  """
13196 
  Attributes:
13197 
   - itemId
13198 
   - inventory
13199 
  """
13200 
 
13201 
  thrift_spec = (
13202 
    None, # 0
13203 
    (1, TType.I64, 'itemId', None, None, ), # 1
13204 
    (2, TType.I64, 'inventory', None, None, ), # 2
13205 
  )
13206 
 
13207 
  def __init__(self, itemId=None, inventory=None,):
13208 
    self.itemId = itemId
13209 
    self.inventory = inventory
13210 
 
13211 
  def read(self, iprot):
13212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13214 
      return
13215 
    iprot.readStructBegin()
13216 
    while True:
13217 
      (fname, ftype, fid) = iprot.readFieldBegin()
13218 
      if ftype == TType.STOP:
13219 
        break
13220 
      if fid == 1:
13221 
        if ftype == TType.I64:
13222 
          self.itemId = iprot.readI64();
13223 
        else:
13224 
          iprot.skip(ftype)
13225 
      elif fid == 2:
13226 
        if ftype == TType.I64:
13227 
          self.inventory = iprot.readI64();
13228 
        else:
13229 
          iprot.skip(ftype)
13230 
      else:
13231 
        iprot.skip(ftype)
13232 
      iprot.readFieldEnd()
13233 
    iprot.readStructEnd()
13234 
 
13235 
  def write(self, oprot):
13236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13238 
      return
13239 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
13240 
    if self.itemId is not None:
13241 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13242 
      oprot.writeI64(self.itemId)
13243 
      oprot.writeFieldEnd()
13244 
    if self.inventory is not None:
13245 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
13246 
      oprot.writeI64(self.inventory)
13247 
      oprot.writeFieldEnd()
13248 
    oprot.writeFieldStop()
13249 
    oprot.writeStructEnd()
13250 
 
13251 
  def validate(self):
13252 
    return
13253 
 
13254 
 
13255 
  def __repr__(self):
13256 
    L = ['%s=%r' % (key, value)
13257 
      for key, value in self.__dict__.iteritems()]
13258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13259 
 
13260 
  def __eq__(self, other):
13261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13262 
 
13263 
  def __ne__(self, other):
13264 
    return not (self == other)
13265 
 
13266 
class acceptOrdersForItemId_result:
13267 
  """
13268 
  Attributes:
13269 
   - success
13270 
   - ex
13271 
  """
13272 
 
13273 
  thrift_spec = (
13274 
    (0, TType.BOOL, 'success', None, None, ), # 0
13275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13276 
  )
13277 
 
13278 
  def __init__(self, success=None, ex=None,):
13279 
    self.success = success
13280 
    self.ex = ex
13281 
 
13282 
  def read(self, iprot):
13283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13285 
      return
13286 
    iprot.readStructBegin()
13287 
    while True:
13288 
      (fname, ftype, fid) = iprot.readFieldBegin()
13289 
      if ftype == TType.STOP:
13290 
        break
13291 
      if fid == 0:
13292 
        if ftype == TType.BOOL:
13293 
          self.success = iprot.readBool();
13294 
        else:
13295 
          iprot.skip(ftype)
13296 
      elif fid == 1:
13297 
        if ftype == TType.STRUCT:
13298 
          self.ex = TransactionServiceException()
13299 
          self.ex.read(iprot)
13300 
        else:
13301 
          iprot.skip(ftype)
13302 
      else:
13303 
        iprot.skip(ftype)
13304 
      iprot.readFieldEnd()
13305 
    iprot.readStructEnd()
13306 
 
13307 
  def write(self, oprot):
13308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13310 
      return
13311 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
13312 
    if self.success is not None:
13313 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13314 
      oprot.writeBool(self.success)
13315 
      oprot.writeFieldEnd()
13316 
    if self.ex is not None:
13317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13318 
      self.ex.write(oprot)
13319 
      oprot.writeFieldEnd()
13320 
    oprot.writeFieldStop()
13321 
    oprot.writeStructEnd()
13322 
 
13323 
  def validate(self):
13324 
    return
13325 
 
13326 
 
13327 
  def __repr__(self):
13328 
    L = ['%s=%r' % (key, value)
13329 
      for key, value in self.__dict__.iteritems()]
13330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13331 
 
13332 
  def __eq__(self, other):
13333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13334 
 
13335 
  def __ne__(self, other):
13336 
    return not (self == other)