Subversion Repositories SmartDukaan

Rev

Rev 4444 | Rev 4454 | 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 
 
4444 rajveer 219 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 220 
    """
221 
    Parameters:
4394 rajveer 222 
     - type
4444 rajveer 223 
     - warehouseId
4394 rajveer 224 
     - status
225 
     - timestamp
3064 chandransh 226 
    """
227 
    pass
228 
 
4444 rajveer 229 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 230 
    """
231 
    Parameters:
232 
     - type
4444 rajveer 233 
     - warehouseId
4394 rajveer 234 
     - description
3064 chandransh 235 
    """
236 
    pass
237 
 
4444 rajveer 238 
  def markAlertsAsSeen(self, warehouseId):
239 
    """
240 
    Parameters:
241 
     - warehouseId
242 
    """
243 
    pass
244 
 
3064 chandransh 245 
  def getValidOrderCount(self, ):
246 
    """
247 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
248 
    """
249 
    pass
250 
 
251 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
252 
    """
253 
    Returns the number of distinct customers who have done successful transactions
254 
    """
255 
    pass
256 
 
257 
  def getValidOrdersAmountRange(self, ):
258 
    """
259 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
260 
    List contains two values, first minimum amount and second maximum amount.
261 
    """
262 
    pass
263 
 
264 
  def getValidOrders(self, limit):
265 
    """
266 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
267 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 268 
 
3064 chandransh 269 
    Parameters:
270 
     - limit
271 
    """
272 
    pass
273 
 
1220 chandransh 274 
  def batchOrders(self, warehouseId):
275 
    """
276 
    Create a batch of all the pending orders for the given warehouse.
277 
    The returned list is orderd by created_timestamp.
278 
    If there are no pending orders, an empty list is returned.
3431 rajveer 279 
 
1220 chandransh 280 
    Parameters:
281 
     - warehouseId
282 
    """
283 
    pass
284 
 
1208 chandransh 285 
  def markOrderAsOutOfStock(self, orderId):
286 
    """
287 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 288 
 
1208 chandransh 289 
    Parameters:
290 
     - orderId
291 
    """
292 
    pass
293 
 
3064 chandransh 294 
  def verifyOrder(self, orderId):
759 chandransh 295 
    """
3064 chandransh 296 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
297 
    timestamp. It is intended to be used for COD orders but can be harmlessly
298 
    used for all other orders as well.
299 
    Throws an exception if no such order exists.
3431 rajveer 300 
 
759 chandransh 301 
    Parameters:
3064 chandransh 302 
     - orderId
303 
    """
304 
    pass
305 
 
306 
  def acceptOrder(self, orderId):
307 
    """
308 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
309 
    given order is not a COD order, it also captures the payment if the same has
310 
    not been captured.
311 
    Throws an exception if no such order exists.
3431 rajveer 312 
 
3064 chandransh 313 
    Parameters:
314 
     - orderId
315 
    """
316 
    pass
317 
 
4283 anupam.sin 318 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 319 
    """
320 
    Add billing details such as the bill number and the biller to the Order.
321 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
322 
    the IMEI no. if a -1 is supplied.
323 
    Also, it generates an invoice number for the order, marks the order as
324 
    BILLED and sets the billing timestamp.
325 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 326 
 
3064 chandransh 327 
    Parameters:
328 
     - orderId
4283 anupam.sin 329 
     - invoice_number
3064 chandransh 330 
     - imeiNumber
331 
     - itemNumber
4283 anupam.sin 332 
     - billed_by
333 
     - jacketNumber
3064 chandransh 334 
     - billingType
4283 anupam.sin 335 
     - vendorId
3064 chandransh 336 
    """
337 
    pass
338 
 
339 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
340 
    """
341 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 342 
    given warehouse and were picked up by the given provider as MANIFESTED.
343 
 
344 
    Parameters:
345 
     - warehouseId
346 
     - providerId
347 
     - cod
348 
    """
349 
    pass
350 
 
351 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
352 
    """
353 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
3064 chandransh 354 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 355 
 
3064 chandransh 356 
    Parameters:
759 chandransh 357 
     - warehouseId
358 
     - providerId
3064 chandransh 359 
     - cod
759 chandransh 360 
    """
361 
    pass
362 
 
1113 chandransh 363 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
364 
    """
365 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
366 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
367 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 368 
 
1113 chandransh 369 
    Parameters:
370 
     - providerId
371 
     - pickupDetails
372 
    """
373 
    pass
374 
 
1132 chandransh 375 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
376 
    """
377 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
378 
    the name of the receiver.
379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 380 
 
1132 chandransh 381 
    Parameters:
382 
     - providerId
383 
     - deliveredOrders
384 
    """
385 
    pass
386 
 
1135 chandransh 387 
  def markOrdersAsFailed(self, providerId, returnedOrders):
388 
    """
389 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
390 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 391 
 
1135 chandransh 392 
    Parameters:
393 
     - providerId
394 
     - returnedOrders
395 
    """
396 
    pass
397 
 
1246 chandransh 398 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
399 
    """
400 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 401 
 
1246 chandransh 402 
    Parameters:
403 
     - providerId
404 
     - undeliveredOrders
405 
    """
406 
    pass
407 
 
1408 ankur.sing 408 
  def getUndeliveredOrders(self, providerId, warehouseId):
409 
    """
410 
    Returns the list of orders whose delivery time has passed but have not been
411 
    delivered yet for the given provider and warehouse. To get a complete list of
412 
    undelivered orders, pass them as -1.
413 
    Returns an empty list if no such orders exist.
3431 rajveer 414 
 
1408 ankur.sing 415 
    Parameters:
416 
     - providerId
417 
     - warehouseId
418 
    """
419 
    pass
420 
 
2536 chandransh 421 
  def toggleDOAFlag(self, orderId):
422 
    """
423 
    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.
424 
    Returns the final flag status.
425 
    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 426 
 
2536 chandransh 427 
    Parameters:
428 
     - orderId
429 
    """
430 
    pass
1886 ankur.sing 431 
 
2536 chandransh 432 
  def requestPickupNumber(self, orderId):
433 
    """
434 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 435 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
436 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 437 
    For any other status, it returns false.
438 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 439 
 
2536 chandransh 440 
    Parameters:
441 
     - orderId
442 
    """
443 
    pass
444 
 
445 
  def authorizePickup(self, orderId, pickupNumber):
446 
    """
4452 rajveer 447 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 448 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
449 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
450 
    	3. Returns true
2591 chandransh 451 
    If the order is in any other status, it returns false.
2536 chandransh 452 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 453 
 
2536 chandransh 454 
    Parameters:
455 
     - orderId
456 
     - pickupNumber
457 
    """
458 
    pass
459 
 
2764 chandransh 460 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
461 
    """
462 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
463 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 464 
 
2764 chandransh 465 
    Parameters:
466 
     - providerId
467 
     - pickupDetails
468 
    """
469 
    pass
470 
 
2616 chandransh 471 
  def receiveReturn(self, orderId):
2591 chandransh 472 
    """
4452 rajveer 473 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
2616 chandransh 474 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 475 
    If the order is in any other state, it returns false.
476 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 477 
 
2591 chandransh 478 
    Parameters:
479 
     - orderId
480 
    """
481 
    pass
2536 chandransh 482 
 
2591 chandransh 483 
  def validateDoa(self, orderId, isValid):
484 
    """
4452 rajveer 485 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 486 
    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 487 
    If the order is in any other state, it returns false.
488 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 489 
 
2591 chandransh 490 
    Parameters:
491 
     - orderId
492 
     - isValid
493 
    """
494 
    pass
495 
 
2616 chandransh 496 
  def reshipOrder(self, orderId):
497 
    """
498 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
499 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
500 
    	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.
501 
 
502 
    If the order is in DOA_CERT_VALID state, it does the following:
503 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
504 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 505 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 506 
 
2616 chandransh 507 
    Returns the id of the newly created order.
3431 rajveer 508 
 
2616 chandransh 509 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 510 
 
2616 chandransh 511 
    Parameters:
512 
     - orderId
513 
    """
514 
    pass
2591 chandransh 515 
 
3226 chandransh 516 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 517 
    """
518 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
519 
    	1. Creates a refund request for batch processing.
520 
    	2. Creates a return order for the warehouse executive to return the shipped material.
521 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 522 
 
2616 chandransh 523 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
524 
    	1. Creates a refund request for batch processing.
3226 chandransh 525 
    	2. Cancels the reservation of the item in the warehouse.
526 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 527 
 
3226 chandransh 528 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
529 
    	1. Cancels the reservation of the item in the warehouse.
530 
    	2. Marks the current order as CANCELED.
531 
 
532 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
533 
 
2616 chandransh 534 
    Returns True if it is successful, False otherwise.
3431 rajveer 535 
 
2616 chandransh 536 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 537 
 
2616 chandransh 538 
    Parameters:
539 
     - orderId
3226 chandransh 540 
     - refundedBy
541 
     - reason
2616 chandransh 542 
    """
543 
    pass
544 
 
2690 chandransh 545 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
546 
    """
547 
    Get all return orders created between the from and to dates for the given warehouse.
548 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 549 
 
2690 chandransh 550 
    Parameters:
551 
     - warehouseId
552 
     - fromDate
553 
     - toDate
554 
    """
555 
    pass
2616 chandransh 556 
 
2700 chandransh 557 
  def getReturnOrder(self, id):
558 
    """
559 
    Returns the ReturnOrder corresponding to the given id.
560 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 561 
 
2700 chandransh 562 
    Parameters:
563 
     - id
564 
    """
565 
    pass
566 
 
2690 chandransh 567 
  def processReturn(self, returnOrderId):
568 
    """
569 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 570 
 
2690 chandransh 571 
    Parameters:
572 
     - returnOrderId
573 
    """
574 
    pass
575 
 
2819 chandransh 576 
  def createPurchaseOrder(self, warehouseId):
577 
    """
578 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 579 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 580 
 
2819 chandransh 581 
    Parameters:
582 
     - warehouseId
583 
    """
584 
    pass
2690 chandransh 585 
 
3451 chandransh 586 
  def updateWeight(self, orderId, weight):
587 
    """
588 
    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 589 
 
3451 chandransh 590 
    Parameters:
591 
     - orderId
592 
     - weight
593 
    """
594 
    pass
595 
 
3469 chandransh 596 
  def changeItem(self, orderId, itemId):
597 
    """
598 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
599 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 600 
 
3469 chandransh 601 
    Parameters:
602 
     - orderId
603 
     - itemId
604 
    """
605 
    pass
606 
 
607 
  def shiftToWarehouse(self, orderId, warehouseId):
608 
    """
609 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
610 
 
611 
    Parameters:
612 
     - orderId
613 
     - warehouseId
614 
    """
615 
    pass
616 
 
3986 chandransh 617 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 618 
    """
619 
    Adds the given delay reason to the given order.
3986 chandransh 620 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 621 
    Raises an exception if no order with the given id can be found.
3469 chandransh 622 
 
3553 chandransh 623 
    Parameters:
624 
     - orderId
625 
     - delayReason
3986 chandransh 626 
     - furtherDelay
3553 chandransh 627 
    """
628 
    pass
629 
 
3956 chandransh 630 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
631 
    """
632 
    Marks the COD orders with given AWB nos. as having been processed.
633 
    Updates the captured amount for the corresponding payment.
3553 chandransh 634 
 
3956 chandransh 635 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
636 
    1. There is no order corresponding to an AWB number.
637 
    2. The captured amount for a payment exceeds the total payment.
638 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
639 
 
640 
    Parameters:
641 
     - collectedAmountMap
642 
     - xferBy
643 
     - xferTxnId
644 
     - xferDate
645 
    """
646 
    pass
647 
 
4008 mandeep.dh 648 
  def getTransactionsRequiringExtraProcessing(self, category):
649 
    """
4065 mandeep.dh 650 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 651 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 652 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 653 
 
4008 mandeep.dh 654 
    Parameters:
655 
     - category
656 
    """
657 
    pass
658 
 
659 
  def markTransactionAsProcessed(self, transactionId, category):
660 
    """
661 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 662 
    It essentially deletes the transaction id record for a particular
663 
    processing type category (if present) from DB.
664 
    This is currently used by CRM application.
4008 mandeep.dh 665 
 
666 
    Parameters:
667 
     - transactionId
668 
     - category
669 
    """
670 
    pass
671 
 
4018 chandransh 672 
  def getItemWiseRiskyOrdersCount(self, ):
673 
    """
674 
    Returns a map containing the number of risky orders keyed by item id. A risky order
675 
    is defined as one whose shipping date is about to expire.
676 
    """
677 
    pass
4008 mandeep.dh 678 
 
4295 varun.gupt 679 
  def getOrdersForItemIds(self, itemIds):
680 
    """
681 
    Returns a list of all orders which have items with given id
682 
 
683 
    Parameters:
684 
     - itemIds
685 
    """
686 
    pass
687 
 
4247 rajveer 688 
  def markOrderCancellationRequestReceived(self, orderId):
689 
    """
690 
    Mark order as cancellation request received. If customer sends request of cancellation of
691 
    a particular order, this method will be called. It will just change status of the order
692 
    depending on its current status. It also records the previous status, so that we can move
693 
    back to that status if cancellation request is denied.
4018 chandransh 694 
 
4247 rajveer 695 
    Parameters:
696 
     - orderId
697 
    """
698 
    pass
699 
 
700 
  def markOrderCancellationRequestConfirmed(self, orderId):
701 
    """
702 
    If we decide to to cancel order, CRM will call this method to move the status of order to
703 
    cancellation request confirmed. After this OM will be able to cancel the order.
704 
 
705 
    Parameters:
706 
     - orderId
707 
    """
708 
    pass
709 
 
710 
  def markOrderCancellationRequestDenied(self, orderId):
711 
    """
712 
    If we decide to not to cancel order, we will move the order ro previous status.
713 
 
714 
    Parameters:
715 
     - orderId
716 
    """
717 
    pass
718 
 
4258 rajveer 719 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 720 
    """
4258 rajveer 721 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
722 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 723 
 
724 
    Parameters:
4258 rajveer 725 
     - transactionId
4247 rajveer 726 
    """
727 
    pass
728 
 
4259 anupam.sin 729 
  def refundTransaction(self, transactionId, refundedBy, reason):
730 
    """
731 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
732 
    need to be cancelled
4247 rajveer 733 
 
4259 anupam.sin 734 
    Parameters:
735 
     - transactionId
736 
     - refundedBy
737 
     - reason
738 
    """
739 
    pass
740 
 
4324 mandeep.dh 741 
  def updateShipmentAddress(self, orderId, addressId):
742 
    """
743 
    Updates shipment address of an order. Delivery and shipping date estimates
744 
    etc. are also updated here.
745 
 
746 
    Throws TransactionServiceException in case address change is not
747 
    possible due to certain reasons such as new pincode in address is
748 
    not serviceable etc.
749 
 
750 
    Parameters:
751 
     - orderId
752 
     - addressId
753 
    """
754 
    pass
755 
 
4285 rajveer 756 
  def acceptOrdersForItemId(self, itemId, inventory):
757 
    """
758 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
759 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 760 
 
4285 rajveer 761 
    Parameters:
762 
     - itemId
763 
     - inventory
764 
    """
765 
    pass
766 
 
4369 rajveer 767 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 768 
    """
769 
    Parameters:
770 
     - vendorId
771 
     - itemId
772 
     - quantity
773 
     - estimate
4369 rajveer 774 
     - isReminder
4303 rajveer 775 
    """
776 
    pass
4285 rajveer 777 
 
4369 rajveer 778 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 779 
    """
780 
    Parameters:
781 
     - vendorId
782 
     - itemId
783 
     - quantity
784 
     - estimate
4369 rajveer 785 
     - isReminder
4303 rajveer 786 
    """
787 
    pass
788 
 
4369 rajveer 789 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 790 
    """
791 
    Parameters:
792 
     - vendorId
793 
     - itemId
794 
     - quantity
795 
     - estimate
4369 rajveer 796 
     - isReminder
4303 rajveer 797 
    """
798 
    pass
799 
 
4369 rajveer 800 
  def markOrdersAsTimeout(self, vendorId):
801 
    """
802 
    Parameters:
803 
     - vendorId
804 
    """
805 
    pass
4303 rajveer 806 
 
4386 anupam.sin 807 
  def getOrderForAwb(self, awb):
808 
    """
809 
    Returns the order corresponding to an AWB number
4369 rajveer 810 
 
4386 anupam.sin 811 
    Parameters:
812 
     - awb
813 
    """
814 
    pass
815 
 
816 
 
3376 rajveer 817 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 818 
  def __init__(self, iprot, oprot=None):
3376 rajveer 819 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 820 
 
821 
  def createTransaction(self, transaction):
822 
    """
823 
    Parameters:
824 
     - transaction
825 
    """
826 
    self.send_createTransaction(transaction)
132 ashish 827 
    return self.recv_createTransaction()
94 ashish 828 
 
829 
  def send_createTransaction(self, transaction):
830 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
831 
    args = createTransaction_args()
832 
    args.transaction = transaction
833 
    args.write(self._oprot)
834 
    self._oprot.writeMessageEnd()
835 
    self._oprot.trans.flush()
836 
 
837 
  def recv_createTransaction(self, ):
838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
839 
    if mtype == TMessageType.EXCEPTION:
840 
      x = TApplicationException()
841 
      x.read(self._iprot)
842 
      self._iprot.readMessageEnd()
843 
      raise x
844 
    result = createTransaction_result()
845 
    result.read(self._iprot)
846 
    self._iprot.readMessageEnd()
3431 rajveer 847 
    if result.success is not None:
132 ashish 848 
      return result.success
3431 rajveer 849 
    if result.ex is not None:
94 ashish 850 
      raise result.ex
132 ashish 851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 852 
 
853 
  def getTransaction(self, id):
854 
    """
855 
    Parameters:
856 
     - id
857 
    """
858 
    self.send_getTransaction(id)
859 
    return self.recv_getTransaction()
860 
 
861 
  def send_getTransaction(self, id):
862 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
863 
    args = getTransaction_args()
864 
    args.id = id
865 
    args.write(self._oprot)
866 
    self._oprot.writeMessageEnd()
867 
    self._oprot.trans.flush()
868 
 
869 
  def recv_getTransaction(self, ):
870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
871 
    if mtype == TMessageType.EXCEPTION:
872 
      x = TApplicationException()
873 
      x.read(self._iprot)
874 
      self._iprot.readMessageEnd()
875 
      raise x
876 
    result = getTransaction_result()
877 
    result.read(self._iprot)
878 
    self._iprot.readMessageEnd()
3431 rajveer 879 
    if result.success is not None:
94 ashish 880 
      return result.success
3431 rajveer 881 
    if result.ex is not None:
94 ashish 882 
      raise result.ex
883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
884 
 
885 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
886 
    """
887 
    Parameters:
888 
     - customerId
889 
     - from_date
890 
     - to_date
891 
     - status
892 
    """
893 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
894 
    return self.recv_getTransactionsForCustomer()
895 
 
896 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
897 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
898 
    args = getTransactionsForCustomer_args()
899 
    args.customerId = customerId
900 
    args.from_date = from_date
901 
    args.to_date = to_date
902 
    args.status = status
903 
    args.write(self._oprot)
904 
    self._oprot.writeMessageEnd()
905 
    self._oprot.trans.flush()
906 
 
907 
  def recv_getTransactionsForCustomer(self, ):
908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
909 
    if mtype == TMessageType.EXCEPTION:
910 
      x = TApplicationException()
911 
      x.read(self._iprot)
912 
      self._iprot.readMessageEnd()
913 
      raise x
914 
    result = getTransactionsForCustomer_result()
915 
    result.read(self._iprot)
916 
    self._iprot.readMessageEnd()
3431 rajveer 917 
    if result.success is not None:
94 ashish 918 
      return result.success
3431 rajveer 919 
    if result.ex is not None:
94 ashish 920 
      raise result.ex
921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
922 
 
132 ashish 923 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
924 
    """
925 
    Parameters:
926 
     - shoppingCartId
927 
    """
928 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
929 
    return self.recv_getTransactionsForShoppingCartId()
930 
 
931 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
932 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
933 
    args = getTransactionsForShoppingCartId_args()
934 
    args.shoppingCartId = shoppingCartId
935 
    args.write(self._oprot)
936 
    self._oprot.writeMessageEnd()
937 
    self._oprot.trans.flush()
938 
 
939 
  def recv_getTransactionsForShoppingCartId(self, ):
940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
941 
    if mtype == TMessageType.EXCEPTION:
942 
      x = TApplicationException()
943 
      x.read(self._iprot)
944 
      self._iprot.readMessageEnd()
945 
      raise x
946 
    result = getTransactionsForShoppingCartId_result()
947 
    result.read(self._iprot)
948 
    self._iprot.readMessageEnd()
3431 rajveer 949 
    if result.success is not None:
132 ashish 950 
      return result.success
3431 rajveer 951 
    if result.ex is not None:
132 ashish 952 
      raise result.ex
953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
954 
 
94 ashish 955 
  def getTransactionStatus(self, transactionId):
956 
    """
957 
    Parameters:
958 
     - transactionId
959 
    """
960 
    self.send_getTransactionStatus(transactionId)
961 
    return self.recv_getTransactionStatus()
962 
 
963 
  def send_getTransactionStatus(self, transactionId):
964 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
965 
    args = getTransactionStatus_args()
966 
    args.transactionId = transactionId
967 
    args.write(self._oprot)
968 
    self._oprot.writeMessageEnd()
969 
    self._oprot.trans.flush()
970 
 
971 
  def recv_getTransactionStatus(self, ):
972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
973 
    if mtype == TMessageType.EXCEPTION:
974 
      x = TApplicationException()
975 
      x.read(self._iprot)
976 
      self._iprot.readMessageEnd()
977 
      raise x
978 
    result = getTransactionStatus_result()
979 
    result.read(self._iprot)
980 
    self._iprot.readMessageEnd()
3431 rajveer 981 
    if result.success is not None:
94 ashish 982 
      return result.success
3431 rajveer 983 
    if result.ex is not None:
94 ashish 984 
      raise result.ex
985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
986 
 
987 
  def changeTransactionStatus(self, transactionId, status, description):
988 
    """
989 
    Parameters:
990 
     - transactionId
991 
     - status
992 
     - description
993 
    """
994 
    self.send_changeTransactionStatus(transactionId, status, description)
995 
    return self.recv_changeTransactionStatus()
996 
 
997 
  def send_changeTransactionStatus(self, transactionId, status, description):
998 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
999 
    args = changeTransactionStatus_args()
1000 
    args.transactionId = transactionId
1001 
    args.status = status
1002 
    args.description = description
1003 
    args.write(self._oprot)
1004 
    self._oprot.writeMessageEnd()
1005 
    self._oprot.trans.flush()
1006 
 
1007 
  def recv_changeTransactionStatus(self, ):
1008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1009 
    if mtype == TMessageType.EXCEPTION:
1010 
      x = TApplicationException()
1011 
      x.read(self._iprot)
1012 
      self._iprot.readMessageEnd()
1013 
      raise x
1014 
    result = changeTransactionStatus_result()
1015 
    result.read(self._iprot)
1016 
    self._iprot.readMessageEnd()
3431 rajveer 1017 
    if result.success is not None:
94 ashish 1018 
      return result.success
3431 rajveer 1019 
    if result.ex is not None:
94 ashish 1020 
      raise result.ex
1021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1022 
 
1398 varun.gupt 1023 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1024 
    """
1025 
    Parameters:
1026 
     - transactionId
1027 
    """
1398 varun.gupt 1028 
    self.send_enqueueTransactionInfoEmail(transactionId)
1029 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1030 
 
1398 varun.gupt 1031 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1032 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1033 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1034 
    args.transactionId = transactionId
1035 
    args.write(self._oprot)
1036 
    self._oprot.writeMessageEnd()
1037 
    self._oprot.trans.flush()
1038 
 
1398 varun.gupt 1039 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1041 
    if mtype == TMessageType.EXCEPTION:
1042 
      x = TApplicationException()
1043 
      x.read(self._iprot)
1044 
      self._iprot.readMessageEnd()
1045 
      raise x
1398 varun.gupt 1046 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1047 
    result.read(self._iprot)
1048 
    self._iprot.readMessageEnd()
3431 rajveer 1049 
    if result.success is not None:
1382 varun.gupt 1050 
      return result.success
3431 rajveer 1051 
    if result.ex is not None:
1382 varun.gupt 1052 
      raise result.ex
1398 varun.gupt 1053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1054 
 
483 rajveer 1055 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1056 
    """
1057 
    Parameters:
483 rajveer 1058 
     - status
1059 
     - from_date
1060 
     - to_date
1061 
     - warehouse_id
94 ashish 1062 
    """
483 rajveer 1063 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1064 
    return self.recv_getAllOrders()
94 ashish 1065 
 
483 rajveer 1066 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1067 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1068 
    args = getAllOrders_args()
1069 
    args.status = status
1070 
    args.from_date = from_date
1071 
    args.to_date = to_date
1072 
    args.warehouse_id = warehouse_id
94 ashish 1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
483 rajveer 1077 
  def recv_getAllOrders(self, ):
94 ashish 1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
483 rajveer 1084 
    result = getAllOrders_result()
94 ashish 1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
3431 rajveer 1087 
    if result.success is not None:
94 ashish 1088 
      return result.success
3431 rajveer 1089 
    if result.ex is not None:
94 ashish 1090 
      raise result.ex
483 rajveer 1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1092 
 
4133 chandransh 1093 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1094 
    """
1095 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1096 
    Pass the status as null and the limit as 0 to ignore them.
1097 
 
1098 
    Parameters:
1099 
     - statuses
1100 
     - offset
1101 
     - limit
1102 
     - warehouse_id
1103 
    """
1104 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1105 
    return self.recv_getOrdersInBatch()
1106 
 
1107 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1108 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1109 
    args = getOrdersInBatch_args()
1110 
    args.statuses = statuses
1111 
    args.offset = offset
1112 
    args.limit = limit
1113 
    args.warehouse_id = warehouse_id
1114 
    args.write(self._oprot)
1115 
    self._oprot.writeMessageEnd()
1116 
    self._oprot.trans.flush()
1117 
 
1118 
  def recv_getOrdersInBatch(self, ):
1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1120 
    if mtype == TMessageType.EXCEPTION:
1121 
      x = TApplicationException()
1122 
      x.read(self._iprot)
1123 
      self._iprot.readMessageEnd()
1124 
      raise x
1125 
    result = getOrdersInBatch_result()
1126 
    result.read(self._iprot)
1127 
    self._iprot.readMessageEnd()
1128 
    if result.success is not None:
1129 
      return result.success
1130 
    if result.ex is not None:
1131 
      raise result.ex
1132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1133 
 
1134 
  def getOrderCount(self, statuses, warehouseId):
1135 
    """
1136 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1137 
 
1138 
    Parameters:
1139 
     - statuses
1140 
     - warehouseId
1141 
    """
1142 
    self.send_getOrderCount(statuses, warehouseId)
1143 
    return self.recv_getOrderCount()
1144 
 
1145 
  def send_getOrderCount(self, statuses, warehouseId):
1146 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1147 
    args = getOrderCount_args()
1148 
    args.statuses = statuses
1149 
    args.warehouseId = warehouseId
1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_getOrderCount(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 = getOrderCount_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
1164 
    if result.success is not None:
1165 
      return result.success
1166 
    if result.ex is not None:
1167 
      raise result.ex
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1169 
 
999 varun.gupt 1170 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1171 
    """
1132 chandransh 1172 
    Returns orders within a range of their billing dates
3431 rajveer 1173 
 
999 varun.gupt 1174 
    Parameters:
1175 
     - status
1176 
     - start_billing_date
1177 
     - end_billing_date
1178 
     - warehouse_id
1179 
    """
1180 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1181 
    return self.recv_getOrdersByBillingDate()
1182 
 
1183 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1184 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1185 
    args = getOrdersByBillingDate_args()
1186 
    args.status = status
1187 
    args.start_billing_date = start_billing_date
1188 
    args.end_billing_date = end_billing_date
1189 
    args.warehouse_id = warehouse_id
1190 
    args.write(self._oprot)
1191 
    self._oprot.writeMessageEnd()
1192 
    self._oprot.trans.flush()
1193 
 
1194 
  def recv_getOrdersByBillingDate(self, ):
1195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1196 
    if mtype == TMessageType.EXCEPTION:
1197 
      x = TApplicationException()
1198 
      x.read(self._iprot)
1199 
      self._iprot.readMessageEnd()
1200 
      raise x
1201 
    result = getOrdersByBillingDate_result()
1202 
    result.read(self._iprot)
1203 
    self._iprot.readMessageEnd()
3431 rajveer 1204 
    if result.success is not None:
999 varun.gupt 1205 
      return result.success
3431 rajveer 1206 
    if result.ex is not None:
999 varun.gupt 1207 
      raise result.ex
1208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1209 
 
3451 chandransh 1210 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1211 
    """
1212 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1213 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1214 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1215 
 
3427 chandransh 1216 
    Parameters:
1217 
     - fromShippingDate
1218 
     - toShippingDate
1219 
     - providerId
1220 
     - warehouseId
3451 chandransh 1221 
     - cod
3427 chandransh 1222 
    """
3451 chandransh 1223 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1224 
    return self.recv_getOrdersByShippingDate()
1225 
 
3451 chandransh 1226 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1227 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1228 
    args = getOrdersByShippingDate_args()
1229 
    args.fromShippingDate = fromShippingDate
1230 
    args.toShippingDate = toShippingDate
1231 
    args.providerId = providerId
1232 
    args.warehouseId = warehouseId
3451 chandransh 1233 
    args.cod = cod
3427 chandransh 1234 
    args.write(self._oprot)
1235 
    self._oprot.writeMessageEnd()
1236 
    self._oprot.trans.flush()
1237 
 
1238 
  def recv_getOrdersByShippingDate(self, ):
1239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1240 
    if mtype == TMessageType.EXCEPTION:
1241 
      x = TApplicationException()
1242 
      x.read(self._iprot)
1243 
      self._iprot.readMessageEnd()
1244 
      raise x
1245 
    result = getOrdersByShippingDate_result()
1246 
    result.read(self._iprot)
1247 
    self._iprot.readMessageEnd()
3431 rajveer 1248 
    if result.success is not None:
3427 chandransh 1249 
      return result.success
3431 rajveer 1250 
    if result.ex is not None:
3427 chandransh 1251 
      raise result.ex
1252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1253 
 
1382 varun.gupt 1254 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1255 
    """
1256 
    Returns order ids for orders which can be returned
3431 rajveer 1257 
 
1382 varun.gupt 1258 
    Parameters:
1259 
     - customer_id
1260 
     - limit
1261 
    """
1262 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1263 
    return self.recv_getReturnableOrdersForCustomer()
1264 
 
1265 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1266 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1267 
    args = getReturnableOrdersForCustomer_args()
1268 
    args.customer_id = customer_id
1269 
    args.limit = limit
1270 
    args.write(self._oprot)
1271 
    self._oprot.writeMessageEnd()
1272 
    self._oprot.trans.flush()
1273 
 
1274 
  def recv_getReturnableOrdersForCustomer(self, ):
1275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1276 
    if mtype == TMessageType.EXCEPTION:
1277 
      x = TApplicationException()
1278 
      x.read(self._iprot)
1279 
      self._iprot.readMessageEnd()
1280 
      raise x
1281 
    result = getReturnableOrdersForCustomer_result()
1282 
    result.read(self._iprot)
1283 
    self._iprot.readMessageEnd()
3431 rajveer 1284 
    if result.success is not None:
1382 varun.gupt 1285 
      return result.success
3431 rajveer 1286 
    if result.ex is not None:
1382 varun.gupt 1287 
      raise result.ex
1288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1289 
 
1290 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1291 
    """
1292 
    Returns order ids for orders which can be cancelled
3431 rajveer 1293 
 
1382 varun.gupt 1294 
    Parameters:
1295 
     - customer_id
1296 
     - limit
1297 
    """
1298 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1299 
    return self.recv_getCancellableOrdersForCustomer()
1300 
 
1301 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1302 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1303 
    args = getCancellableOrdersForCustomer_args()
1304 
    args.customer_id = customer_id
1305 
    args.limit = limit
1306 
    args.write(self._oprot)
1307 
    self._oprot.writeMessageEnd()
1308 
    self._oprot.trans.flush()
1309 
 
1310 
  def recv_getCancellableOrdersForCustomer(self, ):
1311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1312 
    if mtype == TMessageType.EXCEPTION:
1313 
      x = TApplicationException()
1314 
      x.read(self._iprot)
1315 
      self._iprot.readMessageEnd()
1316 
      raise x
1317 
    result = getCancellableOrdersForCustomer_result()
1318 
    result.read(self._iprot)
1319 
    self._iprot.readMessageEnd()
3431 rajveer 1320 
    if result.success is not None:
1382 varun.gupt 1321 
      return result.success
3431 rajveer 1322 
    if result.ex is not None:
1382 varun.gupt 1323 
      raise result.ex
1324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1325 
 
483 rajveer 1326 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1327 
    """
1328 
    Parameters:
483 rajveer 1329 
     - orderId
1330 
     - status
1331 
     - description
94 ashish 1332 
    """
483 rajveer 1333 
    self.send_changeOrderStatus(orderId, status, description)
1334 
    return self.recv_changeOrderStatus()
94 ashish 1335 
 
483 rajveer 1336 
  def send_changeOrderStatus(self, orderId, status, description):
1337 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1338 
    args = changeOrderStatus_args()
1339 
    args.orderId = orderId
1340 
    args.status = status
1341 
    args.description = description
94 ashish 1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
483 rajveer 1346 
  def recv_changeOrderStatus(self, ):
94 ashish 1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
483 rajveer 1353 
    result = changeOrderStatus_result()
94 ashish 1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
3431 rajveer 1356 
    if result.success is not None:
94 ashish 1357 
      return result.success
3431 rajveer 1358 
    if result.ex is not None:
94 ashish 1359 
      raise result.ex
483 rajveer 1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1361 
 
1528 ankur.sing 1362 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1363 
    """
1528 ankur.sing 1364 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1365 
    only user who owns the transaction can view its order details.
3431 rajveer 1366 
 
94 ashish 1367 
    Parameters:
1368 
     - transactionId
1528 ankur.sing 1369 
     - customerId
94 ashish 1370 
    """
1528 ankur.sing 1371 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1372 
    return self.recv_getOrdersForTransaction()
94 ashish 1373 
 
1528 ankur.sing 1374 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1375 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1376 
    args = getOrdersForTransaction_args()
94 ashish 1377 
    args.transactionId = transactionId
1528 ankur.sing 1378 
    args.customerId = customerId
94 ashish 1379 
    args.write(self._oprot)
1380 
    self._oprot.writeMessageEnd()
1381 
    self._oprot.trans.flush()
1382 
 
483 rajveer 1383 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1385 
    if mtype == TMessageType.EXCEPTION:
1386 
      x = TApplicationException()
1387 
      x.read(self._iprot)
1388 
      self._iprot.readMessageEnd()
1389 
      raise x
483 rajveer 1390 
    result = getOrdersForTransaction_result()
94 ashish 1391 
    result.read(self._iprot)
1392 
    self._iprot.readMessageEnd()
3431 rajveer 1393 
    if result.success is not None:
94 ashish 1394 
      return result.success
3431 rajveer 1395 
    if result.ex is not None:
94 ashish 1396 
      raise result.ex
483 rajveer 1397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1398 
 
3014 chandransh 1399 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1400 
    """
3014 chandransh 1401 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1402 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1403 
 
94 ashish 1404 
    Parameters:
483 rajveer 1405 
     - customerId
1406 
     - from_date
1407 
     - to_date
3014 chandransh 1408 
     - statuses
94 ashish 1409 
    """
3014 chandransh 1410 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1411 
    return self.recv_getOrdersForCustomer()
94 ashish 1412 
 
3014 chandransh 1413 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1414 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1415 
    args = getOrdersForCustomer_args()
1416 
    args.customerId = customerId
1417 
    args.from_date = from_date
1418 
    args.to_date = to_date
3014 chandransh 1419 
    args.statuses = statuses
94 ashish 1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
483 rajveer 1424 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
483 rajveer 1431 
    result = getOrdersForCustomer_result()
94 ashish 1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
3431 rajveer 1434 
    if result.success is not None:
94 ashish 1435 
      return result.success
3431 rajveer 1436 
    if result.ex is not None:
94 ashish 1437 
      raise result.ex
483 rajveer 1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1439 
 
483 rajveer 1440 
  def createOrder(self, order):
94 ashish 1441 
    """
1442 
    Parameters:
483 rajveer 1443 
     - order
94 ashish 1444 
    """
483 rajveer 1445 
    self.send_createOrder(order)
1446 
    return self.recv_createOrder()
94 ashish 1447 
 
483 rajveer 1448 
  def send_createOrder(self, order):
1449 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1450 
    args = createOrder_args()
1451 
    args.order = order
94 ashish 1452 
    args.write(self._oprot)
1453 
    self._oprot.writeMessageEnd()
1454 
    self._oprot.trans.flush()
1455 
 
483 rajveer 1456 
  def recv_createOrder(self, ):
94 ashish 1457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1458 
    if mtype == TMessageType.EXCEPTION:
1459 
      x = TApplicationException()
1460 
      x.read(self._iprot)
1461 
      self._iprot.readMessageEnd()
1462 
      raise x
483 rajveer 1463 
    result = createOrder_result()
94 ashish 1464 
    result.read(self._iprot)
1465 
    self._iprot.readMessageEnd()
3431 rajveer 1466 
    if result.success is not None:
94 ashish 1467 
      return result.success
3431 rajveer 1468 
    if result.ex is not None:
94 ashish 1469 
      raise result.ex
483 rajveer 1470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1471 
 
483 rajveer 1472 
  def getOrder(self, id):
94 ashish 1473 
    """
1474 
    Parameters:
483 rajveer 1475 
     - id
94 ashish 1476 
    """
483 rajveer 1477 
    self.send_getOrder(id)
1478 
    return self.recv_getOrder()
94 ashish 1479 
 
483 rajveer 1480 
  def send_getOrder(self, id):
1481 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1482 
    args = getOrder_args()
1483 
    args.id = id
94 ashish 1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
483 rajveer 1488 
  def recv_getOrder(self, ):
94 ashish 1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
483 rajveer 1495 
    result = getOrder_result()
94 ashish 1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
3431 rajveer 1498 
    if result.success is not None:
94 ashish 1499 
      return result.success
3431 rajveer 1500 
    if result.ex is not None:
94 ashish 1501 
      raise result.ex
483 rajveer 1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1503 
 
483 rajveer 1504 
  def getLineItemsForOrder(self, orderId):
94 ashish 1505 
    """
1506 
    Parameters:
483 rajveer 1507 
     - orderId
94 ashish 1508 
    """
483 rajveer 1509 
    self.send_getLineItemsForOrder(orderId)
1510 
    return self.recv_getLineItemsForOrder()
94 ashish 1511 
 
483 rajveer 1512 
  def send_getLineItemsForOrder(self, orderId):
1513 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1514 
    args = getLineItemsForOrder_args()
1515 
    args.orderId = orderId
94 ashish 1516 
    args.write(self._oprot)
1517 
    self._oprot.writeMessageEnd()
1518 
    self._oprot.trans.flush()
1519 
 
483 rajveer 1520 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1522 
    if mtype == TMessageType.EXCEPTION:
1523 
      x = TApplicationException()
1524 
      x.read(self._iprot)
1525 
      self._iprot.readMessageEnd()
1526 
      raise x
483 rajveer 1527 
    result = getLineItemsForOrder_result()
94 ashish 1528 
    result.read(self._iprot)
1529 
    self._iprot.readMessageEnd()
3431 rajveer 1530 
    if result.success is not None:
94 ashish 1531 
      return result.success
3431 rajveer 1532 
    if result.ex is not None:
94 ashish 1533 
      raise result.ex
483 rajveer 1534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1535 
 
1528 ankur.sing 1536 
  def getOrderForCustomer(self, orderId, customerId):
1537 
    """
1538 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1539 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1540 
 
1528 ankur.sing 1541 
    Parameters:
1542 
     - orderId
1543 
     - customerId
1544 
    """
1545 
    self.send_getOrderForCustomer(orderId, customerId)
1546 
    return self.recv_getOrderForCustomer()
1547 
 
1548 
  def send_getOrderForCustomer(self, orderId, customerId):
1549 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1550 
    args = getOrderForCustomer_args()
1551 
    args.orderId = orderId
1552 
    args.customerId = customerId
1553 
    args.write(self._oprot)
1554 
    self._oprot.writeMessageEnd()
1555 
    self._oprot.trans.flush()
1556 
 
1557 
  def recv_getOrderForCustomer(self, ):
1558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1559 
    if mtype == TMessageType.EXCEPTION:
1560 
      x = TApplicationException()
1561 
      x.read(self._iprot)
1562 
      self._iprot.readMessageEnd()
1563 
      raise x
1564 
    result = getOrderForCustomer_result()
1565 
    result.read(self._iprot)
1566 
    self._iprot.readMessageEnd()
3431 rajveer 1567 
    if result.success is not None:
1528 ankur.sing 1568 
      return result.success
3431 rajveer 1569 
    if result.ex is not None:
1528 ankur.sing 1570 
      raise result.ex
1571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1572 
 
4444 rajveer 1573 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1574 
    """
1575 
    Parameters:
4394 rajveer 1576 
     - type
4444 rajveer 1577 
     - warehouseId
4394 rajveer 1578 
     - status
1579 
     - timestamp
3064 chandransh 1580 
    """
4444 rajveer 1581 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1582 
    return self.recv_getAlerts()
1583 
 
4444 rajveer 1584 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1585 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1586 
    args = getAlerts_args()
4394 rajveer 1587 
    args.type = type
4444 rajveer 1588 
    args.warehouseId = warehouseId
4394 rajveer 1589 
    args.status = status
1590 
    args.timestamp = timestamp
3064 chandransh 1591 
    args.write(self._oprot)
1592 
    self._oprot.writeMessageEnd()
1593 
    self._oprot.trans.flush()
1594 
 
1595 
  def recv_getAlerts(self, ):
1596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1597 
    if mtype == TMessageType.EXCEPTION:
1598 
      x = TApplicationException()
1599 
      x.read(self._iprot)
1600 
      self._iprot.readMessageEnd()
1601 
      raise x
1602 
    result = getAlerts_result()
1603 
    result.read(self._iprot)
1604 
    self._iprot.readMessageEnd()
3431 rajveer 1605 
    if result.success is not None:
3064 chandransh 1606 
      return result.success
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1608 
 
4444 rajveer 1609 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1610 
    """
1611 
    Parameters:
1612 
     - type
4444 rajveer 1613 
     - warehouseId
4394 rajveer 1614 
     - description
3064 chandransh 1615 
    """
4444 rajveer 1616 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1617 
    self.recv_addAlert()
3064 chandransh 1618 
 
4444 rajveer 1619 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1620 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1621 
    args = addAlert_args()
3064 chandransh 1622 
    args.type = type
4444 rajveer 1623 
    args.warehouseId = warehouseId
4394 rajveer 1624 
    args.description = description
3064 chandransh 1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
4394 rajveer 1629 
  def recv_addAlert(self, ):
3064 chandransh 1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
4394 rajveer 1636 
    result = addAlert_result()
3064 chandransh 1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
1639 
    return
1640 
 
4444 rajveer 1641 
  def markAlertsAsSeen(self, warehouseId):
1642 
    """
1643 
    Parameters:
1644 
     - warehouseId
1645 
    """
1646 
    self.send_markAlertsAsSeen(warehouseId)
1647 
    self.recv_markAlertsAsSeen()
1648 
 
1649 
  def send_markAlertsAsSeen(self, warehouseId):
1650 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1651 
    args = markAlertsAsSeen_args()
1652 
    args.warehouseId = warehouseId
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_markAlertsAsSeen(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = markAlertsAsSeen_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    return
1668 
 
3064 chandransh 1669 
  def getValidOrderCount(self, ):
1670 
    """
1671 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1672 
    """
1673 
    self.send_getValidOrderCount()
1674 
    return self.recv_getValidOrderCount()
1675 
 
1676 
  def send_getValidOrderCount(self, ):
1677 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1678 
    args = getValidOrderCount_args()
1679 
    args.write(self._oprot)
1680 
    self._oprot.writeMessageEnd()
1681 
    self._oprot.trans.flush()
1682 
 
1683 
  def recv_getValidOrderCount(self, ):
1684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1685 
    if mtype == TMessageType.EXCEPTION:
1686 
      x = TApplicationException()
1687 
      x.read(self._iprot)
1688 
      self._iprot.readMessageEnd()
1689 
      raise x
1690 
    result = getValidOrderCount_result()
1691 
    result.read(self._iprot)
1692 
    self._iprot.readMessageEnd()
3431 rajveer 1693 
    if result.success is not None:
3064 chandransh 1694 
      return result.success
1695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1696 
 
1697 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1698 
    """
1699 
    Returns the number of distinct customers who have done successful transactions
1700 
    """
1701 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1702 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1703 
 
1704 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1705 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1706 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1707 
    args.write(self._oprot)
1708 
    self._oprot.writeMessageEnd()
1709 
    self._oprot.trans.flush()
1710 
 
1711 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1713 
    if mtype == TMessageType.EXCEPTION:
1714 
      x = TApplicationException()
1715 
      x.read(self._iprot)
1716 
      self._iprot.readMessageEnd()
1717 
      raise x
1718 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1719 
    result.read(self._iprot)
1720 
    self._iprot.readMessageEnd()
3431 rajveer 1721 
    if result.success is not None:
3064 chandransh 1722 
      return result.success
1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1724 
 
1725 
  def getValidOrdersAmountRange(self, ):
1726 
    """
1727 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1728 
    List contains two values, first minimum amount and second maximum amount.
1729 
    """
1730 
    self.send_getValidOrdersAmountRange()
1731 
    return self.recv_getValidOrdersAmountRange()
1732 
 
1733 
  def send_getValidOrdersAmountRange(self, ):
1734 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1735 
    args = getValidOrdersAmountRange_args()
1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
1740 
  def recv_getValidOrdersAmountRange(self, ):
1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
1747 
    result = getValidOrdersAmountRange_result()
1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
3431 rajveer 1750 
    if result.success is not None:
3064 chandransh 1751 
      return result.success
1752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1753 
 
1754 
  def getValidOrders(self, limit):
1755 
    """
1756 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1757 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1758 
 
3064 chandransh 1759 
    Parameters:
1760 
     - limit
1761 
    """
1762 
    self.send_getValidOrders(limit)
1763 
    return self.recv_getValidOrders()
1764 
 
1765 
  def send_getValidOrders(self, limit):
1766 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1767 
    args = getValidOrders_args()
1768 
    args.limit = limit
1769 
    args.write(self._oprot)
1770 
    self._oprot.writeMessageEnd()
1771 
    self._oprot.trans.flush()
1772 
 
1773 
  def recv_getValidOrders(self, ):
1774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1775 
    if mtype == TMessageType.EXCEPTION:
1776 
      x = TApplicationException()
1777 
      x.read(self._iprot)
1778 
      self._iprot.readMessageEnd()
1779 
      raise x
1780 
    result = getValidOrders_result()
1781 
    result.read(self._iprot)
1782 
    self._iprot.readMessageEnd()
3431 rajveer 1783 
    if result.success is not None:
3064 chandransh 1784 
      return result.success
1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1786 
 
1220 chandransh 1787 
  def batchOrders(self, warehouseId):
1788 
    """
1789 
    Create a batch of all the pending orders for the given warehouse.
1790 
    The returned list is orderd by created_timestamp.
1791 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1792 
 
1220 chandransh 1793 
    Parameters:
1794 
     - warehouseId
1795 
    """
1796 
    self.send_batchOrders(warehouseId)
1797 
    return self.recv_batchOrders()
1798 
 
1799 
  def send_batchOrders(self, warehouseId):
1800 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1801 
    args = batchOrders_args()
1802 
    args.warehouseId = warehouseId
1803 
    args.write(self._oprot)
1804 
    self._oprot.writeMessageEnd()
1805 
    self._oprot.trans.flush()
1806 
 
1807 
  def recv_batchOrders(self, ):
1808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1809 
    if mtype == TMessageType.EXCEPTION:
1810 
      x = TApplicationException()
1811 
      x.read(self._iprot)
1812 
      self._iprot.readMessageEnd()
1813 
      raise x
1814 
    result = batchOrders_result()
1815 
    result.read(self._iprot)
1816 
    self._iprot.readMessageEnd()
3431 rajveer 1817 
    if result.success is not None:
1220 chandransh 1818 
      return result.success
3431 rajveer 1819 
    if result.ex is not None:
1220 chandransh 1820 
      raise result.ex
1821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1822 
 
1208 chandransh 1823 
  def markOrderAsOutOfStock(self, orderId):
1824 
    """
1825 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1826 
 
1208 chandransh 1827 
    Parameters:
1828 
     - orderId
1829 
    """
1830 
    self.send_markOrderAsOutOfStock(orderId)
1831 
    return self.recv_markOrderAsOutOfStock()
1832 
 
1833 
  def send_markOrderAsOutOfStock(self, orderId):
1834 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1835 
    args = markOrderAsOutOfStock_args()
1836 
    args.orderId = orderId
1837 
    args.write(self._oprot)
1838 
    self._oprot.writeMessageEnd()
1839 
    self._oprot.trans.flush()
1840 
 
1841 
  def recv_markOrderAsOutOfStock(self, ):
1842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1843 
    if mtype == TMessageType.EXCEPTION:
1844 
      x = TApplicationException()
1845 
      x.read(self._iprot)
1846 
      self._iprot.readMessageEnd()
1847 
      raise x
1848 
    result = markOrderAsOutOfStock_result()
1849 
    result.read(self._iprot)
1850 
    self._iprot.readMessageEnd()
3431 rajveer 1851 
    if result.success is not None:
1208 chandransh 1852 
      return result.success
3431 rajveer 1853 
    if result.ex is not None:
1208 chandransh 1854 
      raise result.ex
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1856 
 
3064 chandransh 1857 
  def verifyOrder(self, orderId):
759 chandransh 1858 
    """
3064 chandransh 1859 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1860 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1861 
    used for all other orders as well.
1862 
    Throws an exception if no such order exists.
3431 rajveer 1863 
 
759 chandransh 1864 
    Parameters:
3064 chandransh 1865 
     - orderId
759 chandransh 1866 
    """
3064 chandransh 1867 
    self.send_verifyOrder(orderId)
1868 
    return self.recv_verifyOrder()
759 chandransh 1869 
 
3064 chandransh 1870 
  def send_verifyOrder(self, orderId):
1871 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1872 
    args = verifyOrder_args()
1873 
    args.orderId = orderId
759 chandransh 1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
3064 chandransh 1878 
  def recv_verifyOrder(self, ):
759 chandransh 1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
3064 chandransh 1885 
    result = verifyOrder_result()
759 chandransh 1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
759 chandransh 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
759 chandransh 1891 
      raise result.ex
3064 chandransh 1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1893 
 
3064 chandransh 1894 
  def acceptOrder(self, orderId):
1113 chandransh 1895 
    """
3064 chandransh 1896 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1897 
    given order is not a COD order, it also captures the payment if the same has
1898 
    not been captured.
1899 
    Throws an exception if no such order exists.
3431 rajveer 1900 
 
1113 chandransh 1901 
    Parameters:
3064 chandransh 1902 
     - orderId
1113 chandransh 1903 
    """
3064 chandransh 1904 
    self.send_acceptOrder(orderId)
1905 
    return self.recv_acceptOrder()
1113 chandransh 1906 
 
3064 chandransh 1907 
  def send_acceptOrder(self, orderId):
1908 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1909 
    args = acceptOrder_args()
1910 
    args.orderId = orderId
1113 chandransh 1911 
    args.write(self._oprot)
1912 
    self._oprot.writeMessageEnd()
1913 
    self._oprot.trans.flush()
1914 
 
3064 chandransh 1915 
  def recv_acceptOrder(self, ):
1113 chandransh 1916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1917 
    if mtype == TMessageType.EXCEPTION:
1918 
      x = TApplicationException()
1919 
      x.read(self._iprot)
1920 
      self._iprot.readMessageEnd()
1921 
      raise x
3064 chandransh 1922 
    result = acceptOrder_result()
1113 chandransh 1923 
    result.read(self._iprot)
1924 
    self._iprot.readMessageEnd()
3431 rajveer 1925 
    if result.success is not None:
1113 chandransh 1926 
      return result.success
3431 rajveer 1927 
    if result.ex is not None:
1113 chandransh 1928 
      raise result.ex
3064 chandransh 1929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1930 
 
4283 anupam.sin 1931 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1932 
    """
3064 chandransh 1933 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1934 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1935 
    the IMEI no. if a -1 is supplied.
1936 
    Also, it generates an invoice number for the order, marks the order as
1937 
    BILLED and sets the billing timestamp.
1938 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1939 
 
1135 chandransh 1940 
    Parameters:
3064 chandransh 1941 
     - orderId
1942 
     - invoice_number
4283 anupam.sin 1943 
     - imeiNumber
1944 
     - itemNumber
3064 chandransh 1945 
     - billed_by
4264 rajveer 1946 
     - jacketNumber
4283 anupam.sin 1947 
     - billingType
1948 
     - vendorId
1135 chandransh 1949 
    """
4283 anupam.sin 1950 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1951 
    return self.recv_addBillingDetails()
1135 chandransh 1952 
 
4283 anupam.sin 1953 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1954 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1955 
    args = addBillingDetails_args()
1956 
    args.orderId = orderId
1957 
    args.invoice_number = invoice_number
4283 anupam.sin 1958 
    args.imeiNumber = imeiNumber
1959 
    args.itemNumber = itemNumber
3064 chandransh 1960 
    args.billed_by = billed_by
4264 rajveer 1961 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1962 
    args.billingType = billingType
1963 
    args.vendorId = vendorId
1135 chandransh 1964 
    args.write(self._oprot)
1965 
    self._oprot.writeMessageEnd()
1966 
    self._oprot.trans.flush()
1967 
 
3064 chandransh 1968 
  def recv_addBillingDetails(self, ):
1135 chandransh 1969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1970 
    if mtype == TMessageType.EXCEPTION:
1971 
      x = TApplicationException()
1972 
      x.read(self._iprot)
1973 
      self._iprot.readMessageEnd()
1974 
      raise x
3064 chandransh 1975 
    result = addBillingDetails_result()
1135 chandransh 1976 
    result.read(self._iprot)
1977 
    self._iprot.readMessageEnd()
3431 rajveer 1978 
    if result.success is not None:
3064 chandransh 1979 
      return result.success
3431 rajveer 1980 
    if result.ex is not None:
1135 chandransh 1981 
      raise result.ex
3064 chandransh 1982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 1983 
 
3064 chandransh 1984 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 1985 
    """
3064 chandransh 1986 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 1987 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 1988 
 
1408 ankur.sing 1989 
    Parameters:
3064 chandransh 1990 
     - warehouseId
1408 ankur.sing 1991 
     - providerId
3064 chandransh 1992 
     - cod
1408 ankur.sing 1993 
    """
3064 chandransh 1994 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
1995 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 1996 
 
3064 chandransh 1997 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
1998 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1999 
    args = markOrdersAsManifested_args()
2000 
    args.warehouseId = warehouseId
1408 ankur.sing 2001 
    args.providerId = providerId
3064 chandransh 2002 
    args.cod = cod
1408 ankur.sing 2003 
    args.write(self._oprot)
2004 
    self._oprot.writeMessageEnd()
2005 
    self._oprot.trans.flush()
2006 
 
3064 chandransh 2007 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2009 
    if mtype == TMessageType.EXCEPTION:
2010 
      x = TApplicationException()
2011 
      x.read(self._iprot)
2012 
      self._iprot.readMessageEnd()
2013 
      raise x
3064 chandransh 2014 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2015 
    result.read(self._iprot)
2016 
    self._iprot.readMessageEnd()
3431 rajveer 2017 
    if result.success is not None:
1408 ankur.sing 2018 
      return result.success
3431 rajveer 2019 
    if result.ex is not None:
3064 chandransh 2020 
      raise result.ex
2021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2022 
 
4410 rajveer 2023 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2024 
    """
2025 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2026 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2027 
 
2028 
    Parameters:
2029 
     - warehouseId
2030 
     - providerId
2031 
     - cod
2032 
    """
2033 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2034 
    return self.recv_markOrdersAsShippedFromWarehouse()
2035 
 
2036 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2037 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2038 
    args = markOrdersAsShippedFromWarehouse_args()
2039 
    args.warehouseId = warehouseId
2040 
    args.providerId = providerId
2041 
    args.cod = cod
2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
2046 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
2053 
    result = markOrdersAsShippedFromWarehouse_result()
2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
2056 
    if result.success is not None:
2057 
      return result.success
2058 
    if result.ex is not None:
2059 
      raise result.ex
2060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2061 
 
3064 chandransh 2062 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2063 
    """
3064 chandransh 2064 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2065 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2066 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2067 
 
94 ashish 2068 
    Parameters:
3064 chandransh 2069 
     - providerId
2070 
     - pickupDetails
304 ashish 2071 
    """
3064 chandransh 2072 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2073 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2074 
 
3064 chandransh 2075 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2076 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2077 
    args = markOrdersAsPickedUp_args()
2078 
    args.providerId = providerId
2079 
    args.pickupDetails = pickupDetails
304 ashish 2080 
    args.write(self._oprot)
2081 
    self._oprot.writeMessageEnd()
2082 
    self._oprot.trans.flush()
2083 
 
3064 chandransh 2084 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2086 
    if mtype == TMessageType.EXCEPTION:
2087 
      x = TApplicationException()
2088 
      x.read(self._iprot)
2089 
      self._iprot.readMessageEnd()
2090 
      raise x
3064 chandransh 2091 
    result = markOrdersAsPickedUp_result()
304 ashish 2092 
    result.read(self._iprot)
2093 
    self._iprot.readMessageEnd()
3431 rajveer 2094 
    if result.success is not None:
304 ashish 2095 
      return result.success
3431 rajveer 2096 
    if result.ex is not None:
3064 chandransh 2097 
      raise result.ex
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2099 
 
3064 chandransh 2100 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2101 
    """
3064 chandransh 2102 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2103 
    the name of the receiver.
2104 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2105 
 
304 ashish 2106 
    Parameters:
3064 chandransh 2107 
     - providerId
2108 
     - deliveredOrders
304 ashish 2109 
    """
3064 chandransh 2110 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2111 
    self.recv_markOrdersAsDelivered()
304 ashish 2112 
 
3064 chandransh 2113 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2114 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2115 
    args = markOrdersAsDelivered_args()
2116 
    args.providerId = providerId
2117 
    args.deliveredOrders = deliveredOrders
304 ashish 2118 
    args.write(self._oprot)
2119 
    self._oprot.writeMessageEnd()
2120 
    self._oprot.trans.flush()
2121 
 
3064 chandransh 2122 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2124 
    if mtype == TMessageType.EXCEPTION:
2125 
      x = TApplicationException()
2126 
      x.read(self._iprot)
2127 
      self._iprot.readMessageEnd()
2128 
      raise x
3064 chandransh 2129 
    result = markOrdersAsDelivered_result()
304 ashish 2130 
    result.read(self._iprot)
2131 
    self._iprot.readMessageEnd()
3431 rajveer 2132 
    if result.ex is not None:
3064 chandransh 2133 
      raise result.ex
304 ashish 2134 
    return
2135 
 
3064 chandransh 2136 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2137 
    """
3064 chandransh 2138 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2139 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2140 
 
3064 chandransh 2141 
    Parameters:
2142 
     - providerId
2143 
     - returnedOrders
1596 ankur.sing 2144 
    """
3064 chandransh 2145 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2146 
    self.recv_markOrdersAsFailed()
304 ashish 2147 
 
3064 chandransh 2148 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2149 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2150 
    args = markOrdersAsFailed_args()
2151 
    args.providerId = providerId
2152 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
3064 chandransh 2157 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
3064 chandransh 2164 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
3431 rajveer 2167 
    if result.ex is not None:
3064 chandransh 2168 
      raise result.ex
2169 
    return
1596 ankur.sing 2170 
 
3064 chandransh 2171 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2172 
    """
3064 chandransh 2173 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2174 
 
3064 chandransh 2175 
    Parameters:
2176 
     - providerId
2177 
     - undeliveredOrders
1627 ankur.sing 2178 
    """
3064 chandransh 2179 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2180 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2181 
 
3064 chandransh 2182 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2183 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2184 
    args = updateNonDeliveryReason_args()
2185 
    args.providerId = providerId
2186 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2187 
    args.write(self._oprot)
2188 
    self._oprot.writeMessageEnd()
2189 
    self._oprot.trans.flush()
2190 
 
3064 chandransh 2191 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2193 
    if mtype == TMessageType.EXCEPTION:
2194 
      x = TApplicationException()
2195 
      x.read(self._iprot)
2196 
      self._iprot.readMessageEnd()
2197 
      raise x
3064 chandransh 2198 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2199 
    result.read(self._iprot)
2200 
    self._iprot.readMessageEnd()
3431 rajveer 2201 
    if result.ex is not None:
3064 chandransh 2202 
      raise result.ex
2203 
    return
1627 ankur.sing 2204 
 
3064 chandransh 2205 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2206 
    """
3064 chandransh 2207 
    Returns the list of orders whose delivery time has passed but have not been
2208 
    delivered yet for the given provider and warehouse. To get a complete list of
2209 
    undelivered orders, pass them as -1.
2210 
    Returns an empty list if no such orders exist.
3431 rajveer 2211 
 
1886 ankur.sing 2212 
    Parameters:
3064 chandransh 2213 
     - providerId
2214 
     - warehouseId
1886 ankur.sing 2215 
    """
3064 chandransh 2216 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2217 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2218 
 
3064 chandransh 2219 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2220 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2221 
    args = getUndeliveredOrders_args()
2222 
    args.providerId = providerId
2223 
    args.warehouseId = warehouseId
1886 ankur.sing 2224 
    args.write(self._oprot)
2225 
    self._oprot.writeMessageEnd()
2226 
    self._oprot.trans.flush()
2227 
 
3064 chandransh 2228 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2230 
    if mtype == TMessageType.EXCEPTION:
2231 
      x = TApplicationException()
2232 
      x.read(self._iprot)
2233 
      self._iprot.readMessageEnd()
2234 
      raise x
3064 chandransh 2235 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2236 
    result.read(self._iprot)
2237 
    self._iprot.readMessageEnd()
3431 rajveer 2238 
    if result.success is not None:
1886 ankur.sing 2239 
      return result.success
3064 chandransh 2240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2241 
 
2536 chandransh 2242 
  def toggleDOAFlag(self, orderId):
2243 
    """
2244 
    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.
2245 
    Returns the final flag status.
2246 
    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 2247 
 
2536 chandransh 2248 
    Parameters:
2249 
     - orderId
2250 
    """
2251 
    self.send_toggleDOAFlag(orderId)
2252 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2253 
 
2536 chandransh 2254 
  def send_toggleDOAFlag(self, orderId):
2255 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2256 
    args = toggleDOAFlag_args()
2257 
    args.orderId = orderId
2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_toggleDOAFlag(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = toggleDOAFlag_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
3431 rajveer 2272 
    if result.success is not None:
2536 chandransh 2273 
      return result.success
3431 rajveer 2274 
    if result.ex is not None:
2536 chandransh 2275 
      raise result.ex
2276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2277 
 
2278 
  def requestPickupNumber(self, orderId):
2279 
    """
2280 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2281 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2282 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2283 
    For any other status, it returns false.
2284 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2285 
 
2536 chandransh 2286 
    Parameters:
2287 
     - orderId
2288 
    """
2289 
    self.send_requestPickupNumber(orderId)
2290 
    return self.recv_requestPickupNumber()
2291 
 
2292 
  def send_requestPickupNumber(self, orderId):
2293 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2294 
    args = requestPickupNumber_args()
2295 
    args.orderId = orderId
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_requestPickupNumber(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = requestPickupNumber_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
3431 rajveer 2310 
    if result.success is not None:
2536 chandransh 2311 
      return result.success
3431 rajveer 2312 
    if result.ex is not None:
2536 chandransh 2313 
      raise result.ex
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2315 
 
2316 
  def authorizePickup(self, orderId, pickupNumber):
2317 
    """
4452 rajveer 2318 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2319 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2320 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2321 
    	3. Returns true
2591 chandransh 2322 
    If the order is in any other status, it returns false.
2536 chandransh 2323 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2324 
 
2536 chandransh 2325 
    Parameters:
2326 
     - orderId
2327 
     - pickupNumber
2328 
    """
2329 
    self.send_authorizePickup(orderId, pickupNumber)
2330 
    return self.recv_authorizePickup()
2331 
 
2332 
  def send_authorizePickup(self, orderId, pickupNumber):
2333 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2334 
    args = authorizePickup_args()
2335 
    args.orderId = orderId
2336 
    args.pickupNumber = pickupNumber
2337 
    args.write(self._oprot)
2338 
    self._oprot.writeMessageEnd()
2339 
    self._oprot.trans.flush()
2340 
 
2341 
  def recv_authorizePickup(self, ):
2342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2343 
    if mtype == TMessageType.EXCEPTION:
2344 
      x = TApplicationException()
2345 
      x.read(self._iprot)
2346 
      self._iprot.readMessageEnd()
2347 
      raise x
2348 
    result = authorizePickup_result()
2349 
    result.read(self._iprot)
2350 
    self._iprot.readMessageEnd()
3431 rajveer 2351 
    if result.success is not None:
2536 chandransh 2352 
      return result.success
3431 rajveer 2353 
    if result.ex is not None:
2536 chandransh 2354 
      raise result.ex
2355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2356 
 
2764 chandransh 2357 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2358 
    """
2359 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2360 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2361 
 
2764 chandransh 2362 
    Parameters:
2363 
     - providerId
2364 
     - pickupDetails
2365 
    """
2366 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2367 
    return self.recv_markDoasAsPickedUp()
2368 
 
2369 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2370 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2371 
    args = markDoasAsPickedUp_args()
2372 
    args.providerId = providerId
2373 
    args.pickupDetails = pickupDetails
2374 
    args.write(self._oprot)
2375 
    self._oprot.writeMessageEnd()
2376 
    self._oprot.trans.flush()
2377 
 
2378 
  def recv_markDoasAsPickedUp(self, ):
2379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2380 
    if mtype == TMessageType.EXCEPTION:
2381 
      x = TApplicationException()
2382 
      x.read(self._iprot)
2383 
      self._iprot.readMessageEnd()
2384 
      raise x
2385 
    result = markDoasAsPickedUp_result()
2386 
    result.read(self._iprot)
2387 
    self._iprot.readMessageEnd()
3431 rajveer 2388 
    if result.success is not None:
2764 chandransh 2389 
      return result.success
2390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2391 
 
2616 chandransh 2392 
  def receiveReturn(self, orderId):
2591 chandransh 2393 
    """
4452 rajveer 2394 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
2616 chandransh 2395 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2396 
    If the order is in any other state, it returns false.
2397 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2398 
 
2591 chandransh 2399 
    Parameters:
2400 
     - orderId
2401 
    """
2616 chandransh 2402 
    self.send_receiveReturn(orderId)
2403 
    return self.recv_receiveReturn()
2536 chandransh 2404 
 
2616 chandransh 2405 
  def send_receiveReturn(self, orderId):
2406 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2407 
    args = receiveReturn_args()
2591 chandransh 2408 
    args.orderId = orderId
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2616 chandransh 2413 
  def recv_receiveReturn(self, ):
2591 chandransh 2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2616 chandransh 2420 
    result = receiveReturn_result()
2591 chandransh 2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
3431 rajveer 2423 
    if result.success is not None:
2591 chandransh 2424 
      return result.success
3431 rajveer 2425 
    if result.ex is not None:
2591 chandransh 2426 
      raise result.ex
2616 chandransh 2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2428 
 
2429 
  def validateDoa(self, orderId, isValid):
2430 
    """
4452 rajveer 2431 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2432 
    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 2433 
    If the order is in any other state, it returns false.
2434 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2435 
 
2591 chandransh 2436 
    Parameters:
2437 
     - orderId
2438 
     - isValid
2439 
    """
2440 
    self.send_validateDoa(orderId, isValid)
2441 
    return self.recv_validateDoa()
2442 
 
2443 
  def send_validateDoa(self, orderId, isValid):
2444 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2445 
    args = validateDoa_args()
2446 
    args.orderId = orderId
2447 
    args.isValid = isValid
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_validateDoa(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = validateDoa_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.success is not None:
2591 chandransh 2463 
      return result.success
3431 rajveer 2464 
    if result.ex is not None:
2591 chandransh 2465 
      raise result.ex
2466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2467 
 
2616 chandransh 2468 
  def reshipOrder(self, orderId):
2469 
    """
2470 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2471 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2472 
    	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.
2473 
 
2474 
    If the order is in DOA_CERT_VALID state, it does the following:
2475 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2476 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2477 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2478 
 
2616 chandransh 2479 
    Returns the id of the newly created order.
3431 rajveer 2480 
 
2616 chandransh 2481 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2482 
 
2616 chandransh 2483 
    Parameters:
2484 
     - orderId
2485 
    """
2486 
    self.send_reshipOrder(orderId)
2487 
    return self.recv_reshipOrder()
2591 chandransh 2488 
 
2616 chandransh 2489 
  def send_reshipOrder(self, orderId):
2490 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2491 
    args = reshipOrder_args()
2492 
    args.orderId = orderId
2493 
    args.write(self._oprot)
2494 
    self._oprot.writeMessageEnd()
2495 
    self._oprot.trans.flush()
2496 
 
2497 
  def recv_reshipOrder(self, ):
2498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2499 
    if mtype == TMessageType.EXCEPTION:
2500 
      x = TApplicationException()
2501 
      x.read(self._iprot)
2502 
      self._iprot.readMessageEnd()
2503 
      raise x
2504 
    result = reshipOrder_result()
2505 
    result.read(self._iprot)
2506 
    self._iprot.readMessageEnd()
3431 rajveer 2507 
    if result.success is not None:
2616 chandransh 2508 
      return result.success
3431 rajveer 2509 
    if result.ex is not None:
2616 chandransh 2510 
      raise result.ex
2511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2512 
 
3226 chandransh 2513 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2514 
    """
2515 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2516 
    	1. Creates a refund request for batch processing.
2517 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2518 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2519 
 
2616 chandransh 2520 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2521 
    	1. Creates a refund request for batch processing.
3226 chandransh 2522 
    	2. Cancels the reservation of the item in the warehouse.
2523 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2524 
 
3226 chandransh 2525 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2526 
    	1. Cancels the reservation of the item in the warehouse.
2527 
    	2. Marks the current order as CANCELED.
2528 
 
2529 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2530 
 
2616 chandransh 2531 
    Returns True if it is successful, False otherwise.
3431 rajveer 2532 
 
2616 chandransh 2533 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2534 
 
2616 chandransh 2535 
    Parameters:
2536 
     - orderId
3226 chandransh 2537 
     - refundedBy
2538 
     - reason
2616 chandransh 2539 
    """
3226 chandransh 2540 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2541 
    return self.recv_refundOrder()
2542 
 
3226 chandransh 2543 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2544 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2545 
    args = refundOrder_args()
2546 
    args.orderId = orderId
3226 chandransh 2547 
    args.refundedBy = refundedBy
2548 
    args.reason = reason
2616 chandransh 2549 
    args.write(self._oprot)
2550 
    self._oprot.writeMessageEnd()
2551 
    self._oprot.trans.flush()
2552 
 
2553 
  def recv_refundOrder(self, ):
2554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2555 
    if mtype == TMessageType.EXCEPTION:
2556 
      x = TApplicationException()
2557 
      x.read(self._iprot)
2558 
      self._iprot.readMessageEnd()
2559 
      raise x
2560 
    result = refundOrder_result()
2561 
    result.read(self._iprot)
2562 
    self._iprot.readMessageEnd()
3431 rajveer 2563 
    if result.success is not None:
2616 chandransh 2564 
      return result.success
3431 rajveer 2565 
    if result.ex is not None:
2616 chandransh 2566 
      raise result.ex
2567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2568 
 
2690 chandransh 2569 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2570 
    """
2571 
    Get all return orders created between the from and to dates for the given warehouse.
2572 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2573 
 
2690 chandransh 2574 
    Parameters:
2575 
     - warehouseId
2576 
     - fromDate
2577 
     - toDate
2578 
    """
2579 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2580 
    return self.recv_getReturnOrders()
2616 chandransh 2581 
 
2690 chandransh 2582 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2583 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2584 
    args = getReturnOrders_args()
2585 
    args.warehouseId = warehouseId
2586 
    args.fromDate = fromDate
2587 
    args.toDate = toDate
2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
2592 
  def recv_getReturnOrders(self, ):
2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
2599 
    result = getReturnOrders_result()
2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
3431 rajveer 2602 
    if result.success is not None:
2690 chandransh 2603 
      return result.success
2604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2605 
 
2700 chandransh 2606 
  def getReturnOrder(self, id):
2607 
    """
2608 
    Returns the ReturnOrder corresponding to the given id.
2609 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2610 
 
2700 chandransh 2611 
    Parameters:
2612 
     - id
2613 
    """
2614 
    self.send_getReturnOrder(id)
2615 
    return self.recv_getReturnOrder()
2616 
 
2617 
  def send_getReturnOrder(self, id):
2618 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2619 
    args = getReturnOrder_args()
2620 
    args.id = id
2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
2625 
  def recv_getReturnOrder(self, ):
2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
2632 
    result = getReturnOrder_result()
2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
3431 rajveer 2635 
    if result.success is not None:
2700 chandransh 2636 
      return result.success
3431 rajveer 2637 
    if result.ex is not None:
2700 chandransh 2638 
      raise result.ex
2639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2640 
 
2690 chandransh 2641 
  def processReturn(self, returnOrderId):
2642 
    """
2643 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2644 
 
2690 chandransh 2645 
    Parameters:
2646 
     - returnOrderId
2647 
    """
2648 
    self.send_processReturn(returnOrderId)
2649 
    self.recv_processReturn()
2650 
 
2651 
  def send_processReturn(self, returnOrderId):
2652 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2653 
    args = processReturn_args()
2654 
    args.returnOrderId = returnOrderId
2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
2659 
  def recv_processReturn(self, ):
2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
2666 
    result = processReturn_result()
2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
3431 rajveer 2669 
    if result.ex is not None:
2690 chandransh 2670 
      raise result.ex
2671 
    return
2672 
 
2819 chandransh 2673 
  def createPurchaseOrder(self, warehouseId):
2674 
    """
2675 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2676 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2677 
 
2819 chandransh 2678 
    Parameters:
2679 
     - warehouseId
2680 
    """
2681 
    self.send_createPurchaseOrder(warehouseId)
2682 
    return self.recv_createPurchaseOrder()
2690 chandransh 2683 
 
2819 chandransh 2684 
  def send_createPurchaseOrder(self, warehouseId):
2685 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2686 
    args = createPurchaseOrder_args()
2687 
    args.warehouseId = warehouseId
2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2692 
  def recv_createPurchaseOrder(self, ):
2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2699 
    result = createPurchaseOrder_result()
2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
3431 rajveer 2702 
    if result.success is not None:
2819 chandransh 2703 
      return result.success
3431 rajveer 2704 
    if result.ex is not None:
2819 chandransh 2705 
      raise result.ex
2706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2707 
 
3451 chandransh 2708 
  def updateWeight(self, orderId, weight):
2709 
    """
2710 
    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 2711 
 
3451 chandransh 2712 
    Parameters:
2713 
     - orderId
2714 
     - weight
2715 
    """
2716 
    self.send_updateWeight(orderId, weight)
2717 
    return self.recv_updateWeight()
2718 
 
2719 
  def send_updateWeight(self, orderId, weight):
2720 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2721 
    args = updateWeight_args()
2722 
    args.orderId = orderId
2723 
    args.weight = weight
2724 
    args.write(self._oprot)
2725 
    self._oprot.writeMessageEnd()
2726 
    self._oprot.trans.flush()
2727 
 
2728 
  def recv_updateWeight(self, ):
2729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2730 
    if mtype == TMessageType.EXCEPTION:
2731 
      x = TApplicationException()
2732 
      x.read(self._iprot)
2733 
      self._iprot.readMessageEnd()
2734 
      raise x
2735 
    result = updateWeight_result()
2736 
    result.read(self._iprot)
2737 
    self._iprot.readMessageEnd()
2738 
    if result.success is not None:
2739 
      return result.success
2740 
    if result.ex is not None:
2741 
      raise result.ex
2742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2743 
 
3469 chandransh 2744 
  def changeItem(self, orderId, itemId):
2745 
    """
2746 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2747 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2748 
 
3469 chandransh 2749 
    Parameters:
2750 
     - orderId
2751 
     - itemId
2752 
    """
2753 
    self.send_changeItem(orderId, itemId)
2754 
    return self.recv_changeItem()
2755 
 
2756 
  def send_changeItem(self, orderId, itemId):
2757 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2758 
    args = changeItem_args()
2759 
    args.orderId = orderId
2760 
    args.itemId = itemId
2761 
    args.write(self._oprot)
2762 
    self._oprot.writeMessageEnd()
2763 
    self._oprot.trans.flush()
2764 
 
2765 
  def recv_changeItem(self, ):
2766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2767 
    if mtype == TMessageType.EXCEPTION:
2768 
      x = TApplicationException()
2769 
      x.read(self._iprot)
2770 
      self._iprot.readMessageEnd()
2771 
      raise x
2772 
    result = changeItem_result()
2773 
    result.read(self._iprot)
2774 
    self._iprot.readMessageEnd()
2775 
    if result.success is not None:
2776 
      return result.success
2777 
    if result.ex is not None:
2778 
      raise result.ex
2779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2780 
 
2781 
  def shiftToWarehouse(self, orderId, warehouseId):
2782 
    """
2783 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2784 
 
2785 
    Parameters:
2786 
     - orderId
2787 
     - warehouseId
2788 
    """
2789 
    self.send_shiftToWarehouse(orderId, warehouseId)
2790 
    return self.recv_shiftToWarehouse()
2791 
 
2792 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2793 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2794 
    args = shiftToWarehouse_args()
2795 
    args.orderId = orderId
2796 
    args.warehouseId = warehouseId
2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
2801 
  def recv_shiftToWarehouse(self, ):
2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
2808 
    result = shiftToWarehouse_result()
2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
2811 
    if result.success is not None:
2812 
      return result.success
2813 
    if result.ex is not None:
2814 
      raise result.ex
2815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2816 
 
3986 chandransh 2817 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2818 
    """
2819 
    Adds the given delay reason to the given order.
3986 chandransh 2820 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2821 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2822 
 
3553 chandransh 2823 
    Parameters:
2824 
     - orderId
2825 
     - delayReason
3986 chandransh 2826 
     - furtherDelay
3553 chandransh 2827 
    """
3986 chandransh 2828 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2829 
    return self.recv_addDelayReason()
2830 
 
3986 chandransh 2831 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2832 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2833 
    args = addDelayReason_args()
2834 
    args.orderId = orderId
2835 
    args.delayReason = delayReason
3986 chandransh 2836 
    args.furtherDelay = furtherDelay
3553 chandransh 2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_addDelayReason(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = addDelayReason_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
2851 
    if result.success is not None:
2852 
      return result.success
2853 
    if result.ex is not None:
2854 
      raise result.ex
2855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2856 
 
3956 chandransh 2857 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2858 
    """
2859 
    Marks the COD orders with given AWB nos. as having been processed.
2860 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2861 
 
3956 chandransh 2862 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2863 
    1. There is no order corresponding to an AWB number.
2864 
    2. The captured amount for a payment exceeds the total payment.
2865 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2866 
 
2867 
    Parameters:
2868 
     - collectedAmountMap
2869 
     - xferBy
2870 
     - xferTxnId
2871 
     - xferDate
2872 
    """
2873 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2874 
    return self.recv_reconcileCodCollection()
2875 
 
2876 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2877 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2878 
    args = reconcileCodCollection_args()
2879 
    args.collectedAmountMap = collectedAmountMap
2880 
    args.xferBy = xferBy
2881 
    args.xferTxnId = xferTxnId
2882 
    args.xferDate = xferDate
2883 
    args.write(self._oprot)
2884 
    self._oprot.writeMessageEnd()
2885 
    self._oprot.trans.flush()
2886 
 
2887 
  def recv_reconcileCodCollection(self, ):
2888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2889 
    if mtype == TMessageType.EXCEPTION:
2890 
      x = TApplicationException()
2891 
      x.read(self._iprot)
2892 
      self._iprot.readMessageEnd()
2893 
      raise x
2894 
    result = reconcileCodCollection_result()
2895 
    result.read(self._iprot)
2896 
    self._iprot.readMessageEnd()
2897 
    if result.success is not None:
2898 
      return result.success
2899 
    if result.ex is not None:
2900 
      raise result.ex
2901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2902 
 
4008 mandeep.dh 2903 
  def getTransactionsRequiringExtraProcessing(self, category):
2904 
    """
4065 mandeep.dh 2905 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2906 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2907 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2908 
 
4008 mandeep.dh 2909 
    Parameters:
2910 
     - category
2911 
    """
2912 
    self.send_getTransactionsRequiringExtraProcessing(category)
2913 
    return self.recv_getTransactionsRequiringExtraProcessing()
2914 
 
2915 
  def send_getTransactionsRequiringExtraProcessing(self, category):
2916 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
2917 
    args = getTransactionsRequiringExtraProcessing_args()
2918 
    args.category = category
2919 
    args.write(self._oprot)
2920 
    self._oprot.writeMessageEnd()
2921 
    self._oprot.trans.flush()
2922 
 
2923 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
2924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2925 
    if mtype == TMessageType.EXCEPTION:
2926 
      x = TApplicationException()
2927 
      x.read(self._iprot)
2928 
      self._iprot.readMessageEnd()
2929 
      raise x
2930 
    result = getTransactionsRequiringExtraProcessing_result()
2931 
    result.read(self._iprot)
2932 
    self._iprot.readMessageEnd()
2933 
    if result.success is not None:
2934 
      return result.success
2935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
2936 
 
2937 
  def markTransactionAsProcessed(self, transactionId, category):
2938 
    """
2939 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 2940 
    It essentially deletes the transaction id record for a particular
2941 
    processing type category (if present) from DB.
2942 
    This is currently used by CRM application.
4008 mandeep.dh 2943 
 
2944 
    Parameters:
2945 
     - transactionId
2946 
     - category
2947 
    """
2948 
    self.send_markTransactionAsProcessed(transactionId, category)
2949 
    self.recv_markTransactionAsProcessed()
2950 
 
2951 
  def send_markTransactionAsProcessed(self, transactionId, category):
2952 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
2953 
    args = markTransactionAsProcessed_args()
2954 
    args.transactionId = transactionId
2955 
    args.category = category
2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
2960 
  def recv_markTransactionAsProcessed(self, ):
2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
2967 
    result = markTransactionAsProcessed_result()
2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
2970 
    return
2971 
 
4018 chandransh 2972 
  def getItemWiseRiskyOrdersCount(self, ):
2973 
    """
2974 
    Returns a map containing the number of risky orders keyed by item id. A risky order
2975 
    is defined as one whose shipping date is about to expire.
2976 
    """
2977 
    self.send_getItemWiseRiskyOrdersCount()
2978 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 2979 
 
4018 chandransh 2980 
  def send_getItemWiseRiskyOrdersCount(self, ):
2981 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
2982 
    args = getItemWiseRiskyOrdersCount_args()
2983 
    args.write(self._oprot)
2984 
    self._oprot.writeMessageEnd()
2985 
    self._oprot.trans.flush()
2986 
 
2987 
  def recv_getItemWiseRiskyOrdersCount(self, ):
2988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2989 
    if mtype == TMessageType.EXCEPTION:
2990 
      x = TApplicationException()
2991 
      x.read(self._iprot)
2992 
      self._iprot.readMessageEnd()
2993 
      raise x
2994 
    result = getItemWiseRiskyOrdersCount_result()
2995 
    result.read(self._iprot)
2996 
    self._iprot.readMessageEnd()
2997 
    if result.success is not None:
2998 
      return result.success
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3000 
 
4295 varun.gupt 3001 
  def getOrdersForItemIds(self, itemIds):
3002 
    """
3003 
    Returns a list of all orders which have items with given id
3004 
 
3005 
    Parameters:
3006 
     - itemIds
3007 
    """
3008 
    self.send_getOrdersForItemIds(itemIds)
3009 
    return self.recv_getOrdersForItemIds()
3010 
 
3011 
  def send_getOrdersForItemIds(self, itemIds):
3012 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3013 
    args = getOrdersForItemIds_args()
3014 
    args.itemIds = itemIds
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_getOrdersForItemIds(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = getOrdersForItemIds_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.success is not None:
3030 
      return result.success
3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3032 
 
4247 rajveer 3033 
  def markOrderCancellationRequestReceived(self, orderId):
3034 
    """
3035 
    Mark order as cancellation request received. If customer sends request of cancellation of
3036 
    a particular order, this method will be called. It will just change status of the order
3037 
    depending on its current status. It also records the previous status, so that we can move
3038 
    back to that status if cancellation request is denied.
4018 chandransh 3039 
 
4247 rajveer 3040 
    Parameters:
3041 
     - orderId
3042 
    """
3043 
    self.send_markOrderCancellationRequestReceived(orderId)
3044 
    self.recv_markOrderCancellationRequestReceived()
3045 
 
3046 
  def send_markOrderCancellationRequestReceived(self, orderId):
3047 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3048 
    args = markOrderCancellationRequestReceived_args()
3049 
    args.orderId = orderId
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_markOrderCancellationRequestReceived(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = markOrderCancellationRequestReceived_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.ex is not None:
3065 
      raise result.ex
3066 
    return
3067 
 
3068 
  def markOrderCancellationRequestConfirmed(self, orderId):
3069 
    """
3070 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3071 
    cancellation request confirmed. After this OM will be able to cancel the order.
3072 
 
3073 
    Parameters:
3074 
     - orderId
3075 
    """
3076 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3077 
    self.recv_markOrderCancellationRequestConfirmed()
3078 
 
3079 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3080 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3081 
    args = markOrderCancellationRequestConfirmed_args()
3082 
    args.orderId = orderId
3083 
    args.write(self._oprot)
3084 
    self._oprot.writeMessageEnd()
3085 
    self._oprot.trans.flush()
3086 
 
3087 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3089 
    if mtype == TMessageType.EXCEPTION:
3090 
      x = TApplicationException()
3091 
      x.read(self._iprot)
3092 
      self._iprot.readMessageEnd()
3093 
      raise x
3094 
    result = markOrderCancellationRequestConfirmed_result()
3095 
    result.read(self._iprot)
3096 
    self._iprot.readMessageEnd()
3097 
    if result.ex is not None:
3098 
      raise result.ex
3099 
    return
3100 
 
3101 
  def markOrderCancellationRequestDenied(self, orderId):
3102 
    """
3103 
    If we decide to not to cancel order, we will move the order ro previous status.
3104 
 
3105 
    Parameters:
3106 
     - orderId
3107 
    """
3108 
    self.send_markOrderCancellationRequestDenied(orderId)
3109 
    self.recv_markOrderCancellationRequestDenied()
3110 
 
3111 
  def send_markOrderCancellationRequestDenied(self, orderId):
3112 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3113 
    args = markOrderCancellationRequestDenied_args()
3114 
    args.orderId = orderId
3115 
    args.write(self._oprot)
3116 
    self._oprot.writeMessageEnd()
3117 
    self._oprot.trans.flush()
3118 
 
3119 
  def recv_markOrderCancellationRequestDenied(self, ):
3120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3121 
    if mtype == TMessageType.EXCEPTION:
3122 
      x = TApplicationException()
3123 
      x.read(self._iprot)
3124 
      self._iprot.readMessageEnd()
3125 
      raise x
3126 
    result = markOrderCancellationRequestDenied_result()
3127 
    result.read(self._iprot)
3128 
    self._iprot.readMessageEnd()
3129 
    if result.ex is not None:
3130 
      raise result.ex
3131 
    return
3132 
 
4258 rajveer 3133 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3134 
    """
4258 rajveer 3135 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3136 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3137 
 
3138 
    Parameters:
4258 rajveer 3139 
     - transactionId
4247 rajveer 3140 
    """
4258 rajveer 3141 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3142 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3143 
 
4258 rajveer 3144 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3145 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3146 
    args = markTransactionAsPaymentFlagRemoved_args()
3147 
    args.transactionId = transactionId
4247 rajveer 3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
4258 rajveer 3152 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
4258 rajveer 3159 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3162 
    if result.ex is not None:
3163 
      raise result.ex
3164 
    return
3165 
 
4259 anupam.sin 3166 
  def refundTransaction(self, transactionId, refundedBy, reason):
3167 
    """
3168 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3169 
    need to be cancelled
4247 rajveer 3170 
 
4259 anupam.sin 3171 
    Parameters:
3172 
     - transactionId
3173 
     - refundedBy
3174 
     - reason
3175 
    """
3176 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3177 
    self.recv_refundTransaction()
3178 
 
3179 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3180 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3181 
    args = refundTransaction_args()
3182 
    args.transactionId = transactionId
3183 
    args.refundedBy = refundedBy
3184 
    args.reason = reason
3185 
    args.write(self._oprot)
3186 
    self._oprot.writeMessageEnd()
3187 
    self._oprot.trans.flush()
3188 
 
3189 
  def recv_refundTransaction(self, ):
3190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3191 
    if mtype == TMessageType.EXCEPTION:
3192 
      x = TApplicationException()
3193 
      x.read(self._iprot)
3194 
      self._iprot.readMessageEnd()
3195 
      raise x
3196 
    result = refundTransaction_result()
3197 
    result.read(self._iprot)
3198 
    self._iprot.readMessageEnd()
3199 
    if result.ex is not None:
3200 
      raise result.ex
3201 
    return
3202 
 
4324 mandeep.dh 3203 
  def updateShipmentAddress(self, orderId, addressId):
3204 
    """
3205 
    Updates shipment address of an order. Delivery and shipping date estimates
3206 
    etc. are also updated here.
3207 
 
3208 
    Throws TransactionServiceException in case address change is not
3209 
    possible due to certain reasons such as new pincode in address is
3210 
    not serviceable etc.
3211 
 
3212 
    Parameters:
3213 
     - orderId
3214 
     - addressId
3215 
    """
3216 
    self.send_updateShipmentAddress(orderId, addressId)
3217 
    self.recv_updateShipmentAddress()
3218 
 
3219 
  def send_updateShipmentAddress(self, orderId, addressId):
3220 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3221 
    args = updateShipmentAddress_args()
3222 
    args.orderId = orderId
3223 
    args.addressId = addressId
3224 
    args.write(self._oprot)
3225 
    self._oprot.writeMessageEnd()
3226 
    self._oprot.trans.flush()
3227 
 
3228 
  def recv_updateShipmentAddress(self, ):
3229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3230 
    if mtype == TMessageType.EXCEPTION:
3231 
      x = TApplicationException()
3232 
      x.read(self._iprot)
3233 
      self._iprot.readMessageEnd()
3234 
      raise x
3235 
    result = updateShipmentAddress_result()
3236 
    result.read(self._iprot)
3237 
    self._iprot.readMessageEnd()
3238 
    if result.ex is not None:
3239 
      raise result.ex
3240 
    return
3241 
 
4285 rajveer 3242 
  def acceptOrdersForItemId(self, itemId, inventory):
3243 
    """
3244 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3245 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3246 
 
4285 rajveer 3247 
    Parameters:
3248 
     - itemId
3249 
     - inventory
3250 
    """
3251 
    self.send_acceptOrdersForItemId(itemId, inventory)
3252 
    return self.recv_acceptOrdersForItemId()
3253 
 
3254 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3255 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3256 
    args = acceptOrdersForItemId_args()
3257 
    args.itemId = itemId
3258 
    args.inventory = inventory
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_acceptOrdersForItemId(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = acceptOrdersForItemId_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.ex is not None:
3276 
      raise result.ex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3278 
 
4369 rajveer 3279 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3280 
    """
3281 
    Parameters:
3282 
     - vendorId
3283 
     - itemId
3284 
     - quantity
3285 
     - estimate
4369 rajveer 3286 
     - isReminder
4303 rajveer 3287 
    """
4369 rajveer 3288 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3289 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3290 
 
4369 rajveer 3291 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3292 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3293 
    args = markOrdersAsPORaised_args()
3294 
    args.vendorId = vendorId
3295 
    args.itemId = itemId
3296 
    args.quantity = quantity
3297 
    args.estimate = estimate
4369 rajveer 3298 
    args.isReminder = isReminder
4303 rajveer 3299 
    args.write(self._oprot)
3300 
    self._oprot.writeMessageEnd()
3301 
    self._oprot.trans.flush()
3302 
 
3303 
  def recv_markOrdersAsPORaised(self, ):
3304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3305 
    if mtype == TMessageType.EXCEPTION:
3306 
      x = TApplicationException()
3307 
      x.read(self._iprot)
3308 
      self._iprot.readMessageEnd()
3309 
      raise x
3310 
    result = markOrdersAsPORaised_result()
3311 
    result.read(self._iprot)
3312 
    self._iprot.readMessageEnd()
3313 
    if result.ex is not None:
3314 
      raise result.ex
3315 
    return
3316 
 
4369 rajveer 3317 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3318 
    """
3319 
    Parameters:
3320 
     - vendorId
3321 
     - itemId
3322 
     - quantity
3323 
     - estimate
4369 rajveer 3324 
     - isReminder
4303 rajveer 3325 
    """
4369 rajveer 3326 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3327 
    self.recv_markOrdersAsReversalInitiated()
3328 
 
4369 rajveer 3329 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3330 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3331 
    args = markOrdersAsReversalInitiated_args()
3332 
    args.vendorId = vendorId
3333 
    args.itemId = itemId
3334 
    args.quantity = quantity
3335 
    args.estimate = estimate
4369 rajveer 3336 
    args.isReminder = isReminder
4303 rajveer 3337 
    args.write(self._oprot)
3338 
    self._oprot.writeMessageEnd()
3339 
    self._oprot.trans.flush()
3340 
 
3341 
  def recv_markOrdersAsReversalInitiated(self, ):
3342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3343 
    if mtype == TMessageType.EXCEPTION:
3344 
      x = TApplicationException()
3345 
      x.read(self._iprot)
3346 
      self._iprot.readMessageEnd()
3347 
      raise x
3348 
    result = markOrdersAsReversalInitiated_result()
3349 
    result.read(self._iprot)
3350 
    self._iprot.readMessageEnd()
3351 
    if result.ex is not None:
3352 
      raise result.ex
3353 
    return
3354 
 
4369 rajveer 3355 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3356 
    """
3357 
    Parameters:
3358 
     - vendorId
3359 
     - itemId
3360 
     - quantity
3361 
     - estimate
4369 rajveer 3362 
     - isReminder
4303 rajveer 3363 
    """
4369 rajveer 3364 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3365 
    self.recv_markOrdersAsNotAvailabke()
3366 
 
4369 rajveer 3367 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3368 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3369 
    args = markOrdersAsNotAvailabke_args()
3370 
    args.vendorId = vendorId
3371 
    args.itemId = itemId
3372 
    args.quantity = quantity
3373 
    args.estimate = estimate
4369 rajveer 3374 
    args.isReminder = isReminder
4303 rajveer 3375 
    args.write(self._oprot)
3376 
    self._oprot.writeMessageEnd()
3377 
    self._oprot.trans.flush()
3378 
 
3379 
  def recv_markOrdersAsNotAvailabke(self, ):
3380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3381 
    if mtype == TMessageType.EXCEPTION:
3382 
      x = TApplicationException()
3383 
      x.read(self._iprot)
3384 
      self._iprot.readMessageEnd()
3385 
      raise x
3386 
    result = markOrdersAsNotAvailabke_result()
3387 
    result.read(self._iprot)
3388 
    self._iprot.readMessageEnd()
3389 
    if result.ex is not None:
3390 
      raise result.ex
3391 
    return
3392 
 
4369 rajveer 3393 
  def markOrdersAsTimeout(self, vendorId):
3394 
    """
3395 
    Parameters:
3396 
     - vendorId
3397 
    """
3398 
    self.send_markOrdersAsTimeout(vendorId)
3399 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3400 
 
4369 rajveer 3401 
  def send_markOrdersAsTimeout(self, vendorId):
3402 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3403 
    args = markOrdersAsTimeout_args()
3404 
    args.vendorId = vendorId
3405 
    args.write(self._oprot)
3406 
    self._oprot.writeMessageEnd()
3407 
    self._oprot.trans.flush()
3408 
 
3409 
  def recv_markOrdersAsTimeout(self, ):
3410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3411 
    if mtype == TMessageType.EXCEPTION:
3412 
      x = TApplicationException()
3413 
      x.read(self._iprot)
3414 
      self._iprot.readMessageEnd()
3415 
      raise x
3416 
    result = markOrdersAsTimeout_result()
3417 
    result.read(self._iprot)
3418 
    self._iprot.readMessageEnd()
3419 
    if result.success is not None:
3420 
      return result.success
3421 
    if result.ex is not None:
3422 
      raise result.ex
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3424 
 
4386 anupam.sin 3425 
  def getOrderForAwb(self, awb):
3426 
    """
3427 
    Returns the order corresponding to an AWB number
4369 rajveer 3428 
 
4386 anupam.sin 3429 
    Parameters:
3430 
     - awb
3431 
    """
3432 
    self.send_getOrderForAwb(awb)
3433 
    return self.recv_getOrderForAwb()
3434 
 
3435 
  def send_getOrderForAwb(self, awb):
3436 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3437 
    args = getOrderForAwb_args()
3438 
    args.awb = awb
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_getOrderForAwb(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = getOrderForAwb_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    if result.success is not None:
3454 
      return result.success
3455 
    if result.ex is not None:
3456 
      raise result.ex
3457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3458 
 
3459 
 
3376 rajveer 3460 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3461 
  def __init__(self, handler):
3376 rajveer 3462 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3463 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3464 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3465 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3466 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3467 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3468 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3469 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3470 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3471 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3472 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3473 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3474 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3475 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3476 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3477 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3478 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3479 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3480 
    self._processMap["createOrder"] = Processor.process_createOrder
3481 
    self._processMap["getOrder"] = Processor.process_getOrder
3482 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3483 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3484 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3485 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3486 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3487 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3488 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3489 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3490 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3491 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3492 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3493 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3494 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3495 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3496 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3497 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3498 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3499 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3500 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3501 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3502 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3503 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
3504 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3505 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3506 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3507 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3508 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3509 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3510 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3511 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3512 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3513 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3514 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3515 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3516 
    self._processMap["changeItem"] = Processor.process_changeItem
3517 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3518 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3519 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3520 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3521 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3522 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3523 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3524 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3525 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3526 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3527 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3528 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3529 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3530 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3531 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3532 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3533 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3534 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3535 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3536 
 
3537 
  def process(self, iprot, oprot):
3538 
    (name, type, seqid) = iprot.readMessageBegin()
3539 
    if name not in self._processMap:
3540 
      iprot.skip(TType.STRUCT)
3541 
      iprot.readMessageEnd()
3542 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3543 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3544 
      x.write(oprot)
3545 
      oprot.writeMessageEnd()
3546 
      oprot.trans.flush()
3547 
      return
3548 
    else:
3549 
      self._processMap[name](self, seqid, iprot, oprot)
3550 
    return True
3551 
 
3552 
  def process_createTransaction(self, seqid, iprot, oprot):
3553 
    args = createTransaction_args()
3554 
    args.read(iprot)
3555 
    iprot.readMessageEnd()
3556 
    result = createTransaction_result()
3557 
    try:
132 ashish 3558 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3559 
    except TransactionServiceException, ex:
3560 
      result.ex = ex
3561 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3562 
    result.write(oprot)
3563 
    oprot.writeMessageEnd()
3564 
    oprot.trans.flush()
3565 
 
3566 
  def process_getTransaction(self, seqid, iprot, oprot):
3567 
    args = getTransaction_args()
3568 
    args.read(iprot)
3569 
    iprot.readMessageEnd()
3570 
    result = getTransaction_result()
3571 
    try:
3572 
      result.success = self._handler.getTransaction(args.id)
3573 
    except TransactionServiceException, ex:
3574 
      result.ex = ex
3575 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3576 
    result.write(oprot)
3577 
    oprot.writeMessageEnd()
3578 
    oprot.trans.flush()
3579 
 
3580 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3581 
    args = getTransactionsForCustomer_args()
3582 
    args.read(iprot)
3583 
    iprot.readMessageEnd()
3584 
    result = getTransactionsForCustomer_result()
3585 
    try:
3586 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3587 
    except TransactionServiceException, ex:
3588 
      result.ex = ex
3589 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3590 
    result.write(oprot)
3591 
    oprot.writeMessageEnd()
3592 
    oprot.trans.flush()
3593 
 
132 ashish 3594 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3595 
    args = getTransactionsForShoppingCartId_args()
3596 
    args.read(iprot)
3597 
    iprot.readMessageEnd()
3598 
    result = getTransactionsForShoppingCartId_result()
3599 
    try:
3600 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3601 
    except TransactionServiceException, ex:
3602 
      result.ex = ex
3603 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3604 
    result.write(oprot)
3605 
    oprot.writeMessageEnd()
3606 
    oprot.trans.flush()
3607 
 
94 ashish 3608 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3609 
    args = getTransactionStatus_args()
3610 
    args.read(iprot)
3611 
    iprot.readMessageEnd()
3612 
    result = getTransactionStatus_result()
3613 
    try:
3614 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3615 
    except TransactionServiceException, ex:
3616 
      result.ex = ex
3617 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3618 
    result.write(oprot)
3619 
    oprot.writeMessageEnd()
3620 
    oprot.trans.flush()
3621 
 
3622 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3623 
    args = changeTransactionStatus_args()
3624 
    args.read(iprot)
3625 
    iprot.readMessageEnd()
3626 
    result = changeTransactionStatus_result()
3627 
    try:
3628 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3629 
    except TransactionServiceException, ex:
3630 
      result.ex = ex
3631 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3632 
    result.write(oprot)
3633 
    oprot.writeMessageEnd()
3634 
    oprot.trans.flush()
3635 
 
1398 varun.gupt 3636 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3637 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3638 
    args.read(iprot)
3639 
    iprot.readMessageEnd()
1398 varun.gupt 3640 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3641 
    try:
1398 varun.gupt 3642 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3643 
    except TransactionServiceException, ex:
3644 
      result.ex = ex
1398 varun.gupt 3645 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3646 
    result.write(oprot)
3647 
    oprot.writeMessageEnd()
3648 
    oprot.trans.flush()
3649 
 
483 rajveer 3650 
  def process_getAllOrders(self, seqid, iprot, oprot):
3651 
    args = getAllOrders_args()
94 ashish 3652 
    args.read(iprot)
3653 
    iprot.readMessageEnd()
483 rajveer 3654 
    result = getAllOrders_result()
94 ashish 3655 
    try:
483 rajveer 3656 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3657 
    except TransactionServiceException, ex:
3658 
      result.ex = ex
483 rajveer 3659 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3660 
    result.write(oprot)
3661 
    oprot.writeMessageEnd()
3662 
    oprot.trans.flush()
3663 
 
4133 chandransh 3664 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3665 
    args = getOrdersInBatch_args()
3666 
    args.read(iprot)
3667 
    iprot.readMessageEnd()
3668 
    result = getOrdersInBatch_result()
3669 
    try:
3670 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3671 
    except TransactionServiceException, ex:
3672 
      result.ex = ex
3673 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3674 
    result.write(oprot)
3675 
    oprot.writeMessageEnd()
3676 
    oprot.trans.flush()
3677 
 
3678 
  def process_getOrderCount(self, seqid, iprot, oprot):
3679 
    args = getOrderCount_args()
3680 
    args.read(iprot)
3681 
    iprot.readMessageEnd()
3682 
    result = getOrderCount_result()
3683 
    try:
3684 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3685 
    except TransactionServiceException, ex:
3686 
      result.ex = ex
3687 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3688 
    result.write(oprot)
3689 
    oprot.writeMessageEnd()
3690 
    oprot.trans.flush()
3691 
 
999 varun.gupt 3692 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3693 
    args = getOrdersByBillingDate_args()
3694 
    args.read(iprot)
3695 
    iprot.readMessageEnd()
3696 
    result = getOrdersByBillingDate_result()
3697 
    try:
3698 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3699 
    except TransactionServiceException, ex:
3700 
      result.ex = ex
3701 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3702 
    result.write(oprot)
3703 
    oprot.writeMessageEnd()
3704 
    oprot.trans.flush()
3705 
 
3427 chandransh 3706 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3707 
    args = getOrdersByShippingDate_args()
3708 
    args.read(iprot)
3709 
    iprot.readMessageEnd()
3710 
    result = getOrdersByShippingDate_result()
3711 
    try:
3451 chandransh 3712 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3713 
    except TransactionServiceException, ex:
3714 
      result.ex = ex
3715 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3716 
    result.write(oprot)
3717 
    oprot.writeMessageEnd()
3718 
    oprot.trans.flush()
3719 
 
1382 varun.gupt 3720 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3721 
    args = getReturnableOrdersForCustomer_args()
3722 
    args.read(iprot)
3723 
    iprot.readMessageEnd()
3724 
    result = getReturnableOrdersForCustomer_result()
3725 
    try:
3726 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3727 
    except TransactionServiceException, ex:
3728 
      result.ex = ex
3729 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3730 
    result.write(oprot)
3731 
    oprot.writeMessageEnd()
3732 
    oprot.trans.flush()
3733 
 
3734 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3735 
    args = getCancellableOrdersForCustomer_args()
3736 
    args.read(iprot)
3737 
    iprot.readMessageEnd()
3738 
    result = getCancellableOrdersForCustomer_result()
3739 
    try:
3740 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3741 
    except TransactionServiceException, ex:
3742 
      result.ex = ex
3743 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3744 
    result.write(oprot)
3745 
    oprot.writeMessageEnd()
3746 
    oprot.trans.flush()
3747 
 
483 rajveer 3748 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3749 
    args = changeOrderStatus_args()
94 ashish 3750 
    args.read(iprot)
3751 
    iprot.readMessageEnd()
483 rajveer 3752 
    result = changeOrderStatus_result()
94 ashish 3753 
    try:
483 rajveer 3754 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3755 
    except TransactionServiceException, ex:
3756 
      result.ex = ex
483 rajveer 3757 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3758 
    result.write(oprot)
3759 
    oprot.writeMessageEnd()
3760 
    oprot.trans.flush()
3761 
 
483 rajveer 3762 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3763 
    args = getOrdersForTransaction_args()
94 ashish 3764 
    args.read(iprot)
3765 
    iprot.readMessageEnd()
483 rajveer 3766 
    result = getOrdersForTransaction_result()
94 ashish 3767 
    try:
1528 ankur.sing 3768 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3769 
    except TransactionServiceException, ex:
3770 
      result.ex = ex
483 rajveer 3771 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3772 
    result.write(oprot)
3773 
    oprot.writeMessageEnd()
3774 
    oprot.trans.flush()
3775 
 
483 rajveer 3776 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3777 
    args = getOrdersForCustomer_args()
94 ashish 3778 
    args.read(iprot)
3779 
    iprot.readMessageEnd()
483 rajveer 3780 
    result = getOrdersForCustomer_result()
94 ashish 3781 
    try:
3014 chandransh 3782 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3783 
    except TransactionServiceException, ex:
3784 
      result.ex = ex
483 rajveer 3785 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
483 rajveer 3790 
  def process_createOrder(self, seqid, iprot, oprot):
3791 
    args = createOrder_args()
94 ashish 3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
483 rajveer 3794 
    result = createOrder_result()
94 ashish 3795 
    try:
483 rajveer 3796 
      result.success = self._handler.createOrder(args.order)
94 ashish 3797 
    except TransactionServiceException, ex:
3798 
      result.ex = ex
483 rajveer 3799 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3800 
    result.write(oprot)
3801 
    oprot.writeMessageEnd()
3802 
    oprot.trans.flush()
3803 
 
483 rajveer 3804 
  def process_getOrder(self, seqid, iprot, oprot):
3805 
    args = getOrder_args()
94 ashish 3806 
    args.read(iprot)
3807 
    iprot.readMessageEnd()
483 rajveer 3808 
    result = getOrder_result()
94 ashish 3809 
    try:
483 rajveer 3810 
      result.success = self._handler.getOrder(args.id)
94 ashish 3811 
    except TransactionServiceException, ex:
3812 
      result.ex = ex
483 rajveer 3813 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3814 
    result.write(oprot)
3815 
    oprot.writeMessageEnd()
3816 
    oprot.trans.flush()
3817 
 
483 rajveer 3818 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3819 
    args = getLineItemsForOrder_args()
94 ashish 3820 
    args.read(iprot)
3821 
    iprot.readMessageEnd()
483 rajveer 3822 
    result = getLineItemsForOrder_result()
94 ashish 3823 
    try:
483 rajveer 3824 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3825 
    except TransactionServiceException, ex:
3826 
      result.ex = ex
483 rajveer 3827 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
3831 
 
1528 ankur.sing 3832 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3833 
    args = getOrderForCustomer_args()
3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
3836 
    result = getOrderForCustomer_result()
3837 
    try:
3838 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3839 
    except TransactionServiceException, ex:
3840 
      result.ex = ex
3841 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
3845 
 
3064 chandransh 3846 
  def process_getAlerts(self, seqid, iprot, oprot):
3847 
    args = getAlerts_args()
3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
3850 
    result = getAlerts_result()
4444 rajveer 3851 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 3852 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3853 
    result.write(oprot)
3854 
    oprot.writeMessageEnd()
3855 
    oprot.trans.flush()
3856 
 
4394 rajveer 3857 
  def process_addAlert(self, seqid, iprot, oprot):
3858 
    args = addAlert_args()
3064 chandransh 3859 
    args.read(iprot)
3860 
    iprot.readMessageEnd()
4394 rajveer 3861 
    result = addAlert_result()
4444 rajveer 3862 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 3863 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 3864 
    result.write(oprot)
3865 
    oprot.writeMessageEnd()
3866 
    oprot.trans.flush()
3867 
 
4444 rajveer 3868 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
3869 
    args = markAlertsAsSeen_args()
3870 
    args.read(iprot)
3871 
    iprot.readMessageEnd()
3872 
    result = markAlertsAsSeen_result()
3873 
    self._handler.markAlertsAsSeen(args.warehouseId)
3874 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
3875 
    result.write(oprot)
3876 
    oprot.writeMessageEnd()
3877 
    oprot.trans.flush()
3878 
 
3064 chandransh 3879 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3880 
    args = getValidOrderCount_args()
3881 
    args.read(iprot)
3882 
    iprot.readMessageEnd()
3883 
    result = getValidOrderCount_result()
3884 
    result.success = self._handler.getValidOrderCount()
3885 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3886 
    result.write(oprot)
3887 
    oprot.writeMessageEnd()
3888 
    oprot.trans.flush()
3889 
 
3890 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3891 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3892 
    args.read(iprot)
3893 
    iprot.readMessageEnd()
3894 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3895 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3896 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3900 
 
3901 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3902 
    args = getValidOrdersAmountRange_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = getValidOrdersAmountRange_result()
3906 
    result.success = self._handler.getValidOrdersAmountRange()
3907 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
3908 
    result.write(oprot)
3909 
    oprot.writeMessageEnd()
3910 
    oprot.trans.flush()
3911 
 
3912 
  def process_getValidOrders(self, seqid, iprot, oprot):
3913 
    args = getValidOrders_args()
3914 
    args.read(iprot)
3915 
    iprot.readMessageEnd()
3916 
    result = getValidOrders_result()
3917 
    result.success = self._handler.getValidOrders(args.limit)
3918 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
3919 
    result.write(oprot)
3920 
    oprot.writeMessageEnd()
3921 
    oprot.trans.flush()
3922 
 
1220 chandransh 3923 
  def process_batchOrders(self, seqid, iprot, oprot):
3924 
    args = batchOrders_args()
3925 
    args.read(iprot)
3926 
    iprot.readMessageEnd()
3927 
    result = batchOrders_result()
3928 
    try:
3929 
      result.success = self._handler.batchOrders(args.warehouseId)
3930 
    except TransactionServiceException, ex:
3931 
      result.ex = ex
3932 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
3933 
    result.write(oprot)
3934 
    oprot.writeMessageEnd()
3935 
    oprot.trans.flush()
3936 
 
1208 chandransh 3937 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
3938 
    args = markOrderAsOutOfStock_args()
3939 
    args.read(iprot)
3940 
    iprot.readMessageEnd()
3941 
    result = markOrderAsOutOfStock_result()
3942 
    try:
3943 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
3944 
    except TransactionServiceException, ex:
3945 
      result.ex = ex
3946 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
3947 
    result.write(oprot)
3948 
    oprot.writeMessageEnd()
3949 
    oprot.trans.flush()
3950 
 
3064 chandransh 3951 
  def process_verifyOrder(self, seqid, iprot, oprot):
3952 
    args = verifyOrder_args()
759 chandransh 3953 
    args.read(iprot)
3954 
    iprot.readMessageEnd()
3064 chandransh 3955 
    result = verifyOrder_result()
759 chandransh 3956 
    try:
3064 chandransh 3957 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 3958 
    except TransactionServiceException, ex:
3959 
      result.ex = ex
3064 chandransh 3960 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 3961 
    result.write(oprot)
3962 
    oprot.writeMessageEnd()
3963 
    oprot.trans.flush()
3964 
 
3064 chandransh 3965 
  def process_acceptOrder(self, seqid, iprot, oprot):
3966 
    args = acceptOrder_args()
1113 chandransh 3967 
    args.read(iprot)
3968 
    iprot.readMessageEnd()
3064 chandransh 3969 
    result = acceptOrder_result()
1113 chandransh 3970 
    try:
3064 chandransh 3971 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 3972 
    except TransactionServiceException, ex:
3973 
      result.ex = ex
3064 chandransh 3974 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 3975 
    result.write(oprot)
3976 
    oprot.writeMessageEnd()
3977 
    oprot.trans.flush()
3978 
 
3064 chandransh 3979 
  def process_addBillingDetails(self, seqid, iprot, oprot):
3980 
    args = addBillingDetails_args()
1135 chandransh 3981 
    args.read(iprot)
3982 
    iprot.readMessageEnd()
3064 chandransh 3983 
    result = addBillingDetails_result()
1135 chandransh 3984 
    try:
4283 anupam.sin 3985 
      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 3986 
    except TransactionServiceException, ex:
3987 
      result.ex = ex
3064 chandransh 3988 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 3989 
    result.write(oprot)
3990 
    oprot.writeMessageEnd()
3991 
    oprot.trans.flush()
3992 
 
3064 chandransh 3993 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
3994 
    args = markOrdersAsManifested_args()
1408 ankur.sing 3995 
    args.read(iprot)
3996 
    iprot.readMessageEnd()
3064 chandransh 3997 
    result = markOrdersAsManifested_result()
3998 
    try:
3999 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4000 
    except TransactionServiceException, ex:
4001 
      result.ex = ex
4002 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4003 
    result.write(oprot)
4004 
    oprot.writeMessageEnd()
4005 
    oprot.trans.flush()
4006 
 
4410 rajveer 4007 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4008 
    args = markOrdersAsShippedFromWarehouse_args()
4009 
    args.read(iprot)
4010 
    iprot.readMessageEnd()
4011 
    result = markOrdersAsShippedFromWarehouse_result()
4012 
    try:
4013 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4014 
    except TransactionServiceException, ex:
4015 
      result.ex = ex
4016 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4017 
    result.write(oprot)
4018 
    oprot.writeMessageEnd()
4019 
    oprot.trans.flush()
4020 
 
3064 chandransh 4021 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4022 
    args = markOrdersAsPickedUp_args()
304 ashish 4023 
    args.read(iprot)
4024 
    iprot.readMessageEnd()
3064 chandransh 4025 
    result = markOrdersAsPickedUp_result()
4026 
    try:
4027 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4028 
    except TransactionServiceException, ex:
4029 
      result.ex = ex
4030 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4031 
    result.write(oprot)
4032 
    oprot.writeMessageEnd()
4033 
    oprot.trans.flush()
94 ashish 4034 
 
3064 chandransh 4035 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4036 
    args = markOrdersAsDelivered_args()
304 ashish 4037 
    args.read(iprot)
4038 
    iprot.readMessageEnd()
3064 chandransh 4039 
    result = markOrdersAsDelivered_result()
4040 
    try:
4041 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4042 
    except TransactionServiceException, ex:
4043 
      result.ex = ex
4044 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4045 
    result.write(oprot)
4046 
    oprot.writeMessageEnd()
4047 
    oprot.trans.flush()
4048 
 
3064 chandransh 4049 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4050 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4051 
    args.read(iprot)
4052 
    iprot.readMessageEnd()
3064 chandransh 4053 
    result = markOrdersAsFailed_result()
4054 
    try:
4055 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4056 
    except TransactionServiceException, ex:
4057 
      result.ex = ex
4058 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4059 
    result.write(oprot)
4060 
    oprot.writeMessageEnd()
4061 
    oprot.trans.flush()
304 ashish 4062 
 
3064 chandransh 4063 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4064 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4065 
    args.read(iprot)
4066 
    iprot.readMessageEnd()
3064 chandransh 4067 
    result = updateNonDeliveryReason_result()
4068 
    try:
4069 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4070 
    except TransactionServiceException, ex:
4071 
      result.ex = ex
4072 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4073 
    result.write(oprot)
4074 
    oprot.writeMessageEnd()
4075 
    oprot.trans.flush()
1596 ankur.sing 4076 
 
3064 chandransh 4077 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4078 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4079 
    args.read(iprot)
4080 
    iprot.readMessageEnd()
3064 chandransh 4081 
    result = getUndeliveredOrders_result()
4082 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4083 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4084 
    result.write(oprot)
4085 
    oprot.writeMessageEnd()
4086 
    oprot.trans.flush()
4087 
 
2536 chandransh 4088 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4089 
    args = toggleDOAFlag_args()
4090 
    args.read(iprot)
4091 
    iprot.readMessageEnd()
4092 
    result = toggleDOAFlag_result()
4093 
    try:
4094 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4095 
    except TransactionServiceException, ex:
4096 
      result.ex = ex
4097 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4098 
    result.write(oprot)
4099 
    oprot.writeMessageEnd()
4100 
    oprot.trans.flush()
1886 ankur.sing 4101 
 
2536 chandransh 4102 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4103 
    args = requestPickupNumber_args()
4104 
    args.read(iprot)
4105 
    iprot.readMessageEnd()
4106 
    result = requestPickupNumber_result()
4107 
    try:
4108 
      result.success = self._handler.requestPickupNumber(args.orderId)
4109 
    except TransactionServiceException, ex:
4110 
      result.ex = ex
4111 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4112 
    result.write(oprot)
4113 
    oprot.writeMessageEnd()
4114 
    oprot.trans.flush()
4115 
 
4116 
  def process_authorizePickup(self, seqid, iprot, oprot):
4117 
    args = authorizePickup_args()
4118 
    args.read(iprot)
4119 
    iprot.readMessageEnd()
4120 
    result = authorizePickup_result()
4121 
    try:
4122 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4123 
    except TransactionServiceException, ex:
4124 
      result.ex = ex
4125 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4126 
    result.write(oprot)
4127 
    oprot.writeMessageEnd()
4128 
    oprot.trans.flush()
4129 
 
2764 chandransh 4130 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4131 
    args = markDoasAsPickedUp_args()
4132 
    args.read(iprot)
4133 
    iprot.readMessageEnd()
4134 
    result = markDoasAsPickedUp_result()
4135 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4136 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4137 
    result.write(oprot)
4138 
    oprot.writeMessageEnd()
4139 
    oprot.trans.flush()
4140 
 
2616 chandransh 4141 
  def process_receiveReturn(self, seqid, iprot, oprot):
4142 
    args = receiveReturn_args()
2591 chandransh 4143 
    args.read(iprot)
4144 
    iprot.readMessageEnd()
2616 chandransh 4145 
    result = receiveReturn_result()
2591 chandransh 4146 
    try:
2616 chandransh 4147 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 4148 
    except TransactionServiceException, ex:
4149 
      result.ex = ex
2616 chandransh 4150 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
2536 chandransh 4154 
 
2591 chandransh 4155 
  def process_validateDoa(self, seqid, iprot, oprot):
4156 
    args = validateDoa_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = validateDoa_result()
4160 
    try:
4161 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4162 
    except TransactionServiceException, ex:
4163 
      result.ex = ex
4164 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
2616 chandransh 4169 
  def process_reshipOrder(self, seqid, iprot, oprot):
4170 
    args = reshipOrder_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = reshipOrder_result()
4174 
    try:
4175 
      result.success = self._handler.reshipOrder(args.orderId)
4176 
    except TransactionServiceException, ex:
4177 
      result.ex = ex
4178 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
2591 chandransh 4182 
 
2616 chandransh 4183 
  def process_refundOrder(self, seqid, iprot, oprot):
4184 
    args = refundOrder_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = refundOrder_result()
4188 
    try:
3226 chandransh 4189 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4190 
    except TransactionServiceException, ex:
4191 
      result.ex = ex
4192 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
2690 chandransh 4197 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4198 
    args = getReturnOrders_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = getReturnOrders_result()
4202 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4203 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4204 
    result.write(oprot)
4205 
    oprot.writeMessageEnd()
4206 
    oprot.trans.flush()
2616 chandransh 4207 
 
2700 chandransh 4208 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4209 
    args = getReturnOrder_args()
4210 
    args.read(iprot)
4211 
    iprot.readMessageEnd()
4212 
    result = getReturnOrder_result()
4213 
    try:
4214 
      result.success = self._handler.getReturnOrder(args.id)
4215 
    except TransactionServiceException, ex:
4216 
      result.ex = ex
4217 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4218 
    result.write(oprot)
4219 
    oprot.writeMessageEnd()
4220 
    oprot.trans.flush()
4221 
 
2690 chandransh 4222 
  def process_processReturn(self, seqid, iprot, oprot):
4223 
    args = processReturn_args()
4224 
    args.read(iprot)
4225 
    iprot.readMessageEnd()
4226 
    result = processReturn_result()
4227 
    try:
4228 
      self._handler.processReturn(args.returnOrderId)
4229 
    except TransactionServiceException, ex:
4230 
      result.ex = ex
4231 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4232 
    result.write(oprot)
4233 
    oprot.writeMessageEnd()
4234 
    oprot.trans.flush()
4235 
 
2819 chandransh 4236 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4237 
    args = createPurchaseOrder_args()
4238 
    args.read(iprot)
4239 
    iprot.readMessageEnd()
4240 
    result = createPurchaseOrder_result()
4241 
    try:
4242 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4243 
    except TransactionServiceException, ex:
4244 
      result.ex = ex
4245 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4246 
    result.write(oprot)
4247 
    oprot.writeMessageEnd()
4248 
    oprot.trans.flush()
2690 chandransh 4249 
 
3451 chandransh 4250 
  def process_updateWeight(self, seqid, iprot, oprot):
4251 
    args = updateWeight_args()
4252 
    args.read(iprot)
4253 
    iprot.readMessageEnd()
4254 
    result = updateWeight_result()
4255 
    try:
4256 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4257 
    except TransactionServiceException, ex:
4258 
      result.ex = ex
4259 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4260 
    result.write(oprot)
4261 
    oprot.writeMessageEnd()
4262 
    oprot.trans.flush()
2819 chandransh 4263 
 
3469 chandransh 4264 
  def process_changeItem(self, seqid, iprot, oprot):
4265 
    args = changeItem_args()
4266 
    args.read(iprot)
4267 
    iprot.readMessageEnd()
4268 
    result = changeItem_result()
4269 
    try:
4270 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4271 
    except TransactionServiceException, ex:
4272 
      result.ex = ex
4273 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
3451 chandransh 4277 
 
3469 chandransh 4278 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4279 
    args = shiftToWarehouse_args()
4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
4282 
    result = shiftToWarehouse_result()
4283 
    try:
4284 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4285 
    except TransactionServiceException, ex:
4286 
      result.ex = ex
4287 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4288 
    result.write(oprot)
4289 
    oprot.writeMessageEnd()
4290 
    oprot.trans.flush()
4291 
 
3553 chandransh 4292 
  def process_addDelayReason(self, seqid, iprot, oprot):
4293 
    args = addDelayReason_args()
4294 
    args.read(iprot)
4295 
    iprot.readMessageEnd()
4296 
    result = addDelayReason_result()
4297 
    try:
3986 chandransh 4298 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4299 
    except TransactionServiceException, ex:
4300 
      result.ex = ex
4301 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
3469 chandransh 4305 
 
3956 chandransh 4306 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4307 
    args = reconcileCodCollection_args()
4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
4310 
    result = reconcileCodCollection_result()
4311 
    try:
4312 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4313 
    except TransactionServiceException, ex:
4314 
      result.ex = ex
4315 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
3553 chandransh 4319 
 
4008 mandeep.dh 4320 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4321 
    args = getTransactionsRequiringExtraProcessing_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = getTransactionsRequiringExtraProcessing_result()
4325 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4326 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
3956 chandransh 4330 
 
4008 mandeep.dh 4331 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4332 
    args = markTransactionAsProcessed_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = markTransactionAsProcessed_result()
4336 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4337 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
4341 
 
4018 chandransh 4342 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4343 
    args = getItemWiseRiskyOrdersCount_args()
4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
4346 
    result = getItemWiseRiskyOrdersCount_result()
4347 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4348 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4349 
    result.write(oprot)
4350 
    oprot.writeMessageEnd()
4351 
    oprot.trans.flush()
4008 mandeep.dh 4352 
 
4295 varun.gupt 4353 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4354 
    args = getOrdersForItemIds_args()
4355 
    args.read(iprot)
4356 
    iprot.readMessageEnd()
4357 
    result = getOrdersForItemIds_result()
4358 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4359 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4360 
    result.write(oprot)
4361 
    oprot.writeMessageEnd()
4362 
    oprot.trans.flush()
4363 
 
4247 rajveer 4364 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4365 
    args = markOrderCancellationRequestReceived_args()
4366 
    args.read(iprot)
4367 
    iprot.readMessageEnd()
4368 
    result = markOrderCancellationRequestReceived_result()
4369 
    try:
4370 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4371 
    except TransactionServiceException, ex:
4372 
      result.ex = ex
4373 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4374 
    result.write(oprot)
4375 
    oprot.writeMessageEnd()
4376 
    oprot.trans.flush()
4018 chandransh 4377 
 
4247 rajveer 4378 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4379 
    args = markOrderCancellationRequestConfirmed_args()
4380 
    args.read(iprot)
4381 
    iprot.readMessageEnd()
4382 
    result = markOrderCancellationRequestConfirmed_result()
4383 
    try:
4384 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4385 
    except TransactionServiceException, ex:
4386 
      result.ex = ex
4387 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4388 
    result.write(oprot)
4389 
    oprot.writeMessageEnd()
4390 
    oprot.trans.flush()
4391 
 
4392 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4393 
    args = markOrderCancellationRequestDenied_args()
4394 
    args.read(iprot)
4395 
    iprot.readMessageEnd()
4396 
    result = markOrderCancellationRequestDenied_result()
4397 
    try:
4398 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4399 
    except TransactionServiceException, ex:
4400 
      result.ex = ex
4401 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4402 
    result.write(oprot)
4403 
    oprot.writeMessageEnd()
4404 
    oprot.trans.flush()
4405 
 
4258 rajveer 4406 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4407 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4408 
    args.read(iprot)
4409 
    iprot.readMessageEnd()
4258 rajveer 4410 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4411 
    try:
4258 rajveer 4412 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4413 
    except TransactionServiceException, ex:
4414 
      result.ex = ex
4258 rajveer 4415 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4416 
    result.write(oprot)
4417 
    oprot.writeMessageEnd()
4418 
    oprot.trans.flush()
4419 
 
4259 anupam.sin 4420 
  def process_refundTransaction(self, seqid, iprot, oprot):
4421 
    args = refundTransaction_args()
4422 
    args.read(iprot)
4423 
    iprot.readMessageEnd()
4424 
    result = refundTransaction_result()
4425 
    try:
4426 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4427 
    except TransactionServiceException, ex:
4428 
      result.ex = ex
4429 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4430 
    result.write(oprot)
4431 
    oprot.writeMessageEnd()
4432 
    oprot.trans.flush()
4247 rajveer 4433 
 
4324 mandeep.dh 4434 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4435 
    args = updateShipmentAddress_args()
4436 
    args.read(iprot)
4437 
    iprot.readMessageEnd()
4438 
    result = updateShipmentAddress_result()
4439 
    try:
4440 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4441 
    except TransactionServiceException, ex:
4442 
      result.ex = ex
4443 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4444 
    result.write(oprot)
4445 
    oprot.writeMessageEnd()
4446 
    oprot.trans.flush()
4447 
 
4285 rajveer 4448 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4449 
    args = acceptOrdersForItemId_args()
4450 
    args.read(iprot)
4451 
    iprot.readMessageEnd()
4452 
    result = acceptOrdersForItemId_result()
4453 
    try:
4454 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4455 
    except TransactionServiceException, ex:
4456 
      result.ex = ex
4457 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4458 
    result.write(oprot)
4459 
    oprot.writeMessageEnd()
4460 
    oprot.trans.flush()
4259 anupam.sin 4461 
 
4303 rajveer 4462 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4463 
    args = markOrdersAsPORaised_args()
4464 
    args.read(iprot)
4465 
    iprot.readMessageEnd()
4466 
    result = markOrdersAsPORaised_result()
4467 
    try:
4369 rajveer 4468 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4469 
    except TransactionServiceException, ex:
4470 
      result.ex = ex
4471 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4472 
    result.write(oprot)
4473 
    oprot.writeMessageEnd()
4474 
    oprot.trans.flush()
4285 rajveer 4475 
 
4303 rajveer 4476 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4477 
    args = markOrdersAsReversalInitiated_args()
4478 
    args.read(iprot)
4479 
    iprot.readMessageEnd()
4480 
    result = markOrdersAsReversalInitiated_result()
4481 
    try:
4369 rajveer 4482 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4483 
    except TransactionServiceException, ex:
4484 
      result.ex = ex
4485 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4486 
    result.write(oprot)
4487 
    oprot.writeMessageEnd()
4488 
    oprot.trans.flush()
4489 
 
4490 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4491 
    args = markOrdersAsNotAvailabke_args()
4492 
    args.read(iprot)
4493 
    iprot.readMessageEnd()
4494 
    result = markOrdersAsNotAvailabke_result()
4495 
    try:
4369 rajveer 4496 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4497 
    except TransactionServiceException, ex:
4498 
      result.ex = ex
4499 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4500 
    result.write(oprot)
4501 
    oprot.writeMessageEnd()
4502 
    oprot.trans.flush()
4503 
 
4369 rajveer 4504 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4505 
    args = markOrdersAsTimeout_args()
4506 
    args.read(iprot)
4507 
    iprot.readMessageEnd()
4508 
    result = markOrdersAsTimeout_result()
4509 
    try:
4510 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4511 
    except TransactionServiceException, ex:
4512 
      result.ex = ex
4513 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4514 
    result.write(oprot)
4515 
    oprot.writeMessageEnd()
4516 
    oprot.trans.flush()
4303 rajveer 4517 
 
4386 anupam.sin 4518 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4519 
    args = getOrderForAwb_args()
4520 
    args.read(iprot)
4521 
    iprot.readMessageEnd()
4522 
    result = getOrderForAwb_result()
4523 
    try:
4524 
      result.success = self._handler.getOrderForAwb(args.awb)
4525 
    except TransactionServiceException, ex:
4526 
      result.ex = ex
4527 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4528 
    result.write(oprot)
4529 
    oprot.writeMessageEnd()
4530 
    oprot.trans.flush()
4369 rajveer 4531 
 
4386 anupam.sin 4532 
 
94 ashish 4533 
# HELPER FUNCTIONS AND STRUCTURES
4534 
 
4535 
class createTransaction_args:
4536 
  """
4537 
  Attributes:
4538 
   - transaction
4539 
  """
4540 
 
4541 
  thrift_spec = (
4542 
    None, # 0
4543 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4544 
  )
4545 
 
4546 
  def __init__(self, transaction=None,):
4547 
    self.transaction = transaction
4548 
 
4549 
  def read(self, iprot):
4550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4552 
      return
4553 
    iprot.readStructBegin()
4554 
    while True:
4555 
      (fname, ftype, fid) = iprot.readFieldBegin()
4556 
      if ftype == TType.STOP:
4557 
        break
4558 
      if fid == 1:
4559 
        if ftype == TType.STRUCT:
4560 
          self.transaction = Transaction()
4561 
          self.transaction.read(iprot)
4562 
        else:
4563 
          iprot.skip(ftype)
4564 
      else:
4565 
        iprot.skip(ftype)
4566 
      iprot.readFieldEnd()
4567 
    iprot.readStructEnd()
4568 
 
4569 
  def write(self, oprot):
4570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4572 
      return
4573 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4574 
    if self.transaction is not None:
94 ashish 4575 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4576 
      self.transaction.write(oprot)
4577 
      oprot.writeFieldEnd()
4578 
    oprot.writeFieldStop()
4579 
    oprot.writeStructEnd()
4580 
 
3431 rajveer 4581 
  def validate(self):
4582 
    return
4583 
 
4584 
 
94 ashish 4585 
  def __repr__(self):
4586 
    L = ['%s=%r' % (key, value)
4587 
      for key, value in self.__dict__.iteritems()]
4588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4589 
 
4590 
  def __eq__(self, other):
4591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4592 
 
4593 
  def __ne__(self, other):
4594 
    return not (self == other)
4595 
 
4596 
class createTransaction_result:
4597 
  """
4598 
  Attributes:
132 ashish 4599 
   - success
94 ashish 4600 
   - ex
4601 
  """
4602 
 
4603 
  thrift_spec = (
132 ashish 4604 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4605 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4606 
  )
4607 
 
132 ashish 4608 
  def __init__(self, success=None, ex=None,):
4609 
    self.success = success
94 ashish 4610 
    self.ex = ex
4611 
 
4612 
  def read(self, iprot):
4613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4615 
      return
4616 
    iprot.readStructBegin()
4617 
    while True:
4618 
      (fname, ftype, fid) = iprot.readFieldBegin()
4619 
      if ftype == TType.STOP:
4620 
        break
132 ashish 4621 
      if fid == 0:
4622 
        if ftype == TType.I64:
4623 
          self.success = iprot.readI64();
4624 
        else:
4625 
          iprot.skip(ftype)
4626 
      elif fid == 1:
94 ashish 4627 
        if ftype == TType.STRUCT:
4628 
          self.ex = TransactionServiceException()
4629 
          self.ex.read(iprot)
4630 
        else:
4631 
          iprot.skip(ftype)
4632 
      else:
4633 
        iprot.skip(ftype)
4634 
      iprot.readFieldEnd()
4635 
    iprot.readStructEnd()
4636 
 
4637 
  def write(self, oprot):
4638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4640 
      return
4641 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4642 
    if self.success is not None:
132 ashish 4643 
      oprot.writeFieldBegin('success', TType.I64, 0)
4644 
      oprot.writeI64(self.success)
4645 
      oprot.writeFieldEnd()
3431 rajveer 4646 
    if self.ex is not None:
94 ashish 4647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4648 
      self.ex.write(oprot)
4649 
      oprot.writeFieldEnd()
4650 
    oprot.writeFieldStop()
4651 
    oprot.writeStructEnd()
4652 
 
3431 rajveer 4653 
  def validate(self):
4654 
    return
4655 
 
4656 
 
94 ashish 4657 
  def __repr__(self):
4658 
    L = ['%s=%r' % (key, value)
4659 
      for key, value in self.__dict__.iteritems()]
4660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4661 
 
4662 
  def __eq__(self, other):
4663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4664 
 
4665 
  def __ne__(self, other):
4666 
    return not (self == other)
4667 
 
4668 
class getTransaction_args:
4669 
  """
4670 
  Attributes:
4671 
   - id
4672 
  """
4673 
 
4674 
  thrift_spec = (
4675 
    None, # 0
4676 
    (1, TType.I64, 'id', None, None, ), # 1
4677 
  )
4678 
 
4679 
  def __init__(self, id=None,):
4680 
    self.id = id
4681 
 
4682 
  def read(self, iprot):
4683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4685 
      return
4686 
    iprot.readStructBegin()
4687 
    while True:
4688 
      (fname, ftype, fid) = iprot.readFieldBegin()
4689 
      if ftype == TType.STOP:
4690 
        break
4691 
      if fid == 1:
4692 
        if ftype == TType.I64:
4693 
          self.id = iprot.readI64();
4694 
        else:
4695 
          iprot.skip(ftype)
4696 
      else:
4697 
        iprot.skip(ftype)
4698 
      iprot.readFieldEnd()
4699 
    iprot.readStructEnd()
4700 
 
4701 
  def write(self, oprot):
4702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4704 
      return
4705 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4706 
    if self.id is not None:
94 ashish 4707 
      oprot.writeFieldBegin('id', TType.I64, 1)
4708 
      oprot.writeI64(self.id)
4709 
      oprot.writeFieldEnd()
4710 
    oprot.writeFieldStop()
4711 
    oprot.writeStructEnd()
4712 
 
3431 rajveer 4713 
  def validate(self):
4714 
    return
4715 
 
4716 
 
94 ashish 4717 
  def __repr__(self):
4718 
    L = ['%s=%r' % (key, value)
4719 
      for key, value in self.__dict__.iteritems()]
4720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4721 
 
4722 
  def __eq__(self, other):
4723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4724 
 
4725 
  def __ne__(self, other):
4726 
    return not (self == other)
4727 
 
4728 
class getTransaction_result:
4729 
  """
4730 
  Attributes:
4731 
   - success
4732 
   - ex
4733 
  """
4734 
 
4735 
  thrift_spec = (
4736 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4738 
  )
4739 
 
4740 
  def __init__(self, success=None, ex=None,):
4741 
    self.success = success
4742 
    self.ex = ex
4743 
 
4744 
  def read(self, iprot):
4745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4747 
      return
4748 
    iprot.readStructBegin()
4749 
    while True:
4750 
      (fname, ftype, fid) = iprot.readFieldBegin()
4751 
      if ftype == TType.STOP:
4752 
        break
4753 
      if fid == 0:
4754 
        if ftype == TType.STRUCT:
4755 
          self.success = Transaction()
4756 
          self.success.read(iprot)
4757 
        else:
4758 
          iprot.skip(ftype)
4759 
      elif fid == 1:
4760 
        if ftype == TType.STRUCT:
4761 
          self.ex = TransactionServiceException()
4762 
          self.ex.read(iprot)
4763 
        else:
4764 
          iprot.skip(ftype)
4765 
      else:
4766 
        iprot.skip(ftype)
4767 
      iprot.readFieldEnd()
4768 
    iprot.readStructEnd()
4769 
 
4770 
  def write(self, oprot):
4771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4773 
      return
4774 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4775 
    if self.success is not None:
94 ashish 4776 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4777 
      self.success.write(oprot)
4778 
      oprot.writeFieldEnd()
3431 rajveer 4779 
    if self.ex is not None:
94 ashish 4780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4781 
      self.ex.write(oprot)
4782 
      oprot.writeFieldEnd()
4783 
    oprot.writeFieldStop()
4784 
    oprot.writeStructEnd()
4785 
 
3431 rajveer 4786 
  def validate(self):
4787 
    return
4788 
 
4789 
 
94 ashish 4790 
  def __repr__(self):
4791 
    L = ['%s=%r' % (key, value)
4792 
      for key, value in self.__dict__.iteritems()]
4793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4794 
 
4795 
  def __eq__(self, other):
4796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4797 
 
4798 
  def __ne__(self, other):
4799 
    return not (self == other)
4800 
 
4801 
class getTransactionsForCustomer_args:
4802 
  """
4803 
  Attributes:
4804 
   - customerId
4805 
   - from_date
4806 
   - to_date
4807 
   - status
4808 
  """
4809 
 
4810 
  thrift_spec = (
4811 
    None, # 0
4812 
    (1, TType.I64, 'customerId', None, None, ), # 1
4813 
    (2, TType.I64, 'from_date', None, None, ), # 2
4814 
    (3, TType.I64, 'to_date', None, None, ), # 3
4815 
    (4, TType.I32, 'status', None, None, ), # 4
4816 
  )
4817 
 
4818 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4819 
    self.customerId = customerId
4820 
    self.from_date = from_date
4821 
    self.to_date = to_date
4822 
    self.status = status
4823 
 
4824 
  def read(self, iprot):
4825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4827 
      return
4828 
    iprot.readStructBegin()
4829 
    while True:
4830 
      (fname, ftype, fid) = iprot.readFieldBegin()
4831 
      if ftype == TType.STOP:
4832 
        break
4833 
      if fid == 1:
4834 
        if ftype == TType.I64:
4835 
          self.customerId = iprot.readI64();
4836 
        else:
4837 
          iprot.skip(ftype)
4838 
      elif fid == 2:
4839 
        if ftype == TType.I64:
4840 
          self.from_date = iprot.readI64();
4841 
        else:
4842 
          iprot.skip(ftype)
4843 
      elif fid == 3:
4844 
        if ftype == TType.I64:
4845 
          self.to_date = iprot.readI64();
4846 
        else:
4847 
          iprot.skip(ftype)
4848 
      elif fid == 4:
4849 
        if ftype == TType.I32:
4850 
          self.status = iprot.readI32();
4851 
        else:
4852 
          iprot.skip(ftype)
4853 
      else:
4854 
        iprot.skip(ftype)
4855 
      iprot.readFieldEnd()
4856 
    iprot.readStructEnd()
4857 
 
4858 
  def write(self, oprot):
4859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4861 
      return
4862 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4863 
    if self.customerId is not None:
94 ashish 4864 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4865 
      oprot.writeI64(self.customerId)
4866 
      oprot.writeFieldEnd()
3431 rajveer 4867 
    if self.from_date is not None:
94 ashish 4868 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4869 
      oprot.writeI64(self.from_date)
4870 
      oprot.writeFieldEnd()
3431 rajveer 4871 
    if self.to_date is not None:
94 ashish 4872 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4873 
      oprot.writeI64(self.to_date)
4874 
      oprot.writeFieldEnd()
3431 rajveer 4875 
    if self.status is not None:
94 ashish 4876 
      oprot.writeFieldBegin('status', TType.I32, 4)
4877 
      oprot.writeI32(self.status)
4878 
      oprot.writeFieldEnd()
4879 
    oprot.writeFieldStop()
4880 
    oprot.writeStructEnd()
4881 
 
3431 rajveer 4882 
  def validate(self):
4883 
    return
4884 
 
4885 
 
94 ashish 4886 
  def __repr__(self):
4887 
    L = ['%s=%r' % (key, value)
4888 
      for key, value in self.__dict__.iteritems()]
4889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4890 
 
4891 
  def __eq__(self, other):
4892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4893 
 
4894 
  def __ne__(self, other):
4895 
    return not (self == other)
4896 
 
4897 
class getTransactionsForCustomer_result:
4898 
  """
4899 
  Attributes:
4900 
   - success
4901 
   - ex
4902 
  """
4903 
 
4904 
  thrift_spec = (
4905 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
4906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4907 
  )
4908 
 
4909 
  def __init__(self, success=None, ex=None,):
4910 
    self.success = success
4911 
    self.ex = ex
4912 
 
4913 
  def read(self, iprot):
4914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4916 
      return
4917 
    iprot.readStructBegin()
4918 
    while True:
4919 
      (fname, ftype, fid) = iprot.readFieldBegin()
4920 
      if ftype == TType.STOP:
4921 
        break
4922 
      if fid == 0:
4923 
        if ftype == TType.LIST:
4924 
          self.success = []
685 chandransh 4925 
          (_etype17, _size14) = iprot.readListBegin()
4926 
          for _i18 in xrange(_size14):
4927 
            _elem19 = Transaction()
4928 
            _elem19.read(iprot)
4929 
            self.success.append(_elem19)
94 ashish 4930 
          iprot.readListEnd()
4931 
        else:
4932 
          iprot.skip(ftype)
4933 
      elif fid == 1:
4934 
        if ftype == TType.STRUCT:
4935 
          self.ex = TransactionServiceException()
4936 
          self.ex.read(iprot)
4937 
        else:
4938 
          iprot.skip(ftype)
4939 
      else:
4940 
        iprot.skip(ftype)
4941 
      iprot.readFieldEnd()
4942 
    iprot.readStructEnd()
4943 
 
4944 
  def write(self, oprot):
4945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4947 
      return
4948 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 4949 
    if self.success is not None:
94 ashish 4950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4952 
      for iter20 in self.success:
4953 
        iter20.write(oprot)
94 ashish 4954 
      oprot.writeListEnd()
4955 
      oprot.writeFieldEnd()
3431 rajveer 4956 
    if self.ex is not None:
94 ashish 4957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4958 
      self.ex.write(oprot)
4959 
      oprot.writeFieldEnd()
4960 
    oprot.writeFieldStop()
4961 
    oprot.writeStructEnd()
4962 
 
3431 rajveer 4963 
  def validate(self):
4964 
    return
4965 
 
4966 
 
94 ashish 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 
 
132 ashish 4978 
class getTransactionsForShoppingCartId_args:
4979 
  """
4980 
  Attributes:
4981 
   - shoppingCartId
4982 
  """
4983 
 
4984 
  thrift_spec = (
4985 
    None, # 0
4986 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
4987 
  )
4988 
 
4989 
  def __init__(self, shoppingCartId=None,):
4990 
    self.shoppingCartId = shoppingCartId
4991 
 
4992 
  def read(self, iprot):
4993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4995 
      return
4996 
    iprot.readStructBegin()
4997 
    while True:
4998 
      (fname, ftype, fid) = iprot.readFieldBegin()
4999 
      if ftype == TType.STOP:
5000 
        break
5001 
      if fid == 1:
5002 
        if ftype == TType.I64:
5003 
          self.shoppingCartId = iprot.readI64();
5004 
        else:
5005 
          iprot.skip(ftype)
5006 
      else:
5007 
        iprot.skip(ftype)
5008 
      iprot.readFieldEnd()
5009 
    iprot.readStructEnd()
5010 
 
5011 
  def write(self, oprot):
5012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5014 
      return
5015 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5016 
    if self.shoppingCartId is not None:
132 ashish 5017 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5018 
      oprot.writeI64(self.shoppingCartId)
5019 
      oprot.writeFieldEnd()
5020 
    oprot.writeFieldStop()
5021 
    oprot.writeStructEnd()
5022 
 
3431 rajveer 5023 
  def validate(self):
5024 
    return
5025 
 
5026 
 
132 ashish 5027 
  def __repr__(self):
5028 
    L = ['%s=%r' % (key, value)
5029 
      for key, value in self.__dict__.iteritems()]
5030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5031 
 
5032 
  def __eq__(self, other):
5033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5034 
 
5035 
  def __ne__(self, other):
5036 
    return not (self == other)
5037 
 
5038 
class getTransactionsForShoppingCartId_result:
5039 
  """
5040 
  Attributes:
5041 
   - success
5042 
   - ex
5043 
  """
5044 
 
5045 
  thrift_spec = (
5046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5048 
  )
5049 
 
5050 
  def __init__(self, success=None, ex=None,):
5051 
    self.success = success
5052 
    self.ex = ex
5053 
 
5054 
  def read(self, iprot):
5055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5057 
      return
5058 
    iprot.readStructBegin()
5059 
    while True:
5060 
      (fname, ftype, fid) = iprot.readFieldBegin()
5061 
      if ftype == TType.STOP:
5062 
        break
5063 
      if fid == 0:
5064 
        if ftype == TType.LIST:
5065 
          self.success = []
685 chandransh 5066 
          (_etype24, _size21) = iprot.readListBegin()
5067 
          for _i25 in xrange(_size21):
5068 
            _elem26 = Transaction()
5069 
            _elem26.read(iprot)
5070 
            self.success.append(_elem26)
132 ashish 5071 
          iprot.readListEnd()
5072 
        else:
5073 
          iprot.skip(ftype)
5074 
      elif fid == 1:
5075 
        if ftype == TType.STRUCT:
5076 
          self.ex = TransactionServiceException()
5077 
          self.ex.read(iprot)
5078 
        else:
5079 
          iprot.skip(ftype)
5080 
      else:
5081 
        iprot.skip(ftype)
5082 
      iprot.readFieldEnd()
5083 
    iprot.readStructEnd()
5084 
 
5085 
  def write(self, oprot):
5086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5088 
      return
5089 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5090 
    if self.success is not None:
132 ashish 5091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5093 
      for iter27 in self.success:
5094 
        iter27.write(oprot)
132 ashish 5095 
      oprot.writeListEnd()
5096 
      oprot.writeFieldEnd()
3431 rajveer 5097 
    if self.ex is not None:
132 ashish 5098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5099 
      self.ex.write(oprot)
5100 
      oprot.writeFieldEnd()
5101 
    oprot.writeFieldStop()
5102 
    oprot.writeStructEnd()
5103 
 
3431 rajveer 5104 
  def validate(self):
5105 
    return
5106 
 
5107 
 
132 ashish 5108 
  def __repr__(self):
5109 
    L = ['%s=%r' % (key, value)
5110 
      for key, value in self.__dict__.iteritems()]
5111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5112 
 
5113 
  def __eq__(self, other):
5114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5115 
 
5116 
  def __ne__(self, other):
5117 
    return not (self == other)
5118 
 
94 ashish 5119 
class getTransactionStatus_args:
5120 
  """
5121 
  Attributes:
5122 
   - transactionId
5123 
  """
5124 
 
5125 
  thrift_spec = (
5126 
    None, # 0
5127 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5128 
  )
5129 
 
5130 
  def __init__(self, transactionId=None,):
5131 
    self.transactionId = transactionId
5132 
 
5133 
  def read(self, iprot):
5134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5136 
      return
5137 
    iprot.readStructBegin()
5138 
    while True:
5139 
      (fname, ftype, fid) = iprot.readFieldBegin()
5140 
      if ftype == TType.STOP:
5141 
        break
5142 
      if fid == 1:
5143 
        if ftype == TType.I64:
5144 
          self.transactionId = iprot.readI64();
5145 
        else:
5146 
          iprot.skip(ftype)
5147 
      else:
5148 
        iprot.skip(ftype)
5149 
      iprot.readFieldEnd()
5150 
    iprot.readStructEnd()
5151 
 
5152 
  def write(self, oprot):
5153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5155 
      return
5156 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5157 
    if self.transactionId is not None:
94 ashish 5158 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5159 
      oprot.writeI64(self.transactionId)
5160 
      oprot.writeFieldEnd()
5161 
    oprot.writeFieldStop()
5162 
    oprot.writeStructEnd()
5163 
 
3431 rajveer 5164 
  def validate(self):
5165 
    return
5166 
 
5167 
 
94 ashish 5168 
  def __repr__(self):
5169 
    L = ['%s=%r' % (key, value)
5170 
      for key, value in self.__dict__.iteritems()]
5171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5172 
 
5173 
  def __eq__(self, other):
5174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5175 
 
5176 
  def __ne__(self, other):
5177 
    return not (self == other)
5178 
 
5179 
class getTransactionStatus_result:
5180 
  """
5181 
  Attributes:
5182 
   - success
5183 
   - ex
5184 
  """
5185 
 
5186 
  thrift_spec = (
5187 
    (0, TType.I32, 'success', None, None, ), # 0
5188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5189 
  )
5190 
 
5191 
  def __init__(self, success=None, ex=None,):
5192 
    self.success = success
5193 
    self.ex = ex
5194 
 
5195 
  def read(self, iprot):
5196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5198 
      return
5199 
    iprot.readStructBegin()
5200 
    while True:
5201 
      (fname, ftype, fid) = iprot.readFieldBegin()
5202 
      if ftype == TType.STOP:
5203 
        break
5204 
      if fid == 0:
5205 
        if ftype == TType.I32:
5206 
          self.success = iprot.readI32();
5207 
        else:
5208 
          iprot.skip(ftype)
5209 
      elif fid == 1:
5210 
        if ftype == TType.STRUCT:
5211 
          self.ex = TransactionServiceException()
5212 
          self.ex.read(iprot)
5213 
        else:
5214 
          iprot.skip(ftype)
5215 
      else:
5216 
        iprot.skip(ftype)
5217 
      iprot.readFieldEnd()
5218 
    iprot.readStructEnd()
5219 
 
5220 
  def write(self, oprot):
5221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5223 
      return
5224 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5225 
    if self.success is not None:
94 ashish 5226 
      oprot.writeFieldBegin('success', TType.I32, 0)
5227 
      oprot.writeI32(self.success)
5228 
      oprot.writeFieldEnd()
3431 rajveer 5229 
    if self.ex is not None:
94 ashish 5230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5231 
      self.ex.write(oprot)
5232 
      oprot.writeFieldEnd()
5233 
    oprot.writeFieldStop()
5234 
    oprot.writeStructEnd()
5235 
 
3431 rajveer 5236 
  def validate(self):
5237 
    return
5238 
 
5239 
 
94 ashish 5240 
  def __repr__(self):
5241 
    L = ['%s=%r' % (key, value)
5242 
      for key, value in self.__dict__.iteritems()]
5243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5244 
 
5245 
  def __eq__(self, other):
5246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5247 
 
5248 
  def __ne__(self, other):
5249 
    return not (self == other)
5250 
 
5251 
class changeTransactionStatus_args:
5252 
  """
5253 
  Attributes:
5254 
   - transactionId
5255 
   - status
5256 
   - description
5257 
  """
5258 
 
5259 
  thrift_spec = (
5260 
    None, # 0
5261 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5262 
    (2, TType.I32, 'status', None, None, ), # 2
5263 
    (3, TType.STRING, 'description', None, None, ), # 3
5264 
  )
5265 
 
5266 
  def __init__(self, transactionId=None, status=None, description=None,):
5267 
    self.transactionId = transactionId
5268 
    self.status = status
5269 
    self.description = description
5270 
 
5271 
  def read(self, iprot):
5272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5274 
      return
5275 
    iprot.readStructBegin()
5276 
    while True:
5277 
      (fname, ftype, fid) = iprot.readFieldBegin()
5278 
      if ftype == TType.STOP:
5279 
        break
5280 
      if fid == 1:
5281 
        if ftype == TType.I64:
5282 
          self.transactionId = iprot.readI64();
5283 
        else:
5284 
          iprot.skip(ftype)
5285 
      elif fid == 2:
5286 
        if ftype == TType.I32:
5287 
          self.status = iprot.readI32();
5288 
        else:
5289 
          iprot.skip(ftype)
5290 
      elif fid == 3:
5291 
        if ftype == TType.STRING:
5292 
          self.description = iprot.readString();
5293 
        else:
5294 
          iprot.skip(ftype)
5295 
      else:
5296 
        iprot.skip(ftype)
5297 
      iprot.readFieldEnd()
5298 
    iprot.readStructEnd()
5299 
 
5300 
  def write(self, oprot):
5301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5303 
      return
5304 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5305 
    if self.transactionId is not None:
94 ashish 5306 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5307 
      oprot.writeI64(self.transactionId)
5308 
      oprot.writeFieldEnd()
3431 rajveer 5309 
    if self.status is not None:
94 ashish 5310 
      oprot.writeFieldBegin('status', TType.I32, 2)
5311 
      oprot.writeI32(self.status)
5312 
      oprot.writeFieldEnd()
3431 rajveer 5313 
    if self.description is not None:
94 ashish 5314 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5315 
      oprot.writeString(self.description)
5316 
      oprot.writeFieldEnd()
5317 
    oprot.writeFieldStop()
5318 
    oprot.writeStructEnd()
5319 
 
3431 rajveer 5320 
  def validate(self):
5321 
    return
5322 
 
5323 
 
94 ashish 5324 
  def __repr__(self):
5325 
    L = ['%s=%r' % (key, value)
5326 
      for key, value in self.__dict__.iteritems()]
5327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5328 
 
5329 
  def __eq__(self, other):
5330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5331 
 
5332 
  def __ne__(self, other):
5333 
    return not (self == other)
5334 
 
5335 
class changeTransactionStatus_result:
5336 
  """
5337 
  Attributes:
5338 
   - success
5339 
   - ex
5340 
  """
5341 
 
5342 
  thrift_spec = (
5343 
    (0, TType.BOOL, 'success', None, None, ), # 0
5344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5345 
  )
5346 
 
5347 
  def __init__(self, success=None, ex=None,):
5348 
    self.success = success
5349 
    self.ex = ex
5350 
 
5351 
  def read(self, iprot):
5352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5354 
      return
5355 
    iprot.readStructBegin()
5356 
    while True:
5357 
      (fname, ftype, fid) = iprot.readFieldBegin()
5358 
      if ftype == TType.STOP:
5359 
        break
5360 
      if fid == 0:
5361 
        if ftype == TType.BOOL:
5362 
          self.success = iprot.readBool();
5363 
        else:
5364 
          iprot.skip(ftype)
5365 
      elif fid == 1:
5366 
        if ftype == TType.STRUCT:
5367 
          self.ex = TransactionServiceException()
5368 
          self.ex.read(iprot)
5369 
        else:
5370 
          iprot.skip(ftype)
5371 
      else:
5372 
        iprot.skip(ftype)
5373 
      iprot.readFieldEnd()
5374 
    iprot.readStructEnd()
5375 
 
5376 
  def write(self, oprot):
5377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5379 
      return
5380 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5381 
    if self.success is not None:
94 ashish 5382 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5383 
      oprot.writeBool(self.success)
5384 
      oprot.writeFieldEnd()
3431 rajveer 5385 
    if self.ex is not None:
94 ashish 5386 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5387 
      self.ex.write(oprot)
5388 
      oprot.writeFieldEnd()
5389 
    oprot.writeFieldStop()
5390 
    oprot.writeStructEnd()
5391 
 
3431 rajveer 5392 
  def validate(self):
5393 
    return
5394 
 
5395 
 
94 ashish 5396 
  def __repr__(self):
5397 
    L = ['%s=%r' % (key, value)
5398 
      for key, value in self.__dict__.iteritems()]
5399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5400 
 
5401 
  def __eq__(self, other):
5402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5403 
 
5404 
  def __ne__(self, other):
5405 
    return not (self == other)
5406 
 
1398 varun.gupt 5407 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5408 
  """
5409 
  Attributes:
5410 
   - transactionId
5411 
  """
5412 
 
5413 
  thrift_spec = (
5414 
    None, # 0
5415 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5416 
  )
5417 
 
5418 
  def __init__(self, transactionId=None,):
5419 
    self.transactionId = transactionId
5420 
 
5421 
  def read(self, iprot):
5422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5424 
      return
5425 
    iprot.readStructBegin()
5426 
    while True:
5427 
      (fname, ftype, fid) = iprot.readFieldBegin()
5428 
      if ftype == TType.STOP:
5429 
        break
5430 
      if fid == 1:
5431 
        if ftype == TType.I64:
5432 
          self.transactionId = iprot.readI64();
5433 
        else:
5434 
          iprot.skip(ftype)
5435 
      else:
5436 
        iprot.skip(ftype)
5437 
      iprot.readFieldEnd()
5438 
    iprot.readStructEnd()
5439 
 
5440 
  def write(self, oprot):
5441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5443 
      return
1398 varun.gupt 5444 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5445 
    if self.transactionId is not None:
1382 varun.gupt 5446 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5447 
      oprot.writeI64(self.transactionId)
5448 
      oprot.writeFieldEnd()
5449 
    oprot.writeFieldStop()
5450 
    oprot.writeStructEnd()
5451 
 
3431 rajveer 5452 
  def validate(self):
5453 
    return
5454 
 
5455 
 
1382 varun.gupt 5456 
  def __repr__(self):
5457 
    L = ['%s=%r' % (key, value)
5458 
      for key, value in self.__dict__.iteritems()]
5459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5460 
 
5461 
  def __eq__(self, other):
5462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5463 
 
5464 
  def __ne__(self, other):
5465 
    return not (self == other)
5466 
 
1398 varun.gupt 5467 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5468 
  """
5469 
  Attributes:
5470 
   - success
5471 
   - ex
5472 
  """
5473 
 
5474 
  thrift_spec = (
5475 
    (0, TType.BOOL, 'success', None, None, ), # 0
5476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5477 
  )
5478 
 
5479 
  def __init__(self, success=None, ex=None,):
5480 
    self.success = success
5481 
    self.ex = ex
5482 
 
5483 
  def read(self, iprot):
5484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5486 
      return
5487 
    iprot.readStructBegin()
5488 
    while True:
5489 
      (fname, ftype, fid) = iprot.readFieldBegin()
5490 
      if ftype == TType.STOP:
5491 
        break
5492 
      if fid == 0:
5493 
        if ftype == TType.BOOL:
5494 
          self.success = iprot.readBool();
5495 
        else:
5496 
          iprot.skip(ftype)
5497 
      elif fid == 1:
5498 
        if ftype == TType.STRUCT:
5499 
          self.ex = TransactionServiceException()
5500 
          self.ex.read(iprot)
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      else:
5504 
        iprot.skip(ftype)
5505 
      iprot.readFieldEnd()
5506 
    iprot.readStructEnd()
5507 
 
5508 
  def write(self, oprot):
5509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5511 
      return
1398 varun.gupt 5512 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5513 
    if self.success is not None:
1382 varun.gupt 5514 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5515 
      oprot.writeBool(self.success)
5516 
      oprot.writeFieldEnd()
3431 rajveer 5517 
    if self.ex is not None:
1382 varun.gupt 5518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5519 
      self.ex.write(oprot)
5520 
      oprot.writeFieldEnd()
5521 
    oprot.writeFieldStop()
5522 
    oprot.writeStructEnd()
5523 
 
3431 rajveer 5524 
  def validate(self):
5525 
    return
5526 
 
5527 
 
1382 varun.gupt 5528 
  def __repr__(self):
5529 
    L = ['%s=%r' % (key, value)
5530 
      for key, value in self.__dict__.iteritems()]
5531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5532 
 
5533 
  def __eq__(self, other):
5534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5535 
 
5536 
  def __ne__(self, other):
5537 
    return not (self == other)
5538 
 
483 rajveer 5539 
class getAllOrders_args:
94 ashish 5540 
  """
5541 
  Attributes:
483 rajveer 5542 
   - status
5543 
   - from_date
5544 
   - to_date
5545 
   - warehouse_id
94 ashish 5546 
  """
5547 
 
5548 
  thrift_spec = (
5549 
    None, # 0
483 rajveer 5550 
    (1, TType.I32, 'status', None, None, ), # 1
5551 
    (2, TType.I64, 'from_date', None, None, ), # 2
5552 
    (3, TType.I64, 'to_date', None, None, ), # 3
5553 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5554 
  )
5555 
 
483 rajveer 5556 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5557 
    self.status = status
5558 
    self.from_date = from_date
5559 
    self.to_date = to_date
5560 
    self.warehouse_id = warehouse_id
94 ashish 5561 
 
5562 
  def read(self, iprot):
5563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5565 
      return
5566 
    iprot.readStructBegin()
5567 
    while True:
5568 
      (fname, ftype, fid) = iprot.readFieldBegin()
5569 
      if ftype == TType.STOP:
5570 
        break
5571 
      if fid == 1:
483 rajveer 5572 
        if ftype == TType.I32:
5573 
          self.status = iprot.readI32();
94 ashish 5574 
        else:
5575 
          iprot.skip(ftype)
483 rajveer 5576 
      elif fid == 2:
5577 
        if ftype == TType.I64:
5578 
          self.from_date = iprot.readI64();
94 ashish 5579 
        else:
5580 
          iprot.skip(ftype)
483 rajveer 5581 
      elif fid == 3:
5582 
        if ftype == TType.I64:
5583 
          self.to_date = iprot.readI64();
94 ashish 5584 
        else:
5585 
          iprot.skip(ftype)
483 rajveer 5586 
      elif fid == 4:
94 ashish 5587 
        if ftype == TType.I64:
483 rajveer 5588 
          self.warehouse_id = iprot.readI64();
94 ashish 5589 
        else:
5590 
          iprot.skip(ftype)
5591 
      else:
5592 
        iprot.skip(ftype)
5593 
      iprot.readFieldEnd()
5594 
    iprot.readStructEnd()
5595 
 
5596 
  def write(self, oprot):
5597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5599 
      return
483 rajveer 5600 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5601 
    if self.status is not None:
483 rajveer 5602 
      oprot.writeFieldBegin('status', TType.I32, 1)
5603 
      oprot.writeI32(self.status)
94 ashish 5604 
      oprot.writeFieldEnd()
3431 rajveer 5605 
    if self.from_date is not None:
483 rajveer 5606 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5607 
      oprot.writeI64(self.from_date)
94 ashish 5608 
      oprot.writeFieldEnd()
3431 rajveer 5609 
    if self.to_date is not None:
483 rajveer 5610 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5611 
      oprot.writeI64(self.to_date)
94 ashish 5612 
      oprot.writeFieldEnd()
3431 rajveer 5613 
    if self.warehouse_id is not None:
483 rajveer 5614 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5615 
      oprot.writeI64(self.warehouse_id)
94 ashish 5616 
      oprot.writeFieldEnd()
5617 
    oprot.writeFieldStop()
5618 
    oprot.writeStructEnd()
5619 
 
3431 rajveer 5620 
  def validate(self):
5621 
    return
5622 
 
5623 
 
94 ashish 5624 
  def __repr__(self):
5625 
    L = ['%s=%r' % (key, value)
5626 
      for key, value in self.__dict__.iteritems()]
5627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5628 
 
5629 
  def __eq__(self, other):
5630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5631 
 
5632 
  def __ne__(self, other):
5633 
    return not (self == other)
5634 
 
483 rajveer 5635 
class getAllOrders_result:
94 ashish 5636 
  """
5637 
  Attributes:
5638 
   - success
5639 
   - ex
5640 
  """
5641 
 
5642 
  thrift_spec = (
483 rajveer 5643 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5645 
  )
5646 
 
5647 
  def __init__(self, success=None, ex=None,):
5648 
    self.success = success
5649 
    self.ex = ex
5650 
 
5651 
  def read(self, iprot):
5652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5654 
      return
5655 
    iprot.readStructBegin()
5656 
    while True:
5657 
      (fname, ftype, fid) = iprot.readFieldBegin()
5658 
      if ftype == TType.STOP:
5659 
        break
5660 
      if fid == 0:
483 rajveer 5661 
        if ftype == TType.LIST:
5662 
          self.success = []
685 chandransh 5663 
          (_etype31, _size28) = iprot.readListBegin()
5664 
          for _i32 in xrange(_size28):
5665 
            _elem33 = Order()
5666 
            _elem33.read(iprot)
5667 
            self.success.append(_elem33)
483 rajveer 5668 
          iprot.readListEnd()
94 ashish 5669 
        else:
5670 
          iprot.skip(ftype)
5671 
      elif fid == 1:
5672 
        if ftype == TType.STRUCT:
5673 
          self.ex = TransactionServiceException()
5674 
          self.ex.read(iprot)
5675 
        else:
5676 
          iprot.skip(ftype)
5677 
      else:
5678 
        iprot.skip(ftype)
5679 
      iprot.readFieldEnd()
5680 
    iprot.readStructEnd()
5681 
 
5682 
  def write(self, oprot):
5683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5685 
      return
483 rajveer 5686 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5687 
    if self.success is not None:
483 rajveer 5688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5689 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5690 
      for iter34 in self.success:
5691 
        iter34.write(oprot)
483 rajveer 5692 
      oprot.writeListEnd()
94 ashish 5693 
      oprot.writeFieldEnd()
3431 rajveer 5694 
    if self.ex is not None:
94 ashish 5695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5696 
      self.ex.write(oprot)
5697 
      oprot.writeFieldEnd()
5698 
    oprot.writeFieldStop()
5699 
    oprot.writeStructEnd()
5700 
 
3431 rajveer 5701 
  def validate(self):
5702 
    return
5703 
 
5704 
 
94 ashish 5705 
  def __repr__(self):
5706 
    L = ['%s=%r' % (key, value)
5707 
      for key, value in self.__dict__.iteritems()]
5708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5709 
 
5710 
  def __eq__(self, other):
5711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5712 
 
5713 
  def __ne__(self, other):
5714 
    return not (self == other)
5715 
 
4133 chandransh 5716 
class getOrdersInBatch_args:
5717 
  """
5718 
  Attributes:
5719 
   - statuses
5720 
   - offset
5721 
   - limit
5722 
   - warehouse_id
5723 
  """
5724 
 
5725 
  thrift_spec = (
5726 
    None, # 0
5727 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5728 
    (2, TType.I64, 'offset', None, None, ), # 2
5729 
    (3, TType.I64, 'limit', None, None, ), # 3
5730 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5731 
  )
5732 
 
5733 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5734 
    self.statuses = statuses
5735 
    self.offset = offset
5736 
    self.limit = limit
5737 
    self.warehouse_id = warehouse_id
5738 
 
5739 
  def read(self, iprot):
5740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5742 
      return
5743 
    iprot.readStructBegin()
5744 
    while True:
5745 
      (fname, ftype, fid) = iprot.readFieldBegin()
5746 
      if ftype == TType.STOP:
5747 
        break
5748 
      if fid == 1:
5749 
        if ftype == TType.LIST:
5750 
          self.statuses = []
5751 
          (_etype38, _size35) = iprot.readListBegin()
5752 
          for _i39 in xrange(_size35):
5753 
            _elem40 = iprot.readI32();
5754 
            self.statuses.append(_elem40)
5755 
          iprot.readListEnd()
5756 
        else:
5757 
          iprot.skip(ftype)
5758 
      elif fid == 2:
5759 
        if ftype == TType.I64:
5760 
          self.offset = iprot.readI64();
5761 
        else:
5762 
          iprot.skip(ftype)
5763 
      elif fid == 3:
5764 
        if ftype == TType.I64:
5765 
          self.limit = iprot.readI64();
5766 
        else:
5767 
          iprot.skip(ftype)
5768 
      elif fid == 4:
5769 
        if ftype == TType.I64:
5770 
          self.warehouse_id = iprot.readI64();
5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
5782 
    oprot.writeStructBegin('getOrdersInBatch_args')
5783 
    if self.statuses is not None:
5784 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5785 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5786 
      for iter41 in self.statuses:
5787 
        oprot.writeI32(iter41)
5788 
      oprot.writeListEnd()
5789 
      oprot.writeFieldEnd()
5790 
    if self.offset is not None:
5791 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5792 
      oprot.writeI64(self.offset)
5793 
      oprot.writeFieldEnd()
5794 
    if self.limit is not None:
5795 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5796 
      oprot.writeI64(self.limit)
5797 
      oprot.writeFieldEnd()
5798 
    if self.warehouse_id is not None:
5799 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5800 
      oprot.writeI64(self.warehouse_id)
5801 
      oprot.writeFieldEnd()
5802 
    oprot.writeFieldStop()
5803 
    oprot.writeStructEnd()
5804 
 
5805 
  def validate(self):
5806 
    return
5807 
 
5808 
 
5809 
  def __repr__(self):
5810 
    L = ['%s=%r' % (key, value)
5811 
      for key, value in self.__dict__.iteritems()]
5812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5813 
 
5814 
  def __eq__(self, other):
5815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5816 
 
5817 
  def __ne__(self, other):
5818 
    return not (self == other)
5819 
 
5820 
class getOrdersInBatch_result:
5821 
  """
5822 
  Attributes:
5823 
   - success
5824 
   - ex
5825 
  """
5826 
 
5827 
  thrift_spec = (
5828 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5830 
  )
5831 
 
5832 
  def __init__(self, success=None, ex=None,):
5833 
    self.success = success
5834 
    self.ex = ex
5835 
 
5836 
  def read(self, iprot):
5837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5839 
      return
5840 
    iprot.readStructBegin()
5841 
    while True:
5842 
      (fname, ftype, fid) = iprot.readFieldBegin()
5843 
      if ftype == TType.STOP:
5844 
        break
5845 
      if fid == 0:
5846 
        if ftype == TType.LIST:
5847 
          self.success = []
5848 
          (_etype45, _size42) = iprot.readListBegin()
5849 
          for _i46 in xrange(_size42):
5850 
            _elem47 = Order()
5851 
            _elem47.read(iprot)
5852 
            self.success.append(_elem47)
5853 
          iprot.readListEnd()
5854 
        else:
5855 
          iprot.skip(ftype)
5856 
      elif fid == 1:
5857 
        if ftype == TType.STRUCT:
5858 
          self.ex = TransactionServiceException()
5859 
          self.ex.read(iprot)
5860 
        else:
5861 
          iprot.skip(ftype)
5862 
      else:
5863 
        iprot.skip(ftype)
5864 
      iprot.readFieldEnd()
5865 
    iprot.readStructEnd()
5866 
 
5867 
  def write(self, oprot):
5868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5870 
      return
5871 
    oprot.writeStructBegin('getOrdersInBatch_result')
5872 
    if self.success is not None:
5873 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5874 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5875 
      for iter48 in self.success:
5876 
        iter48.write(oprot)
5877 
      oprot.writeListEnd()
5878 
      oprot.writeFieldEnd()
5879 
    if self.ex is not None:
5880 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5881 
      self.ex.write(oprot)
5882 
      oprot.writeFieldEnd()
5883 
    oprot.writeFieldStop()
5884 
    oprot.writeStructEnd()
5885 
 
5886 
  def validate(self):
5887 
    return
5888 
 
5889 
 
5890 
  def __repr__(self):
5891 
    L = ['%s=%r' % (key, value)
5892 
      for key, value in self.__dict__.iteritems()]
5893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5894 
 
5895 
  def __eq__(self, other):
5896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5897 
 
5898 
  def __ne__(self, other):
5899 
    return not (self == other)
5900 
 
5901 
class getOrderCount_args:
5902 
  """
5903 
  Attributes:
5904 
   - statuses
5905 
   - warehouseId
5906 
  """
5907 
 
5908 
  thrift_spec = (
5909 
    None, # 0
5910 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5911 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5912 
  )
5913 
 
5914 
  def __init__(self, statuses=None, warehouseId=None,):
5915 
    self.statuses = statuses
5916 
    self.warehouseId = warehouseId
5917 
 
5918 
  def read(self, iprot):
5919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5921 
      return
5922 
    iprot.readStructBegin()
5923 
    while True:
5924 
      (fname, ftype, fid) = iprot.readFieldBegin()
5925 
      if ftype == TType.STOP:
5926 
        break
5927 
      if fid == 1:
5928 
        if ftype == TType.LIST:
5929 
          self.statuses = []
5930 
          (_etype52, _size49) = iprot.readListBegin()
5931 
          for _i53 in xrange(_size49):
5932 
            _elem54 = iprot.readI32();
5933 
            self.statuses.append(_elem54)
5934 
          iprot.readListEnd()
5935 
        else:
5936 
          iprot.skip(ftype)
5937 
      elif fid == 2:
5938 
        if ftype == TType.I64:
5939 
          self.warehouseId = iprot.readI64();
5940 
        else:
5941 
          iprot.skip(ftype)
5942 
      else:
5943 
        iprot.skip(ftype)
5944 
      iprot.readFieldEnd()
5945 
    iprot.readStructEnd()
5946 
 
5947 
  def write(self, oprot):
5948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5950 
      return
5951 
    oprot.writeStructBegin('getOrderCount_args')
5952 
    if self.statuses is not None:
5953 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5954 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5955 
      for iter55 in self.statuses:
5956 
        oprot.writeI32(iter55)
5957 
      oprot.writeListEnd()
5958 
      oprot.writeFieldEnd()
5959 
    if self.warehouseId is not None:
5960 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5961 
      oprot.writeI64(self.warehouseId)
5962 
      oprot.writeFieldEnd()
5963 
    oprot.writeFieldStop()
5964 
    oprot.writeStructEnd()
5965 
 
5966 
  def validate(self):
5967 
    return
5968 
 
5969 
 
5970 
  def __repr__(self):
5971 
    L = ['%s=%r' % (key, value)
5972 
      for key, value in self.__dict__.iteritems()]
5973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5974 
 
5975 
  def __eq__(self, other):
5976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5977 
 
5978 
  def __ne__(self, other):
5979 
    return not (self == other)
5980 
 
5981 
class getOrderCount_result:
5982 
  """
5983 
  Attributes:
5984 
   - success
5985 
   - ex
5986 
  """
5987 
 
5988 
  thrift_spec = (
5989 
    (0, TType.I32, 'success', None, None, ), # 0
5990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5991 
  )
5992 
 
5993 
  def __init__(self, success=None, ex=None,):
5994 
    self.success = success
5995 
    self.ex = ex
5996 
 
5997 
  def read(self, iprot):
5998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6000 
      return
6001 
    iprot.readStructBegin()
6002 
    while True:
6003 
      (fname, ftype, fid) = iprot.readFieldBegin()
6004 
      if ftype == TType.STOP:
6005 
        break
6006 
      if fid == 0:
6007 
        if ftype == TType.I32:
6008 
          self.success = iprot.readI32();
6009 
        else:
6010 
          iprot.skip(ftype)
6011 
      elif fid == 1:
6012 
        if ftype == TType.STRUCT:
6013 
          self.ex = TransactionServiceException()
6014 
          self.ex.read(iprot)
6015 
        else:
6016 
          iprot.skip(ftype)
6017 
      else:
6018 
        iprot.skip(ftype)
6019 
      iprot.readFieldEnd()
6020 
    iprot.readStructEnd()
6021 
 
6022 
  def write(self, oprot):
6023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6025 
      return
6026 
    oprot.writeStructBegin('getOrderCount_result')
6027 
    if self.success is not None:
6028 
      oprot.writeFieldBegin('success', TType.I32, 0)
6029 
      oprot.writeI32(self.success)
6030 
      oprot.writeFieldEnd()
6031 
    if self.ex is not None:
6032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6033 
      self.ex.write(oprot)
6034 
      oprot.writeFieldEnd()
6035 
    oprot.writeFieldStop()
6036 
    oprot.writeStructEnd()
6037 
 
6038 
  def validate(self):
6039 
    return
6040 
 
6041 
 
6042 
  def __repr__(self):
6043 
    L = ['%s=%r' % (key, value)
6044 
      for key, value in self.__dict__.iteritems()]
6045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6046 
 
6047 
  def __eq__(self, other):
6048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6049 
 
6050 
  def __ne__(self, other):
6051 
    return not (self == other)
6052 
 
999 varun.gupt 6053 
class getOrdersByBillingDate_args:
6054 
  """
6055 
  Attributes:
6056 
   - status
6057 
   - start_billing_date
6058 
   - end_billing_date
6059 
   - warehouse_id
6060 
  """
6061 
 
6062 
  thrift_spec = (
6063 
    None, # 0
6064 
    (1, TType.I32, 'status', None, None, ), # 1
6065 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6066 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6067 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6068 
  )
6069 
 
6070 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6071 
    self.status = status
6072 
    self.start_billing_date = start_billing_date
6073 
    self.end_billing_date = end_billing_date
6074 
    self.warehouse_id = warehouse_id
6075 
 
6076 
  def read(self, iprot):
6077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6079 
      return
6080 
    iprot.readStructBegin()
6081 
    while True:
6082 
      (fname, ftype, fid) = iprot.readFieldBegin()
6083 
      if ftype == TType.STOP:
6084 
        break
6085 
      if fid == 1:
6086 
        if ftype == TType.I32:
6087 
          self.status = iprot.readI32();
6088 
        else:
6089 
          iprot.skip(ftype)
6090 
      elif fid == 2:
6091 
        if ftype == TType.I64:
6092 
          self.start_billing_date = iprot.readI64();
6093 
        else:
6094 
          iprot.skip(ftype)
6095 
      elif fid == 3:
6096 
        if ftype == TType.I64:
6097 
          self.end_billing_date = iprot.readI64();
6098 
        else:
6099 
          iprot.skip(ftype)
6100 
      elif fid == 4:
6101 
        if ftype == TType.I64:
6102 
          self.warehouse_id = iprot.readI64();
6103 
        else:
6104 
          iprot.skip(ftype)
6105 
      else:
6106 
        iprot.skip(ftype)
6107 
      iprot.readFieldEnd()
6108 
    iprot.readStructEnd()
6109 
 
6110 
  def write(self, oprot):
6111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6113 
      return
6114 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6115 
    if self.status is not None:
999 varun.gupt 6116 
      oprot.writeFieldBegin('status', TType.I32, 1)
6117 
      oprot.writeI32(self.status)
6118 
      oprot.writeFieldEnd()
3431 rajveer 6119 
    if self.start_billing_date is not None:
999 varun.gupt 6120 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6121 
      oprot.writeI64(self.start_billing_date)
6122 
      oprot.writeFieldEnd()
3431 rajveer 6123 
    if self.end_billing_date is not None:
999 varun.gupt 6124 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6125 
      oprot.writeI64(self.end_billing_date)
6126 
      oprot.writeFieldEnd()
3431 rajveer 6127 
    if self.warehouse_id is not None:
999 varun.gupt 6128 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6129 
      oprot.writeI64(self.warehouse_id)
6130 
      oprot.writeFieldEnd()
6131 
    oprot.writeFieldStop()
6132 
    oprot.writeStructEnd()
6133 
 
3431 rajveer 6134 
  def validate(self):
6135 
    return
6136 
 
6137 
 
999 varun.gupt 6138 
  def __repr__(self):
6139 
    L = ['%s=%r' % (key, value)
6140 
      for key, value in self.__dict__.iteritems()]
6141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6142 
 
6143 
  def __eq__(self, other):
6144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6145 
 
6146 
  def __ne__(self, other):
6147 
    return not (self == other)
6148 
 
6149 
class getOrdersByBillingDate_result:
6150 
  """
6151 
  Attributes:
6152 
   - success
6153 
   - ex
6154 
  """
6155 
 
6156 
  thrift_spec = (
6157 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6159 
  )
6160 
 
6161 
  def __init__(self, success=None, ex=None,):
6162 
    self.success = success
6163 
    self.ex = ex
6164 
 
6165 
  def read(self, iprot):
6166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6168 
      return
6169 
    iprot.readStructBegin()
6170 
    while True:
6171 
      (fname, ftype, fid) = iprot.readFieldBegin()
6172 
      if ftype == TType.STOP:
6173 
        break
6174 
      if fid == 0:
6175 
        if ftype == TType.LIST:
6176 
          self.success = []
4133 chandransh 6177 
          (_etype59, _size56) = iprot.readListBegin()
6178 
          for _i60 in xrange(_size56):
6179 
            _elem61 = Order()
6180 
            _elem61.read(iprot)
6181 
            self.success.append(_elem61)
999 varun.gupt 6182 
          iprot.readListEnd()
6183 
        else:
6184 
          iprot.skip(ftype)
6185 
      elif fid == 1:
6186 
        if ftype == TType.STRUCT:
6187 
          self.ex = TransactionServiceException()
6188 
          self.ex.read(iprot)
6189 
        else:
6190 
          iprot.skip(ftype)
6191 
      else:
6192 
        iprot.skip(ftype)
6193 
      iprot.readFieldEnd()
6194 
    iprot.readStructEnd()
6195 
 
6196 
  def write(self, oprot):
6197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6199 
      return
6200 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6201 
    if self.success is not None:
999 varun.gupt 6202 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6203 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6204 
      for iter62 in self.success:
6205 
        iter62.write(oprot)
999 varun.gupt 6206 
      oprot.writeListEnd()
6207 
      oprot.writeFieldEnd()
3431 rajveer 6208 
    if self.ex is not None:
999 varun.gupt 6209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6210 
      self.ex.write(oprot)
6211 
      oprot.writeFieldEnd()
6212 
    oprot.writeFieldStop()
6213 
    oprot.writeStructEnd()
6214 
 
3431 rajveer 6215 
  def validate(self):
6216 
    return
6217 
 
6218 
 
999 varun.gupt 6219 
  def __repr__(self):
6220 
    L = ['%s=%r' % (key, value)
6221 
      for key, value in self.__dict__.iteritems()]
6222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6223 
 
6224 
  def __eq__(self, other):
6225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6226 
 
6227 
  def __ne__(self, other):
6228 
    return not (self == other)
6229 
 
3427 chandransh 6230 
class getOrdersByShippingDate_args:
6231 
  """
6232 
  Attributes:
6233 
   - fromShippingDate
6234 
   - toShippingDate
6235 
   - providerId
6236 
   - warehouseId
3451 chandransh 6237 
   - cod
3427 chandransh 6238 
  """
6239 
 
6240 
  thrift_spec = (
6241 
    None, # 0
6242 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6243 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6244 
    (3, TType.I64, 'providerId', None, None, ), # 3
6245 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6246 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6247 
  )
6248 
 
3451 chandransh 6249 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6250 
    self.fromShippingDate = fromShippingDate
6251 
    self.toShippingDate = toShippingDate
6252 
    self.providerId = providerId
6253 
    self.warehouseId = warehouseId
3451 chandransh 6254 
    self.cod = cod
3427 chandransh 6255 
 
6256 
  def read(self, iprot):
6257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6259 
      return
6260 
    iprot.readStructBegin()
6261 
    while True:
6262 
      (fname, ftype, fid) = iprot.readFieldBegin()
6263 
      if ftype == TType.STOP:
6264 
        break
6265 
      if fid == 1:
6266 
        if ftype == TType.I64:
6267 
          self.fromShippingDate = iprot.readI64();
6268 
        else:
6269 
          iprot.skip(ftype)
6270 
      elif fid == 2:
6271 
        if ftype == TType.I64:
6272 
          self.toShippingDate = iprot.readI64();
6273 
        else:
6274 
          iprot.skip(ftype)
6275 
      elif fid == 3:
6276 
        if ftype == TType.I64:
6277 
          self.providerId = iprot.readI64();
6278 
        else:
6279 
          iprot.skip(ftype)
6280 
      elif fid == 4:
6281 
        if ftype == TType.I64:
6282 
          self.warehouseId = iprot.readI64();
6283 
        else:
6284 
          iprot.skip(ftype)
3451 chandransh 6285 
      elif fid == 5:
6286 
        if ftype == TType.BOOL:
6287 
          self.cod = iprot.readBool();
6288 
        else:
6289 
          iprot.skip(ftype)
3427 chandransh 6290 
      else:
6291 
        iprot.skip(ftype)
6292 
      iprot.readFieldEnd()
6293 
    iprot.readStructEnd()
6294 
 
6295 
  def write(self, oprot):
6296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6298 
      return
6299 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6300 
    if self.fromShippingDate is not None:
3427 chandransh 6301 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6302 
      oprot.writeI64(self.fromShippingDate)
6303 
      oprot.writeFieldEnd()
3431 rajveer 6304 
    if self.toShippingDate is not None:
3427 chandransh 6305 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6306 
      oprot.writeI64(self.toShippingDate)
6307 
      oprot.writeFieldEnd()
3431 rajveer 6308 
    if self.providerId is not None:
3427 chandransh 6309 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6310 
      oprot.writeI64(self.providerId)
6311 
      oprot.writeFieldEnd()
3431 rajveer 6312 
    if self.warehouseId is not None:
3427 chandransh 6313 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6314 
      oprot.writeI64(self.warehouseId)
6315 
      oprot.writeFieldEnd()
3451 chandransh 6316 
    if self.cod is not None:
6317 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6318 
      oprot.writeBool(self.cod)
6319 
      oprot.writeFieldEnd()
3427 chandransh 6320 
    oprot.writeFieldStop()
6321 
    oprot.writeStructEnd()
6322 
 
3431 rajveer 6323 
  def validate(self):
6324 
    return
6325 
 
6326 
 
3427 chandransh 6327 
  def __repr__(self):
6328 
    L = ['%s=%r' % (key, value)
6329 
      for key, value in self.__dict__.iteritems()]
6330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6331 
 
6332 
  def __eq__(self, other):
6333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6334 
 
6335 
  def __ne__(self, other):
6336 
    return not (self == other)
6337 
 
6338 
class getOrdersByShippingDate_result:
6339 
  """
6340 
  Attributes:
6341 
   - success
6342 
   - ex
6343 
  """
6344 
 
6345 
  thrift_spec = (
6346 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6348 
  )
6349 
 
6350 
  def __init__(self, success=None, ex=None,):
6351 
    self.success = success
6352 
    self.ex = ex
6353 
 
6354 
  def read(self, iprot):
6355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6357 
      return
6358 
    iprot.readStructBegin()
6359 
    while True:
6360 
      (fname, ftype, fid) = iprot.readFieldBegin()
6361 
      if ftype == TType.STOP:
6362 
        break
6363 
      if fid == 0:
6364 
        if ftype == TType.LIST:
6365 
          self.success = []
4133 chandransh 6366 
          (_etype66, _size63) = iprot.readListBegin()
6367 
          for _i67 in xrange(_size63):
6368 
            _elem68 = Order()
6369 
            _elem68.read(iprot)
6370 
            self.success.append(_elem68)
3427 chandransh 6371 
          iprot.readListEnd()
6372 
        else:
6373 
          iprot.skip(ftype)
6374 
      elif fid == 1:
6375 
        if ftype == TType.STRUCT:
6376 
          self.ex = TransactionServiceException()
6377 
          self.ex.read(iprot)
6378 
        else:
6379 
          iprot.skip(ftype)
6380 
      else:
6381 
        iprot.skip(ftype)
6382 
      iprot.readFieldEnd()
6383 
    iprot.readStructEnd()
6384 
 
6385 
  def write(self, oprot):
6386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6388 
      return
6389 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6390 
    if self.success is not None:
3427 chandransh 6391 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6392 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6393 
      for iter69 in self.success:
6394 
        iter69.write(oprot)
3427 chandransh 6395 
      oprot.writeListEnd()
6396 
      oprot.writeFieldEnd()
3431 rajveer 6397 
    if self.ex is not None:
3427 chandransh 6398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6399 
      self.ex.write(oprot)
6400 
      oprot.writeFieldEnd()
6401 
    oprot.writeFieldStop()
6402 
    oprot.writeStructEnd()
6403 
 
3431 rajveer 6404 
  def validate(self):
6405 
    return
6406 
 
6407 
 
3427 chandransh 6408 
  def __repr__(self):
6409 
    L = ['%s=%r' % (key, value)
6410 
      for key, value in self.__dict__.iteritems()]
6411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6412 
 
6413 
  def __eq__(self, other):
6414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6415 
 
6416 
  def __ne__(self, other):
6417 
    return not (self == other)
6418 
 
1382 varun.gupt 6419 
class getReturnableOrdersForCustomer_args:
6420 
  """
6421 
  Attributes:
6422 
   - customer_id
6423 
   - limit
6424 
  """
6425 
 
6426 
  thrift_spec = (
6427 
    None, # 0
6428 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6429 
    (2, TType.I64, 'limit', None, None, ), # 2
6430 
  )
6431 
 
6432 
  def __init__(self, customer_id=None, limit=None,):
6433 
    self.customer_id = customer_id
6434 
    self.limit = limit
6435 
 
6436 
  def read(self, iprot):
6437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6439 
      return
6440 
    iprot.readStructBegin()
6441 
    while True:
6442 
      (fname, ftype, fid) = iprot.readFieldBegin()
6443 
      if ftype == TType.STOP:
6444 
        break
6445 
      if fid == 1:
6446 
        if ftype == TType.I64:
6447 
          self.customer_id = iprot.readI64();
6448 
        else:
6449 
          iprot.skip(ftype)
6450 
      elif fid == 2:
6451 
        if ftype == TType.I64:
6452 
          self.limit = iprot.readI64();
6453 
        else:
6454 
          iprot.skip(ftype)
6455 
      else:
6456 
        iprot.skip(ftype)
6457 
      iprot.readFieldEnd()
6458 
    iprot.readStructEnd()
6459 
 
6460 
  def write(self, oprot):
6461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6463 
      return
6464 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6465 
    if self.customer_id is not None:
1382 varun.gupt 6466 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6467 
      oprot.writeI64(self.customer_id)
6468 
      oprot.writeFieldEnd()
3431 rajveer 6469 
    if self.limit is not None:
1382 varun.gupt 6470 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6471 
      oprot.writeI64(self.limit)
6472 
      oprot.writeFieldEnd()
6473 
    oprot.writeFieldStop()
6474 
    oprot.writeStructEnd()
6475 
 
3431 rajveer 6476 
  def validate(self):
6477 
    return
6478 
 
6479 
 
1382 varun.gupt 6480 
  def __repr__(self):
6481 
    L = ['%s=%r' % (key, value)
6482 
      for key, value in self.__dict__.iteritems()]
6483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6484 
 
6485 
  def __eq__(self, other):
6486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6487 
 
6488 
  def __ne__(self, other):
6489 
    return not (self == other)
6490 
 
6491 
class getReturnableOrdersForCustomer_result:
6492 
  """
6493 
  Attributes:
6494 
   - success
6495 
   - ex
6496 
  """
6497 
 
6498 
  thrift_spec = (
6499 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6501 
  )
6502 
 
6503 
  def __init__(self, success=None, ex=None,):
6504 
    self.success = success
6505 
    self.ex = ex
6506 
 
6507 
  def read(self, iprot):
6508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6510 
      return
6511 
    iprot.readStructBegin()
6512 
    while True:
6513 
      (fname, ftype, fid) = iprot.readFieldBegin()
6514 
      if ftype == TType.STOP:
6515 
        break
6516 
      if fid == 0:
6517 
        if ftype == TType.LIST:
6518 
          self.success = []
4133 chandransh 6519 
          (_etype73, _size70) = iprot.readListBegin()
6520 
          for _i74 in xrange(_size70):
6521 
            _elem75 = iprot.readI64();
6522 
            self.success.append(_elem75)
1382 varun.gupt 6523 
          iprot.readListEnd()
6524 
        else:
6525 
          iprot.skip(ftype)
6526 
      elif fid == 1:
6527 
        if ftype == TType.STRUCT:
6528 
          self.ex = TransactionServiceException()
6529 
          self.ex.read(iprot)
6530 
        else:
6531 
          iprot.skip(ftype)
6532 
      else:
6533 
        iprot.skip(ftype)
6534 
      iprot.readFieldEnd()
6535 
    iprot.readStructEnd()
6536 
 
6537 
  def write(self, oprot):
6538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6540 
      return
6541 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6542 
    if self.success is not None:
1382 varun.gupt 6543 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6544 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6545 
      for iter76 in self.success:
6546 
        oprot.writeI64(iter76)
1382 varun.gupt 6547 
      oprot.writeListEnd()
6548 
      oprot.writeFieldEnd()
3431 rajveer 6549 
    if self.ex is not None:
1382 varun.gupt 6550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6551 
      self.ex.write(oprot)
6552 
      oprot.writeFieldEnd()
6553 
    oprot.writeFieldStop()
6554 
    oprot.writeStructEnd()
6555 
 
3431 rajveer 6556 
  def validate(self):
6557 
    return
6558 
 
6559 
 
1382 varun.gupt 6560 
  def __repr__(self):
6561 
    L = ['%s=%r' % (key, value)
6562 
      for key, value in self.__dict__.iteritems()]
6563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6564 
 
6565 
  def __eq__(self, other):
6566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6567 
 
6568 
  def __ne__(self, other):
6569 
    return not (self == other)
6570 
 
6571 
class getCancellableOrdersForCustomer_args:
6572 
  """
6573 
  Attributes:
6574 
   - customer_id
6575 
   - limit
6576 
  """
6577 
 
6578 
  thrift_spec = (
6579 
    None, # 0
6580 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6581 
    (2, TType.I64, 'limit', None, None, ), # 2
6582 
  )
6583 
 
6584 
  def __init__(self, customer_id=None, limit=None,):
6585 
    self.customer_id = customer_id
6586 
    self.limit = limit
6587 
 
6588 
  def read(self, iprot):
6589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6591 
      return
6592 
    iprot.readStructBegin()
6593 
    while True:
6594 
      (fname, ftype, fid) = iprot.readFieldBegin()
6595 
      if ftype == TType.STOP:
6596 
        break
6597 
      if fid == 1:
6598 
        if ftype == TType.I64:
6599 
          self.customer_id = iprot.readI64();
6600 
        else:
6601 
          iprot.skip(ftype)
6602 
      elif fid == 2:
6603 
        if ftype == TType.I64:
6604 
          self.limit = iprot.readI64();
6605 
        else:
6606 
          iprot.skip(ftype)
6607 
      else:
6608 
        iprot.skip(ftype)
6609 
      iprot.readFieldEnd()
6610 
    iprot.readStructEnd()
6611 
 
6612 
  def write(self, oprot):
6613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6615 
      return
6616 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6617 
    if self.customer_id is not None:
1382 varun.gupt 6618 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6619 
      oprot.writeI64(self.customer_id)
6620 
      oprot.writeFieldEnd()
3431 rajveer 6621 
    if self.limit is not None:
1382 varun.gupt 6622 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6623 
      oprot.writeI64(self.limit)
6624 
      oprot.writeFieldEnd()
6625 
    oprot.writeFieldStop()
6626 
    oprot.writeStructEnd()
6627 
 
3431 rajveer 6628 
  def validate(self):
6629 
    return
6630 
 
6631 
 
1382 varun.gupt 6632 
  def __repr__(self):
6633 
    L = ['%s=%r' % (key, value)
6634 
      for key, value in self.__dict__.iteritems()]
6635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6636 
 
6637 
  def __eq__(self, other):
6638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6639 
 
6640 
  def __ne__(self, other):
6641 
    return not (self == other)
6642 
 
6643 
class getCancellableOrdersForCustomer_result:
6644 
  """
6645 
  Attributes:
6646 
   - success
6647 
   - ex
6648 
  """
6649 
 
6650 
  thrift_spec = (
6651 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6653 
  )
6654 
 
6655 
  def __init__(self, success=None, ex=None,):
6656 
    self.success = success
6657 
    self.ex = ex
6658 
 
6659 
  def read(self, iprot):
6660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6662 
      return
6663 
    iprot.readStructBegin()
6664 
    while True:
6665 
      (fname, ftype, fid) = iprot.readFieldBegin()
6666 
      if ftype == TType.STOP:
6667 
        break
6668 
      if fid == 0:
6669 
        if ftype == TType.LIST:
6670 
          self.success = []
4133 chandransh 6671 
          (_etype80, _size77) = iprot.readListBegin()
6672 
          for _i81 in xrange(_size77):
6673 
            _elem82 = iprot.readI64();
6674 
            self.success.append(_elem82)
1382 varun.gupt 6675 
          iprot.readListEnd()
6676 
        else:
6677 
          iprot.skip(ftype)
6678 
      elif fid == 1:
6679 
        if ftype == TType.STRUCT:
6680 
          self.ex = TransactionServiceException()
6681 
          self.ex.read(iprot)
6682 
        else:
6683 
          iprot.skip(ftype)
6684 
      else:
6685 
        iprot.skip(ftype)
6686 
      iprot.readFieldEnd()
6687 
    iprot.readStructEnd()
6688 
 
6689 
  def write(self, oprot):
6690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6692 
      return
6693 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6694 
    if self.success is not None:
1382 varun.gupt 6695 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6696 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6697 
      for iter83 in self.success:
6698 
        oprot.writeI64(iter83)
1382 varun.gupt 6699 
      oprot.writeListEnd()
6700 
      oprot.writeFieldEnd()
3431 rajveer 6701 
    if self.ex is not None:
1382 varun.gupt 6702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6703 
      self.ex.write(oprot)
6704 
      oprot.writeFieldEnd()
6705 
    oprot.writeFieldStop()
6706 
    oprot.writeStructEnd()
6707 
 
3431 rajveer 6708 
  def validate(self):
6709 
    return
6710 
 
6711 
 
1382 varun.gupt 6712 
  def __repr__(self):
6713 
    L = ['%s=%r' % (key, value)
6714 
      for key, value in self.__dict__.iteritems()]
6715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6716 
 
6717 
  def __eq__(self, other):
6718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6719 
 
6720 
  def __ne__(self, other):
6721 
    return not (self == other)
6722 
 
483 rajveer 6723 
class changeOrderStatus_args:
94 ashish 6724 
  """
6725 
  Attributes:
483 rajveer 6726 
   - orderId
6727 
   - status
6728 
   - description
94 ashish 6729 
  """
6730 
 
6731 
  thrift_spec = (
6732 
    None, # 0
483 rajveer 6733 
    (1, TType.I64, 'orderId', None, None, ), # 1
6734 
    (2, TType.I32, 'status', None, None, ), # 2
6735 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6736 
  )
6737 
 
483 rajveer 6738 
  def __init__(self, orderId=None, status=None, description=None,):
6739 
    self.orderId = orderId
6740 
    self.status = status
6741 
    self.description = description
94 ashish 6742 
 
6743 
  def read(self, iprot):
6744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6746 
      return
6747 
    iprot.readStructBegin()
6748 
    while True:
6749 
      (fname, ftype, fid) = iprot.readFieldBegin()
6750 
      if ftype == TType.STOP:
6751 
        break
6752 
      if fid == 1:
6753 
        if ftype == TType.I64:
483 rajveer 6754 
          self.orderId = iprot.readI64();
94 ashish 6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      elif fid == 2:
483 rajveer 6758 
        if ftype == TType.I32:
6759 
          self.status = iprot.readI32();
94 ashish 6760 
        else:
6761 
          iprot.skip(ftype)
483 rajveer 6762 
      elif fid == 3:
6763 
        if ftype == TType.STRING:
6764 
          self.description = iprot.readString();
6765 
        else:
6766 
          iprot.skip(ftype)
94 ashish 6767 
      else:
6768 
        iprot.skip(ftype)
6769 
      iprot.readFieldEnd()
6770 
    iprot.readStructEnd()
6771 
 
6772 
  def write(self, oprot):
6773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6775 
      return
483 rajveer 6776 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6777 
    if self.orderId is not None:
483 rajveer 6778 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6779 
      oprot.writeI64(self.orderId)
94 ashish 6780 
      oprot.writeFieldEnd()
3431 rajveer 6781 
    if self.status is not None:
483 rajveer 6782 
      oprot.writeFieldBegin('status', TType.I32, 2)
6783 
      oprot.writeI32(self.status)
94 ashish 6784 
      oprot.writeFieldEnd()
3431 rajveer 6785 
    if self.description is not None:
483 rajveer 6786 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6787 
      oprot.writeString(self.description)
6788 
      oprot.writeFieldEnd()
94 ashish 6789 
    oprot.writeFieldStop()
6790 
    oprot.writeStructEnd()
6791 
 
3431 rajveer 6792 
  def validate(self):
6793 
    return
6794 
 
6795 
 
94 ashish 6796 
  def __repr__(self):
6797 
    L = ['%s=%r' % (key, value)
6798 
      for key, value in self.__dict__.iteritems()]
6799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6800 
 
6801 
  def __eq__(self, other):
6802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6803 
 
6804 
  def __ne__(self, other):
6805 
    return not (self == other)
6806 
 
483 rajveer 6807 
class changeOrderStatus_result:
94 ashish 6808 
  """
6809 
  Attributes:
6810 
   - success
6811 
   - ex
6812 
  """
6813 
 
6814 
  thrift_spec = (
6815 
    (0, TType.BOOL, 'success', None, None, ), # 0
6816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6817 
  )
6818 
 
6819 
  def __init__(self, success=None, ex=None,):
6820 
    self.success = success
6821 
    self.ex = ex
6822 
 
6823 
  def read(self, iprot):
6824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6826 
      return
6827 
    iprot.readStructBegin()
6828 
    while True:
6829 
      (fname, ftype, fid) = iprot.readFieldBegin()
6830 
      if ftype == TType.STOP:
6831 
        break
6832 
      if fid == 0:
6833 
        if ftype == TType.BOOL:
6834 
          self.success = iprot.readBool();
6835 
        else:
6836 
          iprot.skip(ftype)
6837 
      elif fid == 1:
6838 
        if ftype == TType.STRUCT:
6839 
          self.ex = TransactionServiceException()
6840 
          self.ex.read(iprot)
6841 
        else:
6842 
          iprot.skip(ftype)
6843 
      else:
6844 
        iprot.skip(ftype)
6845 
      iprot.readFieldEnd()
6846 
    iprot.readStructEnd()
6847 
 
6848 
  def write(self, oprot):
6849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6851 
      return
483 rajveer 6852 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6853 
    if self.success is not None:
94 ashish 6854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6855 
      oprot.writeBool(self.success)
6856 
      oprot.writeFieldEnd()
3431 rajveer 6857 
    if self.ex is not None:
94 ashish 6858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6859 
      self.ex.write(oprot)
6860 
      oprot.writeFieldEnd()
6861 
    oprot.writeFieldStop()
6862 
    oprot.writeStructEnd()
6863 
 
3431 rajveer 6864 
  def validate(self):
6865 
    return
6866 
 
6867 
 
94 ashish 6868 
  def __repr__(self):
6869 
    L = ['%s=%r' % (key, value)
6870 
      for key, value in self.__dict__.iteritems()]
6871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6872 
 
6873 
  def __eq__(self, other):
6874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6875 
 
6876 
  def __ne__(self, other):
6877 
    return not (self == other)
6878 
 
3064 chandransh 6879 
class getOrdersForTransaction_args:
494 rajveer 6880 
  """
6881 
  Attributes:
3064 chandransh 6882 
   - transactionId
6883 
   - customerId
494 rajveer 6884 
  """
6885 
 
6886 
  thrift_spec = (
6887 
    None, # 0
3064 chandransh 6888 
    (1, TType.I64, 'transactionId', None, None, ), # 1
6889 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 6890 
  )
6891 
 
3064 chandransh 6892 
  def __init__(self, transactionId=None, customerId=None,):
6893 
    self.transactionId = transactionId
6894 
    self.customerId = customerId
494 rajveer 6895 
 
6896 
  def read(self, iprot):
6897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6899 
      return
6900 
    iprot.readStructBegin()
6901 
    while True:
6902 
      (fname, ftype, fid) = iprot.readFieldBegin()
6903 
      if ftype == TType.STOP:
6904 
        break
6905 
      if fid == 1:
6906 
        if ftype == TType.I64:
3064 chandransh 6907 
          self.transactionId = iprot.readI64();
494 rajveer 6908 
        else:
6909 
          iprot.skip(ftype)
6910 
      elif fid == 2:
3064 chandransh 6911 
        if ftype == TType.I64:
6912 
          self.customerId = iprot.readI64();
494 rajveer 6913 
        else:
6914 
          iprot.skip(ftype)
6915 
      else:
6916 
        iprot.skip(ftype)
6917 
      iprot.readFieldEnd()
6918 
    iprot.readStructEnd()
6919 
 
6920 
  def write(self, oprot):
6921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6923 
      return
3064 chandransh 6924 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 6925 
    if self.transactionId is not None:
3064 chandransh 6926 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
6927 
      oprot.writeI64(self.transactionId)
494 rajveer 6928 
      oprot.writeFieldEnd()
3431 rajveer 6929 
    if self.customerId is not None:
3064 chandransh 6930 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6931 
      oprot.writeI64(self.customerId)
494 rajveer 6932 
      oprot.writeFieldEnd()
6933 
    oprot.writeFieldStop()
6934 
    oprot.writeStructEnd()
6935 
 
3431 rajveer 6936 
  def validate(self):
6937 
    return
6938 
 
6939 
 
494 rajveer 6940 
  def __repr__(self):
6941 
    L = ['%s=%r' % (key, value)
6942 
      for key, value in self.__dict__.iteritems()]
6943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6944 
 
6945 
  def __eq__(self, other):
6946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6947 
 
6948 
  def __ne__(self, other):
6949 
    return not (self == other)
6950 
 
3064 chandransh 6951 
class getOrdersForTransaction_result:
494 rajveer 6952 
  """
6953 
  Attributes:
6954 
   - success
6955 
   - ex
6956 
  """
6957 
 
6958 
  thrift_spec = (
3064 chandransh 6959 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 6960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6961 
  )
6962 
 
6963 
  def __init__(self, success=None, ex=None,):
6964 
    self.success = success
6965 
    self.ex = ex
6966 
 
6967 
  def read(self, iprot):
6968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6970 
      return
6971 
    iprot.readStructBegin()
6972 
    while True:
6973 
      (fname, ftype, fid) = iprot.readFieldBegin()
6974 
      if ftype == TType.STOP:
6975 
        break
6976 
      if fid == 0:
3064 chandransh 6977 
        if ftype == TType.LIST:
6978 
          self.success = []
4133 chandransh 6979 
          (_etype87, _size84) = iprot.readListBegin()
6980 
          for _i88 in xrange(_size84):
6981 
            _elem89 = Order()
6982 
            _elem89.read(iprot)
6983 
            self.success.append(_elem89)
3064 chandransh 6984 
          iprot.readListEnd()
494 rajveer 6985 
        else:
6986 
          iprot.skip(ftype)
6987 
      elif fid == 1:
6988 
        if ftype == TType.STRUCT:
6989 
          self.ex = TransactionServiceException()
6990 
          self.ex.read(iprot)
6991 
        else:
6992 
          iprot.skip(ftype)
6993 
      else:
6994 
        iprot.skip(ftype)
6995 
      iprot.readFieldEnd()
6996 
    iprot.readStructEnd()
6997 
 
6998 
  def write(self, oprot):
6999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7001 
      return
3064 chandransh 7002 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7003 
    if self.success is not None:
3064 chandransh 7004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7006 
      for iter90 in self.success:
7007 
        iter90.write(oprot)
3064 chandransh 7008 
      oprot.writeListEnd()
494 rajveer 7009 
      oprot.writeFieldEnd()
3431 rajveer 7010 
    if self.ex is not None:
494 rajveer 7011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7012 
      self.ex.write(oprot)
7013 
      oprot.writeFieldEnd()
7014 
    oprot.writeFieldStop()
7015 
    oprot.writeStructEnd()
7016 
 
3431 rajveer 7017 
  def validate(self):
7018 
    return
7019 
 
7020 
 
494 rajveer 7021 
  def __repr__(self):
7022 
    L = ['%s=%r' % (key, value)
7023 
      for key, value in self.__dict__.iteritems()]
7024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7025 
 
7026 
  def __eq__(self, other):
7027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7028 
 
7029 
  def __ne__(self, other):
7030 
    return not (self == other)
7031 
 
3064 chandransh 7032 
class getOrdersForCustomer_args:
1149 chandransh 7033 
  """
7034 
  Attributes:
3064 chandransh 7035 
   - customerId
7036 
   - from_date
7037 
   - to_date
7038 
   - statuses
1149 chandransh 7039 
  """
7040 
 
7041 
  thrift_spec = (
7042 
    None, # 0
3064 chandransh 7043 
    (1, TType.I64, 'customerId', None, None, ), # 1
7044 
    (2, TType.I64, 'from_date', None, None, ), # 2
7045 
    (3, TType.I64, 'to_date', None, None, ), # 3
7046 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7047 
  )
7048 
 
3064 chandransh 7049 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7050 
    self.customerId = customerId
7051 
    self.from_date = from_date
7052 
    self.to_date = to_date
7053 
    self.statuses = statuses
1149 chandransh 7054 
 
7055 
  def read(self, iprot):
7056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7058 
      return
7059 
    iprot.readStructBegin()
7060 
    while True:
7061 
      (fname, ftype, fid) = iprot.readFieldBegin()
7062 
      if ftype == TType.STOP:
7063 
        break
7064 
      if fid == 1:
7065 
        if ftype == TType.I64:
3064 chandransh 7066 
          self.customerId = iprot.readI64();
1149 chandransh 7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      elif fid == 2:
7070 
        if ftype == TType.I64:
3064 chandransh 7071 
          self.from_date = iprot.readI64();
1149 chandransh 7072 
        else:
7073 
          iprot.skip(ftype)
2783 chandransh 7074 
      elif fid == 3:
7075 
        if ftype == TType.I64:
3064 chandransh 7076 
          self.to_date = iprot.readI64();
2783 chandransh 7077 
        else:
7078 
          iprot.skip(ftype)
7079 
      elif fid == 4:
3064 chandransh 7080 
        if ftype == TType.LIST:
7081 
          self.statuses = []
4133 chandransh 7082 
          (_etype94, _size91) = iprot.readListBegin()
7083 
          for _i95 in xrange(_size91):
7084 
            _elem96 = iprot.readI32();
7085 
            self.statuses.append(_elem96)
3064 chandransh 7086 
          iprot.readListEnd()
2783 chandransh 7087 
        else:
7088 
          iprot.skip(ftype)
1149 chandransh 7089 
      else:
7090 
        iprot.skip(ftype)
7091 
      iprot.readFieldEnd()
7092 
    iprot.readStructEnd()
7093 
 
7094 
  def write(self, oprot):
7095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7097 
      return
3064 chandransh 7098 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7099 
    if self.customerId is not None:
3064 chandransh 7100 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7101 
      oprot.writeI64(self.customerId)
1149 chandransh 7102 
      oprot.writeFieldEnd()
3431 rajveer 7103 
    if self.from_date is not None:
3064 chandransh 7104 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7105 
      oprot.writeI64(self.from_date)
1149 chandransh 7106 
      oprot.writeFieldEnd()
3431 rajveer 7107 
    if self.to_date is not None:
3064 chandransh 7108 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7109 
      oprot.writeI64(self.to_date)
2783 chandransh 7110 
      oprot.writeFieldEnd()
3431 rajveer 7111 
    if self.statuses is not None:
3064 chandransh 7112 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7113 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7114 
      for iter97 in self.statuses:
7115 
        oprot.writeI32(iter97)
3064 chandransh 7116 
      oprot.writeListEnd()
2783 chandransh 7117 
      oprot.writeFieldEnd()
1149 chandransh 7118 
    oprot.writeFieldStop()
7119 
    oprot.writeStructEnd()
7120 
 
3431 rajveer 7121 
  def validate(self):
7122 
    return
7123 
 
7124 
 
1149 chandransh 7125 
  def __repr__(self):
7126 
    L = ['%s=%r' % (key, value)
7127 
      for key, value in self.__dict__.iteritems()]
7128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7129 
 
7130 
  def __eq__(self, other):
7131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7132 
 
7133 
  def __ne__(self, other):
7134 
    return not (self == other)
7135 
 
3064 chandransh 7136 
class getOrdersForCustomer_result:
1149 chandransh 7137 
  """
7138 
  Attributes:
7139 
   - success
7140 
   - ex
7141 
  """
7142 
 
7143 
  thrift_spec = (
3064 chandransh 7144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7146 
  )
7147 
 
7148 
  def __init__(self, success=None, ex=None,):
7149 
    self.success = success
7150 
    self.ex = ex
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 == 0:
3064 chandransh 7162 
        if ftype == TType.LIST:
7163 
          self.success = []
4133 chandransh 7164 
          (_etype101, _size98) = iprot.readListBegin()
7165 
          for _i102 in xrange(_size98):
7166 
            _elem103 = Order()
7167 
            _elem103.read(iprot)
7168 
            self.success.append(_elem103)
3064 chandransh 7169 
          iprot.readListEnd()
1149 chandransh 7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      elif fid == 1:
7173 
        if ftype == TType.STRUCT:
7174 
          self.ex = TransactionServiceException()
7175 
          self.ex.read(iprot)
7176 
        else:
7177 
          iprot.skip(ftype)
7178 
      else:
7179 
        iprot.skip(ftype)
7180 
      iprot.readFieldEnd()
7181 
    iprot.readStructEnd()
7182 
 
7183 
  def write(self, oprot):
7184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7186 
      return
3064 chandransh 7187 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7188 
    if self.success is not None:
3064 chandransh 7189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7191 
      for iter104 in self.success:
7192 
        iter104.write(oprot)
3064 chandransh 7193 
      oprot.writeListEnd()
1149 chandransh 7194 
      oprot.writeFieldEnd()
3431 rajveer 7195 
    if self.ex is not None:
1149 chandransh 7196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7197 
      self.ex.write(oprot)
7198 
      oprot.writeFieldEnd()
7199 
    oprot.writeFieldStop()
7200 
    oprot.writeStructEnd()
7201 
 
3431 rajveer 7202 
  def validate(self):
7203 
    return
7204 
 
7205 
 
1149 chandransh 7206 
  def __repr__(self):
7207 
    L = ['%s=%r' % (key, value)
7208 
      for key, value in self.__dict__.iteritems()]
7209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7210 
 
7211 
  def __eq__(self, other):
7212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7213 
 
7214 
  def __ne__(self, other):
7215 
    return not (self == other)
7216 
 
3064 chandransh 7217 
class createOrder_args:
921 rajveer 7218 
  """
7219 
  Attributes:
3064 chandransh 7220 
   - order
921 rajveer 7221 
  """
7222 
 
7223 
  thrift_spec = (
7224 
    None, # 0
3064 chandransh 7225 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7226 
  )
7227 
 
3064 chandransh 7228 
  def __init__(self, order=None,):
7229 
    self.order = order
921 rajveer 7230 
 
7231 
  def read(self, iprot):
7232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7234 
      return
7235 
    iprot.readStructBegin()
7236 
    while True:
7237 
      (fname, ftype, fid) = iprot.readFieldBegin()
7238 
      if ftype == TType.STOP:
7239 
        break
7240 
      if fid == 1:
3064 chandransh 7241 
        if ftype == TType.STRUCT:
7242 
          self.order = Order()
7243 
          self.order.read(iprot)
921 rajveer 7244 
        else:
7245 
          iprot.skip(ftype)
7246 
      else:
7247 
        iprot.skip(ftype)
7248 
      iprot.readFieldEnd()
7249 
    iprot.readStructEnd()
7250 
 
7251 
  def write(self, oprot):
7252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7254 
      return
3064 chandransh 7255 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7256 
    if self.order is not None:
3064 chandransh 7257 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7258 
      self.order.write(oprot)
921 rajveer 7259 
      oprot.writeFieldEnd()
7260 
    oprot.writeFieldStop()
7261 
    oprot.writeStructEnd()
7262 
 
3431 rajveer 7263 
  def validate(self):
7264 
    return
7265 
 
7266 
 
921 rajveer 7267 
  def __repr__(self):
7268 
    L = ['%s=%r' % (key, value)
7269 
      for key, value in self.__dict__.iteritems()]
7270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7271 
 
7272 
  def __eq__(self, other):
7273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7274 
 
7275 
  def __ne__(self, other):
7276 
    return not (self == other)
7277 
 
3064 chandransh 7278 
class createOrder_result:
921 rajveer 7279 
  """
7280 
  Attributes:
7281 
   - success
7282 
   - ex
7283 
  """
7284 
 
7285 
  thrift_spec = (
3064 chandransh 7286 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7288 
  )
7289 
 
7290 
  def __init__(self, success=None, ex=None,):
7291 
    self.success = success
7292 
    self.ex = ex
7293 
 
7294 
  def read(self, iprot):
7295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7297 
      return
7298 
    iprot.readStructBegin()
7299 
    while True:
7300 
      (fname, ftype, fid) = iprot.readFieldBegin()
7301 
      if ftype == TType.STOP:
7302 
        break
7303 
      if fid == 0:
3064 chandransh 7304 
        if ftype == TType.I64:
7305 
          self.success = iprot.readI64();
921 rajveer 7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      elif fid == 1:
7309 
        if ftype == TType.STRUCT:
7310 
          self.ex = TransactionServiceException()
7311 
          self.ex.read(iprot)
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      else:
7315 
        iprot.skip(ftype)
7316 
      iprot.readFieldEnd()
7317 
    iprot.readStructEnd()
7318 
 
7319 
  def write(self, oprot):
7320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7322 
      return
3064 chandransh 7323 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7324 
    if self.success is not None:
3064 chandransh 7325 
      oprot.writeFieldBegin('success', TType.I64, 0)
7326 
      oprot.writeI64(self.success)
921 rajveer 7327 
      oprot.writeFieldEnd()
3431 rajveer 7328 
    if self.ex is not None:
921 rajveer 7329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7330 
      self.ex.write(oprot)
7331 
      oprot.writeFieldEnd()
7332 
    oprot.writeFieldStop()
7333 
    oprot.writeStructEnd()
7334 
 
3431 rajveer 7335 
  def validate(self):
7336 
    return
7337 
 
7338 
 
921 rajveer 7339 
  def __repr__(self):
7340 
    L = ['%s=%r' % (key, value)
7341 
      for key, value in self.__dict__.iteritems()]
7342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7343 
 
7344 
  def __eq__(self, other):
7345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7346 
 
7347 
  def __ne__(self, other):
7348 
    return not (self == other)
7349 
 
3064 chandransh 7350 
class getOrder_args:
921 rajveer 7351 
  """
7352 
  Attributes:
3064 chandransh 7353 
   - id
921 rajveer 7354 
  """
7355 
 
7356 
  thrift_spec = (
7357 
    None, # 0
3064 chandransh 7358 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7359 
  )
7360 
 
3064 chandransh 7361 
  def __init__(self, id=None,):
7362 
    self.id = id
921 rajveer 7363 
 
7364 
  def read(self, iprot):
7365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7367 
      return
7368 
    iprot.readStructBegin()
7369 
    while True:
7370 
      (fname, ftype, fid) = iprot.readFieldBegin()
7371 
      if ftype == TType.STOP:
7372 
        break
7373 
      if fid == 1:
7374 
        if ftype == TType.I64:
3064 chandransh 7375 
          self.id = iprot.readI64();
921 rajveer 7376 
        else:
7377 
          iprot.skip(ftype)
7378 
      else:
7379 
        iprot.skip(ftype)
7380 
      iprot.readFieldEnd()
7381 
    iprot.readStructEnd()
7382 
 
7383 
  def write(self, oprot):
7384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7386 
      return
3064 chandransh 7387 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7388 
    if self.id is not None:
3064 chandransh 7389 
      oprot.writeFieldBegin('id', TType.I64, 1)
7390 
      oprot.writeI64(self.id)
921 rajveer 7391 
      oprot.writeFieldEnd()
7392 
    oprot.writeFieldStop()
7393 
    oprot.writeStructEnd()
7394 
 
3431 rajveer 7395 
  def validate(self):
7396 
    return
7397 
 
7398 
 
921 rajveer 7399 
  def __repr__(self):
7400 
    L = ['%s=%r' % (key, value)
7401 
      for key, value in self.__dict__.iteritems()]
7402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7403 
 
7404 
  def __eq__(self, other):
7405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7406 
 
7407 
  def __ne__(self, other):
7408 
    return not (self == other)
7409 
 
3064 chandransh 7410 
class getOrder_result:
921 rajveer 7411 
  """
7412 
  Attributes:
7413 
   - success
7414 
   - ex
7415 
  """
7416 
 
7417 
  thrift_spec = (
3064 chandransh 7418 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7420 
  )
7421 
 
7422 
  def __init__(self, success=None, ex=None,):
7423 
    self.success = success
7424 
    self.ex = ex
7425 
 
7426 
  def read(self, iprot):
7427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7429 
      return
7430 
    iprot.readStructBegin()
7431 
    while True:
7432 
      (fname, ftype, fid) = iprot.readFieldBegin()
7433 
      if ftype == TType.STOP:
7434 
        break
7435 
      if fid == 0:
3064 chandransh 7436 
        if ftype == TType.STRUCT:
7437 
          self.success = Order()
7438 
          self.success.read(iprot)
921 rajveer 7439 
        else:
7440 
          iprot.skip(ftype)
7441 
      elif fid == 1:
7442 
        if ftype == TType.STRUCT:
7443 
          self.ex = TransactionServiceException()
7444 
          self.ex.read(iprot)
7445 
        else:
7446 
          iprot.skip(ftype)
7447 
      else:
7448 
        iprot.skip(ftype)
7449 
      iprot.readFieldEnd()
7450 
    iprot.readStructEnd()
7451 
 
7452 
  def write(self, oprot):
7453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7455 
      return
3064 chandransh 7456 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7457 
    if self.success is not None:
3064 chandransh 7458 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7459 
      self.success.write(oprot)
921 rajveer 7460 
      oprot.writeFieldEnd()
3431 rajveer 7461 
    if self.ex is not None:
921 rajveer 7462 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7463 
      self.ex.write(oprot)
7464 
      oprot.writeFieldEnd()
7465 
    oprot.writeFieldStop()
7466 
    oprot.writeStructEnd()
7467 
 
3431 rajveer 7468 
  def validate(self):
7469 
    return
7470 
 
7471 
 
921 rajveer 7472 
  def __repr__(self):
7473 
    L = ['%s=%r' % (key, value)
7474 
      for key, value in self.__dict__.iteritems()]
7475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7476 
 
7477 
  def __eq__(self, other):
7478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7479 
 
7480 
  def __ne__(self, other):
7481 
    return not (self == other)
7482 
 
3064 chandransh 7483 
class getLineItemsForOrder_args:
94 ashish 7484 
  """
7485 
  Attributes:
3064 chandransh 7486 
   - orderId
94 ashish 7487 
  """
7488 
 
7489 
  thrift_spec = (
7490 
    None, # 0
3064 chandransh 7491 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7492 
  )
7493 
 
3064 chandransh 7494 
  def __init__(self, orderId=None,):
7495 
    self.orderId = orderId
94 ashish 7496 
 
7497 
  def read(self, iprot):
7498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7500 
      return
7501 
    iprot.readStructBegin()
7502 
    while True:
7503 
      (fname, ftype, fid) = iprot.readFieldBegin()
7504 
      if ftype == TType.STOP:
7505 
        break
7506 
      if fid == 1:
7507 
        if ftype == TType.I64:
3064 chandransh 7508 
          self.orderId = iprot.readI64();
94 ashish 7509 
        else:
7510 
          iprot.skip(ftype)
7511 
      else:
7512 
        iprot.skip(ftype)
7513 
      iprot.readFieldEnd()
7514 
    iprot.readStructEnd()
7515 
 
7516 
  def write(self, oprot):
7517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7519 
      return
3064 chandransh 7520 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7521 
    if self.orderId is not None:
3064 chandransh 7522 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7523 
      oprot.writeI64(self.orderId)
94 ashish 7524 
      oprot.writeFieldEnd()
7525 
    oprot.writeFieldStop()
7526 
    oprot.writeStructEnd()
7527 
 
3431 rajveer 7528 
  def validate(self):
7529 
    return
7530 
 
7531 
 
94 ashish 7532 
  def __repr__(self):
7533 
    L = ['%s=%r' % (key, value)
7534 
      for key, value in self.__dict__.iteritems()]
7535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7536 
 
7537 
  def __eq__(self, other):
7538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7539 
 
7540 
  def __ne__(self, other):
7541 
    return not (self == other)
7542 
 
3064 chandransh 7543 
class getLineItemsForOrder_result:
94 ashish 7544 
  """
7545 
  Attributes:
7546 
   - success
7547 
   - ex
7548 
  """
7549 
 
7550 
  thrift_spec = (
3064 chandransh 7551 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7553 
  )
7554 
 
7555 
  def __init__(self, success=None, ex=None,):
7556 
    self.success = success
7557 
    self.ex = ex
7558 
 
7559 
  def read(self, iprot):
7560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7562 
      return
7563 
    iprot.readStructBegin()
7564 
    while True:
7565 
      (fname, ftype, fid) = iprot.readFieldBegin()
7566 
      if ftype == TType.STOP:
7567 
        break
7568 
      if fid == 0:
483 rajveer 7569 
        if ftype == TType.LIST:
7570 
          self.success = []
4133 chandransh 7571 
          (_etype108, _size105) = iprot.readListBegin()
7572 
          for _i109 in xrange(_size105):
7573 
            _elem110 = LineItem()
7574 
            _elem110.read(iprot)
7575 
            self.success.append(_elem110)
483 rajveer 7576 
          iprot.readListEnd()
94 ashish 7577 
        else:
7578 
          iprot.skip(ftype)
7579 
      elif fid == 1:
7580 
        if ftype == TType.STRUCT:
7581 
          self.ex = TransactionServiceException()
7582 
          self.ex.read(iprot)
7583 
        else:
7584 
          iprot.skip(ftype)
7585 
      else:
7586 
        iprot.skip(ftype)
7587 
      iprot.readFieldEnd()
7588 
    iprot.readStructEnd()
7589 
 
7590 
  def write(self, oprot):
7591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7593 
      return
3064 chandransh 7594 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7595 
    if self.success is not None:
483 rajveer 7596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7597 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7598 
      for iter111 in self.success:
7599 
        iter111.write(oprot)
483 rajveer 7600 
      oprot.writeListEnd()
94 ashish 7601 
      oprot.writeFieldEnd()
3431 rajveer 7602 
    if self.ex is not None:
94 ashish 7603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7604 
      self.ex.write(oprot)
7605 
      oprot.writeFieldEnd()
7606 
    oprot.writeFieldStop()
7607 
    oprot.writeStructEnd()
7608 
 
3431 rajveer 7609 
  def validate(self):
7610 
    return
7611 
 
7612 
 
94 ashish 7613 
  def __repr__(self):
7614 
    L = ['%s=%r' % (key, value)
7615 
      for key, value in self.__dict__.iteritems()]
7616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7617 
 
7618 
  def __eq__(self, other):
7619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7620 
 
7621 
  def __ne__(self, other):
7622 
    return not (self == other)
7623 
 
3064 chandransh 7624 
class getOrderForCustomer_args:
94 ashish 7625 
  """
7626 
  Attributes:
3064 chandransh 7627 
   - orderId
483 rajveer 7628 
   - customerId
94 ashish 7629 
  """
7630 
 
7631 
  thrift_spec = (
7632 
    None, # 0
3064 chandransh 7633 
    (1, TType.I64, 'orderId', None, None, ), # 1
7634 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7635 
  )
7636 
 
3064 chandransh 7637 
  def __init__(self, orderId=None, customerId=None,):
7638 
    self.orderId = orderId
483 rajveer 7639 
    self.customerId = customerId
94 ashish 7640 
 
7641 
  def read(self, iprot):
7642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7644 
      return
7645 
    iprot.readStructBegin()
7646 
    while True:
7647 
      (fname, ftype, fid) = iprot.readFieldBegin()
7648 
      if ftype == TType.STOP:
7649 
        break
7650 
      if fid == 1:
7651 
        if ftype == TType.I64:
3064 chandransh 7652 
          self.orderId = iprot.readI64();
94 ashish 7653 
        else:
7654 
          iprot.skip(ftype)
7655 
      elif fid == 2:
7656 
        if ftype == TType.I64:
3064 chandransh 7657 
          self.customerId = iprot.readI64();
94 ashish 7658 
        else:
7659 
          iprot.skip(ftype)
7660 
      else:
7661 
        iprot.skip(ftype)
7662 
      iprot.readFieldEnd()
7663 
    iprot.readStructEnd()
7664 
 
7665 
  def write(self, oprot):
7666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7668 
      return
3064 chandransh 7669 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7670 
    if self.orderId is not None:
3064 chandransh 7671 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7672 
      oprot.writeI64(self.orderId)
7673 
      oprot.writeFieldEnd()
3431 rajveer 7674 
    if self.customerId is not None:
3064 chandransh 7675 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7676 
      oprot.writeI64(self.customerId)
94 ashish 7677 
      oprot.writeFieldEnd()
7678 
    oprot.writeFieldStop()
7679 
    oprot.writeStructEnd()
7680 
 
3431 rajveer 7681 
  def validate(self):
7682 
    return
7683 
 
7684 
 
94 ashish 7685 
  def __repr__(self):
7686 
    L = ['%s=%r' % (key, value)
7687 
      for key, value in self.__dict__.iteritems()]
7688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7689 
 
7690 
  def __eq__(self, other):
7691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7692 
 
7693 
  def __ne__(self, other):
7694 
    return not (self == other)
7695 
 
3064 chandransh 7696 
class getOrderForCustomer_result:
94 ashish 7697 
  """
7698 
  Attributes:
7699 
   - success
7700 
   - ex
7701 
  """
7702 
 
7703 
  thrift_spec = (
3064 chandransh 7704 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7706 
  )
7707 
 
7708 
  def __init__(self, success=None, ex=None,):
7709 
    self.success = success
7710 
    self.ex = ex
7711 
 
7712 
  def read(self, iprot):
7713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7715 
      return
7716 
    iprot.readStructBegin()
7717 
    while True:
7718 
      (fname, ftype, fid) = iprot.readFieldBegin()
7719 
      if ftype == TType.STOP:
7720 
        break
7721 
      if fid == 0:
3064 chandransh 7722 
        if ftype == TType.STRUCT:
7723 
          self.success = Order()
7724 
          self.success.read(iprot)
94 ashish 7725 
        else:
7726 
          iprot.skip(ftype)
7727 
      elif fid == 1:
7728 
        if ftype == TType.STRUCT:
7729 
          self.ex = TransactionServiceException()
7730 
          self.ex.read(iprot)
7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      else:
7734 
        iprot.skip(ftype)
7735 
      iprot.readFieldEnd()
7736 
    iprot.readStructEnd()
7737 
 
7738 
  def write(self, oprot):
7739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7741 
      return
3064 chandransh 7742 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7743 
    if self.success is not None:
3064 chandransh 7744 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7745 
      self.success.write(oprot)
94 ashish 7746 
      oprot.writeFieldEnd()
3431 rajveer 7747 
    if self.ex is not None:
94 ashish 7748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7749 
      self.ex.write(oprot)
7750 
      oprot.writeFieldEnd()
7751 
    oprot.writeFieldStop()
7752 
    oprot.writeStructEnd()
7753 
 
3431 rajveer 7754 
  def validate(self):
7755 
    return
7756 
 
7757 
 
94 ashish 7758 
  def __repr__(self):
7759 
    L = ['%s=%r' % (key, value)
7760 
      for key, value in self.__dict__.iteritems()]
7761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7762 
 
7763 
  def __eq__(self, other):
7764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7765 
 
7766 
  def __ne__(self, other):
7767 
    return not (self == other)
7768 
 
3064 chandransh 7769 
class getAlerts_args:
94 ashish 7770 
  """
7771 
  Attributes:
4394 rajveer 7772 
   - type
4444 rajveer 7773 
   - warehouseId
4394 rajveer 7774 
   - status
7775 
   - timestamp
94 ashish 7776 
  """
7777 
 
7778 
  thrift_spec = (
7779 
    None, # 0
4394 rajveer 7780 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 7781 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7782 
    (3, TType.I64, 'status', None, None, ), # 3
7783 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 7784 
  )
7785 
 
4444 rajveer 7786 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 7787 
    self.type = type
4444 rajveer 7788 
    self.warehouseId = warehouseId
4394 rajveer 7789 
    self.status = status
7790 
    self.timestamp = timestamp
94 ashish 7791 
 
7792 
  def read(self, iprot):
7793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7795 
      return
7796 
    iprot.readStructBegin()
7797 
    while True:
7798 
      (fname, ftype, fid) = iprot.readFieldBegin()
7799 
      if ftype == TType.STOP:
7800 
        break
7801 
      if fid == 1:
3064 chandransh 7802 
        if ftype == TType.I64:
4394 rajveer 7803 
          self.type = iprot.readI64();
94 ashish 7804 
        else:
7805 
          iprot.skip(ftype)
3064 chandransh 7806 
      elif fid == 2:
4394 rajveer 7807 
        if ftype == TType.I64:
4444 rajveer 7808 
          self.warehouseId = iprot.readI64();
3064 chandransh 7809 
        else:
7810 
          iprot.skip(ftype)
4394 rajveer 7811 
      elif fid == 3:
7812 
        if ftype == TType.I64:
4444 rajveer 7813 
          self.status = iprot.readI64();
7814 
        else:
7815 
          iprot.skip(ftype)
7816 
      elif fid == 4:
7817 
        if ftype == TType.I64:
4394 rajveer 7818 
          self.timestamp = iprot.readI64();
7819 
        else:
7820 
          iprot.skip(ftype)
94 ashish 7821 
      else:
7822 
        iprot.skip(ftype)
7823 
      iprot.readFieldEnd()
7824 
    iprot.readStructEnd()
7825 
 
7826 
  def write(self, oprot):
7827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7829 
      return
3064 chandransh 7830 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 7831 
    if self.type is not None:
7832 
      oprot.writeFieldBegin('type', TType.I64, 1)
7833 
      oprot.writeI64(self.type)
94 ashish 7834 
      oprot.writeFieldEnd()
4444 rajveer 7835 
    if self.warehouseId is not None:
7836 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7837 
      oprot.writeI64(self.warehouseId)
7838 
      oprot.writeFieldEnd()
4394 rajveer 7839 
    if self.status is not None:
4444 rajveer 7840 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 7841 
      oprot.writeI64(self.status)
3064 chandransh 7842 
      oprot.writeFieldEnd()
4394 rajveer 7843 
    if self.timestamp is not None:
4444 rajveer 7844 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 7845 
      oprot.writeI64(self.timestamp)
7846 
      oprot.writeFieldEnd()
94 ashish 7847 
    oprot.writeFieldStop()
7848 
    oprot.writeStructEnd()
7849 
 
3431 rajveer 7850 
  def validate(self):
7851 
    return
7852 
 
7853 
 
94 ashish 7854 
  def __repr__(self):
7855 
    L = ['%s=%r' % (key, value)
7856 
      for key, value in self.__dict__.iteritems()]
7857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7858 
 
7859 
  def __eq__(self, other):
7860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7861 
 
7862 
  def __ne__(self, other):
7863 
    return not (self == other)
7864 
 
3064 chandransh 7865 
class getAlerts_result:
94 ashish 7866 
  """
7867 
  Attributes:
7868 
   - success
7869 
  """
7870 
 
7871 
  thrift_spec = (
3064 chandransh 7872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7873 
  )
7874 
 
3064 chandransh 7875 
  def __init__(self, success=None,):
94 ashish 7876 
    self.success = success
7877 
 
7878 
  def read(self, iprot):
7879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7881 
      return
7882 
    iprot.readStructBegin()
7883 
    while True:
7884 
      (fname, ftype, fid) = iprot.readFieldBegin()
7885 
      if ftype == TType.STOP:
7886 
        break
7887 
      if fid == 0:
3064 chandransh 7888 
        if ftype == TType.LIST:
7889 
          self.success = []
4133 chandransh 7890 
          (_etype115, _size112) = iprot.readListBegin()
7891 
          for _i116 in xrange(_size112):
7892 
            _elem117 = Alert()
7893 
            _elem117.read(iprot)
7894 
            self.success.append(_elem117)
3064 chandransh 7895 
          iprot.readListEnd()
94 ashish 7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      else:
7899 
        iprot.skip(ftype)
7900 
      iprot.readFieldEnd()
7901 
    iprot.readStructEnd()
7902 
 
7903 
  def write(self, oprot):
7904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7906 
      return
3064 chandransh 7907 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 7908 
    if self.success is not None:
3064 chandransh 7909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7911 
      for iter118 in self.success:
7912 
        iter118.write(oprot)
3064 chandransh 7913 
      oprot.writeListEnd()
94 ashish 7914 
      oprot.writeFieldEnd()
7915 
    oprot.writeFieldStop()
7916 
    oprot.writeStructEnd()
7917 
 
3431 rajveer 7918 
  def validate(self):
7919 
    return
7920 
 
7921 
 
94 ashish 7922 
  def __repr__(self):
7923 
    L = ['%s=%r' % (key, value)
7924 
      for key, value in self.__dict__.iteritems()]
7925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7926 
 
7927 
  def __eq__(self, other):
7928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7929 
 
7930 
  def __ne__(self, other):
7931 
    return not (self == other)
7932 
 
4394 rajveer 7933 
class addAlert_args:
94 ashish 7934 
  """
7935 
  Attributes:
3064 chandransh 7936 
   - type
4444 rajveer 7937 
   - warehouseId
4394 rajveer 7938 
   - description
94 ashish 7939 
  """
7940 
 
7941 
  thrift_spec = (
7942 
    None, # 0
4394 rajveer 7943 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 7944 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7945 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 7946 
  )
7947 
 
4444 rajveer 7948 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 7949 
    self.type = type
4444 rajveer 7950 
    self.warehouseId = warehouseId
4394 rajveer 7951 
    self.description = description
94 ashish 7952 
 
7953 
  def read(self, iprot):
7954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7956 
      return
7957 
    iprot.readStructBegin()
7958 
    while True:
7959 
      (fname, ftype, fid) = iprot.readFieldBegin()
7960 
      if ftype == TType.STOP:
7961 
        break
7962 
      if fid == 1:
7963 
        if ftype == TType.I64:
4394 rajveer 7964 
          self.type = iprot.readI64();
94 ashish 7965 
        else:
7966 
          iprot.skip(ftype)
3064 chandransh 7967 
      elif fid == 2:
4444 rajveer 7968 
        if ftype == TType.I64:
7969 
          self.warehouseId = iprot.readI64();
7970 
        else:
7971 
          iprot.skip(ftype)
7972 
      elif fid == 3:
3064 chandransh 7973 
        if ftype == TType.STRING:
4394 rajveer 7974 
          self.description = iprot.readString();
3064 chandransh 7975 
        else:
7976 
          iprot.skip(ftype)
94 ashish 7977 
      else:
7978 
        iprot.skip(ftype)
7979 
      iprot.readFieldEnd()
7980 
    iprot.readStructEnd()
7981 
 
7982 
  def write(self, oprot):
7983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7985 
      return
4394 rajveer 7986 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 7987 
    if self.type is not None:
4394 rajveer 7988 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 7989 
      oprot.writeI64(self.type)
7990 
      oprot.writeFieldEnd()
4444 rajveer 7991 
    if self.warehouseId is not None:
7992 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7993 
      oprot.writeI64(self.warehouseId)
7994 
      oprot.writeFieldEnd()
4394 rajveer 7995 
    if self.description is not None:
4444 rajveer 7996 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 7997 
      oprot.writeString(self.description)
3064 chandransh 7998 
      oprot.writeFieldEnd()
94 ashish 7999 
    oprot.writeFieldStop()
8000 
    oprot.writeStructEnd()
8001 
 
3431 rajveer 8002 
  def validate(self):
8003 
    return
8004 
 
8005 
 
94 ashish 8006 
  def __repr__(self):
8007 
    L = ['%s=%r' % (key, value)
8008 
      for key, value in self.__dict__.iteritems()]
8009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8010 
 
8011 
  def __eq__(self, other):
8012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8013 
 
8014 
  def __ne__(self, other):
8015 
    return not (self == other)
8016 
 
4394 rajveer 8017 
class addAlert_result:
3064 chandransh 8018 
 
8019 
  thrift_spec = (
8020 
  )
8021 
 
8022 
  def read(self, iprot):
8023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8025 
      return
8026 
    iprot.readStructBegin()
8027 
    while True:
8028 
      (fname, ftype, fid) = iprot.readFieldBegin()
8029 
      if ftype == TType.STOP:
8030 
        break
8031 
      else:
8032 
        iprot.skip(ftype)
8033 
      iprot.readFieldEnd()
8034 
    iprot.readStructEnd()
8035 
 
8036 
  def write(self, oprot):
8037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8039 
      return
4394 rajveer 8040 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8041 
    oprot.writeFieldStop()
8042 
    oprot.writeStructEnd()
8043 
 
3431 rajveer 8044 
  def validate(self):
8045 
    return
8046 
 
8047 
 
3064 chandransh 8048 
  def __repr__(self):
8049 
    L = ['%s=%r' % (key, value)
8050 
      for key, value in self.__dict__.iteritems()]
8051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8052 
 
8053 
  def __eq__(self, other):
8054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8055 
 
8056 
  def __ne__(self, other):
8057 
    return not (self == other)
8058 
 
4444 rajveer 8059 
class markAlertsAsSeen_args:
8060 
  """
8061 
  Attributes:
8062 
   - warehouseId
8063 
  """
8064 
 
8065 
  thrift_spec = (
8066 
    None, # 0
8067 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8068 
  )
8069 
 
8070 
  def __init__(self, warehouseId=None,):
8071 
    self.warehouseId = warehouseId
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 == 1:
8083 
        if ftype == TType.I64:
8084 
          self.warehouseId = iprot.readI64();
8085 
        else:
8086 
          iprot.skip(ftype)
8087 
      else:
8088 
        iprot.skip(ftype)
8089 
      iprot.readFieldEnd()
8090 
    iprot.readStructEnd()
8091 
 
8092 
  def write(self, oprot):
8093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8095 
      return
8096 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8097 
    if self.warehouseId is not None:
8098 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8099 
      oprot.writeI64(self.warehouseId)
8100 
      oprot.writeFieldEnd()
8101 
    oprot.writeFieldStop()
8102 
    oprot.writeStructEnd()
8103 
 
8104 
  def validate(self):
8105 
    return
8106 
 
8107 
 
8108 
  def __repr__(self):
8109 
    L = ['%s=%r' % (key, value)
8110 
      for key, value in self.__dict__.iteritems()]
8111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8112 
 
8113 
  def __eq__(self, other):
8114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8115 
 
8116 
  def __ne__(self, other):
8117 
    return not (self == other)
8118 
 
8119 
class markAlertsAsSeen_result:
8120 
 
8121 
  thrift_spec = (
8122 
  )
8123 
 
8124 
  def read(self, iprot):
8125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8127 
      return
8128 
    iprot.readStructBegin()
8129 
    while True:
8130 
      (fname, ftype, fid) = iprot.readFieldBegin()
8131 
      if ftype == TType.STOP:
8132 
        break
8133 
      else:
8134 
        iprot.skip(ftype)
8135 
      iprot.readFieldEnd()
8136 
    iprot.readStructEnd()
8137 
 
8138 
  def write(self, oprot):
8139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8141 
      return
8142 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8143 
    oprot.writeFieldStop()
8144 
    oprot.writeStructEnd()
8145 
 
8146 
  def validate(self):
8147 
    return
8148 
 
8149 
 
8150 
  def __repr__(self):
8151 
    L = ['%s=%r' % (key, value)
8152 
      for key, value in self.__dict__.iteritems()]
8153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8154 
 
8155 
  def __eq__(self, other):
8156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8157 
 
8158 
  def __ne__(self, other):
8159 
    return not (self == other)
8160 
 
3064 chandransh 8161 
class getValidOrderCount_args:
8162 
 
8163 
  thrift_spec = (
8164 
  )
8165 
 
8166 
  def read(self, iprot):
8167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8169 
      return
8170 
    iprot.readStructBegin()
8171 
    while True:
8172 
      (fname, ftype, fid) = iprot.readFieldBegin()
8173 
      if ftype == TType.STOP:
8174 
        break
8175 
      else:
8176 
        iprot.skip(ftype)
8177 
      iprot.readFieldEnd()
8178 
    iprot.readStructEnd()
8179 
 
8180 
  def write(self, oprot):
8181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8183 
      return
8184 
    oprot.writeStructBegin('getValidOrderCount_args')
8185 
    oprot.writeFieldStop()
8186 
    oprot.writeStructEnd()
8187 
 
3431 rajveer 8188 
  def validate(self):
8189 
    return
8190 
 
8191 
 
3064 chandransh 8192 
  def __repr__(self):
8193 
    L = ['%s=%r' % (key, value)
8194 
      for key, value in self.__dict__.iteritems()]
8195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8196 
 
8197 
  def __eq__(self, other):
8198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8199 
 
8200 
  def __ne__(self, other):
8201 
    return not (self == other)
8202 
 
8203 
class getValidOrderCount_result:
94 ashish 8204 
  """
8205 
  Attributes:
8206 
   - success
8207 
  """
8208 
 
8209 
  thrift_spec = (
3064 chandransh 8210 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8211 
  )
8212 
 
3064 chandransh 8213 
  def __init__(self, success=None,):
94 ashish 8214 
    self.success = success
8215 
 
8216 
  def read(self, iprot):
8217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8219 
      return
8220 
    iprot.readStructBegin()
8221 
    while True:
8222 
      (fname, ftype, fid) = iprot.readFieldBegin()
8223 
      if ftype == TType.STOP:
8224 
        break
8225 
      if fid == 0:
3064 chandransh 8226 
        if ftype == TType.I64:
8227 
          self.success = iprot.readI64();
94 ashish 8228 
        else:
8229 
          iprot.skip(ftype)
8230 
      else:
8231 
        iprot.skip(ftype)
8232 
      iprot.readFieldEnd()
8233 
    iprot.readStructEnd()
8234 
 
8235 
  def write(self, oprot):
8236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8238 
      return
3064 chandransh 8239 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8240 
    if self.success is not None:
3064 chandransh 8241 
      oprot.writeFieldBegin('success', TType.I64, 0)
8242 
      oprot.writeI64(self.success)
94 ashish 8243 
      oprot.writeFieldEnd()
8244 
    oprot.writeFieldStop()
8245 
    oprot.writeStructEnd()
8246 
 
3431 rajveer 8247 
  def validate(self):
8248 
    return
8249 
 
8250 
 
94 ashish 8251 
  def __repr__(self):
8252 
    L = ['%s=%r' % (key, value)
8253 
      for key, value in self.__dict__.iteritems()]
8254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8255 
 
8256 
  def __eq__(self, other):
8257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8258 
 
8259 
  def __ne__(self, other):
8260 
    return not (self == other)
8261 
 
3064 chandransh 8262 
class getNoOfCustomersWithSuccessfulTransaction_args:
8263 
 
8264 
  thrift_spec = (
8265 
  )
8266 
 
8267 
  def read(self, iprot):
8268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8270 
      return
8271 
    iprot.readStructBegin()
8272 
    while True:
8273 
      (fname, ftype, fid) = iprot.readFieldBegin()
8274 
      if ftype == TType.STOP:
8275 
        break
8276 
      else:
8277 
        iprot.skip(ftype)
8278 
      iprot.readFieldEnd()
8279 
    iprot.readStructEnd()
8280 
 
8281 
  def write(self, oprot):
8282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8284 
      return
8285 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8286 
    oprot.writeFieldStop()
8287 
    oprot.writeStructEnd()
8288 
 
3431 rajveer 8289 
  def validate(self):
8290 
    return
8291 
 
8292 
 
3064 chandransh 8293 
  def __repr__(self):
8294 
    L = ['%s=%r' % (key, value)
8295 
      for key, value in self.__dict__.iteritems()]
8296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8297 
 
8298 
  def __eq__(self, other):
8299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8300 
 
8301 
  def __ne__(self, other):
8302 
    return not (self == other)
8303 
 
8304 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8305 
  """
8306 
  Attributes:
3064 chandransh 8307 
   - success
94 ashish 8308 
  """
8309 
 
8310 
  thrift_spec = (
3064 chandransh 8311 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8312 
  )
8313 
 
3064 chandransh 8314 
  def __init__(self, success=None,):
8315 
    self.success = success
94 ashish 8316 
 
8317 
  def read(self, iprot):
8318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8320 
      return
8321 
    iprot.readStructBegin()
8322 
    while True:
8323 
      (fname, ftype, fid) = iprot.readFieldBegin()
8324 
      if ftype == TType.STOP:
8325 
        break
3064 chandransh 8326 
      if fid == 0:
94 ashish 8327 
        if ftype == TType.I64:
3064 chandransh 8328 
          self.success = iprot.readI64();
94 ashish 8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      else:
8332 
        iprot.skip(ftype)
8333 
      iprot.readFieldEnd()
8334 
    iprot.readStructEnd()
8335 
 
8336 
  def write(self, oprot):
8337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8339 
      return
3064 chandransh 8340 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8341 
    if self.success is not None:
3064 chandransh 8342 
      oprot.writeFieldBegin('success', TType.I64, 0)
8343 
      oprot.writeI64(self.success)
94 ashish 8344 
      oprot.writeFieldEnd()
8345 
    oprot.writeFieldStop()
8346 
    oprot.writeStructEnd()
8347 
 
3431 rajveer 8348 
  def validate(self):
8349 
    return
8350 
 
8351 
 
94 ashish 8352 
  def __repr__(self):
8353 
    L = ['%s=%r' % (key, value)
8354 
      for key, value in self.__dict__.iteritems()]
8355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8356 
 
8357 
  def __eq__(self, other):
8358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8359 
 
8360 
  def __ne__(self, other):
8361 
    return not (self == other)
8362 
 
3064 chandransh 8363 
class getValidOrdersAmountRange_args:
8364 
 
8365 
  thrift_spec = (
8366 
  )
8367 
 
8368 
  def read(self, iprot):
8369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8371 
      return
8372 
    iprot.readStructBegin()
8373 
    while True:
8374 
      (fname, ftype, fid) = iprot.readFieldBegin()
8375 
      if ftype == TType.STOP:
8376 
        break
8377 
      else:
8378 
        iprot.skip(ftype)
8379 
      iprot.readFieldEnd()
8380 
    iprot.readStructEnd()
8381 
 
8382 
  def write(self, oprot):
8383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8385 
      return
8386 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8387 
    oprot.writeFieldStop()
8388 
    oprot.writeStructEnd()
8389 
 
3431 rajveer 8390 
  def validate(self):
8391 
    return
8392 
 
8393 
 
3064 chandransh 8394 
  def __repr__(self):
8395 
    L = ['%s=%r' % (key, value)
8396 
      for key, value in self.__dict__.iteritems()]
8397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8398 
 
8399 
  def __eq__(self, other):
8400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8401 
 
8402 
  def __ne__(self, other):
8403 
    return not (self == other)
8404 
 
8405 
class getValidOrdersAmountRange_result:
94 ashish 8406 
  """
8407 
  Attributes:
8408 
   - success
8409 
  """
8410 
 
8411 
  thrift_spec = (
3064 chandransh 8412 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8413 
  )
8414 
 
3064 chandransh 8415 
  def __init__(self, success=None,):
94 ashish 8416 
    self.success = success
8417 
 
8418 
  def read(self, iprot):
8419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8421 
      return
8422 
    iprot.readStructBegin()
8423 
    while True:
8424 
      (fname, ftype, fid) = iprot.readFieldBegin()
8425 
      if ftype == TType.STOP:
8426 
        break
8427 
      if fid == 0:
483 rajveer 8428 
        if ftype == TType.LIST:
8429 
          self.success = []
4133 chandransh 8430 
          (_etype122, _size119) = iprot.readListBegin()
8431 
          for _i123 in xrange(_size119):
8432 
            _elem124 = iprot.readDouble();
8433 
            self.success.append(_elem124)
483 rajveer 8434 
          iprot.readListEnd()
94 ashish 8435 
        else:
8436 
          iprot.skip(ftype)
8437 
      else:
8438 
        iprot.skip(ftype)
8439 
      iprot.readFieldEnd()
8440 
    iprot.readStructEnd()
8441 
 
8442 
  def write(self, oprot):
8443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8445 
      return
3064 chandransh 8446 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8447 
    if self.success is not None:
483 rajveer 8448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8449 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8450 
      for iter125 in self.success:
8451 
        oprot.writeDouble(iter125)
483 rajveer 8452 
      oprot.writeListEnd()
94 ashish 8453 
      oprot.writeFieldEnd()
8454 
    oprot.writeFieldStop()
8455 
    oprot.writeStructEnd()
8456 
 
3431 rajveer 8457 
  def validate(self):
8458 
    return
8459 
 
8460 
 
94 ashish 8461 
  def __repr__(self):
8462 
    L = ['%s=%r' % (key, value)
8463 
      for key, value in self.__dict__.iteritems()]
8464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8465 
 
8466 
  def __eq__(self, other):
8467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8468 
 
8469 
  def __ne__(self, other):
8470 
    return not (self == other)
8471 
 
3064 chandransh 8472 
class getValidOrders_args:
1528 ankur.sing 8473 
  """
8474 
  Attributes:
3064 chandransh 8475 
   - limit
1528 ankur.sing 8476 
  """
8477 
 
8478 
  thrift_spec = (
8479 
    None, # 0
3064 chandransh 8480 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8481 
  )
8482 
 
3064 chandransh 8483 
  def __init__(self, limit=None,):
8484 
    self.limit = limit
1528 ankur.sing 8485 
 
8486 
  def read(self, iprot):
8487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8489 
      return
8490 
    iprot.readStructBegin()
8491 
    while True:
8492 
      (fname, ftype, fid) = iprot.readFieldBegin()
8493 
      if ftype == TType.STOP:
8494 
        break
8495 
      if fid == 1:
8496 
        if ftype == TType.I64:
3064 chandransh 8497 
          self.limit = iprot.readI64();
1528 ankur.sing 8498 
        else:
8499 
          iprot.skip(ftype)
8500 
      else:
8501 
        iprot.skip(ftype)
8502 
      iprot.readFieldEnd()
8503 
    iprot.readStructEnd()
8504 
 
8505 
  def write(self, oprot):
8506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8508 
      return
3064 chandransh 8509 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8510 
    if self.limit is not None:
3064 chandransh 8511 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8512 
      oprot.writeI64(self.limit)
1528 ankur.sing 8513 
      oprot.writeFieldEnd()
8514 
    oprot.writeFieldStop()
8515 
    oprot.writeStructEnd()
8516 
 
3431 rajveer 8517 
  def validate(self):
8518 
    return
8519 
 
8520 
 
1528 ankur.sing 8521 
  def __repr__(self):
8522 
    L = ['%s=%r' % (key, value)
8523 
      for key, value in self.__dict__.iteritems()]
8524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8525 
 
8526 
  def __eq__(self, other):
8527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8528 
 
8529 
  def __ne__(self, other):
8530 
    return not (self == other)
8531 
 
3064 chandransh 8532 
class getValidOrders_result:
1528 ankur.sing 8533 
  """
8534 
  Attributes:
8535 
   - success
8536 
  """
8537 
 
8538 
  thrift_spec = (
3064 chandransh 8539 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8540 
  )
8541 
 
3064 chandransh 8542 
  def __init__(self, success=None,):
1528 ankur.sing 8543 
    self.success = success
8544 
 
8545 
  def read(self, iprot):
8546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8548 
      return
8549 
    iprot.readStructBegin()
8550 
    while True:
8551 
      (fname, ftype, fid) = iprot.readFieldBegin()
8552 
      if ftype == TType.STOP:
8553 
        break
8554 
      if fid == 0:
3064 chandransh 8555 
        if ftype == TType.LIST:
8556 
          self.success = []
4133 chandransh 8557 
          (_etype129, _size126) = iprot.readListBegin()
8558 
          for _i130 in xrange(_size126):
8559 
            _elem131 = Order()
8560 
            _elem131.read(iprot)
8561 
            self.success.append(_elem131)
3064 chandransh 8562 
          iprot.readListEnd()
1528 ankur.sing 8563 
        else:
8564 
          iprot.skip(ftype)
8565 
      else:
8566 
        iprot.skip(ftype)
8567 
      iprot.readFieldEnd()
8568 
    iprot.readStructEnd()
8569 
 
8570 
  def write(self, oprot):
8571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8573 
      return
3064 chandransh 8574 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8575 
    if self.success is not None:
3064 chandransh 8576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8578 
      for iter132 in self.success:
8579 
        iter132.write(oprot)
3064 chandransh 8580 
      oprot.writeListEnd()
1528 ankur.sing 8581 
      oprot.writeFieldEnd()
8582 
    oprot.writeFieldStop()
8583 
    oprot.writeStructEnd()
8584 
 
3431 rajveer 8585 
  def validate(self):
8586 
    return
8587 
 
8588 
 
1528 ankur.sing 8589 
  def __repr__(self):
8590 
    L = ['%s=%r' % (key, value)
8591 
      for key, value in self.__dict__.iteritems()]
8592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8593 
 
8594 
  def __eq__(self, other):
8595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8596 
 
8597 
  def __ne__(self, other):
8598 
    return not (self == other)
8599 
 
1220 chandransh 8600 
class batchOrders_args:
8601 
  """
8602 
  Attributes:
8603 
   - warehouseId
8604 
  """
8605 
 
8606 
  thrift_spec = (
8607 
    None, # 0
8608 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8609 
  )
8610 
 
8611 
  def __init__(self, warehouseId=None,):
8612 
    self.warehouseId = warehouseId
8613 
 
8614 
  def read(self, iprot):
8615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8617 
      return
8618 
    iprot.readStructBegin()
8619 
    while True:
8620 
      (fname, ftype, fid) = iprot.readFieldBegin()
8621 
      if ftype == TType.STOP:
8622 
        break
8623 
      if fid == 1:
8624 
        if ftype == TType.I64:
8625 
          self.warehouseId = iprot.readI64();
8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      else:
8629 
        iprot.skip(ftype)
8630 
      iprot.readFieldEnd()
8631 
    iprot.readStructEnd()
8632 
 
8633 
  def write(self, oprot):
8634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8636 
      return
8637 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8638 
    if self.warehouseId is not None:
1220 chandransh 8639 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8640 
      oprot.writeI64(self.warehouseId)
8641 
      oprot.writeFieldEnd()
8642 
    oprot.writeFieldStop()
8643 
    oprot.writeStructEnd()
8644 
 
3431 rajveer 8645 
  def validate(self):
8646 
    return
8647 
 
8648 
 
1220 chandransh 8649 
  def __repr__(self):
8650 
    L = ['%s=%r' % (key, value)
8651 
      for key, value in self.__dict__.iteritems()]
8652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8653 
 
8654 
  def __eq__(self, other):
8655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8656 
 
8657 
  def __ne__(self, other):
8658 
    return not (self == other)
8659 
 
8660 
class batchOrders_result:
8661 
  """
8662 
  Attributes:
8663 
   - success
8664 
   - ex
8665 
  """
8666 
 
8667 
  thrift_spec = (
8668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8670 
  )
8671 
 
8672 
  def __init__(self, success=None, ex=None,):
8673 
    self.success = success
8674 
    self.ex = ex
8675 
 
8676 
  def read(self, iprot):
8677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8679 
      return
8680 
    iprot.readStructBegin()
8681 
    while True:
8682 
      (fname, ftype, fid) = iprot.readFieldBegin()
8683 
      if ftype == TType.STOP:
8684 
        break
8685 
      if fid == 0:
8686 
        if ftype == TType.LIST:
8687 
          self.success = []
4133 chandransh 8688 
          (_etype136, _size133) = iprot.readListBegin()
8689 
          for _i137 in xrange(_size133):
8690 
            _elem138 = Order()
8691 
            _elem138.read(iprot)
8692 
            self.success.append(_elem138)
1220 chandransh 8693 
          iprot.readListEnd()
8694 
        else:
8695 
          iprot.skip(ftype)
8696 
      elif fid == 1:
8697 
        if ftype == TType.STRUCT:
8698 
          self.ex = TransactionServiceException()
8699 
          self.ex.read(iprot)
8700 
        else:
8701 
          iprot.skip(ftype)
8702 
      else:
8703 
        iprot.skip(ftype)
8704 
      iprot.readFieldEnd()
8705 
    iprot.readStructEnd()
8706 
 
8707 
  def write(self, oprot):
8708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8710 
      return
8711 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8712 
    if self.success is not None:
1220 chandransh 8713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8715 
      for iter139 in self.success:
8716 
        iter139.write(oprot)
1220 chandransh 8717 
      oprot.writeListEnd()
8718 
      oprot.writeFieldEnd()
3431 rajveer 8719 
    if self.ex is not None:
1220 chandransh 8720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8721 
      self.ex.write(oprot)
8722 
      oprot.writeFieldEnd()
8723 
    oprot.writeFieldStop()
8724 
    oprot.writeStructEnd()
8725 
 
3431 rajveer 8726 
  def validate(self):
8727 
    return
8728 
 
8729 
 
1220 chandransh 8730 
  def __repr__(self):
8731 
    L = ['%s=%r' % (key, value)
8732 
      for key, value in self.__dict__.iteritems()]
8733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8734 
 
8735 
  def __eq__(self, other):
8736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8737 
 
8738 
  def __ne__(self, other):
8739 
    return not (self == other)
8740 
 
1208 chandransh 8741 
class markOrderAsOutOfStock_args:
8742 
  """
8743 
  Attributes:
8744 
   - orderId
8745 
  """
8746 
 
8747 
  thrift_spec = (
8748 
    None, # 0
8749 
    (1, TType.I64, 'orderId', None, None, ), # 1
8750 
  )
8751 
 
8752 
  def __init__(self, orderId=None,):
8753 
    self.orderId = orderId
8754 
 
8755 
  def read(self, iprot):
8756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8758 
      return
8759 
    iprot.readStructBegin()
8760 
    while True:
8761 
      (fname, ftype, fid) = iprot.readFieldBegin()
8762 
      if ftype == TType.STOP:
8763 
        break
8764 
      if fid == 1:
8765 
        if ftype == TType.I64:
8766 
          self.orderId = iprot.readI64();
8767 
        else:
8768 
          iprot.skip(ftype)
8769 
      else:
8770 
        iprot.skip(ftype)
8771 
      iprot.readFieldEnd()
8772 
    iprot.readStructEnd()
8773 
 
8774 
  def write(self, oprot):
8775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8777 
      return
8778 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8779 
    if self.orderId is not None:
1208 chandransh 8780 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8781 
      oprot.writeI64(self.orderId)
8782 
      oprot.writeFieldEnd()
8783 
    oprot.writeFieldStop()
8784 
    oprot.writeStructEnd()
8785 
 
3431 rajveer 8786 
  def validate(self):
8787 
    return
8788 
 
8789 
 
1208 chandransh 8790 
  def __repr__(self):
8791 
    L = ['%s=%r' % (key, value)
8792 
      for key, value in self.__dict__.iteritems()]
8793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8794 
 
8795 
  def __eq__(self, other):
8796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8797 
 
8798 
  def __ne__(self, other):
8799 
    return not (self == other)
8800 
 
8801 
class markOrderAsOutOfStock_result:
8802 
  """
8803 
  Attributes:
8804 
   - success
8805 
   - ex
8806 
  """
8807 
 
8808 
  thrift_spec = (
8809 
    (0, TType.BOOL, 'success', None, None, ), # 0
8810 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8811 
  )
8812 
 
8813 
  def __init__(self, success=None, ex=None,):
8814 
    self.success = success
8815 
    self.ex = ex
8816 
 
8817 
  def read(self, iprot):
8818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8820 
      return
8821 
    iprot.readStructBegin()
8822 
    while True:
8823 
      (fname, ftype, fid) = iprot.readFieldBegin()
8824 
      if ftype == TType.STOP:
8825 
        break
8826 
      if fid == 0:
8827 
        if ftype == TType.BOOL:
8828 
          self.success = iprot.readBool();
8829 
        else:
8830 
          iprot.skip(ftype)
8831 
      elif fid == 1:
8832 
        if ftype == TType.STRUCT:
8833 
          self.ex = TransactionServiceException()
8834 
          self.ex.read(iprot)
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8847 
    if self.success is not None:
1208 chandransh 8848 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8849 
      oprot.writeBool(self.success)
8850 
      oprot.writeFieldEnd()
3431 rajveer 8851 
    if self.ex is not None:
1208 chandransh 8852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8853 
      self.ex.write(oprot)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
3431 rajveer 8858 
  def validate(self):
8859 
    return
8860 
 
8861 
 
1208 chandransh 8862 
  def __repr__(self):
8863 
    L = ['%s=%r' % (key, value)
8864 
      for key, value in self.__dict__.iteritems()]
8865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8866 
 
8867 
  def __eq__(self, other):
8868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8869 
 
8870 
  def __ne__(self, other):
8871 
    return not (self == other)
8872 
 
3064 chandransh 8873 
class verifyOrder_args:
759 chandransh 8874 
  """
8875 
  Attributes:
3064 chandransh 8876 
   - orderId
759 chandransh 8877 
  """
8878 
 
8879 
  thrift_spec = (
8880 
    None, # 0
3064 chandransh 8881 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 8882 
  )
8883 
 
3064 chandransh 8884 
  def __init__(self, orderId=None,):
8885 
    self.orderId = orderId
759 chandransh 8886 
 
8887 
  def read(self, iprot):
8888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8890 
      return
8891 
    iprot.readStructBegin()
8892 
    while True:
8893 
      (fname, ftype, fid) = iprot.readFieldBegin()
8894 
      if ftype == TType.STOP:
8895 
        break
8896 
      if fid == 1:
8897 
        if ftype == TType.I64:
3064 chandransh 8898 
          self.orderId = iprot.readI64();
759 chandransh 8899 
        else:
8900 
          iprot.skip(ftype)
8901 
      else:
8902 
        iprot.skip(ftype)
8903 
      iprot.readFieldEnd()
8904 
    iprot.readStructEnd()
8905 
 
8906 
  def write(self, oprot):
8907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8909 
      return
3064 chandransh 8910 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 8911 
    if self.orderId is not None:
3064 chandransh 8912 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8913 
      oprot.writeI64(self.orderId)
759 chandransh 8914 
      oprot.writeFieldEnd()
8915 
    oprot.writeFieldStop()
8916 
    oprot.writeStructEnd()
8917 
 
3431 rajveer 8918 
  def validate(self):
8919 
    return
8920 
 
8921 
 
759 chandransh 8922 
  def __repr__(self):
8923 
    L = ['%s=%r' % (key, value)
8924 
      for key, value in self.__dict__.iteritems()]
8925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8926 
 
8927 
  def __eq__(self, other):
8928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8929 
 
8930 
  def __ne__(self, other):
8931 
    return not (self == other)
8932 
 
3064 chandransh 8933 
class verifyOrder_result:
759 chandransh 8934 
  """
8935 
  Attributes:
8936 
   - success
8937 
   - ex
8938 
  """
8939 
 
8940 
  thrift_spec = (
8941 
    (0, TType.BOOL, 'success', None, None, ), # 0
8942 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8943 
  )
8944 
 
8945 
  def __init__(self, success=None, ex=None,):
8946 
    self.success = success
8947 
    self.ex = ex
8948 
 
8949 
  def read(self, iprot):
8950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8952 
      return
8953 
    iprot.readStructBegin()
8954 
    while True:
8955 
      (fname, ftype, fid) = iprot.readFieldBegin()
8956 
      if ftype == TType.STOP:
8957 
        break
8958 
      if fid == 0:
8959 
        if ftype == TType.BOOL:
8960 
          self.success = iprot.readBool();
8961 
        else:
8962 
          iprot.skip(ftype)
8963 
      elif fid == 1:
8964 
        if ftype == TType.STRUCT:
8965 
          self.ex = TransactionServiceException()
8966 
          self.ex.read(iprot)
8967 
        else:
8968 
          iprot.skip(ftype)
8969 
      else:
8970 
        iprot.skip(ftype)
8971 
      iprot.readFieldEnd()
8972 
    iprot.readStructEnd()
8973 
 
8974 
  def write(self, oprot):
8975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8977 
      return
3064 chandransh 8978 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 8979 
    if self.success is not None:
759 chandransh 8980 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8981 
      oprot.writeBool(self.success)
8982 
      oprot.writeFieldEnd()
3431 rajveer 8983 
    if self.ex is not None:
759 chandransh 8984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8985 
      self.ex.write(oprot)
8986 
      oprot.writeFieldEnd()
8987 
    oprot.writeFieldStop()
8988 
    oprot.writeStructEnd()
8989 
 
3431 rajveer 8990 
  def validate(self):
8991 
    return
8992 
 
8993 
 
759 chandransh 8994 
  def __repr__(self):
8995 
    L = ['%s=%r' % (key, value)
8996 
      for key, value in self.__dict__.iteritems()]
8997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8998 
 
8999 
  def __eq__(self, other):
9000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9001 
 
9002 
  def __ne__(self, other):
9003 
    return not (self == other)
9004 
 
3064 chandransh 9005 
class acceptOrder_args:
1113 chandransh 9006 
  """
9007 
  Attributes:
3064 chandransh 9008 
   - orderId
1113 chandransh 9009 
  """
9010 
 
9011 
  thrift_spec = (
9012 
    None, # 0
3064 chandransh 9013 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9014 
  )
9015 
 
3064 chandransh 9016 
  def __init__(self, orderId=None,):
9017 
    self.orderId = orderId
1113 chandransh 9018 
 
9019 
  def read(self, iprot):
9020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9022 
      return
9023 
    iprot.readStructBegin()
9024 
    while True:
9025 
      (fname, ftype, fid) = iprot.readFieldBegin()
9026 
      if ftype == TType.STOP:
9027 
        break
9028 
      if fid == 1:
9029 
        if ftype == TType.I64:
3064 chandransh 9030 
          self.orderId = iprot.readI64();
1113 chandransh 9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      else:
9034 
        iprot.skip(ftype)
9035 
      iprot.readFieldEnd()
9036 
    iprot.readStructEnd()
9037 
 
9038 
  def write(self, oprot):
9039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9041 
      return
3064 chandransh 9042 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9043 
    if self.orderId is not None:
3064 chandransh 9044 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9045 
      oprot.writeI64(self.orderId)
1113 chandransh 9046 
      oprot.writeFieldEnd()
9047 
    oprot.writeFieldStop()
9048 
    oprot.writeStructEnd()
9049 
 
3431 rajveer 9050 
  def validate(self):
9051 
    return
9052 
 
9053 
 
1113 chandransh 9054 
  def __repr__(self):
9055 
    L = ['%s=%r' % (key, value)
9056 
      for key, value in self.__dict__.iteritems()]
9057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9058 
 
9059 
  def __eq__(self, other):
9060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9061 
 
9062 
  def __ne__(self, other):
9063 
    return not (self == other)
9064 
 
3064 chandransh 9065 
class acceptOrder_result:
1113 chandransh 9066 
  """
9067 
  Attributes:
9068 
   - success
9069 
   - ex
9070 
  """
9071 
 
9072 
  thrift_spec = (
3064 chandransh 9073 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9075 
  )
9076 
 
9077 
  def __init__(self, success=None, ex=None,):
9078 
    self.success = success
9079 
    self.ex = ex
9080 
 
9081 
  def read(self, iprot):
9082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9084 
      return
9085 
    iprot.readStructBegin()
9086 
    while True:
9087 
      (fname, ftype, fid) = iprot.readFieldBegin()
9088 
      if ftype == TType.STOP:
9089 
        break
9090 
      if fid == 0:
3064 chandransh 9091 
        if ftype == TType.BOOL:
9092 
          self.success = iprot.readBool();
1113 chandransh 9093 
        else:
9094 
          iprot.skip(ftype)
9095 
      elif fid == 1:
9096 
        if ftype == TType.STRUCT:
9097 
          self.ex = TransactionServiceException()
9098 
          self.ex.read(iprot)
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
3064 chandransh 9110 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9111 
    if self.success is not None:
3064 chandransh 9112 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9113 
      oprot.writeBool(self.success)
1113 chandransh 9114 
      oprot.writeFieldEnd()
3431 rajveer 9115 
    if self.ex is not None:
1113 chandransh 9116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9117 
      self.ex.write(oprot)
9118 
      oprot.writeFieldEnd()
9119 
    oprot.writeFieldStop()
9120 
    oprot.writeStructEnd()
9121 
 
3431 rajveer 9122 
  def validate(self):
9123 
    return
9124 
 
9125 
 
1113 chandransh 9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
3064 chandransh 9137 
class addBillingDetails_args:
1135 chandransh 9138 
  """
9139 
  Attributes:
3064 chandransh 9140 
   - orderId
9141 
   - invoice_number
4283 anupam.sin 9142 
   - imeiNumber
9143 
   - itemNumber
3064 chandransh 9144 
   - billed_by
4264 rajveer 9145 
   - jacketNumber
4283 anupam.sin 9146 
   - billingType
9147 
   - vendorId
1135 chandransh 9148 
  """
9149 
 
9150 
  thrift_spec = (
9151 
    None, # 0
3064 chandransh 9152 
    (1, TType.I64, 'orderId', None, None, ), # 1
9153 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9154 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9155 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9156 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9157 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9158 
    (7, TType.I64, 'billingType', None, None, ), # 7
9159 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9160 
  )
9161 
 
4283 anupam.sin 9162 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9163 
    self.orderId = orderId
9164 
    self.invoice_number = invoice_number
4283 anupam.sin 9165 
    self.imeiNumber = imeiNumber
9166 
    self.itemNumber = itemNumber
3064 chandransh 9167 
    self.billed_by = billed_by
4264 rajveer 9168 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9169 
    self.billingType = billingType
9170 
    self.vendorId = vendorId
1135 chandransh 9171 
 
9172 
  def read(self, iprot):
9173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9175 
      return
9176 
    iprot.readStructBegin()
9177 
    while True:
9178 
      (fname, ftype, fid) = iprot.readFieldBegin()
9179 
      if ftype == TType.STOP:
9180 
        break
9181 
      if fid == 1:
9182 
        if ftype == TType.I64:
3064 chandransh 9183 
          self.orderId = iprot.readI64();
1135 chandransh 9184 
        else:
9185 
          iprot.skip(ftype)
9186 
      elif fid == 2:
3064 chandransh 9187 
        if ftype == TType.STRING:
9188 
          self.invoice_number = iprot.readString();
1135 chandransh 9189 
        else:
9190 
          iprot.skip(ftype)
3064 chandransh 9191 
      elif fid == 3:
4264 rajveer 9192 
        if ftype == TType.I64:
3064 chandransh 9193 
          self.imeiNumber = iprot.readI64();
9194 
        else:
9195 
          iprot.skip(ftype)
9196 
      elif fid == 4:
9197 
        if ftype == TType.STRING:
9198 
          self.itemNumber = iprot.readString();
9199 
        else:
9200 
          iprot.skip(ftype)
9201 
      elif fid == 5:
9202 
        if ftype == TType.STRING:
4283 anupam.sin 9203 
          self.billed_by = iprot.readString();
3064 chandransh 9204 
        else:
9205 
          iprot.skip(ftype)
9206 
      elif fid == 6:
9207 
        if ftype == TType.I64:
4283 anupam.sin 9208 
          self.jacketNumber = iprot.readI64();
9209 
        else:
9210 
          iprot.skip(ftype)
9211 
      elif fid == 7:
9212 
        if ftype == TType.I64:
3064 chandransh 9213 
          self.billingType = iprot.readI64();
9214 
        else:
9215 
          iprot.skip(ftype)
4283 anupam.sin 9216 
      elif fid == 8:
9217 
        if ftype == TType.I64:
9218 
          self.vendorId = iprot.readI64();
9219 
        else:
9220 
          iprot.skip(ftype)
1246 chandransh 9221 
      else:
9222 
        iprot.skip(ftype)
9223 
      iprot.readFieldEnd()
9224 
    iprot.readStructEnd()
9225 
 
9226 
  def write(self, oprot):
9227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9229 
      return
4283 anupam.sin 9230 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9231 
    if self.orderId is not None:
3064 chandransh 9232 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9233 
      oprot.writeI64(self.orderId)
1246 chandransh 9234 
      oprot.writeFieldEnd()
4283 anupam.sin 9235 
    if self.invoice_number is not None:
9236 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9237 
      oprot.writeString(self.invoice_number)
1246 chandransh 9238 
      oprot.writeFieldEnd()
3431 rajveer 9239 
    if self.imeiNumber is not None:
3064 chandransh 9240 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9241 
      oprot.writeI64(self.imeiNumber)
9242 
      oprot.writeFieldEnd()
3431 rajveer 9243 
    if self.itemNumber is not None:
3064 chandransh 9244 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9245 
      oprot.writeString(self.itemNumber)
9246 
      oprot.writeFieldEnd()
4283 anupam.sin 9247 
    if self.billed_by is not None:
9248 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9249 
      oprot.writeString(self.billed_by)
3064 chandransh 9250 
      oprot.writeFieldEnd()
4283 anupam.sin 9251 
    if self.jacketNumber is not None:
9252 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9253 
      oprot.writeI64(self.jacketNumber)
9254 
      oprot.writeFieldEnd()
3431 rajveer 9255 
    if self.billingType is not None:
4283 anupam.sin 9256 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9257 
      oprot.writeI64(self.billingType)
9258 
      oprot.writeFieldEnd()
4283 anupam.sin 9259 
    if self.vendorId is not None:
9260 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9261 
      oprot.writeI64(self.vendorId)
9262 
      oprot.writeFieldEnd()
1246 chandransh 9263 
    oprot.writeFieldStop()
9264 
    oprot.writeStructEnd()
9265 
 
3431 rajveer 9266 
  def validate(self):
9267 
    return
9268 
 
9269 
 
1246 chandransh 9270 
  def __repr__(self):
9271 
    L = ['%s=%r' % (key, value)
9272 
      for key, value in self.__dict__.iteritems()]
9273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9274 
 
9275 
  def __eq__(self, other):
9276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9277 
 
9278 
  def __ne__(self, other):
9279 
    return not (self == other)
9280 
 
4283 anupam.sin 9281 
class addBillingDetails_result:
1246 chandransh 9282 
  """
9283 
  Attributes:
3064 chandransh 9284 
   - success
1246 chandransh 9285 
   - ex
9286 
  """
9287 
 
9288 
  thrift_spec = (
3064 chandransh 9289 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9291 
  )
9292 
 
3064 chandransh 9293 
  def __init__(self, success=None, ex=None,):
9294 
    self.success = success
1246 chandransh 9295 
    self.ex = ex
9296 
 
9297 
  def read(self, iprot):
9298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9300 
      return
9301 
    iprot.readStructBegin()
9302 
    while True:
9303 
      (fname, ftype, fid) = iprot.readFieldBegin()
9304 
      if ftype == TType.STOP:
9305 
        break
3064 chandransh 9306 
      if fid == 0:
9307 
        if ftype == TType.BOOL:
9308 
          self.success = iprot.readBool();
9309 
        else:
9310 
          iprot.skip(ftype)
9311 
      elif fid == 1:
1246 chandransh 9312 
        if ftype == TType.STRUCT:
9313 
          self.ex = TransactionServiceException()
9314 
          self.ex.read(iprot)
9315 
        else:
9316 
          iprot.skip(ftype)
9317 
      else:
9318 
        iprot.skip(ftype)
9319 
      iprot.readFieldEnd()
9320 
    iprot.readStructEnd()
9321 
 
9322 
  def write(self, oprot):
9323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9325 
      return
4283 anupam.sin 9326 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9327 
    if self.success is not None:
3064 chandransh 9328 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9329 
      oprot.writeBool(self.success)
9330 
      oprot.writeFieldEnd()
3431 rajveer 9331 
    if self.ex is not None:
1246 chandransh 9332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9333 
      self.ex.write(oprot)
9334 
      oprot.writeFieldEnd()
9335 
    oprot.writeFieldStop()
9336 
    oprot.writeStructEnd()
9337 
 
3431 rajveer 9338 
  def validate(self):
9339 
    return
9340 
 
9341 
 
1246 chandransh 9342 
  def __repr__(self):
9343 
    L = ['%s=%r' % (key, value)
9344 
      for key, value in self.__dict__.iteritems()]
9345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9346 
 
9347 
  def __eq__(self, other):
9348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9349 
 
9350 
  def __ne__(self, other):
9351 
    return not (self == other)
9352 
 
3064 chandransh 9353 
class markOrdersAsManifested_args:
1408 ankur.sing 9354 
  """
9355 
  Attributes:
3064 chandransh 9356 
   - warehouseId
1408 ankur.sing 9357 
   - providerId
3064 chandransh 9358 
   - cod
1408 ankur.sing 9359 
  """
9360 
 
9361 
  thrift_spec = (
9362 
    None, # 0
3064 chandransh 9363 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9364 
    (2, TType.I64, 'providerId', None, None, ), # 2
9365 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9366 
  )
9367 
 
3064 chandransh 9368 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9369 
    self.warehouseId = warehouseId
1408 ankur.sing 9370 
    self.providerId = providerId
3064 chandransh 9371 
    self.cod = cod
1408 ankur.sing 9372 
 
9373 
  def read(self, iprot):
9374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9376 
      return
9377 
    iprot.readStructBegin()
9378 
    while True:
9379 
      (fname, ftype, fid) = iprot.readFieldBegin()
9380 
      if ftype == TType.STOP:
9381 
        break
9382 
      if fid == 1:
9383 
        if ftype == TType.I64:
3064 chandransh 9384 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9385 
        else:
9386 
          iprot.skip(ftype)
9387 
      elif fid == 2:
9388 
        if ftype == TType.I64:
3064 chandransh 9389 
          self.providerId = iprot.readI64();
1408 ankur.sing 9390 
        else:
9391 
          iprot.skip(ftype)
3064 chandransh 9392 
      elif fid == 3:
9393 
        if ftype == TType.BOOL:
9394 
          self.cod = iprot.readBool();
9395 
        else:
9396 
          iprot.skip(ftype)
1408 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('markOrdersAsManifested_args')
3431 rajveer 9407 
    if self.warehouseId is not None:
3064 chandransh 9408 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9409 
      oprot.writeI64(self.warehouseId)
9410 
      oprot.writeFieldEnd()
3431 rajveer 9411 
    if self.providerId is not None:
3064 chandransh 9412 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9413 
      oprot.writeI64(self.providerId)
9414 
      oprot.writeFieldEnd()
3431 rajveer 9415 
    if self.cod is not None:
3064 chandransh 9416 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9417 
      oprot.writeBool(self.cod)
1408 ankur.sing 9418 
      oprot.writeFieldEnd()
9419 
    oprot.writeFieldStop()
9420 
    oprot.writeStructEnd()
9421 
 
3431 rajveer 9422 
  def validate(self):
9423 
    return
9424 
 
9425 
 
1408 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 markOrdersAsManifested_result:
1408 ankur.sing 9438 
  """
9439 
  Attributes:
9440 
   - success
3064 chandransh 9441 
   - ex
1408 ankur.sing 9442 
  """
9443 
 
9444 
  thrift_spec = (
3064 chandransh 9445 
    (0, TType.BOOL, 'success', None, None, ), # 0
9446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9447 
  )
9448 
 
3064 chandransh 9449 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9450 
    self.success = success
3064 chandransh 9451 
    self.ex = ex
1408 ankur.sing 9452 
 
9453 
  def read(self, iprot):
9454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9456 
      return
9457 
    iprot.readStructBegin()
9458 
    while True:
9459 
      (fname, ftype, fid) = iprot.readFieldBegin()
9460 
      if ftype == TType.STOP:
9461 
        break
9462 
      if fid == 0:
3064 chandransh 9463 
        if ftype == TType.BOOL:
9464 
          self.success = iprot.readBool();
1408 ankur.sing 9465 
        else:
9466 
          iprot.skip(ftype)
3064 chandransh 9467 
      elif fid == 1:
9468 
        if ftype == TType.STRUCT:
9469 
          self.ex = TransactionServiceException()
9470 
          self.ex.read(iprot)
9471 
        else:
9472 
          iprot.skip(ftype)
1408 ankur.sing 9473 
      else:
9474 
        iprot.skip(ftype)
9475 
      iprot.readFieldEnd()
9476 
    iprot.readStructEnd()
9477 
 
9478 
  def write(self, oprot):
9479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9481 
      return
3064 chandransh 9482 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9483 
    if self.success is not None:
3064 chandransh 9484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9485 
      oprot.writeBool(self.success)
1408 ankur.sing 9486 
      oprot.writeFieldEnd()
3431 rajveer 9487 
    if self.ex is not None:
3064 chandransh 9488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9489 
      self.ex.write(oprot)
9490 
      oprot.writeFieldEnd()
1408 ankur.sing 9491 
    oprot.writeFieldStop()
9492 
    oprot.writeStructEnd()
9493 
 
3431 rajveer 9494 
  def validate(self):
9495 
    return
9496 
 
9497 
 
1408 ankur.sing 9498 
  def __repr__(self):
9499 
    L = ['%s=%r' % (key, value)
9500 
      for key, value in self.__dict__.iteritems()]
9501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9502 
 
9503 
  def __eq__(self, other):
9504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9505 
 
9506 
  def __ne__(self, other):
9507 
    return not (self == other)
9508 
 
4410 rajveer 9509 
class markOrdersAsShippedFromWarehouse_args:
9510 
  """
9511 
  Attributes:
9512 
   - warehouseId
9513 
   - providerId
9514 
   - cod
9515 
  """
9516 
 
9517 
  thrift_spec = (
9518 
    None, # 0
9519 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9520 
    (2, TType.I64, 'providerId', None, None, ), # 2
9521 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9522 
  )
9523 
 
9524 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9525 
    self.warehouseId = warehouseId
9526 
    self.providerId = providerId
9527 
    self.cod = cod
9528 
 
9529 
  def read(self, iprot):
9530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9532 
      return
9533 
    iprot.readStructBegin()
9534 
    while True:
9535 
      (fname, ftype, fid) = iprot.readFieldBegin()
9536 
      if ftype == TType.STOP:
9537 
        break
9538 
      if fid == 1:
9539 
        if ftype == TType.I64:
9540 
          self.warehouseId = iprot.readI64();
9541 
        else:
9542 
          iprot.skip(ftype)
9543 
      elif fid == 2:
9544 
        if ftype == TType.I64:
9545 
          self.providerId = iprot.readI64();
9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      elif fid == 3:
9549 
        if ftype == TType.BOOL:
9550 
          self.cod = iprot.readBool();
9551 
        else:
9552 
          iprot.skip(ftype)
9553 
      else:
9554 
        iprot.skip(ftype)
9555 
      iprot.readFieldEnd()
9556 
    iprot.readStructEnd()
9557 
 
9558 
  def write(self, oprot):
9559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9561 
      return
9562 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9563 
    if self.warehouseId is not None:
9564 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9565 
      oprot.writeI64(self.warehouseId)
9566 
      oprot.writeFieldEnd()
9567 
    if self.providerId is not None:
9568 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9569 
      oprot.writeI64(self.providerId)
9570 
      oprot.writeFieldEnd()
9571 
    if self.cod is not None:
9572 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9573 
      oprot.writeBool(self.cod)
9574 
      oprot.writeFieldEnd()
9575 
    oprot.writeFieldStop()
9576 
    oprot.writeStructEnd()
9577 
 
9578 
  def validate(self):
9579 
    return
9580 
 
9581 
 
9582 
  def __repr__(self):
9583 
    L = ['%s=%r' % (key, value)
9584 
      for key, value in self.__dict__.iteritems()]
9585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9586 
 
9587 
  def __eq__(self, other):
9588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9589 
 
9590 
  def __ne__(self, other):
9591 
    return not (self == other)
9592 
 
9593 
class markOrdersAsShippedFromWarehouse_result:
9594 
  """
9595 
  Attributes:
9596 
   - success
9597 
   - ex
9598 
  """
9599 
 
9600 
  thrift_spec = (
9601 
    (0, TType.BOOL, 'success', None, None, ), # 0
9602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9603 
  )
9604 
 
9605 
  def __init__(self, success=None, ex=None,):
9606 
    self.success = success
9607 
    self.ex = ex
9608 
 
9609 
  def read(self, iprot):
9610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9612 
      return
9613 
    iprot.readStructBegin()
9614 
    while True:
9615 
      (fname, ftype, fid) = iprot.readFieldBegin()
9616 
      if ftype == TType.STOP:
9617 
        break
9618 
      if fid == 0:
9619 
        if ftype == TType.BOOL:
9620 
          self.success = iprot.readBool();
9621 
        else:
9622 
          iprot.skip(ftype)
9623 
      elif fid == 1:
9624 
        if ftype == TType.STRUCT:
9625 
          self.ex = TransactionServiceException()
9626 
          self.ex.read(iprot)
9627 
        else:
9628 
          iprot.skip(ftype)
9629 
      else:
9630 
        iprot.skip(ftype)
9631 
      iprot.readFieldEnd()
9632 
    iprot.readStructEnd()
9633 
 
9634 
  def write(self, oprot):
9635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9637 
      return
9638 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9639 
    if self.success is not None:
9640 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9641 
      oprot.writeBool(self.success)
9642 
      oprot.writeFieldEnd()
9643 
    if self.ex is not None:
9644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9645 
      self.ex.write(oprot)
9646 
      oprot.writeFieldEnd()
9647 
    oprot.writeFieldStop()
9648 
    oprot.writeStructEnd()
9649 
 
9650 
  def validate(self):
9651 
    return
9652 
 
9653 
 
9654 
  def __repr__(self):
9655 
    L = ['%s=%r' % (key, value)
9656 
      for key, value in self.__dict__.iteritems()]
9657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9658 
 
9659 
  def __eq__(self, other):
9660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9661 
 
9662 
  def __ne__(self, other):
9663 
    return not (self == other)
9664 
 
3064 chandransh 9665 
class markOrdersAsPickedUp_args:
304 ashish 9666 
  """
9667 
  Attributes:
3064 chandransh 9668 
   - providerId
9669 
   - pickupDetails
304 ashish 9670 
  """
94 ashish 9671 
 
304 ashish 9672 
  thrift_spec = (
9673 
    None, # 0
3064 chandransh 9674 
    (1, TType.I64, 'providerId', None, None, ), # 1
9675 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9676 
  )
9677 
 
3064 chandransh 9678 
  def __init__(self, providerId=None, pickupDetails=None,):
9679 
    self.providerId = providerId
9680 
    self.pickupDetails = pickupDetails
304 ashish 9681 
 
9682 
  def read(self, iprot):
9683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9685 
      return
9686 
    iprot.readStructBegin()
9687 
    while True:
9688 
      (fname, ftype, fid) = iprot.readFieldBegin()
9689 
      if ftype == TType.STOP:
9690 
        break
9691 
      if fid == 1:
9692 
        if ftype == TType.I64:
3064 chandransh 9693 
          self.providerId = iprot.readI64();
304 ashish 9694 
        else:
9695 
          iprot.skip(ftype)
9696 
      elif fid == 2:
3064 chandransh 9697 
        if ftype == TType.MAP:
9698 
          self.pickupDetails = {}
4133 chandransh 9699 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9700 
          for _i144 in xrange(_size140):
9701 
            _key145 = iprot.readString();
9702 
            _val146 = iprot.readString();
9703 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9704 
          iprot.readMapEnd()
304 ashish 9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      else:
9708 
        iprot.skip(ftype)
9709 
      iprot.readFieldEnd()
9710 
    iprot.readStructEnd()
9711 
 
9712 
  def write(self, oprot):
9713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9715 
      return
3064 chandransh 9716 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9717 
    if self.providerId is not None:
3064 chandransh 9718 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9719 
      oprot.writeI64(self.providerId)
304 ashish 9720 
      oprot.writeFieldEnd()
3431 rajveer 9721 
    if self.pickupDetails is not None:
3064 chandransh 9722 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9723 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9724 
      for kiter147,viter148 in self.pickupDetails.items():
9725 
        oprot.writeString(kiter147)
9726 
        oprot.writeString(viter148)
3064 chandransh 9727 
      oprot.writeMapEnd()
304 ashish 9728 
      oprot.writeFieldEnd()
9729 
    oprot.writeFieldStop()
9730 
    oprot.writeStructEnd()
9731 
 
3431 rajveer 9732 
  def validate(self):
9733 
    return
9734 
 
9735 
 
304 ashish 9736 
  def __repr__(self):
9737 
    L = ['%s=%r' % (key, value)
9738 
      for key, value in self.__dict__.iteritems()]
9739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9740 
 
9741 
  def __eq__(self, other):
9742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9743 
 
9744 
  def __ne__(self, other):
9745 
    return not (self == other)
9746 
 
3064 chandransh 9747 
class markOrdersAsPickedUp_result:
304 ashish 9748 
  """
9749 
  Attributes:
9750 
   - success
3064 chandransh 9751 
   - ex
304 ashish 9752 
  """
9753 
 
9754 
  thrift_spec = (
3064 chandransh 9755 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9757 
  )
9758 
 
3064 chandransh 9759 
  def __init__(self, success=None, ex=None,):
304 ashish 9760 
    self.success = success
3064 chandransh 9761 
    self.ex = ex
304 ashish 9762 
 
9763 
  def read(self, iprot):
9764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9766 
      return
9767 
    iprot.readStructBegin()
9768 
    while True:
9769 
      (fname, ftype, fid) = iprot.readFieldBegin()
9770 
      if ftype == TType.STOP:
9771 
        break
9772 
      if fid == 0:
9773 
        if ftype == TType.LIST:
9774 
          self.success = []
4133 chandransh 9775 
          (_etype152, _size149) = iprot.readListBegin()
9776 
          for _i153 in xrange(_size149):
9777 
            _elem154 = Order()
9778 
            _elem154.read(iprot)
9779 
            self.success.append(_elem154)
304 ashish 9780 
          iprot.readListEnd()
9781 
        else:
9782 
          iprot.skip(ftype)
3064 chandransh 9783 
      elif fid == 1:
9784 
        if ftype == TType.STRUCT:
9785 
          self.ex = TransactionServiceException()
9786 
          self.ex.read(iprot)
9787 
        else:
9788 
          iprot.skip(ftype)
304 ashish 9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
3064 chandransh 9798 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9799 
    if self.success is not None:
304 ashish 9800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9802 
      for iter155 in self.success:
9803 
        iter155.write(oprot)
304 ashish 9804 
      oprot.writeListEnd()
9805 
      oprot.writeFieldEnd()
3431 rajveer 9806 
    if self.ex is not None:
3064 chandransh 9807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9808 
      self.ex.write(oprot)
9809 
      oprot.writeFieldEnd()
304 ashish 9810 
    oprot.writeFieldStop()
9811 
    oprot.writeStructEnd()
9812 
 
3431 rajveer 9813 
  def validate(self):
9814 
    return
9815 
 
9816 
 
304 ashish 9817 
  def __repr__(self):
9818 
    L = ['%s=%r' % (key, value)
9819 
      for key, value in self.__dict__.iteritems()]
9820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9821 
 
9822 
  def __eq__(self, other):
9823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9824 
 
9825 
  def __ne__(self, other):
9826 
    return not (self == other)
9827 
 
3064 chandransh 9828 
class markOrdersAsDelivered_args:
304 ashish 9829 
  """
9830 
  Attributes:
3064 chandransh 9831 
   - providerId
9832 
   - deliveredOrders
304 ashish 9833 
  """
9834 
 
9835 
  thrift_spec = (
9836 
    None, # 0
3064 chandransh 9837 
    (1, TType.I64, 'providerId', None, None, ), # 1
9838 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9839 
  )
9840 
 
3064 chandransh 9841 
  def __init__(self, providerId=None, deliveredOrders=None,):
9842 
    self.providerId = providerId
9843 
    self.deliveredOrders = deliveredOrders
304 ashish 9844 
 
9845 
  def read(self, iprot):
9846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9848 
      return
9849 
    iprot.readStructBegin()
9850 
    while True:
9851 
      (fname, ftype, fid) = iprot.readFieldBegin()
9852 
      if ftype == TType.STOP:
9853 
        break
9854 
      if fid == 1:
9855 
        if ftype == TType.I64:
3064 chandransh 9856 
          self.providerId = iprot.readI64();
304 ashish 9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      elif fid == 2:
3064 chandransh 9860 
        if ftype == TType.MAP:
9861 
          self.deliveredOrders = {}
4133 chandransh 9862 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9863 
          for _i160 in xrange(_size156):
9864 
            _key161 = iprot.readString();
9865 
            _val162 = iprot.readString();
9866 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9867 
          iprot.readMapEnd()
304 ashish 9868 
        else:
9869 
          iprot.skip(ftype)
9870 
      else:
9871 
        iprot.skip(ftype)
9872 
      iprot.readFieldEnd()
9873 
    iprot.readStructEnd()
9874 
 
9875 
  def write(self, oprot):
9876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9878 
      return
3064 chandransh 9879 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 9880 
    if self.providerId is not None:
3064 chandransh 9881 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9882 
      oprot.writeI64(self.providerId)
304 ashish 9883 
      oprot.writeFieldEnd()
3431 rajveer 9884 
    if self.deliveredOrders is not None:
3064 chandransh 9885 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
9886 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 9887 
      for kiter163,viter164 in self.deliveredOrders.items():
9888 
        oprot.writeString(kiter163)
9889 
        oprot.writeString(viter164)
3064 chandransh 9890 
      oprot.writeMapEnd()
304 ashish 9891 
      oprot.writeFieldEnd()
9892 
    oprot.writeFieldStop()
9893 
    oprot.writeStructEnd()
9894 
 
3431 rajveer 9895 
  def validate(self):
9896 
    return
9897 
 
9898 
 
304 ashish 9899 
  def __repr__(self):
9900 
    L = ['%s=%r' % (key, value)
9901 
      for key, value in self.__dict__.iteritems()]
9902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9903 
 
9904 
  def __eq__(self, other):
9905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9906 
 
9907 
  def __ne__(self, other):
9908 
    return not (self == other)
9909 
 
3064 chandransh 9910 
class markOrdersAsDelivered_result:
9911 
  """
9912 
  Attributes:
9913 
   - ex
9914 
  """
304 ashish 9915 
 
9916 
  thrift_spec = (
3064 chandransh 9917 
    None, # 0
9918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9919 
  )
9920 
 
3064 chandransh 9921 
  def __init__(self, ex=None,):
9922 
    self.ex = ex
304 ashish 9923 
 
1596 ankur.sing 9924 
  def read(self, iprot):
9925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9927 
      return
9928 
    iprot.readStructBegin()
9929 
    while True:
9930 
      (fname, ftype, fid) = iprot.readFieldBegin()
9931 
      if ftype == TType.STOP:
9932 
        break
3064 chandransh 9933 
      if fid == 1:
9934 
        if ftype == TType.STRUCT:
9935 
          self.ex = TransactionServiceException()
9936 
          self.ex.read(iprot)
9937 
        else:
9938 
          iprot.skip(ftype)
1596 ankur.sing 9939 
      else:
9940 
        iprot.skip(ftype)
9941 
      iprot.readFieldEnd()
9942 
    iprot.readStructEnd()
9943 
 
9944 
  def write(self, oprot):
9945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9947 
      return
3064 chandransh 9948 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 9949 
    if self.ex is not None:
3064 chandransh 9950 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9951 
      self.ex.write(oprot)
9952 
      oprot.writeFieldEnd()
1596 ankur.sing 9953 
    oprot.writeFieldStop()
9954 
    oprot.writeStructEnd()
9955 
 
3431 rajveer 9956 
  def validate(self):
9957 
    return
9958 
 
9959 
 
1596 ankur.sing 9960 
  def __repr__(self):
9961 
    L = ['%s=%r' % (key, value)
9962 
      for key, value in self.__dict__.iteritems()]
9963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9964 
 
9965 
  def __eq__(self, other):
9966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9967 
 
9968 
  def __ne__(self, other):
9969 
    return not (self == other)
9970 
 
3064 chandransh 9971 
class markOrdersAsFailed_args:
1596 ankur.sing 9972 
  """
9973 
  Attributes:
3064 chandransh 9974 
   - providerId
9975 
   - returnedOrders
1596 ankur.sing 9976 
  """
9977 
 
9978 
  thrift_spec = (
3064 chandransh 9979 
    None, # 0
9980 
    (1, TType.I64, 'providerId', None, None, ), # 1
9981 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 9982 
  )
9983 
 
3064 chandransh 9984 
  def __init__(self, providerId=None, returnedOrders=None,):
9985 
    self.providerId = providerId
9986 
    self.returnedOrders = returnedOrders
1596 ankur.sing 9987 
 
9988 
  def read(self, iprot):
9989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9991 
      return
9992 
    iprot.readStructBegin()
9993 
    while True:
9994 
      (fname, ftype, fid) = iprot.readFieldBegin()
9995 
      if ftype == TType.STOP:
9996 
        break
3064 chandransh 9997 
      if fid == 1:
1596 ankur.sing 9998 
        if ftype == TType.I64:
3064 chandransh 9999 
          self.providerId = iprot.readI64();
1596 ankur.sing 10000 
        else:
10001 
          iprot.skip(ftype)
3064 chandransh 10002 
      elif fid == 2:
10003 
        if ftype == TType.MAP:
10004 
          self.returnedOrders = {}
4133 chandransh 10005 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10006 
          for _i169 in xrange(_size165):
10007 
            _key170 = iprot.readString();
10008 
            _val171 = iprot.readString();
10009 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10010 
          iprot.readMapEnd()
10011 
        else:
10012 
          iprot.skip(ftype)
1596 ankur.sing 10013 
      else:
10014 
        iprot.skip(ftype)
10015 
      iprot.readFieldEnd()
10016 
    iprot.readStructEnd()
10017 
 
10018 
  def write(self, oprot):
10019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10021 
      return
3064 chandransh 10022 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10023 
    if self.providerId is not None:
3064 chandransh 10024 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10025 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10026 
      oprot.writeFieldEnd()
3431 rajveer 10027 
    if self.returnedOrders is not None:
3064 chandransh 10028 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10029 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10030 
      for kiter172,viter173 in self.returnedOrders.items():
10031 
        oprot.writeString(kiter172)
10032 
        oprot.writeString(viter173)
3064 chandransh 10033 
      oprot.writeMapEnd()
10034 
      oprot.writeFieldEnd()
1596 ankur.sing 10035 
    oprot.writeFieldStop()
10036 
    oprot.writeStructEnd()
10037 
 
3431 rajveer 10038 
  def validate(self):
10039 
    return
10040 
 
10041 
 
1596 ankur.sing 10042 
  def __repr__(self):
10043 
    L = ['%s=%r' % (key, value)
10044 
      for key, value in self.__dict__.iteritems()]
10045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10046 
 
10047 
  def __eq__(self, other):
10048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10049 
 
10050 
  def __ne__(self, other):
10051 
    return not (self == other)
10052 
 
3064 chandransh 10053 
class markOrdersAsFailed_result:
10054 
  """
10055 
  Attributes:
10056 
   - ex
10057 
  """
1596 ankur.sing 10058 
 
1627 ankur.sing 10059 
  thrift_spec = (
3064 chandransh 10060 
    None, # 0
10061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10062 
  )
10063 
 
3064 chandransh 10064 
  def __init__(self, ex=None,):
10065 
    self.ex = ex
10066 
 
1627 ankur.sing 10067 
  def read(self, iprot):
10068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10070 
      return
10071 
    iprot.readStructBegin()
10072 
    while True:
10073 
      (fname, ftype, fid) = iprot.readFieldBegin()
10074 
      if ftype == TType.STOP:
10075 
        break
3064 chandransh 10076 
      if fid == 1:
10077 
        if ftype == TType.STRUCT:
10078 
          self.ex = TransactionServiceException()
10079 
          self.ex.read(iprot)
10080 
        else:
10081 
          iprot.skip(ftype)
1627 ankur.sing 10082 
      else:
10083 
        iprot.skip(ftype)
10084 
      iprot.readFieldEnd()
10085 
    iprot.readStructEnd()
10086 
 
10087 
  def write(self, oprot):
10088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10090 
      return
3064 chandransh 10091 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10092 
    if self.ex is not None:
3064 chandransh 10093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10094 
      self.ex.write(oprot)
10095 
      oprot.writeFieldEnd()
1627 ankur.sing 10096 
    oprot.writeFieldStop()
10097 
    oprot.writeStructEnd()
10098 
 
3431 rajveer 10099 
  def validate(self):
10100 
    return
10101 
 
10102 
 
1627 ankur.sing 10103 
  def __repr__(self):
10104 
    L = ['%s=%r' % (key, value)
10105 
      for key, value in self.__dict__.iteritems()]
10106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10107 
 
10108 
  def __eq__(self, other):
10109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10110 
 
10111 
  def __ne__(self, other):
10112 
    return not (self == other)
10113 
 
3064 chandransh 10114 
class updateNonDeliveryReason_args:
1627 ankur.sing 10115 
  """
10116 
  Attributes:
3064 chandransh 10117 
   - providerId
10118 
   - undeliveredOrders
1627 ankur.sing 10119 
  """
10120 
 
10121 
  thrift_spec = (
3064 chandransh 10122 
    None, # 0
10123 
    (1, TType.I64, 'providerId', None, None, ), # 1
10124 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10125 
  )
10126 
 
3064 chandransh 10127 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10128 
    self.providerId = providerId
10129 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10130 
 
10131 
  def read(self, iprot):
10132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10134 
      return
10135 
    iprot.readStructBegin()
10136 
    while True:
10137 
      (fname, ftype, fid) = iprot.readFieldBegin()
10138 
      if ftype == TType.STOP:
10139 
        break
3064 chandransh 10140 
      if fid == 1:
1627 ankur.sing 10141 
        if ftype == TType.I64:
3064 chandransh 10142 
          self.providerId = iprot.readI64();
1627 ankur.sing 10143 
        else:
10144 
          iprot.skip(ftype)
3064 chandransh 10145 
      elif fid == 2:
10146 
        if ftype == TType.MAP:
10147 
          self.undeliveredOrders = {}
4133 chandransh 10148 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10149 
          for _i178 in xrange(_size174):
10150 
            _key179 = iprot.readString();
10151 
            _val180 = iprot.readString();
10152 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10153 
          iprot.readMapEnd()
10154 
        else:
10155 
          iprot.skip(ftype)
1627 ankur.sing 10156 
      else:
10157 
        iprot.skip(ftype)
10158 
      iprot.readFieldEnd()
10159 
    iprot.readStructEnd()
10160 
 
10161 
  def write(self, oprot):
10162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10164 
      return
3064 chandransh 10165 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10166 
    if self.providerId is not None:
3064 chandransh 10167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10168 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10169 
      oprot.writeFieldEnd()
3431 rajveer 10170 
    if self.undeliveredOrders is not None:
3064 chandransh 10171 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10172 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10173 
      for kiter181,viter182 in self.undeliveredOrders.items():
10174 
        oprot.writeString(kiter181)
10175 
        oprot.writeString(viter182)
3064 chandransh 10176 
      oprot.writeMapEnd()
10177 
      oprot.writeFieldEnd()
1627 ankur.sing 10178 
    oprot.writeFieldStop()
10179 
    oprot.writeStructEnd()
10180 
 
3431 rajveer 10181 
  def validate(self):
10182 
    return
10183 
 
10184 
 
1627 ankur.sing 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 
 
3064 chandransh 10196 
class updateNonDeliveryReason_result:
1627 ankur.sing 10197 
  """
10198 
  Attributes:
3064 chandransh 10199 
   - ex
1627 ankur.sing 10200 
  """
10201 
 
10202 
  thrift_spec = (
3064 chandransh 10203 
    None, # 0
10204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10205 
  )
10206 
 
3064 chandransh 10207 
  def __init__(self, ex=None,):
10208 
    self.ex = ex
1627 ankur.sing 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
3064 chandransh 10219 
      if fid == 1:
10220 
        if ftype == TType.STRUCT:
10221 
          self.ex = TransactionServiceException()
10222 
          self.ex.read(iprot)
1627 ankur.sing 10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      else:
10226 
        iprot.skip(ftype)
10227 
      iprot.readFieldEnd()
10228 
    iprot.readStructEnd()
10229 
 
10230 
  def write(self, oprot):
10231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10233 
      return
3064 chandransh 10234 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10235 
    if self.ex is not None:
3064 chandransh 10236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10237 
      self.ex.write(oprot)
1627 ankur.sing 10238 
      oprot.writeFieldEnd()
10239 
    oprot.writeFieldStop()
10240 
    oprot.writeStructEnd()
10241 
 
3431 rajveer 10242 
  def validate(self):
10243 
    return
10244 
 
10245 
 
1627 ankur.sing 10246 
  def __repr__(self):
10247 
    L = ['%s=%r' % (key, value)
10248 
      for key, value in self.__dict__.iteritems()]
10249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10250 
 
10251 
  def __eq__(self, other):
10252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10253 
 
10254 
  def __ne__(self, other):
10255 
    return not (self == other)
10256 
 
3064 chandransh 10257 
class getUndeliveredOrders_args:
1886 ankur.sing 10258 
  """
10259 
  Attributes:
3064 chandransh 10260 
   - providerId
10261 
   - warehouseId
1886 ankur.sing 10262 
  """
1627 ankur.sing 10263 
 
1886 ankur.sing 10264 
  thrift_spec = (
10265 
    None, # 0
3064 chandransh 10266 
    (1, TType.I64, 'providerId', None, None, ), # 1
10267 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10268 
  )
10269 
 
3064 chandransh 10270 
  def __init__(self, providerId=None, warehouseId=None,):
10271 
    self.providerId = providerId
10272 
    self.warehouseId = warehouseId
1886 ankur.sing 10273 
 
10274 
  def read(self, iprot):
10275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10277 
      return
10278 
    iprot.readStructBegin()
10279 
    while True:
10280 
      (fname, ftype, fid) = iprot.readFieldBegin()
10281 
      if ftype == TType.STOP:
10282 
        break
10283 
      if fid == 1:
10284 
        if ftype == TType.I64:
3064 chandransh 10285 
          self.providerId = iprot.readI64();
1886 ankur.sing 10286 
        else:
10287 
          iprot.skip(ftype)
3064 chandransh 10288 
      elif fid == 2:
10289 
        if ftype == TType.I64:
10290 
          self.warehouseId = iprot.readI64();
10291 
        else:
10292 
          iprot.skip(ftype)
1886 ankur.sing 10293 
      else:
10294 
        iprot.skip(ftype)
10295 
      iprot.readFieldEnd()
10296 
    iprot.readStructEnd()
10297 
 
10298 
  def write(self, oprot):
10299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10301 
      return
3064 chandransh 10302 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10303 
    if self.providerId is not None:
3064 chandransh 10304 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10305 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10306 
      oprot.writeFieldEnd()
3431 rajveer 10307 
    if self.warehouseId is not None:
3064 chandransh 10308 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10309 
      oprot.writeI64(self.warehouseId)
10310 
      oprot.writeFieldEnd()
1886 ankur.sing 10311 
    oprot.writeFieldStop()
10312 
    oprot.writeStructEnd()
10313 
 
3431 rajveer 10314 
  def validate(self):
10315 
    return
10316 
 
10317 
 
1886 ankur.sing 10318 
  def __repr__(self):
10319 
    L = ['%s=%r' % (key, value)
10320 
      for key, value in self.__dict__.iteritems()]
10321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10322 
 
10323 
  def __eq__(self, other):
10324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10325 
 
10326 
  def __ne__(self, other):
10327 
    return not (self == other)
10328 
 
3064 chandransh 10329 
class getUndeliveredOrders_result:
1886 ankur.sing 10330 
  """
10331 
  Attributes:
10332 
   - success
10333 
  """
10334 
 
10335 
  thrift_spec = (
10336 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10337 
  )
10338 
 
10339 
  def __init__(self, success=None,):
10340 
    self.success = success
10341 
 
10342 
  def read(self, iprot):
10343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10345 
      return
10346 
    iprot.readStructBegin()
10347 
    while True:
10348 
      (fname, ftype, fid) = iprot.readFieldBegin()
10349 
      if ftype == TType.STOP:
10350 
        break
10351 
      if fid == 0:
10352 
        if ftype == TType.LIST:
10353 
          self.success = []
4133 chandransh 10354 
          (_etype186, _size183) = iprot.readListBegin()
10355 
          for _i187 in xrange(_size183):
10356 
            _elem188 = Order()
10357 
            _elem188.read(iprot)
10358 
            self.success.append(_elem188)
1886 ankur.sing 10359 
          iprot.readListEnd()
10360 
        else:
10361 
          iprot.skip(ftype)
10362 
      else:
10363 
        iprot.skip(ftype)
10364 
      iprot.readFieldEnd()
10365 
    iprot.readStructEnd()
10366 
 
10367 
  def write(self, oprot):
10368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10370 
      return
3064 chandransh 10371 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10372 
    if self.success is not None:
1886 ankur.sing 10373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10375 
      for iter189 in self.success:
10376 
        iter189.write(oprot)
1886 ankur.sing 10377 
      oprot.writeListEnd()
10378 
      oprot.writeFieldEnd()
10379 
    oprot.writeFieldStop()
10380 
    oprot.writeStructEnd()
10381 
 
3431 rajveer 10382 
  def validate(self):
10383 
    return
10384 
 
10385 
 
1886 ankur.sing 10386 
  def __repr__(self):
10387 
    L = ['%s=%r' % (key, value)
10388 
      for key, value in self.__dict__.iteritems()]
10389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10390 
 
10391 
  def __eq__(self, other):
10392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10393 
 
10394 
  def __ne__(self, other):
10395 
    return not (self == other)
10396 
 
2536 chandransh 10397 
class toggleDOAFlag_args:
10398 
  """
10399 
  Attributes:
10400 
   - orderId
10401 
  """
1886 ankur.sing 10402 
 
2536 chandransh 10403 
  thrift_spec = (
10404 
    None, # 0
10405 
    (1, TType.I64, 'orderId', None, None, ), # 1
10406 
  )
10407 
 
10408 
  def __init__(self, orderId=None,):
10409 
    self.orderId = orderId
10410 
 
10411 
  def read(self, iprot):
10412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10414 
      return
10415 
    iprot.readStructBegin()
10416 
    while True:
10417 
      (fname, ftype, fid) = iprot.readFieldBegin()
10418 
      if ftype == TType.STOP:
10419 
        break
10420 
      if fid == 1:
10421 
        if ftype == TType.I64:
10422 
          self.orderId = iprot.readI64();
10423 
        else:
10424 
          iprot.skip(ftype)
10425 
      else:
10426 
        iprot.skip(ftype)
10427 
      iprot.readFieldEnd()
10428 
    iprot.readStructEnd()
10429 
 
10430 
  def write(self, oprot):
10431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10433 
      return
10434 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10435 
    if self.orderId is not None:
2536 chandransh 10436 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10437 
      oprot.writeI64(self.orderId)
10438 
      oprot.writeFieldEnd()
10439 
    oprot.writeFieldStop()
10440 
    oprot.writeStructEnd()
10441 
 
3431 rajveer 10442 
  def validate(self):
10443 
    return
10444 
 
10445 
 
2536 chandransh 10446 
  def __repr__(self):
10447 
    L = ['%s=%r' % (key, value)
10448 
      for key, value in self.__dict__.iteritems()]
10449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10450 
 
10451 
  def __eq__(self, other):
10452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10453 
 
10454 
  def __ne__(self, other):
10455 
    return not (self == other)
10456 
 
10457 
class toggleDOAFlag_result:
10458 
  """
10459 
  Attributes:
10460 
   - success
10461 
   - ex
10462 
  """
10463 
 
10464 
  thrift_spec = (
10465 
    (0, TType.BOOL, 'success', None, None, ), # 0
10466 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10467 
  )
10468 
 
10469 
  def __init__(self, success=None, ex=None,):
10470 
    self.success = success
10471 
    self.ex = ex
10472 
 
10473 
  def read(self, iprot):
10474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10476 
      return
10477 
    iprot.readStructBegin()
10478 
    while True:
10479 
      (fname, ftype, fid) = iprot.readFieldBegin()
10480 
      if ftype == TType.STOP:
10481 
        break
10482 
      if fid == 0:
10483 
        if ftype == TType.BOOL:
10484 
          self.success = iprot.readBool();
10485 
        else:
10486 
          iprot.skip(ftype)
10487 
      elif fid == 1:
10488 
        if ftype == TType.STRUCT:
10489 
          self.ex = TransactionServiceException()
10490 
          self.ex.read(iprot)
10491 
        else:
10492 
          iprot.skip(ftype)
10493 
      else:
10494 
        iprot.skip(ftype)
10495 
      iprot.readFieldEnd()
10496 
    iprot.readStructEnd()
10497 
 
10498 
  def write(self, oprot):
10499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10501 
      return
10502 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10503 
    if self.success is not None:
2536 chandransh 10504 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10505 
      oprot.writeBool(self.success)
10506 
      oprot.writeFieldEnd()
3431 rajveer 10507 
    if self.ex is not None:
2536 chandransh 10508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10509 
      self.ex.write(oprot)
10510 
      oprot.writeFieldEnd()
10511 
    oprot.writeFieldStop()
10512 
    oprot.writeStructEnd()
10513 
 
3431 rajveer 10514 
  def validate(self):
10515 
    return
10516 
 
10517 
 
2536 chandransh 10518 
  def __repr__(self):
10519 
    L = ['%s=%r' % (key, value)
10520 
      for key, value in self.__dict__.iteritems()]
10521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10522 
 
10523 
  def __eq__(self, other):
10524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10525 
 
10526 
  def __ne__(self, other):
10527 
    return not (self == other)
10528 
 
10529 
class requestPickupNumber_args:
10530 
  """
10531 
  Attributes:
10532 
   - orderId
10533 
  """
10534 
 
10535 
  thrift_spec = (
10536 
    None, # 0
10537 
    (1, TType.I64, 'orderId', None, None, ), # 1
10538 
  )
10539 
 
10540 
  def __init__(self, orderId=None,):
10541 
    self.orderId = orderId
10542 
 
10543 
  def read(self, iprot):
10544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10546 
      return
10547 
    iprot.readStructBegin()
10548 
    while True:
10549 
      (fname, ftype, fid) = iprot.readFieldBegin()
10550 
      if ftype == TType.STOP:
10551 
        break
10552 
      if fid == 1:
10553 
        if ftype == TType.I64:
10554 
          self.orderId = iprot.readI64();
10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      else:
10558 
        iprot.skip(ftype)
10559 
      iprot.readFieldEnd()
10560 
    iprot.readStructEnd()
10561 
 
10562 
  def write(self, oprot):
10563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10565 
      return
10566 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10567 
    if self.orderId is not None:
2536 chandransh 10568 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10569 
      oprot.writeI64(self.orderId)
10570 
      oprot.writeFieldEnd()
10571 
    oprot.writeFieldStop()
10572 
    oprot.writeStructEnd()
10573 
 
3431 rajveer 10574 
  def validate(self):
10575 
    return
10576 
 
10577 
 
2536 chandransh 10578 
  def __repr__(self):
10579 
    L = ['%s=%r' % (key, value)
10580 
      for key, value in self.__dict__.iteritems()]
10581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10582 
 
10583 
  def __eq__(self, other):
10584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10585 
 
10586 
  def __ne__(self, other):
10587 
    return not (self == other)
10588 
 
10589 
class requestPickupNumber_result:
10590 
  """
10591 
  Attributes:
10592 
   - success
10593 
   - ex
10594 
  """
10595 
 
10596 
  thrift_spec = (
10597 
    (0, TType.BOOL, 'success', None, None, ), # 0
10598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10599 
  )
10600 
 
10601 
  def __init__(self, success=None, ex=None,):
10602 
    self.success = success
10603 
    self.ex = ex
10604 
 
10605 
  def read(self, iprot):
10606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10608 
      return
10609 
    iprot.readStructBegin()
10610 
    while True:
10611 
      (fname, ftype, fid) = iprot.readFieldBegin()
10612 
      if ftype == TType.STOP:
10613 
        break
10614 
      if fid == 0:
10615 
        if ftype == TType.BOOL:
10616 
          self.success = iprot.readBool();
10617 
        else:
10618 
          iprot.skip(ftype)
10619 
      elif fid == 1:
10620 
        if ftype == TType.STRUCT:
10621 
          self.ex = TransactionServiceException()
10622 
          self.ex.read(iprot)
10623 
        else:
10624 
          iprot.skip(ftype)
10625 
      else:
10626 
        iprot.skip(ftype)
10627 
      iprot.readFieldEnd()
10628 
    iprot.readStructEnd()
10629 
 
10630 
  def write(self, oprot):
10631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10633 
      return
10634 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 10635 
    if self.success is not None:
2536 chandransh 10636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10637 
      oprot.writeBool(self.success)
10638 
      oprot.writeFieldEnd()
3431 rajveer 10639 
    if self.ex is not None:
2536 chandransh 10640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10641 
      self.ex.write(oprot)
10642 
      oprot.writeFieldEnd()
10643 
    oprot.writeFieldStop()
10644 
    oprot.writeStructEnd()
10645 
 
3431 rajveer 10646 
  def validate(self):
10647 
    return
10648 
 
10649 
 
2536 chandransh 10650 
  def __repr__(self):
10651 
    L = ['%s=%r' % (key, value)
10652 
      for key, value in self.__dict__.iteritems()]
10653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10654 
 
10655 
  def __eq__(self, other):
10656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10657 
 
10658 
  def __ne__(self, other):
10659 
    return not (self == other)
10660 
 
10661 
class authorizePickup_args:
10662 
  """
10663 
  Attributes:
10664 
   - orderId
10665 
   - pickupNumber
10666 
  """
10667 
 
10668 
  thrift_spec = (
10669 
    None, # 0
10670 
    (1, TType.I64, 'orderId', None, None, ), # 1
10671 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
10672 
  )
10673 
 
10674 
  def __init__(self, orderId=None, pickupNumber=None,):
10675 
    self.orderId = orderId
10676 
    self.pickupNumber = pickupNumber
10677 
 
10678 
  def read(self, iprot):
10679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10681 
      return
10682 
    iprot.readStructBegin()
10683 
    while True:
10684 
      (fname, ftype, fid) = iprot.readFieldBegin()
10685 
      if ftype == TType.STOP:
10686 
        break
10687 
      if fid == 1:
10688 
        if ftype == TType.I64:
10689 
          self.orderId = iprot.readI64();
10690 
        else:
10691 
          iprot.skip(ftype)
10692 
      elif fid == 2:
10693 
        if ftype == TType.STRING:
10694 
          self.pickupNumber = iprot.readString();
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      else:
10698 
        iprot.skip(ftype)
10699 
      iprot.readFieldEnd()
10700 
    iprot.readStructEnd()
10701 
 
10702 
  def write(self, oprot):
10703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10705 
      return
10706 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 10707 
    if self.orderId is not None:
2536 chandransh 10708 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10709 
      oprot.writeI64(self.orderId)
10710 
      oprot.writeFieldEnd()
3431 rajveer 10711 
    if self.pickupNumber is not None:
2536 chandransh 10712 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
10713 
      oprot.writeString(self.pickupNumber)
10714 
      oprot.writeFieldEnd()
10715 
    oprot.writeFieldStop()
10716 
    oprot.writeStructEnd()
10717 
 
3431 rajveer 10718 
  def validate(self):
10719 
    return
10720 
 
10721 
 
2536 chandransh 10722 
  def __repr__(self):
10723 
    L = ['%s=%r' % (key, value)
10724 
      for key, value in self.__dict__.iteritems()]
10725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10726 
 
10727 
  def __eq__(self, other):
10728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10729 
 
10730 
  def __ne__(self, other):
10731 
    return not (self == other)
10732 
 
10733 
class authorizePickup_result:
10734 
  """
10735 
  Attributes:
10736 
   - success
10737 
   - ex
10738 
  """
10739 
 
10740 
  thrift_spec = (
10741 
    (0, TType.BOOL, 'success', None, None, ), # 0
10742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10743 
  )
10744 
 
10745 
  def __init__(self, success=None, ex=None,):
10746 
    self.success = success
10747 
    self.ex = ex
10748 
 
10749 
  def read(self, iprot):
10750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10752 
      return
10753 
    iprot.readStructBegin()
10754 
    while True:
10755 
      (fname, ftype, fid) = iprot.readFieldBegin()
10756 
      if ftype == TType.STOP:
10757 
        break
10758 
      if fid == 0:
10759 
        if ftype == TType.BOOL:
10760 
          self.success = iprot.readBool();
10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      elif fid == 1:
10764 
        if ftype == TType.STRUCT:
10765 
          self.ex = TransactionServiceException()
10766 
          self.ex.read(iprot)
10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      else:
10770 
        iprot.skip(ftype)
10771 
      iprot.readFieldEnd()
10772 
    iprot.readStructEnd()
10773 
 
10774 
  def write(self, oprot):
10775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10777 
      return
10778 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 10779 
    if self.success is not None:
2536 chandransh 10780 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10781 
      oprot.writeBool(self.success)
10782 
      oprot.writeFieldEnd()
3431 rajveer 10783 
    if self.ex is not None:
2536 chandransh 10784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10785 
      self.ex.write(oprot)
10786 
      oprot.writeFieldEnd()
10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
3431 rajveer 10790 
  def validate(self):
10791 
    return
10792 
 
10793 
 
2536 chandransh 10794 
  def __repr__(self):
10795 
    L = ['%s=%r' % (key, value)
10796 
      for key, value in self.__dict__.iteritems()]
10797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10798 
 
10799 
  def __eq__(self, other):
10800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10801 
 
10802 
  def __ne__(self, other):
10803 
    return not (self == other)
10804 
 
2764 chandransh 10805 
class markDoasAsPickedUp_args:
10806 
  """
10807 
  Attributes:
10808 
   - providerId
10809 
   - pickupDetails
10810 
  """
10811 
 
10812 
  thrift_spec = (
10813 
    None, # 0
10814 
    (1, TType.I64, 'providerId', None, None, ), # 1
10815 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
10816 
  )
10817 
 
10818 
  def __init__(self, providerId=None, pickupDetails=None,):
10819 
    self.providerId = providerId
10820 
    self.pickupDetails = pickupDetails
10821 
 
10822 
  def read(self, iprot):
10823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10825 
      return
10826 
    iprot.readStructBegin()
10827 
    while True:
10828 
      (fname, ftype, fid) = iprot.readFieldBegin()
10829 
      if ftype == TType.STOP:
10830 
        break
10831 
      if fid == 1:
10832 
        if ftype == TType.I64:
10833 
          self.providerId = iprot.readI64();
10834 
        else:
10835 
          iprot.skip(ftype)
10836 
      elif fid == 2:
10837 
        if ftype == TType.MAP:
10838 
          self.pickupDetails = {}
4133 chandransh 10839 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
10840 
          for _i194 in xrange(_size190):
10841 
            _key195 = iprot.readString();
10842 
            _val196 = iprot.readString();
10843 
            self.pickupDetails[_key195] = _val196
2764 chandransh 10844 
          iprot.readMapEnd()
10845 
        else:
10846 
          iprot.skip(ftype)
10847 
      else:
10848 
        iprot.skip(ftype)
10849 
      iprot.readFieldEnd()
10850 
    iprot.readStructEnd()
10851 
 
10852 
  def write(self, oprot):
10853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10855 
      return
10856 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 10857 
    if self.providerId is not None:
2764 chandransh 10858 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10859 
      oprot.writeI64(self.providerId)
10860 
      oprot.writeFieldEnd()
3431 rajveer 10861 
    if self.pickupDetails is not None:
2764 chandransh 10862 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
10863 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 10864 
      for kiter197,viter198 in self.pickupDetails.items():
10865 
        oprot.writeString(kiter197)
10866 
        oprot.writeString(viter198)
2764 chandransh 10867 
      oprot.writeMapEnd()
10868 
      oprot.writeFieldEnd()
10869 
    oprot.writeFieldStop()
10870 
    oprot.writeStructEnd()
10871 
 
3431 rajveer 10872 
  def validate(self):
10873 
    return
10874 
 
10875 
 
2764 chandransh 10876 
  def __repr__(self):
10877 
    L = ['%s=%r' % (key, value)
10878 
      for key, value in self.__dict__.iteritems()]
10879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10880 
 
10881 
  def __eq__(self, other):
10882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10883 
 
10884 
  def __ne__(self, other):
10885 
    return not (self == other)
10886 
 
10887 
class markDoasAsPickedUp_result:
10888 
  """
10889 
  Attributes:
10890 
   - success
10891 
  """
10892 
 
10893 
  thrift_spec = (
10894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10895 
  )
10896 
 
10897 
  def __init__(self, success=None,):
10898 
    self.success = success
10899 
 
10900 
  def read(self, iprot):
10901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10903 
      return
10904 
    iprot.readStructBegin()
10905 
    while True:
10906 
      (fname, ftype, fid) = iprot.readFieldBegin()
10907 
      if ftype == TType.STOP:
10908 
        break
10909 
      if fid == 0:
10910 
        if ftype == TType.LIST:
10911 
          self.success = []
4133 chandransh 10912 
          (_etype202, _size199) = iprot.readListBegin()
10913 
          for _i203 in xrange(_size199):
10914 
            _elem204 = Order()
10915 
            _elem204.read(iprot)
10916 
            self.success.append(_elem204)
2764 chandransh 10917 
          iprot.readListEnd()
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
10929 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 10930 
    if self.success is not None:
2764 chandransh 10931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10933 
      for iter205 in self.success:
10934 
        iter205.write(oprot)
2764 chandransh 10935 
      oprot.writeListEnd()
10936 
      oprot.writeFieldEnd()
10937 
    oprot.writeFieldStop()
10938 
    oprot.writeStructEnd()
10939 
 
3431 rajveer 10940 
  def validate(self):
10941 
    return
10942 
 
10943 
 
2764 chandransh 10944 
  def __repr__(self):
10945 
    L = ['%s=%r' % (key, value)
10946 
      for key, value in self.__dict__.iteritems()]
10947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10948 
 
10949 
  def __eq__(self, other):
10950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10951 
 
10952 
  def __ne__(self, other):
10953 
    return not (self == other)
10954 
 
2616 chandransh 10955 
class receiveReturn_args:
2591 chandransh 10956 
  """
10957 
  Attributes:
10958 
   - orderId
10959 
  """
2536 chandransh 10960 
 
2591 chandransh 10961 
  thrift_spec = (
10962 
    None, # 0
10963 
    (1, TType.I64, 'orderId', None, None, ), # 1
10964 
  )
10965 
 
10966 
  def __init__(self, orderId=None,):
10967 
    self.orderId = orderId
10968 
 
10969 
  def read(self, iprot):
10970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10972 
      return
10973 
    iprot.readStructBegin()
10974 
    while True:
10975 
      (fname, ftype, fid) = iprot.readFieldBegin()
10976 
      if ftype == TType.STOP:
10977 
        break
10978 
      if fid == 1:
10979 
        if ftype == TType.I64:
10980 
          self.orderId = iprot.readI64();
10981 
        else:
10982 
          iprot.skip(ftype)
10983 
      else:
10984 
        iprot.skip(ftype)
10985 
      iprot.readFieldEnd()
10986 
    iprot.readStructEnd()
10987 
 
10988 
  def write(self, oprot):
10989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10991 
      return
2616 chandransh 10992 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 10993 
    if self.orderId is not None:
2591 chandransh 10994 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10995 
      oprot.writeI64(self.orderId)
10996 
      oprot.writeFieldEnd()
10997 
    oprot.writeFieldStop()
10998 
    oprot.writeStructEnd()
10999 
 
3431 rajveer 11000 
  def validate(self):
11001 
    return
11002 
 
11003 
 
2591 chandransh 11004 
  def __repr__(self):
11005 
    L = ['%s=%r' % (key, value)
11006 
      for key, value in self.__dict__.iteritems()]
11007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11008 
 
11009 
  def __eq__(self, other):
11010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11011 
 
11012 
  def __ne__(self, other):
11013 
    return not (self == other)
11014 
 
2616 chandransh 11015 
class receiveReturn_result:
2591 chandransh 11016 
  """
11017 
  Attributes:
11018 
   - success
11019 
   - ex
11020 
  """
11021 
 
11022 
  thrift_spec = (
11023 
    (0, TType.BOOL, 'success', None, None, ), # 0
11024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11025 
  )
11026 
 
11027 
  def __init__(self, success=None, ex=None,):
11028 
    self.success = success
11029 
    self.ex = ex
11030 
 
11031 
  def read(self, iprot):
11032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11034 
      return
11035 
    iprot.readStructBegin()
11036 
    while True:
11037 
      (fname, ftype, fid) = iprot.readFieldBegin()
11038 
      if ftype == TType.STOP:
11039 
        break
11040 
      if fid == 0:
11041 
        if ftype == TType.BOOL:
11042 
          self.success = iprot.readBool();
11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      elif fid == 1:
11046 
        if ftype == TType.STRUCT:
11047 
          self.ex = TransactionServiceException()
11048 
          self.ex.read(iprot)
11049 
        else:
11050 
          iprot.skip(ftype)
11051 
      else:
11052 
        iprot.skip(ftype)
11053 
      iprot.readFieldEnd()
11054 
    iprot.readStructEnd()
11055 
 
11056 
  def write(self, oprot):
11057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11059 
      return
2616 chandransh 11060 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11061 
    if self.success is not None:
2591 chandransh 11062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11063 
      oprot.writeBool(self.success)
11064 
      oprot.writeFieldEnd()
3431 rajveer 11065 
    if self.ex is not None:
2591 chandransh 11066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11067 
      self.ex.write(oprot)
11068 
      oprot.writeFieldEnd()
11069 
    oprot.writeFieldStop()
11070 
    oprot.writeStructEnd()
11071 
 
3431 rajveer 11072 
  def validate(self):
11073 
    return
11074 
 
11075 
 
2591 chandransh 11076 
  def __repr__(self):
11077 
    L = ['%s=%r' % (key, value)
11078 
      for key, value in self.__dict__.iteritems()]
11079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11080 
 
11081 
  def __eq__(self, other):
11082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11083 
 
11084 
  def __ne__(self, other):
11085 
    return not (self == other)
11086 
 
11087 
class validateDoa_args:
11088 
  """
11089 
  Attributes:
11090 
   - orderId
11091 
   - isValid
11092 
  """
11093 
 
11094 
  thrift_spec = (
11095 
    None, # 0
11096 
    (1, TType.I64, 'orderId', None, None, ), # 1
11097 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
11098 
  )
11099 
 
11100 
  def __init__(self, orderId=None, isValid=None,):
11101 
    self.orderId = orderId
11102 
    self.isValid = isValid
11103 
 
11104 
  def read(self, iprot):
11105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11107 
      return
11108 
    iprot.readStructBegin()
11109 
    while True:
11110 
      (fname, ftype, fid) = iprot.readFieldBegin()
11111 
      if ftype == TType.STOP:
11112 
        break
11113 
      if fid == 1:
11114 
        if ftype == TType.I64:
11115 
          self.orderId = iprot.readI64();
11116 
        else:
11117 
          iprot.skip(ftype)
11118 
      elif fid == 2:
11119 
        if ftype == TType.BOOL:
11120 
          self.isValid = iprot.readBool();
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
11132 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 11133 
    if self.orderId is not None:
2591 chandransh 11134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11135 
      oprot.writeI64(self.orderId)
11136 
      oprot.writeFieldEnd()
3431 rajveer 11137 
    if self.isValid is not None:
2591 chandransh 11138 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
11139 
      oprot.writeBool(self.isValid)
11140 
      oprot.writeFieldEnd()
11141 
    oprot.writeFieldStop()
11142 
    oprot.writeStructEnd()
11143 
 
3431 rajveer 11144 
  def validate(self):
11145 
    return
11146 
 
11147 
 
2591 chandransh 11148 
  def __repr__(self):
11149 
    L = ['%s=%r' % (key, value)
11150 
      for key, value in self.__dict__.iteritems()]
11151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11152 
 
11153 
  def __eq__(self, other):
11154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11155 
 
11156 
  def __ne__(self, other):
11157 
    return not (self == other)
11158 
 
11159 
class validateDoa_result:
11160 
  """
11161 
  Attributes:
11162 
   - success
11163 
   - ex
11164 
  """
11165 
 
11166 
  thrift_spec = (
11167 
    (0, TType.BOOL, 'success', None, None, ), # 0
11168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11169 
  )
11170 
 
11171 
  def __init__(self, success=None, ex=None,):
11172 
    self.success = success
11173 
    self.ex = ex
11174 
 
11175 
  def read(self, iprot):
11176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11178 
      return
11179 
    iprot.readStructBegin()
11180 
    while True:
11181 
      (fname, ftype, fid) = iprot.readFieldBegin()
11182 
      if ftype == TType.STOP:
11183 
        break
11184 
      if fid == 0:
11185 
        if ftype == TType.BOOL:
11186 
          self.success = iprot.readBool();
11187 
        else:
11188 
          iprot.skip(ftype)
11189 
      elif fid == 1:
11190 
        if ftype == TType.STRUCT:
11191 
          self.ex = TransactionServiceException()
11192 
          self.ex.read(iprot)
11193 
        else:
11194 
          iprot.skip(ftype)
11195 
      else:
11196 
        iprot.skip(ftype)
11197 
      iprot.readFieldEnd()
11198 
    iprot.readStructEnd()
11199 
 
11200 
  def write(self, oprot):
11201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11203 
      return
11204 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 11205 
    if self.success is not None:
2591 chandransh 11206 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11207 
      oprot.writeBool(self.success)
11208 
      oprot.writeFieldEnd()
3431 rajveer 11209 
    if self.ex is not None:
2591 chandransh 11210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11211 
      self.ex.write(oprot)
11212 
      oprot.writeFieldEnd()
11213 
    oprot.writeFieldStop()
11214 
    oprot.writeStructEnd()
11215 
 
3431 rajveer 11216 
  def validate(self):
11217 
    return
11218 
 
11219 
 
2591 chandransh 11220 
  def __repr__(self):
11221 
    L = ['%s=%r' % (key, value)
11222 
      for key, value in self.__dict__.iteritems()]
11223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11224 
 
11225 
  def __eq__(self, other):
11226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11227 
 
11228 
  def __ne__(self, other):
11229 
    return not (self == other)
11230 
 
2616 chandransh 11231 
class reshipOrder_args:
11232 
  """
11233 
  Attributes:
11234 
   - orderId
11235 
  """
2591 chandransh 11236 
 
2616 chandransh 11237 
  thrift_spec = (
11238 
    None, # 0
11239 
    (1, TType.I64, 'orderId', None, None, ), # 1
11240 
  )
11241 
 
11242 
  def __init__(self, orderId=None,):
11243 
    self.orderId = orderId
11244 
 
11245 
  def read(self, iprot):
11246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11248 
      return
11249 
    iprot.readStructBegin()
11250 
    while True:
11251 
      (fname, ftype, fid) = iprot.readFieldBegin()
11252 
      if ftype == TType.STOP:
11253 
        break
11254 
      if fid == 1:
11255 
        if ftype == TType.I64:
11256 
          self.orderId = iprot.readI64();
11257 
        else:
11258 
          iprot.skip(ftype)
11259 
      else:
11260 
        iprot.skip(ftype)
11261 
      iprot.readFieldEnd()
11262 
    iprot.readStructEnd()
11263 
 
11264 
  def write(self, oprot):
11265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11267 
      return
11268 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 11269 
    if self.orderId is not None:
2616 chandransh 11270 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11271 
      oprot.writeI64(self.orderId)
11272 
      oprot.writeFieldEnd()
11273 
    oprot.writeFieldStop()
11274 
    oprot.writeStructEnd()
11275 
 
3431 rajveer 11276 
  def validate(self):
11277 
    return
11278 
 
11279 
 
2616 chandransh 11280 
  def __repr__(self):
11281 
    L = ['%s=%r' % (key, value)
11282 
      for key, value in self.__dict__.iteritems()]
11283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11284 
 
11285 
  def __eq__(self, other):
11286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11287 
 
11288 
  def __ne__(self, other):
11289 
    return not (self == other)
11290 
 
11291 
class reshipOrder_result:
11292 
  """
11293 
  Attributes:
11294 
   - success
11295 
   - ex
11296 
  """
11297 
 
11298 
  thrift_spec = (
11299 
    (0, TType.I64, 'success', None, None, ), # 0
11300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11301 
  )
11302 
 
11303 
  def __init__(self, success=None, ex=None,):
11304 
    self.success = success
11305 
    self.ex = ex
11306 
 
11307 
  def read(self, iprot):
11308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11310 
      return
11311 
    iprot.readStructBegin()
11312 
    while True:
11313 
      (fname, ftype, fid) = iprot.readFieldBegin()
11314 
      if ftype == TType.STOP:
11315 
        break
11316 
      if fid == 0:
11317 
        if ftype == TType.I64:
11318 
          self.success = iprot.readI64();
11319 
        else:
11320 
          iprot.skip(ftype)
11321 
      elif fid == 1:
11322 
        if ftype == TType.STRUCT:
11323 
          self.ex = TransactionServiceException()
11324 
          self.ex.read(iprot)
11325 
        else:
11326 
          iprot.skip(ftype)
11327 
      else:
11328 
        iprot.skip(ftype)
11329 
      iprot.readFieldEnd()
11330 
    iprot.readStructEnd()
11331 
 
11332 
  def write(self, oprot):
11333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11335 
      return
11336 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 11337 
    if self.success is not None:
2616 chandransh 11338 
      oprot.writeFieldBegin('success', TType.I64, 0)
11339 
      oprot.writeI64(self.success)
11340 
      oprot.writeFieldEnd()
3431 rajveer 11341 
    if self.ex is not None:
2616 chandransh 11342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11343 
      self.ex.write(oprot)
11344 
      oprot.writeFieldEnd()
11345 
    oprot.writeFieldStop()
11346 
    oprot.writeStructEnd()
11347 
 
3431 rajveer 11348 
  def validate(self):
11349 
    return
11350 
 
11351 
 
2616 chandransh 11352 
  def __repr__(self):
11353 
    L = ['%s=%r' % (key, value)
11354 
      for key, value in self.__dict__.iteritems()]
11355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11356 
 
11357 
  def __eq__(self, other):
11358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11359 
 
11360 
  def __ne__(self, other):
11361 
    return not (self == other)
11362 
 
11363 
class refundOrder_args:
11364 
  """
11365 
  Attributes:
11366 
   - orderId
3226 chandransh 11367 
   - refundedBy
11368 
   - reason
2616 chandransh 11369 
  """
11370 
 
11371 
  thrift_spec = (
11372 
    None, # 0
11373 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 11374 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
11375 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 11376 
  )
11377 
 
3226 chandransh 11378 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 11379 
    self.orderId = orderId
3226 chandransh 11380 
    self.refundedBy = refundedBy
11381 
    self.reason = reason
2616 chandransh 11382 
 
11383 
  def read(self, iprot):
11384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11386 
      return
11387 
    iprot.readStructBegin()
11388 
    while True:
11389 
      (fname, ftype, fid) = iprot.readFieldBegin()
11390 
      if ftype == TType.STOP:
11391 
        break
11392 
      if fid == 1:
11393 
        if ftype == TType.I64:
11394 
          self.orderId = iprot.readI64();
11395 
        else:
11396 
          iprot.skip(ftype)
3226 chandransh 11397 
      elif fid == 2:
11398 
        if ftype == TType.STRING:
11399 
          self.refundedBy = iprot.readString();
11400 
        else:
11401 
          iprot.skip(ftype)
11402 
      elif fid == 3:
11403 
        if ftype == TType.STRING:
11404 
          self.reason = iprot.readString();
11405 
        else:
11406 
          iprot.skip(ftype)
2616 chandransh 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('refundOrder_args')
3431 rajveer 11417 
    if self.orderId is not None:
2616 chandransh 11418 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11419 
      oprot.writeI64(self.orderId)
11420 
      oprot.writeFieldEnd()
3431 rajveer 11421 
    if self.refundedBy is not None:
3226 chandransh 11422 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11423 
      oprot.writeString(self.refundedBy)
11424 
      oprot.writeFieldEnd()
3431 rajveer 11425 
    if self.reason is not None:
3226 chandransh 11426 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11427 
      oprot.writeString(self.reason)
11428 
      oprot.writeFieldEnd()
2616 chandransh 11429 
    oprot.writeFieldStop()
11430 
    oprot.writeStructEnd()
11431 
 
3431 rajveer 11432 
  def validate(self):
11433 
    return
11434 
 
11435 
 
2616 chandransh 11436 
  def __repr__(self):
11437 
    L = ['%s=%r' % (key, value)
11438 
      for key, value in self.__dict__.iteritems()]
11439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11440 
 
11441 
  def __eq__(self, other):
11442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11443 
 
11444 
  def __ne__(self, other):
11445 
    return not (self == other)
11446 
 
11447 
class refundOrder_result:
11448 
  """
11449 
  Attributes:
11450 
   - success
11451 
   - ex
11452 
  """
11453 
 
11454 
  thrift_spec = (
11455 
    (0, TType.BOOL, 'success', None, None, ), # 0
11456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11457 
  )
11458 
 
11459 
  def __init__(self, success=None, ex=None,):
11460 
    self.success = success
11461 
    self.ex = ex
11462 
 
11463 
  def read(self, iprot):
11464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11466 
      return
11467 
    iprot.readStructBegin()
11468 
    while True:
11469 
      (fname, ftype, fid) = iprot.readFieldBegin()
11470 
      if ftype == TType.STOP:
11471 
        break
11472 
      if fid == 0:
11473 
        if ftype == TType.BOOL:
11474 
          self.success = iprot.readBool();
11475 
        else:
11476 
          iprot.skip(ftype)
11477 
      elif fid == 1:
11478 
        if ftype == TType.STRUCT:
11479 
          self.ex = TransactionServiceException()
11480 
          self.ex.read(iprot)
11481 
        else:
11482 
          iprot.skip(ftype)
11483 
      else:
11484 
        iprot.skip(ftype)
11485 
      iprot.readFieldEnd()
11486 
    iprot.readStructEnd()
11487 
 
11488 
  def write(self, oprot):
11489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11491 
      return
11492 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11493 
    if self.success is not None:
2616 chandransh 11494 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11495 
      oprot.writeBool(self.success)
11496 
      oprot.writeFieldEnd()
3431 rajveer 11497 
    if self.ex is not None:
2616 chandransh 11498 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11499 
      self.ex.write(oprot)
11500 
      oprot.writeFieldEnd()
11501 
    oprot.writeFieldStop()
11502 
    oprot.writeStructEnd()
11503 
 
3431 rajveer 11504 
  def validate(self):
11505 
    return
11506 
 
11507 
 
2616 chandransh 11508 
  def __repr__(self):
11509 
    L = ['%s=%r' % (key, value)
11510 
      for key, value in self.__dict__.iteritems()]
11511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11512 
 
11513 
  def __eq__(self, other):
11514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11515 
 
11516 
  def __ne__(self, other):
11517 
    return not (self == other)
11518 
 
2690 chandransh 11519 
class getReturnOrders_args:
11520 
  """
11521 
  Attributes:
11522 
   - warehouseId
11523 
   - fromDate
11524 
   - toDate
11525 
  """
2616 chandransh 11526 
 
2690 chandransh 11527 
  thrift_spec = (
11528 
    None, # 0
11529 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11530 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11531 
    (3, TType.I64, 'toDate', None, None, ), # 3
11532 
  )
11533 
 
11534 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11535 
    self.warehouseId = warehouseId
11536 
    self.fromDate = fromDate
11537 
    self.toDate = toDate
11538 
 
11539 
  def read(self, iprot):
11540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11542 
      return
11543 
    iprot.readStructBegin()
11544 
    while True:
11545 
      (fname, ftype, fid) = iprot.readFieldBegin()
11546 
      if ftype == TType.STOP:
11547 
        break
11548 
      if fid == 1:
11549 
        if ftype == TType.I64:
11550 
          self.warehouseId = iprot.readI64();
11551 
        else:
11552 
          iprot.skip(ftype)
11553 
      elif fid == 2:
11554 
        if ftype == TType.I64:
11555 
          self.fromDate = iprot.readI64();
11556 
        else:
11557 
          iprot.skip(ftype)
11558 
      elif fid == 3:
11559 
        if ftype == TType.I64:
11560 
          self.toDate = iprot.readI64();
11561 
        else:
11562 
          iprot.skip(ftype)
11563 
      else:
11564 
        iprot.skip(ftype)
11565 
      iprot.readFieldEnd()
11566 
    iprot.readStructEnd()
11567 
 
11568 
  def write(self, oprot):
11569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11571 
      return
11572 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11573 
    if self.warehouseId is not None:
2690 chandransh 11574 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11575 
      oprot.writeI64(self.warehouseId)
11576 
      oprot.writeFieldEnd()
3431 rajveer 11577 
    if self.fromDate is not None:
2690 chandransh 11578 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11579 
      oprot.writeI64(self.fromDate)
11580 
      oprot.writeFieldEnd()
3431 rajveer 11581 
    if self.toDate is not None:
2690 chandransh 11582 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11583 
      oprot.writeI64(self.toDate)
11584 
      oprot.writeFieldEnd()
11585 
    oprot.writeFieldStop()
11586 
    oprot.writeStructEnd()
11587 
 
3431 rajveer 11588 
  def validate(self):
11589 
    return
11590 
 
11591 
 
2690 chandransh 11592 
  def __repr__(self):
11593 
    L = ['%s=%r' % (key, value)
11594 
      for key, value in self.__dict__.iteritems()]
11595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11596 
 
11597 
  def __eq__(self, other):
11598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11599 
 
11600 
  def __ne__(self, other):
11601 
    return not (self == other)
11602 
 
11603 
class getReturnOrders_result:
11604 
  """
11605 
  Attributes:
11606 
   - success
11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
11611 
  )
11612 
 
11613 
  def __init__(self, success=None,):
11614 
    self.success = success
11615 
 
11616 
  def read(self, iprot):
11617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11619 
      return
11620 
    iprot.readStructBegin()
11621 
    while True:
11622 
      (fname, ftype, fid) = iprot.readFieldBegin()
11623 
      if ftype == TType.STOP:
11624 
        break
11625 
      if fid == 0:
11626 
        if ftype == TType.LIST:
11627 
          self.success = []
4133 chandransh 11628 
          (_etype209, _size206) = iprot.readListBegin()
11629 
          for _i210 in xrange(_size206):
11630 
            _elem211 = ReturnOrder()
11631 
            _elem211.read(iprot)
11632 
            self.success.append(_elem211)
2690 chandransh 11633 
          iprot.readListEnd()
11634 
        else:
11635 
          iprot.skip(ftype)
11636 
      else:
11637 
        iprot.skip(ftype)
11638 
      iprot.readFieldEnd()
11639 
    iprot.readStructEnd()
11640 
 
11641 
  def write(self, oprot):
11642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11644 
      return
11645 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 11646 
    if self.success is not None:
2690 chandransh 11647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11649 
      for iter212 in self.success:
11650 
        iter212.write(oprot)
2690 chandransh 11651 
      oprot.writeListEnd()
11652 
      oprot.writeFieldEnd()
11653 
    oprot.writeFieldStop()
11654 
    oprot.writeStructEnd()
11655 
 
3431 rajveer 11656 
  def validate(self):
11657 
    return
11658 
 
11659 
 
2690 chandransh 11660 
  def __repr__(self):
11661 
    L = ['%s=%r' % (key, value)
11662 
      for key, value in self.__dict__.iteritems()]
11663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11664 
 
11665 
  def __eq__(self, other):
11666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11667 
 
11668 
  def __ne__(self, other):
11669 
    return not (self == other)
11670 
 
2700 chandransh 11671 
class getReturnOrder_args:
11672 
  """
11673 
  Attributes:
11674 
   - id
11675 
  """
11676 
 
11677 
  thrift_spec = (
11678 
    None, # 0
11679 
    (1, TType.I64, 'id', None, None, ), # 1
11680 
  )
11681 
 
11682 
  def __init__(self, id=None,):
11683 
    self.id = id
11684 
 
11685 
  def read(self, iprot):
11686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11688 
      return
11689 
    iprot.readStructBegin()
11690 
    while True:
11691 
      (fname, ftype, fid) = iprot.readFieldBegin()
11692 
      if ftype == TType.STOP:
11693 
        break
11694 
      if fid == 1:
11695 
        if ftype == TType.I64:
11696 
          self.id = iprot.readI64();
11697 
        else:
11698 
          iprot.skip(ftype)
11699 
      else:
11700 
        iprot.skip(ftype)
11701 
      iprot.readFieldEnd()
11702 
    iprot.readStructEnd()
11703 
 
11704 
  def write(self, oprot):
11705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11707 
      return
11708 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 11709 
    if self.id is not None:
2700 chandransh 11710 
      oprot.writeFieldBegin('id', TType.I64, 1)
11711 
      oprot.writeI64(self.id)
11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
3431 rajveer 11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
2700 chandransh 11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
11731 
class getReturnOrder_result:
11732 
  """
11733 
  Attributes:
11734 
   - success
11735 
   - ex
11736 
  """
11737 
 
11738 
  thrift_spec = (
11739 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
11740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11741 
  )
11742 
 
11743 
  def __init__(self, success=None, ex=None,):
11744 
    self.success = success
11745 
    self.ex = ex
11746 
 
11747 
  def read(self, iprot):
11748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11750 
      return
11751 
    iprot.readStructBegin()
11752 
    while True:
11753 
      (fname, ftype, fid) = iprot.readFieldBegin()
11754 
      if ftype == TType.STOP:
11755 
        break
11756 
      if fid == 0:
11757 
        if ftype == TType.STRUCT:
11758 
          self.success = ReturnOrder()
11759 
          self.success.read(iprot)
11760 
        else:
11761 
          iprot.skip(ftype)
11762 
      elif fid == 1:
11763 
        if ftype == TType.STRUCT:
11764 
          self.ex = TransactionServiceException()
11765 
          self.ex.read(iprot)
11766 
        else:
11767 
          iprot.skip(ftype)
11768 
      else:
11769 
        iprot.skip(ftype)
11770 
      iprot.readFieldEnd()
11771 
    iprot.readStructEnd()
11772 
 
11773 
  def write(self, oprot):
11774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11776 
      return
11777 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 11778 
    if self.success is not None:
2700 chandransh 11779 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11780 
      self.success.write(oprot)
11781 
      oprot.writeFieldEnd()
3431 rajveer 11782 
    if self.ex is not None:
2700 chandransh 11783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11784 
      self.ex.write(oprot)
11785 
      oprot.writeFieldEnd()
11786 
    oprot.writeFieldStop()
11787 
    oprot.writeStructEnd()
11788 
 
3431 rajveer 11789 
  def validate(self):
11790 
    return
11791 
 
11792 
 
2700 chandransh 11793 
  def __repr__(self):
11794 
    L = ['%s=%r' % (key, value)
11795 
      for key, value in self.__dict__.iteritems()]
11796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11797 
 
11798 
  def __eq__(self, other):
11799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11800 
 
11801 
  def __ne__(self, other):
11802 
    return not (self == other)
11803 
 
2690 chandransh 11804 
class processReturn_args:
11805 
  """
11806 
  Attributes:
11807 
   - returnOrderId
11808 
  """
11809 
 
11810 
  thrift_spec = (
11811 
    None, # 0
11812 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
11813 
  )
11814 
 
11815 
  def __init__(self, returnOrderId=None,):
11816 
    self.returnOrderId = returnOrderId
11817 
 
11818 
  def read(self, iprot):
11819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11821 
      return
11822 
    iprot.readStructBegin()
11823 
    while True:
11824 
      (fname, ftype, fid) = iprot.readFieldBegin()
11825 
      if ftype == TType.STOP:
11826 
        break
11827 
      if fid == 1:
11828 
        if ftype == TType.I64:
11829 
          self.returnOrderId = iprot.readI64();
11830 
        else:
11831 
          iprot.skip(ftype)
11832 
      else:
11833 
        iprot.skip(ftype)
11834 
      iprot.readFieldEnd()
11835 
    iprot.readStructEnd()
11836 
 
11837 
  def write(self, oprot):
11838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11840 
      return
11841 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 11842 
    if self.returnOrderId is not None:
2690 chandransh 11843 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
11844 
      oprot.writeI64(self.returnOrderId)
11845 
      oprot.writeFieldEnd()
11846 
    oprot.writeFieldStop()
11847 
    oprot.writeStructEnd()
11848 
 
3431 rajveer 11849 
  def validate(self):
11850 
    return
11851 
 
11852 
 
2690 chandransh 11853 
  def __repr__(self):
11854 
    L = ['%s=%r' % (key, value)
11855 
      for key, value in self.__dict__.iteritems()]
11856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11857 
 
11858 
  def __eq__(self, other):
11859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11860 
 
11861 
  def __ne__(self, other):
11862 
    return not (self == other)
11863 
 
11864 
class processReturn_result:
11865 
  """
11866 
  Attributes:
11867 
   - ex
11868 
  """
11869 
 
11870 
  thrift_spec = (
11871 
    None, # 0
11872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11873 
  )
11874 
 
11875 
  def __init__(self, ex=None,):
11876 
    self.ex = ex
11877 
 
11878 
  def read(self, iprot):
11879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11881 
      return
11882 
    iprot.readStructBegin()
11883 
    while True:
11884 
      (fname, ftype, fid) = iprot.readFieldBegin()
11885 
      if ftype == TType.STOP:
11886 
        break
11887 
      if fid == 1:
11888 
        if ftype == TType.STRUCT:
11889 
          self.ex = TransactionServiceException()
11890 
          self.ex.read(iprot)
11891 
        else:
11892 
          iprot.skip(ftype)
11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
11902 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 11903 
    if self.ex is not None:
2690 chandransh 11904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11905 
      self.ex.write(oprot)
11906 
      oprot.writeFieldEnd()
11907 
    oprot.writeFieldStop()
11908 
    oprot.writeStructEnd()
11909 
 
3431 rajveer 11910 
  def validate(self):
11911 
    return
11912 
 
11913 
 
2690 chandransh 11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
2819 chandransh 11925 
class createPurchaseOrder_args:
11926 
  """
11927 
  Attributes:
11928 
   - warehouseId
11929 
  """
2690 chandransh 11930 
 
2819 chandransh 11931 
  thrift_spec = (
11932 
    None, # 0
11933 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11934 
  )
11935 
 
11936 
  def __init__(self, warehouseId=None,):
11937 
    self.warehouseId = warehouseId
11938 
 
11939 
  def read(self, iprot):
11940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11942 
      return
11943 
    iprot.readStructBegin()
11944 
    while True:
11945 
      (fname, ftype, fid) = iprot.readFieldBegin()
11946 
      if ftype == TType.STOP:
11947 
        break
11948 
      if fid == 1:
11949 
        if ftype == TType.I64:
11950 
          self.warehouseId = iprot.readI64();
11951 
        else:
11952 
          iprot.skip(ftype)
11953 
      else:
11954 
        iprot.skip(ftype)
11955 
      iprot.readFieldEnd()
11956 
    iprot.readStructEnd()
11957 
 
11958 
  def write(self, oprot):
11959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11961 
      return
11962 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 11963 
    if self.warehouseId is not None:
2819 chandransh 11964 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11965 
      oprot.writeI64(self.warehouseId)
11966 
      oprot.writeFieldEnd()
11967 
    oprot.writeFieldStop()
11968 
    oprot.writeStructEnd()
11969 
 
3431 rajveer 11970 
  def validate(self):
11971 
    return
11972 
 
11973 
 
2819 chandransh 11974 
  def __repr__(self):
11975 
    L = ['%s=%r' % (key, value)
11976 
      for key, value in self.__dict__.iteritems()]
11977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11978 
 
11979 
  def __eq__(self, other):
11980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11981 
 
11982 
  def __ne__(self, other):
11983 
    return not (self == other)
11984 
 
11985 
class createPurchaseOrder_result:
11986 
  """
11987 
  Attributes:
11988 
   - success
11989 
   - ex
11990 
  """
11991 
 
11992 
  thrift_spec = (
11993 
    (0, TType.I64, 'success', None, None, ), # 0
11994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11995 
  )
11996 
 
11997 
  def __init__(self, success=None, ex=None,):
11998 
    self.success = success
11999 
    self.ex = ex
12000 
 
12001 
  def read(self, iprot):
12002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12004 
      return
12005 
    iprot.readStructBegin()
12006 
    while True:
12007 
      (fname, ftype, fid) = iprot.readFieldBegin()
12008 
      if ftype == TType.STOP:
12009 
        break
12010 
      if fid == 0:
12011 
        if ftype == TType.I64:
12012 
          self.success = iprot.readI64();
12013 
        else:
12014 
          iprot.skip(ftype)
12015 
      elif fid == 1:
12016 
        if ftype == TType.STRUCT:
12017 
          self.ex = TransactionServiceException()
12018 
          self.ex.read(iprot)
12019 
        else:
12020 
          iprot.skip(ftype)
12021 
      else:
12022 
        iprot.skip(ftype)
12023 
      iprot.readFieldEnd()
12024 
    iprot.readStructEnd()
12025 
 
12026 
  def write(self, oprot):
12027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12029 
      return
12030 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 12031 
    if self.success is not None:
2819 chandransh 12032 
      oprot.writeFieldBegin('success', TType.I64, 0)
12033 
      oprot.writeI64(self.success)
12034 
      oprot.writeFieldEnd()
3431 rajveer 12035 
    if self.ex is not None:
2819 chandransh 12036 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12037 
      self.ex.write(oprot)
12038 
      oprot.writeFieldEnd()
12039 
    oprot.writeFieldStop()
12040 
    oprot.writeStructEnd()
12041 
 
3431 rajveer 12042 
  def validate(self):
12043 
    return
12044 
 
12045 
 
2819 chandransh 12046 
  def __repr__(self):
12047 
    L = ['%s=%r' % (key, value)
12048 
      for key, value in self.__dict__.iteritems()]
12049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12050 
 
12051 
  def __eq__(self, other):
12052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12053 
 
12054 
  def __ne__(self, other):
12055 
    return not (self == other)
3451 chandransh 12056 
 
12057 
class updateWeight_args:
12058 
  """
12059 
  Attributes:
12060 
   - orderId
12061 
   - weight
12062 
  """
12063 
 
12064 
  thrift_spec = (
12065 
    None, # 0
12066 
    (1, TType.I64, 'orderId', None, None, ), # 1
12067 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
12068 
  )
12069 
 
12070 
  def __init__(self, orderId=None, weight=None,):
12071 
    self.orderId = orderId
12072 
    self.weight = weight
12073 
 
12074 
  def read(self, iprot):
12075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12077 
      return
12078 
    iprot.readStructBegin()
12079 
    while True:
12080 
      (fname, ftype, fid) = iprot.readFieldBegin()
12081 
      if ftype == TType.STOP:
12082 
        break
12083 
      if fid == 1:
12084 
        if ftype == TType.I64:
12085 
          self.orderId = iprot.readI64();
12086 
        else:
12087 
          iprot.skip(ftype)
12088 
      elif fid == 2:
12089 
        if ftype == TType.DOUBLE:
12090 
          self.weight = iprot.readDouble();
12091 
        else:
12092 
          iprot.skip(ftype)
12093 
      else:
12094 
        iprot.skip(ftype)
12095 
      iprot.readFieldEnd()
12096 
    iprot.readStructEnd()
12097 
 
12098 
  def write(self, oprot):
12099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12101 
      return
12102 
    oprot.writeStructBegin('updateWeight_args')
12103 
    if self.orderId is not None:
12104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12105 
      oprot.writeI64(self.orderId)
12106 
      oprot.writeFieldEnd()
12107 
    if self.weight is not None:
12108 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
12109 
      oprot.writeDouble(self.weight)
12110 
      oprot.writeFieldEnd()
12111 
    oprot.writeFieldStop()
12112 
    oprot.writeStructEnd()
12113 
 
12114 
  def validate(self):
12115 
    return
12116 
 
12117 
 
12118 
  def __repr__(self):
12119 
    L = ['%s=%r' % (key, value)
12120 
      for key, value in self.__dict__.iteritems()]
12121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12122 
 
12123 
  def __eq__(self, other):
12124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12125 
 
12126 
  def __ne__(self, other):
12127 
    return not (self == other)
12128 
 
12129 
class updateWeight_result:
12130 
  """
12131 
  Attributes:
12132 
   - success
12133 
   - ex
12134 
  """
12135 
 
12136 
  thrift_spec = (
12137 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12139 
  )
12140 
 
12141 
  def __init__(self, success=None, ex=None,):
12142 
    self.success = success
12143 
    self.ex = ex
12144 
 
12145 
  def read(self, iprot):
12146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12148 
      return
12149 
    iprot.readStructBegin()
12150 
    while True:
12151 
      (fname, ftype, fid) = iprot.readFieldBegin()
12152 
      if ftype == TType.STOP:
12153 
        break
12154 
      if fid == 0:
12155 
        if ftype == TType.STRUCT:
12156 
          self.success = Order()
12157 
          self.success.read(iprot)
12158 
        else:
12159 
          iprot.skip(ftype)
12160 
      elif fid == 1:
12161 
        if ftype == TType.STRUCT:
12162 
          self.ex = TransactionServiceException()
12163 
          self.ex.read(iprot)
12164 
        else:
12165 
          iprot.skip(ftype)
12166 
      else:
12167 
        iprot.skip(ftype)
12168 
      iprot.readFieldEnd()
12169 
    iprot.readStructEnd()
12170 
 
12171 
  def write(self, oprot):
12172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12174 
      return
12175 
    oprot.writeStructBegin('updateWeight_result')
12176 
    if self.success is not None:
12177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12178 
      self.success.write(oprot)
12179 
      oprot.writeFieldEnd()
12180 
    if self.ex is not None:
12181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12182 
      self.ex.write(oprot)
12183 
      oprot.writeFieldEnd()
12184 
    oprot.writeFieldStop()
12185 
    oprot.writeStructEnd()
12186 
 
12187 
  def validate(self):
12188 
    return
12189 
 
12190 
 
12191 
  def __repr__(self):
12192 
    L = ['%s=%r' % (key, value)
12193 
      for key, value in self.__dict__.iteritems()]
12194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12195 
 
12196 
  def __eq__(self, other):
12197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12198 
 
12199 
  def __ne__(self, other):
12200 
    return not (self == other)
3469 chandransh 12201 
 
12202 
class changeItem_args:
12203 
  """
12204 
  Attributes:
12205 
   - orderId
12206 
   - itemId
12207 
  """
12208 
 
12209 
  thrift_spec = (
12210 
    None, # 0
12211 
    (1, TType.I64, 'orderId', None, None, ), # 1
12212 
    (2, TType.I64, 'itemId', None, None, ), # 2
12213 
  )
12214 
 
12215 
  def __init__(self, orderId=None, itemId=None,):
12216 
    self.orderId = orderId
12217 
    self.itemId = itemId
12218 
 
12219 
  def read(self, iprot):
12220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12222 
      return
12223 
    iprot.readStructBegin()
12224 
    while True:
12225 
      (fname, ftype, fid) = iprot.readFieldBegin()
12226 
      if ftype == TType.STOP:
12227 
        break
12228 
      if fid == 1:
12229 
        if ftype == TType.I64:
12230 
          self.orderId = iprot.readI64();
12231 
        else:
12232 
          iprot.skip(ftype)
12233 
      elif fid == 2:
12234 
        if ftype == TType.I64:
12235 
          self.itemId = iprot.readI64();
12236 
        else:
12237 
          iprot.skip(ftype)
12238 
      else:
12239 
        iprot.skip(ftype)
12240 
      iprot.readFieldEnd()
12241 
    iprot.readStructEnd()
12242 
 
12243 
  def write(self, oprot):
12244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12246 
      return
12247 
    oprot.writeStructBegin('changeItem_args')
12248 
    if self.orderId is not None:
12249 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12250 
      oprot.writeI64(self.orderId)
12251 
      oprot.writeFieldEnd()
12252 
    if self.itemId is not None:
12253 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12254 
      oprot.writeI64(self.itemId)
12255 
      oprot.writeFieldEnd()
12256 
    oprot.writeFieldStop()
12257 
    oprot.writeStructEnd()
12258 
 
12259 
  def validate(self):
12260 
    return
12261 
 
12262 
 
12263 
  def __repr__(self):
12264 
    L = ['%s=%r' % (key, value)
12265 
      for key, value in self.__dict__.iteritems()]
12266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12267 
 
12268 
  def __eq__(self, other):
12269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12270 
 
12271 
  def __ne__(self, other):
12272 
    return not (self == other)
12273 
 
12274 
class changeItem_result:
12275 
  """
12276 
  Attributes:
12277 
   - success
12278 
   - ex
12279 
  """
12280 
 
12281 
  thrift_spec = (
12282 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12284 
  )
12285 
 
12286 
  def __init__(self, success=None, ex=None,):
12287 
    self.success = success
12288 
    self.ex = ex
12289 
 
12290 
  def read(self, iprot):
12291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12293 
      return
12294 
    iprot.readStructBegin()
12295 
    while True:
12296 
      (fname, ftype, fid) = iprot.readFieldBegin()
12297 
      if ftype == TType.STOP:
12298 
        break
12299 
      if fid == 0:
12300 
        if ftype == TType.STRUCT:
12301 
          self.success = Order()
12302 
          self.success.read(iprot)
12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      elif fid == 1:
12306 
        if ftype == TType.STRUCT:
12307 
          self.ex = TransactionServiceException()
12308 
          self.ex.read(iprot)
12309 
        else:
12310 
          iprot.skip(ftype)
12311 
      else:
12312 
        iprot.skip(ftype)
12313 
      iprot.readFieldEnd()
12314 
    iprot.readStructEnd()
12315 
 
12316 
  def write(self, oprot):
12317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12319 
      return
12320 
    oprot.writeStructBegin('changeItem_result')
12321 
    if self.success is not None:
12322 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12323 
      self.success.write(oprot)
12324 
      oprot.writeFieldEnd()
12325 
    if self.ex is not None:
12326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12327 
      self.ex.write(oprot)
12328 
      oprot.writeFieldEnd()
12329 
    oprot.writeFieldStop()
12330 
    oprot.writeStructEnd()
12331 
 
12332 
  def validate(self):
12333 
    return
12334 
 
12335 
 
12336 
  def __repr__(self):
12337 
    L = ['%s=%r' % (key, value)
12338 
      for key, value in self.__dict__.iteritems()]
12339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12340 
 
12341 
  def __eq__(self, other):
12342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12343 
 
12344 
  def __ne__(self, other):
12345 
    return not (self == other)
12346 
 
12347 
class shiftToWarehouse_args:
12348 
  """
12349 
  Attributes:
12350 
   - orderId
12351 
   - warehouseId
12352 
  """
12353 
 
12354 
  thrift_spec = (
12355 
    None, # 0
12356 
    (1, TType.I64, 'orderId', None, None, ), # 1
12357 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12358 
  )
12359 
 
12360 
  def __init__(self, orderId=None, warehouseId=None,):
12361 
    self.orderId = orderId
12362 
    self.warehouseId = warehouseId
12363 
 
12364 
  def read(self, iprot):
12365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12367 
      return
12368 
    iprot.readStructBegin()
12369 
    while True:
12370 
      (fname, ftype, fid) = iprot.readFieldBegin()
12371 
      if ftype == TType.STOP:
12372 
        break
12373 
      if fid == 1:
12374 
        if ftype == TType.I64:
12375 
          self.orderId = iprot.readI64();
12376 
        else:
12377 
          iprot.skip(ftype)
12378 
      elif fid == 2:
12379 
        if ftype == TType.I64:
12380 
          self.warehouseId = iprot.readI64();
12381 
        else:
12382 
          iprot.skip(ftype)
12383 
      else:
12384 
        iprot.skip(ftype)
12385 
      iprot.readFieldEnd()
12386 
    iprot.readStructEnd()
12387 
 
12388 
  def write(self, oprot):
12389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12391 
      return
12392 
    oprot.writeStructBegin('shiftToWarehouse_args')
12393 
    if self.orderId is not None:
12394 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12395 
      oprot.writeI64(self.orderId)
12396 
      oprot.writeFieldEnd()
12397 
    if self.warehouseId is not None:
12398 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12399 
      oprot.writeI64(self.warehouseId)
12400 
      oprot.writeFieldEnd()
12401 
    oprot.writeFieldStop()
12402 
    oprot.writeStructEnd()
12403 
 
12404 
  def validate(self):
12405 
    return
12406 
 
12407 
 
12408 
  def __repr__(self):
12409 
    L = ['%s=%r' % (key, value)
12410 
      for key, value in self.__dict__.iteritems()]
12411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12412 
 
12413 
  def __eq__(self, other):
12414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12415 
 
12416 
  def __ne__(self, other):
12417 
    return not (self == other)
12418 
 
12419 
class shiftToWarehouse_result:
12420 
  """
12421 
  Attributes:
12422 
   - success
12423 
   - ex
12424 
  """
12425 
 
12426 
  thrift_spec = (
12427 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12429 
  )
12430 
 
12431 
  def __init__(self, success=None, ex=None,):
12432 
    self.success = success
12433 
    self.ex = ex
12434 
 
12435 
  def read(self, iprot):
12436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12438 
      return
12439 
    iprot.readStructBegin()
12440 
    while True:
12441 
      (fname, ftype, fid) = iprot.readFieldBegin()
12442 
      if ftype == TType.STOP:
12443 
        break
12444 
      if fid == 0:
12445 
        if ftype == TType.STRUCT:
12446 
          self.success = Order()
12447 
          self.success.read(iprot)
12448 
        else:
12449 
          iprot.skip(ftype)
12450 
      elif fid == 1:
12451 
        if ftype == TType.STRUCT:
12452 
          self.ex = TransactionServiceException()
12453 
          self.ex.read(iprot)
12454 
        else:
12455 
          iprot.skip(ftype)
12456 
      else:
12457 
        iprot.skip(ftype)
12458 
      iprot.readFieldEnd()
12459 
    iprot.readStructEnd()
12460 
 
12461 
  def write(self, oprot):
12462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12464 
      return
12465 
    oprot.writeStructBegin('shiftToWarehouse_result')
12466 
    if self.success is not None:
12467 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12468 
      self.success.write(oprot)
12469 
      oprot.writeFieldEnd()
12470 
    if self.ex is not None:
12471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12472 
      self.ex.write(oprot)
12473 
      oprot.writeFieldEnd()
12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
3553 chandransh 12491 
 
12492 
class addDelayReason_args:
12493 
  """
12494 
  Attributes:
12495 
   - orderId
12496 
   - delayReason
3986 chandransh 12497 
   - furtherDelay
3553 chandransh 12498 
  """
12499 
 
12500 
  thrift_spec = (
12501 
    None, # 0
12502 
    (1, TType.I64, 'orderId', None, None, ), # 1
12503 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12504 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12505 
  )
12506 
 
3986 chandransh 12507 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12508 
    self.orderId = orderId
12509 
    self.delayReason = delayReason
3986 chandransh 12510 
    self.furtherDelay = furtherDelay
3553 chandransh 12511 
 
12512 
  def read(self, iprot):
12513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12515 
      return
12516 
    iprot.readStructBegin()
12517 
    while True:
12518 
      (fname, ftype, fid) = iprot.readFieldBegin()
12519 
      if ftype == TType.STOP:
12520 
        break
12521 
      if fid == 1:
12522 
        if ftype == TType.I64:
12523 
          self.orderId = iprot.readI64();
12524 
        else:
12525 
          iprot.skip(ftype)
12526 
      elif fid == 2:
12527 
        if ftype == TType.I32:
12528 
          self.delayReason = iprot.readI32();
12529 
        else:
12530 
          iprot.skip(ftype)
3986 chandransh 12531 
      elif fid == 3:
12532 
        if ftype == TType.I64:
12533 
          self.furtherDelay = iprot.readI64();
12534 
        else:
12535 
          iprot.skip(ftype)
3553 chandransh 12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
12545 
    oprot.writeStructBegin('addDelayReason_args')
12546 
    if self.orderId is not None:
12547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12548 
      oprot.writeI64(self.orderId)
12549 
      oprot.writeFieldEnd()
12550 
    if self.delayReason is not None:
12551 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12552 
      oprot.writeI32(self.delayReason)
12553 
      oprot.writeFieldEnd()
3986 chandransh 12554 
    if self.furtherDelay is not None:
12555 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12556 
      oprot.writeI64(self.furtherDelay)
12557 
      oprot.writeFieldEnd()
3553 chandransh 12558 
    oprot.writeFieldStop()
12559 
    oprot.writeStructEnd()
12560 
 
12561 
  def validate(self):
12562 
    return
12563 
 
12564 
 
12565 
  def __repr__(self):
12566 
    L = ['%s=%r' % (key, value)
12567 
      for key, value in self.__dict__.iteritems()]
12568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12569 
 
12570 
  def __eq__(self, other):
12571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12572 
 
12573 
  def __ne__(self, other):
12574 
    return not (self == other)
12575 
 
12576 
class addDelayReason_result:
12577 
  """
12578 
  Attributes:
12579 
   - success
12580 
   - ex
12581 
  """
12582 
 
12583 
  thrift_spec = (
12584 
    (0, TType.BOOL, 'success', None, None, ), # 0
12585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12586 
  )
12587 
 
12588 
  def __init__(self, success=None, ex=None,):
12589 
    self.success = success
12590 
    self.ex = ex
12591 
 
12592 
  def read(self, iprot):
12593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12595 
      return
12596 
    iprot.readStructBegin()
12597 
    while True:
12598 
      (fname, ftype, fid) = iprot.readFieldBegin()
12599 
      if ftype == TType.STOP:
12600 
        break
12601 
      if fid == 0:
12602 
        if ftype == TType.BOOL:
12603 
          self.success = iprot.readBool();
12604 
        else:
12605 
          iprot.skip(ftype)
12606 
      elif fid == 1:
12607 
        if ftype == TType.STRUCT:
12608 
          self.ex = TransactionServiceException()
12609 
          self.ex.read(iprot)
12610 
        else:
12611 
          iprot.skip(ftype)
12612 
      else:
12613 
        iprot.skip(ftype)
12614 
      iprot.readFieldEnd()
12615 
    iprot.readStructEnd()
12616 
 
12617 
  def write(self, oprot):
12618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12620 
      return
12621 
    oprot.writeStructBegin('addDelayReason_result')
12622 
    if self.success is not None:
12623 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12624 
      oprot.writeBool(self.success)
12625 
      oprot.writeFieldEnd()
12626 
    if self.ex is not None:
12627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12628 
      self.ex.write(oprot)
12629 
      oprot.writeFieldEnd()
12630 
    oprot.writeFieldStop()
12631 
    oprot.writeStructEnd()
12632 
 
12633 
  def validate(self):
12634 
    return
12635 
 
12636 
 
12637 
  def __repr__(self):
12638 
    L = ['%s=%r' % (key, value)
12639 
      for key, value in self.__dict__.iteritems()]
12640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12641 
 
12642 
  def __eq__(self, other):
12643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12644 
 
12645 
  def __ne__(self, other):
12646 
    return not (self == other)
3956 chandransh 12647 
 
12648 
class reconcileCodCollection_args:
12649 
  """
12650 
  Attributes:
12651 
   - collectedAmountMap
12652 
   - xferBy
12653 
   - xferTxnId
12654 
   - xferDate
12655 
  """
12656 
 
12657 
  thrift_spec = (
12658 
    None, # 0
12659 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
12660 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
12661 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
12662 
    (4, TType.I64, 'xferDate', None, None, ), # 4
12663 
  )
12664 
 
12665 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
12666 
    self.collectedAmountMap = collectedAmountMap
12667 
    self.xferBy = xferBy
12668 
    self.xferTxnId = xferTxnId
12669 
    self.xferDate = xferDate
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 1:
12681 
        if ftype == TType.MAP:
12682 
          self.collectedAmountMap = {}
4133 chandransh 12683 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
12684 
          for _i217 in xrange(_size213):
12685 
            _key218 = iprot.readString();
12686 
            _val219 = iprot.readDouble();
12687 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 12688 
          iprot.readMapEnd()
12689 
        else:
12690 
          iprot.skip(ftype)
12691 
      elif fid == 2:
12692 
        if ftype == TType.STRING:
12693 
          self.xferBy = iprot.readString();
12694 
        else:
12695 
          iprot.skip(ftype)
12696 
      elif fid == 3:
12697 
        if ftype == TType.STRING:
12698 
          self.xferTxnId = iprot.readString();
12699 
        else:
12700 
          iprot.skip(ftype)
12701 
      elif fid == 4:
12702 
        if ftype == TType.I64:
12703 
          self.xferDate = iprot.readI64();
12704 
        else:
12705 
          iprot.skip(ftype)
12706 
      else:
12707 
        iprot.skip(ftype)
12708 
      iprot.readFieldEnd()
12709 
    iprot.readStructEnd()
12710 
 
12711 
  def write(self, oprot):
12712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12714 
      return
12715 
    oprot.writeStructBegin('reconcileCodCollection_args')
12716 
    if self.collectedAmountMap is not None:
12717 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
12718 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 12719 
      for kiter220,viter221 in self.collectedAmountMap.items():
12720 
        oprot.writeString(kiter220)
12721 
        oprot.writeDouble(viter221)
3956 chandransh 12722 
      oprot.writeMapEnd()
12723 
      oprot.writeFieldEnd()
12724 
    if self.xferBy is not None:
12725 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
12726 
      oprot.writeString(self.xferBy)
12727 
      oprot.writeFieldEnd()
12728 
    if self.xferTxnId is not None:
12729 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
12730 
      oprot.writeString(self.xferTxnId)
12731 
      oprot.writeFieldEnd()
12732 
    if self.xferDate is not None:
12733 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
12734 
      oprot.writeI64(self.xferDate)
12735 
      oprot.writeFieldEnd()
12736 
    oprot.writeFieldStop()
12737 
    oprot.writeStructEnd()
12738 
 
12739 
  def validate(self):
12740 
    return
12741 
 
12742 
 
12743 
  def __repr__(self):
12744 
    L = ['%s=%r' % (key, value)
12745 
      for key, value in self.__dict__.iteritems()]
12746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12747 
 
12748 
  def __eq__(self, other):
12749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12750 
 
12751 
  def __ne__(self, other):
12752 
    return not (self == other)
12753 
 
12754 
class reconcileCodCollection_result:
12755 
  """
12756 
  Attributes:
12757 
   - success
12758 
   - ex
12759 
  """
12760 
 
12761 
  thrift_spec = (
12762 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
12763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12764 
  )
12765 
 
12766 
  def __init__(self, success=None, ex=None,):
12767 
    self.success = success
12768 
    self.ex = ex
12769 
 
12770 
  def read(self, iprot):
12771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12773 
      return
12774 
    iprot.readStructBegin()
12775 
    while True:
12776 
      (fname, ftype, fid) = iprot.readFieldBegin()
12777 
      if ftype == TType.STOP:
12778 
        break
12779 
      if fid == 0:
12780 
        if ftype == TType.MAP:
12781 
          self.success = {}
4133 chandransh 12782 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
12783 
          for _i226 in xrange(_size222):
12784 
            _key227 = iprot.readString();
12785 
            _val228 = iprot.readString();
12786 
            self.success[_key227] = _val228
3956 chandransh 12787 
          iprot.readMapEnd()
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 1:
12791 
        if ftype == TType.STRUCT:
12792 
          self.ex = TransactionServiceException()
12793 
          self.ex.read(iprot)
12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      else:
12797 
        iprot.skip(ftype)
12798 
      iprot.readFieldEnd()
12799 
    iprot.readStructEnd()
12800 
 
12801 
  def write(self, oprot):
12802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12804 
      return
12805 
    oprot.writeStructBegin('reconcileCodCollection_result')
12806 
    if self.success is not None:
12807 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12808 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 12809 
      for kiter229,viter230 in self.success.items():
12810 
        oprot.writeString(kiter229)
12811 
        oprot.writeString(viter230)
3956 chandransh 12812 
      oprot.writeMapEnd()
12813 
      oprot.writeFieldEnd()
12814 
    if self.ex is not None:
12815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12816 
      self.ex.write(oprot)
12817 
      oprot.writeFieldEnd()
12818 
    oprot.writeFieldStop()
12819 
    oprot.writeStructEnd()
12820 
 
12821 
  def validate(self):
12822 
    return
12823 
 
12824 
 
12825 
  def __repr__(self):
12826 
    L = ['%s=%r' % (key, value)
12827 
      for key, value in self.__dict__.iteritems()]
12828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12829 
 
12830 
  def __eq__(self, other):
12831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12832 
 
12833 
  def __ne__(self, other):
12834 
    return not (self == other)
4008 mandeep.dh 12835 
 
12836 
class getTransactionsRequiringExtraProcessing_args:
12837 
  """
12838 
  Attributes:
12839 
   - category
12840 
  """
12841 
 
12842 
  thrift_spec = (
12843 
    None, # 0
12844 
    (1, TType.I32, 'category', None, None, ), # 1
12845 
  )
12846 
 
12847 
  def __init__(self, category=None,):
12848 
    self.category = category
12849 
 
12850 
  def read(self, iprot):
12851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12853 
      return
12854 
    iprot.readStructBegin()
12855 
    while True:
12856 
      (fname, ftype, fid) = iprot.readFieldBegin()
12857 
      if ftype == TType.STOP:
12858 
        break
12859 
      if fid == 1:
12860 
        if ftype == TType.I32:
12861 
          self.category = iprot.readI32();
12862 
        else:
12863 
          iprot.skip(ftype)
12864 
      else:
12865 
        iprot.skip(ftype)
12866 
      iprot.readFieldEnd()
12867 
    iprot.readStructEnd()
12868 
 
12869 
  def write(self, oprot):
12870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12872 
      return
12873 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
12874 
    if self.category is not None:
12875 
      oprot.writeFieldBegin('category', TType.I32, 1)
12876 
      oprot.writeI32(self.category)
12877 
      oprot.writeFieldEnd()
12878 
    oprot.writeFieldStop()
12879 
    oprot.writeStructEnd()
12880 
 
12881 
  def validate(self):
12882 
    return
12883 
 
12884 
 
12885 
  def __repr__(self):
12886 
    L = ['%s=%r' % (key, value)
12887 
      for key, value in self.__dict__.iteritems()]
12888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12889 
 
12890 
  def __eq__(self, other):
12891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12892 
 
12893 
  def __ne__(self, other):
12894 
    return not (self == other)
12895 
 
12896 
class getTransactionsRequiringExtraProcessing_result:
12897 
  """
12898 
  Attributes:
12899 
   - success
12900 
  """
12901 
 
12902 
  thrift_spec = (
12903 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12904 
  )
12905 
 
12906 
  def __init__(self, success=None,):
12907 
    self.success = success
12908 
 
12909 
  def read(self, iprot):
12910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12912 
      return
12913 
    iprot.readStructBegin()
12914 
    while True:
12915 
      (fname, ftype, fid) = iprot.readFieldBegin()
12916 
      if ftype == TType.STOP:
12917 
        break
12918 
      if fid == 0:
12919 
        if ftype == TType.LIST:
12920 
          self.success = []
4133 chandransh 12921 
          (_etype234, _size231) = iprot.readListBegin()
12922 
          for _i235 in xrange(_size231):
12923 
            _elem236 = iprot.readI64();
12924 
            self.success.append(_elem236)
4008 mandeep.dh 12925 
          iprot.readListEnd()
12926 
        else:
12927 
          iprot.skip(ftype)
12928 
      else:
12929 
        iprot.skip(ftype)
12930 
      iprot.readFieldEnd()
12931 
    iprot.readStructEnd()
12932 
 
12933 
  def write(self, oprot):
12934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12936 
      return
12937 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
12938 
    if self.success is not None:
12939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12940 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 12941 
      for iter237 in self.success:
12942 
        oprot.writeI64(iter237)
4008 mandeep.dh 12943 
      oprot.writeListEnd()
12944 
      oprot.writeFieldEnd()
12945 
    oprot.writeFieldStop()
12946 
    oprot.writeStructEnd()
12947 
 
12948 
  def validate(self):
12949 
    return
12950 
 
12951 
 
12952 
  def __repr__(self):
12953 
    L = ['%s=%r' % (key, value)
12954 
      for key, value in self.__dict__.iteritems()]
12955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12956 
 
12957 
  def __eq__(self, other):
12958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12959 
 
12960 
  def __ne__(self, other):
12961 
    return not (self == other)
12962 
 
12963 
class markTransactionAsProcessed_args:
12964 
  """
12965 
  Attributes:
12966 
   - transactionId
12967 
   - category
12968 
  """
12969 
 
12970 
  thrift_spec = (
12971 
    None, # 0
12972 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12973 
    (2, TType.I32, 'category', None, None, ), # 2
12974 
  )
12975 
 
12976 
  def __init__(self, transactionId=None, category=None,):
12977 
    self.transactionId = transactionId
12978 
    self.category = category
12979 
 
12980 
  def read(self, iprot):
12981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12983 
      return
12984 
    iprot.readStructBegin()
12985 
    while True:
12986 
      (fname, ftype, fid) = iprot.readFieldBegin()
12987 
      if ftype == TType.STOP:
12988 
        break
12989 
      if fid == 1:
12990 
        if ftype == TType.I64:
12991 
          self.transactionId = iprot.readI64();
12992 
        else:
12993 
          iprot.skip(ftype)
12994 
      elif fid == 2:
12995 
        if ftype == TType.I32:
12996 
          self.category = iprot.readI32();
12997 
        else:
12998 
          iprot.skip(ftype)
12999 
      else:
13000 
        iprot.skip(ftype)
13001 
      iprot.readFieldEnd()
13002 
    iprot.readStructEnd()
13003 
 
13004 
  def write(self, oprot):
13005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13007 
      return
13008 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
13009 
    if self.transactionId is not None:
13010 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13011 
      oprot.writeI64(self.transactionId)
13012 
      oprot.writeFieldEnd()
13013 
    if self.category is not None:
13014 
      oprot.writeFieldBegin('category', TType.I32, 2)
13015 
      oprot.writeI32(self.category)
13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
13035 
class markTransactionAsProcessed_result:
13036 
 
13037 
  thrift_spec = (
13038 
  )
13039 
 
13040 
  def read(self, iprot):
13041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13043 
      return
13044 
    iprot.readStructBegin()
13045 
    while True:
13046 
      (fname, ftype, fid) = iprot.readFieldBegin()
13047 
      if ftype == TType.STOP:
13048 
        break
13049 
      else:
13050 
        iprot.skip(ftype)
13051 
      iprot.readFieldEnd()
13052 
    iprot.readStructEnd()
13053 
 
13054 
  def write(self, oprot):
13055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13057 
      return
13058 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
13059 
    oprot.writeFieldStop()
13060 
    oprot.writeStructEnd()
13061 
 
13062 
  def validate(self):
13063 
    return
13064 
 
13065 
 
13066 
  def __repr__(self):
13067 
    L = ['%s=%r' % (key, value)
13068 
      for key, value in self.__dict__.iteritems()]
13069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13070 
 
13071 
  def __eq__(self, other):
13072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13073 
 
13074 
  def __ne__(self, other):
13075 
    return not (self == other)
4018 chandransh 13076 
 
13077 
class getItemWiseRiskyOrdersCount_args:
13078 
 
13079 
  thrift_spec = (
13080 
  )
13081 
 
13082 
  def read(self, iprot):
13083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13085 
      return
13086 
    iprot.readStructBegin()
13087 
    while True:
13088 
      (fname, ftype, fid) = iprot.readFieldBegin()
13089 
      if ftype == TType.STOP:
13090 
        break
13091 
      else:
13092 
        iprot.skip(ftype)
13093 
      iprot.readFieldEnd()
13094 
    iprot.readStructEnd()
13095 
 
13096 
  def write(self, oprot):
13097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13099 
      return
13100 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
13119 
class getItemWiseRiskyOrdersCount_result:
13120 
  """
13121 
  Attributes:
13122 
   - success
13123 
  """
13124 
 
13125 
  thrift_spec = (
13126 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
13127 
  )
13128 
 
13129 
  def __init__(self, success=None,):
13130 
    self.success = success
13131 
 
13132 
  def read(self, iprot):
13133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13135 
      return
13136 
    iprot.readStructBegin()
13137 
    while True:
13138 
      (fname, ftype, fid) = iprot.readFieldBegin()
13139 
      if ftype == TType.STOP:
13140 
        break
13141 
      if fid == 0:
13142 
        if ftype == TType.MAP:
13143 
          self.success = {}
4133 chandransh 13144 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
13145 
          for _i242 in xrange(_size238):
13146 
            _key243 = iprot.readI64();
13147 
            _val244 = iprot.readI64();
13148 
            self.success[_key243] = _val244
4018 chandransh 13149 
          iprot.readMapEnd()
13150 
        else:
13151 
          iprot.skip(ftype)
13152 
      else:
13153 
        iprot.skip(ftype)
13154 
      iprot.readFieldEnd()
13155 
    iprot.readStructEnd()
13156 
 
13157 
  def write(self, oprot):
13158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13160 
      return
13161 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
13162 
    if self.success is not None:
13163 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13164 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 13165 
      for kiter245,viter246 in self.success.items():
13166 
        oprot.writeI64(kiter245)
13167 
        oprot.writeI64(viter246)
4018 chandransh 13168 
      oprot.writeMapEnd()
13169 
      oprot.writeFieldEnd()
13170 
    oprot.writeFieldStop()
13171 
    oprot.writeStructEnd()
13172 
 
13173 
  def validate(self):
13174 
    return
13175 
 
13176 
 
13177 
  def __repr__(self):
13178 
    L = ['%s=%r' % (key, value)
13179 
      for key, value in self.__dict__.iteritems()]
13180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13181 
 
13182 
  def __eq__(self, other):
13183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13184 
 
13185 
  def __ne__(self, other):
13186 
    return not (self == other)
4247 rajveer 13187 
 
4295 varun.gupt 13188 
class getOrdersForItemIds_args:
13189 
  """
13190 
  Attributes:
13191 
   - itemIds
13192 
  """
13193 
 
13194 
  thrift_spec = (
13195 
    None, # 0
13196 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
13197 
  )
13198 
 
13199 
  def __init__(self, itemIds=None,):
13200 
    self.itemIds = itemIds
13201 
 
13202 
  def read(self, iprot):
13203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13205 
      return
13206 
    iprot.readStructBegin()
13207 
    while True:
13208 
      (fname, ftype, fid) = iprot.readFieldBegin()
13209 
      if ftype == TType.STOP:
13210 
        break
13211 
      if fid == 1:
13212 
        if ftype == TType.LIST:
13213 
          self.itemIds = []
13214 
          (_etype250, _size247) = iprot.readListBegin()
13215 
          for _i251 in xrange(_size247):
13216 
            _elem252 = iprot.readI64();
13217 
            self.itemIds.append(_elem252)
13218 
          iprot.readListEnd()
13219 
        else:
13220 
          iprot.skip(ftype)
13221 
      else:
13222 
        iprot.skip(ftype)
13223 
      iprot.readFieldEnd()
13224 
    iprot.readStructEnd()
13225 
 
13226 
  def write(self, oprot):
13227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13229 
      return
13230 
    oprot.writeStructBegin('getOrdersForItemIds_args')
13231 
    if self.itemIds is not None:
13232 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
13233 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13234 
      for iter253 in self.itemIds:
13235 
        oprot.writeI64(iter253)
13236 
      oprot.writeListEnd()
13237 
      oprot.writeFieldEnd()
13238 
    oprot.writeFieldStop()
13239 
    oprot.writeStructEnd()
13240 
 
13241 
  def validate(self):
13242 
    return
13243 
 
13244 
 
13245 
  def __repr__(self):
13246 
    L = ['%s=%r' % (key, value)
13247 
      for key, value in self.__dict__.iteritems()]
13248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13249 
 
13250 
  def __eq__(self, other):
13251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13252 
 
13253 
  def __ne__(self, other):
13254 
    return not (self == other)
13255 
 
13256 
class getOrdersForItemIds_result:
13257 
  """
13258 
  Attributes:
13259 
   - success
13260 
  """
13261 
 
13262 
  thrift_spec = (
13263 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13264 
  )
13265 
 
13266 
  def __init__(self, success=None,):
13267 
    self.success = success
13268 
 
13269 
  def read(self, iprot):
13270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13272 
      return
13273 
    iprot.readStructBegin()
13274 
    while True:
13275 
      (fname, ftype, fid) = iprot.readFieldBegin()
13276 
      if ftype == TType.STOP:
13277 
        break
13278 
      if fid == 0:
13279 
        if ftype == TType.LIST:
13280 
          self.success = []
13281 
          (_etype257, _size254) = iprot.readListBegin()
13282 
          for _i258 in xrange(_size254):
13283 
            _elem259 = Order()
13284 
            _elem259.read(iprot)
13285 
            self.success.append(_elem259)
13286 
          iprot.readListEnd()
13287 
        else:
13288 
          iprot.skip(ftype)
13289 
      else:
13290 
        iprot.skip(ftype)
13291 
      iprot.readFieldEnd()
13292 
    iprot.readStructEnd()
13293 
 
13294 
  def write(self, oprot):
13295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13297 
      return
13298 
    oprot.writeStructBegin('getOrdersForItemIds_result')
13299 
    if self.success is not None:
13300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13302 
      for iter260 in self.success:
13303 
        iter260.write(oprot)
13304 
      oprot.writeListEnd()
13305 
      oprot.writeFieldEnd()
13306 
    oprot.writeFieldStop()
13307 
    oprot.writeStructEnd()
13308 
 
13309 
  def validate(self):
13310 
    return
13311 
 
13312 
 
13313 
  def __repr__(self):
13314 
    L = ['%s=%r' % (key, value)
13315 
      for key, value in self.__dict__.iteritems()]
13316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13317 
 
13318 
  def __eq__(self, other):
13319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13320 
 
13321 
  def __ne__(self, other):
13322 
    return not (self == other)
13323 
 
4247 rajveer 13324 
class markOrderCancellationRequestReceived_args:
13325 
  """
13326 
  Attributes:
13327 
   - orderId
13328 
  """
13329 
 
13330 
  thrift_spec = (
13331 
    None, # 0
13332 
    (1, TType.I64, 'orderId', None, None, ), # 1
13333 
  )
13334 
 
13335 
  def __init__(self, orderId=None,):
13336 
    self.orderId = orderId
13337 
 
13338 
  def read(self, iprot):
13339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13341 
      return
13342 
    iprot.readStructBegin()
13343 
    while True:
13344 
      (fname, ftype, fid) = iprot.readFieldBegin()
13345 
      if ftype == TType.STOP:
13346 
        break
13347 
      if fid == 1:
13348 
        if ftype == TType.I64:
13349 
          self.orderId = iprot.readI64();
13350 
        else:
13351 
          iprot.skip(ftype)
13352 
      else:
13353 
        iprot.skip(ftype)
13354 
      iprot.readFieldEnd()
13355 
    iprot.readStructEnd()
13356 
 
13357 
  def write(self, oprot):
13358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13360 
      return
13361 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
13362 
    if self.orderId is not None:
13363 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13364 
      oprot.writeI64(self.orderId)
13365 
      oprot.writeFieldEnd()
13366 
    oprot.writeFieldStop()
13367 
    oprot.writeStructEnd()
13368 
 
13369 
  def validate(self):
13370 
    return
13371 
 
13372 
 
13373 
  def __repr__(self):
13374 
    L = ['%s=%r' % (key, value)
13375 
      for key, value in self.__dict__.iteritems()]
13376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13377 
 
13378 
  def __eq__(self, other):
13379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13380 
 
13381 
  def __ne__(self, other):
13382 
    return not (self == other)
13383 
 
13384 
class markOrderCancellationRequestReceived_result:
13385 
  """
13386 
  Attributes:
13387 
   - ex
13388 
  """
13389 
 
13390 
  thrift_spec = (
13391 
    None, # 0
13392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13393 
  )
13394 
 
13395 
  def __init__(self, ex=None,):
13396 
    self.ex = ex
13397 
 
13398 
  def read(self, iprot):
13399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13401 
      return
13402 
    iprot.readStructBegin()
13403 
    while True:
13404 
      (fname, ftype, fid) = iprot.readFieldBegin()
13405 
      if ftype == TType.STOP:
13406 
        break
13407 
      if fid == 1:
13408 
        if ftype == TType.STRUCT:
13409 
          self.ex = TransactionServiceException()
13410 
          self.ex.read(iprot)
13411 
        else:
13412 
          iprot.skip(ftype)
13413 
      else:
13414 
        iprot.skip(ftype)
13415 
      iprot.readFieldEnd()
13416 
    iprot.readStructEnd()
13417 
 
13418 
  def write(self, oprot):
13419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13421 
      return
13422 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13423 
    if self.ex is not None:
13424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13425 
      self.ex.write(oprot)
13426 
      oprot.writeFieldEnd()
13427 
    oprot.writeFieldStop()
13428 
    oprot.writeStructEnd()
13429 
 
13430 
  def validate(self):
13431 
    return
13432 
 
13433 
 
13434 
  def __repr__(self):
13435 
    L = ['%s=%r' % (key, value)
13436 
      for key, value in self.__dict__.iteritems()]
13437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13438 
 
13439 
  def __eq__(self, other):
13440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13441 
 
13442 
  def __ne__(self, other):
13443 
    return not (self == other)
13444 
 
13445 
class markOrderCancellationRequestConfirmed_args:
13446 
  """
13447 
  Attributes:
13448 
   - orderId
13449 
  """
13450 
 
13451 
  thrift_spec = (
13452 
    None, # 0
13453 
    (1, TType.I64, 'orderId', None, None, ), # 1
13454 
  )
13455 
 
13456 
  def __init__(self, orderId=None,):
13457 
    self.orderId = orderId
13458 
 
13459 
  def read(self, iprot):
13460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13462 
      return
13463 
    iprot.readStructBegin()
13464 
    while True:
13465 
      (fname, ftype, fid) = iprot.readFieldBegin()
13466 
      if ftype == TType.STOP:
13467 
        break
13468 
      if fid == 1:
13469 
        if ftype == TType.I64:
13470 
          self.orderId = iprot.readI64();
13471 
        else:
13472 
          iprot.skip(ftype)
13473 
      else:
13474 
        iprot.skip(ftype)
13475 
      iprot.readFieldEnd()
13476 
    iprot.readStructEnd()
13477 
 
13478 
  def write(self, oprot):
13479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13481 
      return
13482 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13483 
    if self.orderId is not None:
13484 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13485 
      oprot.writeI64(self.orderId)
13486 
      oprot.writeFieldEnd()
13487 
    oprot.writeFieldStop()
13488 
    oprot.writeStructEnd()
13489 
 
13490 
  def validate(self):
13491 
    return
13492 
 
13493 
 
13494 
  def __repr__(self):
13495 
    L = ['%s=%r' % (key, value)
13496 
      for key, value in self.__dict__.iteritems()]
13497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13498 
 
13499 
  def __eq__(self, other):
13500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13501 
 
13502 
  def __ne__(self, other):
13503 
    return not (self == other)
13504 
 
13505 
class markOrderCancellationRequestConfirmed_result:
13506 
  """
13507 
  Attributes:
13508 
   - ex
13509 
  """
13510 
 
13511 
  thrift_spec = (
13512 
    None, # 0
13513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13514 
  )
13515 
 
13516 
  def __init__(self, ex=None,):
13517 
    self.ex = ex
13518 
 
13519 
  def read(self, iprot):
13520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13522 
      return
13523 
    iprot.readStructBegin()
13524 
    while True:
13525 
      (fname, ftype, fid) = iprot.readFieldBegin()
13526 
      if ftype == TType.STOP:
13527 
        break
13528 
      if fid == 1:
13529 
        if ftype == TType.STRUCT:
13530 
          self.ex = TransactionServiceException()
13531 
          self.ex.read(iprot)
13532 
        else:
13533 
          iprot.skip(ftype)
13534 
      else:
13535 
        iprot.skip(ftype)
13536 
      iprot.readFieldEnd()
13537 
    iprot.readStructEnd()
13538 
 
13539 
  def write(self, oprot):
13540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13542 
      return
13543 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13544 
    if self.ex is not None:
13545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13546 
      self.ex.write(oprot)
13547 
      oprot.writeFieldEnd()
13548 
    oprot.writeFieldStop()
13549 
    oprot.writeStructEnd()
13550 
 
13551 
  def validate(self):
13552 
    return
13553 
 
13554 
 
13555 
  def __repr__(self):
13556 
    L = ['%s=%r' % (key, value)
13557 
      for key, value in self.__dict__.iteritems()]
13558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13559 
 
13560 
  def __eq__(self, other):
13561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13562 
 
13563 
  def __ne__(self, other):
13564 
    return not (self == other)
13565 
 
13566 
class markOrderCancellationRequestDenied_args:
13567 
  """
13568 
  Attributes:
13569 
   - orderId
13570 
  """
13571 
 
13572 
  thrift_spec = (
13573 
    None, # 0
13574 
    (1, TType.I64, 'orderId', None, None, ), # 1
13575 
  )
13576 
 
13577 
  def __init__(self, orderId=None,):
13578 
    self.orderId = orderId
13579 
 
13580 
  def read(self, iprot):
13581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13583 
      return
13584 
    iprot.readStructBegin()
13585 
    while True:
13586 
      (fname, ftype, fid) = iprot.readFieldBegin()
13587 
      if ftype == TType.STOP:
13588 
        break
13589 
      if fid == 1:
13590 
        if ftype == TType.I64:
13591 
          self.orderId = iprot.readI64();
13592 
        else:
13593 
          iprot.skip(ftype)
13594 
      else:
13595 
        iprot.skip(ftype)
13596 
      iprot.readFieldEnd()
13597 
    iprot.readStructEnd()
13598 
 
13599 
  def write(self, oprot):
13600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13602 
      return
13603 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
13604 
    if self.orderId is not None:
13605 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13606 
      oprot.writeI64(self.orderId)
13607 
      oprot.writeFieldEnd()
13608 
    oprot.writeFieldStop()
13609 
    oprot.writeStructEnd()
13610 
 
13611 
  def validate(self):
13612 
    return
13613 
 
13614 
 
13615 
  def __repr__(self):
13616 
    L = ['%s=%r' % (key, value)
13617 
      for key, value in self.__dict__.iteritems()]
13618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13619 
 
13620 
  def __eq__(self, other):
13621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13622 
 
13623 
  def __ne__(self, other):
13624 
    return not (self == other)
13625 
 
13626 
class markOrderCancellationRequestDenied_result:
13627 
  """
13628 
  Attributes:
13629 
   - ex
13630 
  """
13631 
 
13632 
  thrift_spec = (
13633 
    None, # 0
13634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13635 
  )
13636 
 
13637 
  def __init__(self, ex=None,):
13638 
    self.ex = ex
13639 
 
13640 
  def read(self, iprot):
13641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13643 
      return
13644 
    iprot.readStructBegin()
13645 
    while True:
13646 
      (fname, ftype, fid) = iprot.readFieldBegin()
13647 
      if ftype == TType.STOP:
13648 
        break
13649 
      if fid == 1:
13650 
        if ftype == TType.STRUCT:
13651 
          self.ex = TransactionServiceException()
13652 
          self.ex.read(iprot)
13653 
        else:
13654 
          iprot.skip(ftype)
13655 
      else:
13656 
        iprot.skip(ftype)
13657 
      iprot.readFieldEnd()
13658 
    iprot.readStructEnd()
13659 
 
13660 
  def write(self, oprot):
13661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13663 
      return
13664 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
13665 
    if self.ex is not None:
13666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13667 
      self.ex.write(oprot)
13668 
      oprot.writeFieldEnd()
13669 
    oprot.writeFieldStop()
13670 
    oprot.writeStructEnd()
13671 
 
13672 
  def validate(self):
13673 
    return
13674 
 
13675 
 
13676 
  def __repr__(self):
13677 
    L = ['%s=%r' % (key, value)
13678 
      for key, value in self.__dict__.iteritems()]
13679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13680 
 
13681 
  def __eq__(self, other):
13682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13683 
 
13684 
  def __ne__(self, other):
13685 
    return not (self == other)
13686 
 
4258 rajveer 13687 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 13688 
  """
13689 
  Attributes:
4258 rajveer 13690 
   - transactionId
4247 rajveer 13691 
  """
13692 
 
13693 
  thrift_spec = (
13694 
    None, # 0
4258 rajveer 13695 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 13696 
  )
13697 
 
4258 rajveer 13698 
  def __init__(self, transactionId=None,):
13699 
    self.transactionId = transactionId
4247 rajveer 13700 
 
13701 
  def read(self, iprot):
13702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13704 
      return
13705 
    iprot.readStructBegin()
13706 
    while True:
13707 
      (fname, ftype, fid) = iprot.readFieldBegin()
13708 
      if ftype == TType.STOP:
13709 
        break
13710 
      if fid == 1:
13711 
        if ftype == TType.I64:
4258 rajveer 13712 
          self.transactionId = iprot.readI64();
4247 rajveer 13713 
        else:
13714 
          iprot.skip(ftype)
13715 
      else:
13716 
        iprot.skip(ftype)
13717 
      iprot.readFieldEnd()
13718 
    iprot.readStructEnd()
13719 
 
13720 
  def write(self, oprot):
13721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13723 
      return
4258 rajveer 13724 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
13725 
    if self.transactionId is not None:
13726 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13727 
      oprot.writeI64(self.transactionId)
4247 rajveer 13728 
      oprot.writeFieldEnd()
13729 
    oprot.writeFieldStop()
13730 
    oprot.writeStructEnd()
13731 
 
13732 
  def validate(self):
13733 
    return
13734 
 
13735 
 
13736 
  def __repr__(self):
13737 
    L = ['%s=%r' % (key, value)
13738 
      for key, value in self.__dict__.iteritems()]
13739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13740 
 
13741 
  def __eq__(self, other):
13742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13743 
 
13744 
  def __ne__(self, other):
13745 
    return not (self == other)
13746 
 
4258 rajveer 13747 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 13748 
  """
13749 
  Attributes:
13750 
   - ex
13751 
  """
13752 
 
13753 
  thrift_spec = (
13754 
    None, # 0
13755 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13756 
  )
13757 
 
13758 
  def __init__(self, ex=None,):
13759 
    self.ex = ex
13760 
 
13761 
  def read(self, iprot):
13762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13764 
      return
13765 
    iprot.readStructBegin()
13766 
    while True:
13767 
      (fname, ftype, fid) = iprot.readFieldBegin()
13768 
      if ftype == TType.STOP:
13769 
        break
13770 
      if fid == 1:
13771 
        if ftype == TType.STRUCT:
13772 
          self.ex = TransactionServiceException()
13773 
          self.ex.read(iprot)
13774 
        else:
13775 
          iprot.skip(ftype)
13776 
      else:
13777 
        iprot.skip(ftype)
13778 
      iprot.readFieldEnd()
13779 
    iprot.readStructEnd()
13780 
 
13781 
  def write(self, oprot):
13782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13784 
      return
4258 rajveer 13785 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 13786 
    if self.ex is not None:
13787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13788 
      self.ex.write(oprot)
13789 
      oprot.writeFieldEnd()
13790 
    oprot.writeFieldStop()
13791 
    oprot.writeStructEnd()
13792 
 
13793 
  def validate(self):
13794 
    return
13795 
 
13796 
 
13797 
  def __repr__(self):
13798 
    L = ['%s=%r' % (key, value)
13799 
      for key, value in self.__dict__.iteritems()]
13800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13801 
 
13802 
  def __eq__(self, other):
13803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13804 
 
13805 
  def __ne__(self, other):
13806 
    return not (self == other)
4259 anupam.sin 13807 
 
13808 
class refundTransaction_args:
13809 
  """
13810 
  Attributes:
13811 
   - transactionId
13812 
   - refundedBy
13813 
   - reason
13814 
  """
13815 
 
13816 
  thrift_spec = (
13817 
    None, # 0
13818 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13819 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
13820 
    (3, TType.STRING, 'reason', None, None, ), # 3
13821 
  )
13822 
 
13823 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
13824 
    self.transactionId = transactionId
13825 
    self.refundedBy = refundedBy
13826 
    self.reason = reason
13827 
 
13828 
  def read(self, iprot):
13829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13831 
      return
13832 
    iprot.readStructBegin()
13833 
    while True:
13834 
      (fname, ftype, fid) = iprot.readFieldBegin()
13835 
      if ftype == TType.STOP:
13836 
        break
13837 
      if fid == 1:
13838 
        if ftype == TType.I64:
13839 
          self.transactionId = iprot.readI64();
13840 
        else:
13841 
          iprot.skip(ftype)
13842 
      elif fid == 2:
13843 
        if ftype == TType.STRING:
13844 
          self.refundedBy = iprot.readString();
13845 
        else:
13846 
          iprot.skip(ftype)
13847 
      elif fid == 3:
13848 
        if ftype == TType.STRING:
13849 
          self.reason = iprot.readString();
13850 
        else:
13851 
          iprot.skip(ftype)
13852 
      else:
13853 
        iprot.skip(ftype)
13854 
      iprot.readFieldEnd()
13855 
    iprot.readStructEnd()
13856 
 
13857 
  def write(self, oprot):
13858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13860 
      return
13861 
    oprot.writeStructBegin('refundTransaction_args')
13862 
    if self.transactionId is not None:
13863 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13864 
      oprot.writeI64(self.transactionId)
13865 
      oprot.writeFieldEnd()
13866 
    if self.refundedBy is not None:
13867 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
13868 
      oprot.writeString(self.refundedBy)
13869 
      oprot.writeFieldEnd()
13870 
    if self.reason is not None:
13871 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13872 
      oprot.writeString(self.reason)
13873 
      oprot.writeFieldEnd()
13874 
    oprot.writeFieldStop()
13875 
    oprot.writeStructEnd()
13876 
 
13877 
  def validate(self):
13878 
    return
13879 
 
13880 
 
13881 
  def __repr__(self):
13882 
    L = ['%s=%r' % (key, value)
13883 
      for key, value in self.__dict__.iteritems()]
13884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13885 
 
13886 
  def __eq__(self, other):
13887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13888 
 
13889 
  def __ne__(self, other):
13890 
    return not (self == other)
13891 
 
13892 
class refundTransaction_result:
13893 
  """
13894 
  Attributes:
13895 
   - ex
13896 
  """
13897 
 
13898 
  thrift_spec = (
13899 
    None, # 0
13900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13901 
  )
13902 
 
13903 
  def __init__(self, ex=None,):
13904 
    self.ex = ex
13905 
 
13906 
  def read(self, iprot):
13907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13909 
      return
13910 
    iprot.readStructBegin()
13911 
    while True:
13912 
      (fname, ftype, fid) = iprot.readFieldBegin()
13913 
      if ftype == TType.STOP:
13914 
        break
13915 
      if fid == 1:
13916 
        if ftype == TType.STRUCT:
13917 
          self.ex = TransactionServiceException()
13918 
          self.ex.read(iprot)
13919 
        else:
13920 
          iprot.skip(ftype)
13921 
      else:
13922 
        iprot.skip(ftype)
13923 
      iprot.readFieldEnd()
13924 
    iprot.readStructEnd()
13925 
 
13926 
  def write(self, oprot):
13927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13929 
      return
13930 
    oprot.writeStructBegin('refundTransaction_result')
13931 
    if self.ex is not None:
13932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13933 
      self.ex.write(oprot)
13934 
      oprot.writeFieldEnd()
13935 
    oprot.writeFieldStop()
13936 
    oprot.writeStructEnd()
13937 
 
13938 
  def validate(self):
13939 
    return
13940 
 
13941 
 
13942 
  def __repr__(self):
13943 
    L = ['%s=%r' % (key, value)
13944 
      for key, value in self.__dict__.iteritems()]
13945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13946 
 
13947 
  def __eq__(self, other):
13948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13949 
 
13950 
  def __ne__(self, other):
13951 
    return not (self == other)
4285 rajveer 13952 
 
4324 mandeep.dh 13953 
class updateShipmentAddress_args:
13954 
  """
13955 
  Attributes:
13956 
   - orderId
13957 
   - addressId
13958 
  """
13959 
 
13960 
  thrift_spec = (
13961 
    None, # 0
13962 
    (1, TType.I64, 'orderId', None, None, ), # 1
13963 
    (2, TType.I64, 'addressId', None, None, ), # 2
13964 
  )
13965 
 
13966 
  def __init__(self, orderId=None, addressId=None,):
13967 
    self.orderId = orderId
13968 
    self.addressId = addressId
13969 
 
13970 
  def read(self, iprot):
13971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13973 
      return
13974 
    iprot.readStructBegin()
13975 
    while True:
13976 
      (fname, ftype, fid) = iprot.readFieldBegin()
13977 
      if ftype == TType.STOP:
13978 
        break
13979 
      if fid == 1:
13980 
        if ftype == TType.I64:
13981 
          self.orderId = iprot.readI64();
13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      elif fid == 2:
13985 
        if ftype == TType.I64:
13986 
          self.addressId = iprot.readI64();
13987 
        else:
13988 
          iprot.skip(ftype)
13989 
      else:
13990 
        iprot.skip(ftype)
13991 
      iprot.readFieldEnd()
13992 
    iprot.readStructEnd()
13993 
 
13994 
  def write(self, oprot):
13995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13997 
      return
13998 
    oprot.writeStructBegin('updateShipmentAddress_args')
13999 
    if self.orderId is not None:
14000 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14001 
      oprot.writeI64(self.orderId)
14002 
      oprot.writeFieldEnd()
14003 
    if self.addressId is not None:
14004 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
14005 
      oprot.writeI64(self.addressId)
14006 
      oprot.writeFieldEnd()
14007 
    oprot.writeFieldStop()
14008 
    oprot.writeStructEnd()
14009 
 
14010 
  def validate(self):
14011 
    return
14012 
 
14013 
 
14014 
  def __repr__(self):
14015 
    L = ['%s=%r' % (key, value)
14016 
      for key, value in self.__dict__.iteritems()]
14017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14018 
 
14019 
  def __eq__(self, other):
14020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14021 
 
14022 
  def __ne__(self, other):
14023 
    return not (self == other)
14024 
 
14025 
class updateShipmentAddress_result:
14026 
  """
14027 
  Attributes:
14028 
   - ex
14029 
  """
14030 
 
14031 
  thrift_spec = (
14032 
    None, # 0
14033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14034 
  )
14035 
 
14036 
  def __init__(self, ex=None,):
14037 
    self.ex = ex
14038 
 
14039 
  def read(self, iprot):
14040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14042 
      return
14043 
    iprot.readStructBegin()
14044 
    while True:
14045 
      (fname, ftype, fid) = iprot.readFieldBegin()
14046 
      if ftype == TType.STOP:
14047 
        break
14048 
      if fid == 1:
14049 
        if ftype == TType.STRUCT:
14050 
          self.ex = TransactionServiceException()
14051 
          self.ex.read(iprot)
14052 
        else:
14053 
          iprot.skip(ftype)
14054 
      else:
14055 
        iprot.skip(ftype)
14056 
      iprot.readFieldEnd()
14057 
    iprot.readStructEnd()
14058 
 
14059 
  def write(self, oprot):
14060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14062 
      return
14063 
    oprot.writeStructBegin('updateShipmentAddress_result')
14064 
    if self.ex is not None:
14065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14066 
      self.ex.write(oprot)
14067 
      oprot.writeFieldEnd()
14068 
    oprot.writeFieldStop()
14069 
    oprot.writeStructEnd()
14070 
 
14071 
  def validate(self):
14072 
    return
14073 
 
14074 
 
14075 
  def __repr__(self):
14076 
    L = ['%s=%r' % (key, value)
14077 
      for key, value in self.__dict__.iteritems()]
14078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14079 
 
14080 
  def __eq__(self, other):
14081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14082 
 
14083 
  def __ne__(self, other):
14084 
    return not (self == other)
14085 
 
4285 rajveer 14086 
class acceptOrdersForItemId_args:
14087 
  """
14088 
  Attributes:
14089 
   - itemId
14090 
   - inventory
14091 
  """
14092 
 
14093 
  thrift_spec = (
14094 
    None, # 0
14095 
    (1, TType.I64, 'itemId', None, None, ), # 1
14096 
    (2, TType.I64, 'inventory', None, None, ), # 2
14097 
  )
14098 
 
14099 
  def __init__(self, itemId=None, inventory=None,):
14100 
    self.itemId = itemId
14101 
    self.inventory = inventory
14102 
 
14103 
  def read(self, iprot):
14104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14106 
      return
14107 
    iprot.readStructBegin()
14108 
    while True:
14109 
      (fname, ftype, fid) = iprot.readFieldBegin()
14110 
      if ftype == TType.STOP:
14111 
        break
14112 
      if fid == 1:
14113 
        if ftype == TType.I64:
14114 
          self.itemId = iprot.readI64();
14115 
        else:
14116 
          iprot.skip(ftype)
14117 
      elif fid == 2:
14118 
        if ftype == TType.I64:
14119 
          self.inventory = iprot.readI64();
14120 
        else:
14121 
          iprot.skip(ftype)
14122 
      else:
14123 
        iprot.skip(ftype)
14124 
      iprot.readFieldEnd()
14125 
    iprot.readStructEnd()
14126 
 
14127 
  def write(self, oprot):
14128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14130 
      return
14131 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
14132 
    if self.itemId is not None:
14133 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14134 
      oprot.writeI64(self.itemId)
14135 
      oprot.writeFieldEnd()
14136 
    if self.inventory is not None:
14137 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
14138 
      oprot.writeI64(self.inventory)
14139 
      oprot.writeFieldEnd()
14140 
    oprot.writeFieldStop()
14141 
    oprot.writeStructEnd()
14142 
 
14143 
  def validate(self):
14144 
    return
14145 
 
14146 
 
14147 
  def __repr__(self):
14148 
    L = ['%s=%r' % (key, value)
14149 
      for key, value in self.__dict__.iteritems()]
14150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14151 
 
14152 
  def __eq__(self, other):
14153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14154 
 
14155 
  def __ne__(self, other):
14156 
    return not (self == other)
14157 
 
14158 
class acceptOrdersForItemId_result:
14159 
  """
14160 
  Attributes:
14161 
   - success
14162 
   - ex
14163 
  """
14164 
 
14165 
  thrift_spec = (
14166 
    (0, TType.BOOL, 'success', None, None, ), # 0
14167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14168 
  )
14169 
 
14170 
  def __init__(self, success=None, ex=None,):
14171 
    self.success = success
14172 
    self.ex = ex
14173 
 
14174 
  def read(self, iprot):
14175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14177 
      return
14178 
    iprot.readStructBegin()
14179 
    while True:
14180 
      (fname, ftype, fid) = iprot.readFieldBegin()
14181 
      if ftype == TType.STOP:
14182 
        break
14183 
      if fid == 0:
14184 
        if ftype == TType.BOOL:
14185 
          self.success = iprot.readBool();
14186 
        else:
14187 
          iprot.skip(ftype)
14188 
      elif fid == 1:
14189 
        if ftype == TType.STRUCT:
14190 
          self.ex = TransactionServiceException()
14191 
          self.ex.read(iprot)
14192 
        else:
14193 
          iprot.skip(ftype)
14194 
      else:
14195 
        iprot.skip(ftype)
14196 
      iprot.readFieldEnd()
14197 
    iprot.readStructEnd()
14198 
 
14199 
  def write(self, oprot):
14200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14202 
      return
14203 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
14204 
    if self.success is not None:
14205 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14206 
      oprot.writeBool(self.success)
14207 
      oprot.writeFieldEnd()
14208 
    if self.ex is not None:
14209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14210 
      self.ex.write(oprot)
14211 
      oprot.writeFieldEnd()
14212 
    oprot.writeFieldStop()
14213 
    oprot.writeStructEnd()
14214 
 
14215 
  def validate(self):
14216 
    return
14217 
 
14218 
 
14219 
  def __repr__(self):
14220 
    L = ['%s=%r' % (key, value)
14221 
      for key, value in self.__dict__.iteritems()]
14222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14223 
 
14224 
  def __eq__(self, other):
14225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14226 
 
14227 
  def __ne__(self, other):
14228 
    return not (self == other)
4303 rajveer 14229 
 
14230 
class markOrdersAsPORaised_args:
14231 
  """
14232 
  Attributes:
14233 
   - vendorId
14234 
   - itemId
14235 
   - quantity
14236 
   - estimate
4369 rajveer 14237 
   - isReminder
4303 rajveer 14238 
  """
14239 
 
14240 
  thrift_spec = (
14241 
    None, # 0
14242 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14243 
    (2, TType.I64, 'itemId', None, None, ), # 2
14244 
    (3, TType.I64, 'quantity', None, None, ), # 3
14245 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14246 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14247 
  )
14248 
 
4369 rajveer 14249 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14250 
    self.vendorId = vendorId
14251 
    self.itemId = itemId
14252 
    self.quantity = quantity
14253 
    self.estimate = estimate
4369 rajveer 14254 
    self.isReminder = isReminder
4303 rajveer 14255 
 
14256 
  def read(self, iprot):
14257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14259 
      return
14260 
    iprot.readStructBegin()
14261 
    while True:
14262 
      (fname, ftype, fid) = iprot.readFieldBegin()
14263 
      if ftype == TType.STOP:
14264 
        break
14265 
      if fid == 1:
14266 
        if ftype == TType.I64:
14267 
          self.vendorId = iprot.readI64();
14268 
        else:
14269 
          iprot.skip(ftype)
14270 
      elif fid == 2:
14271 
        if ftype == TType.I64:
14272 
          self.itemId = iprot.readI64();
14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      elif fid == 3:
14276 
        if ftype == TType.I64:
14277 
          self.quantity = iprot.readI64();
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      elif fid == 4:
14281 
        if ftype == TType.I64:
14282 
          self.estimate = iprot.readI64();
14283 
        else:
14284 
          iprot.skip(ftype)
4369 rajveer 14285 
      elif fid == 5:
14286 
        if ftype == TType.BOOL:
14287 
          self.isReminder = iprot.readBool();
14288 
        else:
14289 
          iprot.skip(ftype)
4303 rajveer 14290 
      else:
14291 
        iprot.skip(ftype)
14292 
      iprot.readFieldEnd()
14293 
    iprot.readStructEnd()
14294 
 
14295 
  def write(self, oprot):
14296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14298 
      return
14299 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
14300 
    if self.vendorId is not None:
14301 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14302 
      oprot.writeI64(self.vendorId)
14303 
      oprot.writeFieldEnd()
14304 
    if self.itemId is not None:
14305 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14306 
      oprot.writeI64(self.itemId)
14307 
      oprot.writeFieldEnd()
14308 
    if self.quantity is not None:
14309 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14310 
      oprot.writeI64(self.quantity)
14311 
      oprot.writeFieldEnd()
14312 
    if self.estimate is not None:
14313 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14314 
      oprot.writeI64(self.estimate)
14315 
      oprot.writeFieldEnd()
4369 rajveer 14316 
    if self.isReminder is not None:
14317 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14318 
      oprot.writeBool(self.isReminder)
14319 
      oprot.writeFieldEnd()
4303 rajveer 14320 
    oprot.writeFieldStop()
14321 
    oprot.writeStructEnd()
14322 
 
14323 
  def validate(self):
14324 
    return
14325 
 
14326 
 
14327 
  def __repr__(self):
14328 
    L = ['%s=%r' % (key, value)
14329 
      for key, value in self.__dict__.iteritems()]
14330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14331 
 
14332 
  def __eq__(self, other):
14333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14334 
 
14335 
  def __ne__(self, other):
14336 
    return not (self == other)
14337 
 
14338 
class markOrdersAsPORaised_result:
14339 
  """
14340 
  Attributes:
14341 
   - ex
14342 
  """
14343 
 
14344 
  thrift_spec = (
14345 
    None, # 0
14346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14347 
  )
14348 
 
14349 
  def __init__(self, ex=None,):
14350 
    self.ex = ex
14351 
 
14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
14361 
      if fid == 1:
14362 
        if ftype == TType.STRUCT:
14363 
          self.ex = TransactionServiceException()
14364 
          self.ex.read(iprot)
14365 
        else:
14366 
          iprot.skip(ftype)
14367 
      else:
14368 
        iprot.skip(ftype)
14369 
      iprot.readFieldEnd()
14370 
    iprot.readStructEnd()
14371 
 
14372 
  def write(self, oprot):
14373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14375 
      return
14376 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
14377 
    if self.ex is not None:
14378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14379 
      self.ex.write(oprot)
14380 
      oprot.writeFieldEnd()
14381 
    oprot.writeFieldStop()
14382 
    oprot.writeStructEnd()
14383 
 
14384 
  def validate(self):
14385 
    return
14386 
 
14387 
 
14388 
  def __repr__(self):
14389 
    L = ['%s=%r' % (key, value)
14390 
      for key, value in self.__dict__.iteritems()]
14391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14392 
 
14393 
  def __eq__(self, other):
14394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14395 
 
14396 
  def __ne__(self, other):
14397 
    return not (self == other)
14398 
 
14399 
class markOrdersAsReversalInitiated_args:
14400 
  """
14401 
  Attributes:
14402 
   - vendorId
14403 
   - itemId
14404 
   - quantity
14405 
   - estimate
4369 rajveer 14406 
   - isReminder
4303 rajveer 14407 
  """
14408 
 
14409 
  thrift_spec = (
14410 
    None, # 0
14411 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14412 
    (2, TType.I64, 'itemId', None, None, ), # 2
14413 
    (3, TType.I64, 'quantity', None, None, ), # 3
14414 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14415 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14416 
  )
14417 
 
4369 rajveer 14418 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14419 
    self.vendorId = vendorId
14420 
    self.itemId = itemId
14421 
    self.quantity = quantity
14422 
    self.estimate = estimate
4369 rajveer 14423 
    self.isReminder = isReminder
4303 rajveer 14424 
 
14425 
  def read(self, iprot):
14426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14428 
      return
14429 
    iprot.readStructBegin()
14430 
    while True:
14431 
      (fname, ftype, fid) = iprot.readFieldBegin()
14432 
      if ftype == TType.STOP:
14433 
        break
14434 
      if fid == 1:
14435 
        if ftype == TType.I64:
14436 
          self.vendorId = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      elif fid == 2:
14440 
        if ftype == TType.I64:
14441 
          self.itemId = iprot.readI64();
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      elif fid == 3:
14445 
        if ftype == TType.I64:
14446 
          self.quantity = iprot.readI64();
14447 
        else:
14448 
          iprot.skip(ftype)
14449 
      elif fid == 4:
14450 
        if ftype == TType.I64:
14451 
          self.estimate = iprot.readI64();
14452 
        else:
14453 
          iprot.skip(ftype)
4369 rajveer 14454 
      elif fid == 5:
14455 
        if ftype == TType.BOOL:
14456 
          self.isReminder = iprot.readBool();
14457 
        else:
14458 
          iprot.skip(ftype)
4303 rajveer 14459 
      else:
14460 
        iprot.skip(ftype)
14461 
      iprot.readFieldEnd()
14462 
    iprot.readStructEnd()
14463 
 
14464 
  def write(self, oprot):
14465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14467 
      return
14468 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14469 
    if self.vendorId is not None:
14470 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14471 
      oprot.writeI64(self.vendorId)
14472 
      oprot.writeFieldEnd()
14473 
    if self.itemId is not None:
14474 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14475 
      oprot.writeI64(self.itemId)
14476 
      oprot.writeFieldEnd()
14477 
    if self.quantity is not None:
14478 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14479 
      oprot.writeI64(self.quantity)
14480 
      oprot.writeFieldEnd()
14481 
    if self.estimate is not None:
14482 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14483 
      oprot.writeI64(self.estimate)
14484 
      oprot.writeFieldEnd()
4369 rajveer 14485 
    if self.isReminder is not None:
14486 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14487 
      oprot.writeBool(self.isReminder)
14488 
      oprot.writeFieldEnd()
4303 rajveer 14489 
    oprot.writeFieldStop()
14490 
    oprot.writeStructEnd()
14491 
 
14492 
  def validate(self):
14493 
    return
14494 
 
14495 
 
14496 
  def __repr__(self):
14497 
    L = ['%s=%r' % (key, value)
14498 
      for key, value in self.__dict__.iteritems()]
14499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14500 
 
14501 
  def __eq__(self, other):
14502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14503 
 
14504 
  def __ne__(self, other):
14505 
    return not (self == other)
14506 
 
14507 
class markOrdersAsReversalInitiated_result:
14508 
  """
14509 
  Attributes:
14510 
   - ex
14511 
  """
14512 
 
14513 
  thrift_spec = (
14514 
    None, # 0
14515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14516 
  )
14517 
 
14518 
  def __init__(self, ex=None,):
14519 
    self.ex = ex
14520 
 
14521 
  def read(self, iprot):
14522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14524 
      return
14525 
    iprot.readStructBegin()
14526 
    while True:
14527 
      (fname, ftype, fid) = iprot.readFieldBegin()
14528 
      if ftype == TType.STOP:
14529 
        break
14530 
      if fid == 1:
14531 
        if ftype == TType.STRUCT:
14532 
          self.ex = TransactionServiceException()
14533 
          self.ex.read(iprot)
14534 
        else:
14535 
          iprot.skip(ftype)
14536 
      else:
14537 
        iprot.skip(ftype)
14538 
      iprot.readFieldEnd()
14539 
    iprot.readStructEnd()
14540 
 
14541 
  def write(self, oprot):
14542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14544 
      return
14545 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14546 
    if self.ex is not None:
14547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14548 
      self.ex.write(oprot)
14549 
      oprot.writeFieldEnd()
14550 
    oprot.writeFieldStop()
14551 
    oprot.writeStructEnd()
14552 
 
14553 
  def validate(self):
14554 
    return
14555 
 
14556 
 
14557 
  def __repr__(self):
14558 
    L = ['%s=%r' % (key, value)
14559 
      for key, value in self.__dict__.iteritems()]
14560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14561 
 
14562 
  def __eq__(self, other):
14563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14564 
 
14565 
  def __ne__(self, other):
14566 
    return not (self == other)
14567 
 
14568 
class markOrdersAsNotAvailabke_args:
14569 
  """
14570 
  Attributes:
14571 
   - vendorId
14572 
   - itemId
14573 
   - quantity
14574 
   - estimate
4369 rajveer 14575 
   - isReminder
4303 rajveer 14576 
  """
14577 
 
14578 
  thrift_spec = (
14579 
    None, # 0
14580 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14581 
    (2, TType.I64, 'itemId', None, None, ), # 2
14582 
    (3, TType.I64, 'quantity', None, None, ), # 3
14583 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14584 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14585 
  )
14586 
 
4369 rajveer 14587 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14588 
    self.vendorId = vendorId
14589 
    self.itemId = itemId
14590 
    self.quantity = quantity
14591 
    self.estimate = estimate
4369 rajveer 14592 
    self.isReminder = isReminder
4303 rajveer 14593 
 
14594 
  def read(self, iprot):
14595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14597 
      return
14598 
    iprot.readStructBegin()
14599 
    while True:
14600 
      (fname, ftype, fid) = iprot.readFieldBegin()
14601 
      if ftype == TType.STOP:
14602 
        break
14603 
      if fid == 1:
14604 
        if ftype == TType.I64:
14605 
          self.vendorId = iprot.readI64();
14606 
        else:
14607 
          iprot.skip(ftype)
14608 
      elif fid == 2:
14609 
        if ftype == TType.I64:
14610 
          self.itemId = iprot.readI64();
14611 
        else:
14612 
          iprot.skip(ftype)
14613 
      elif fid == 3:
14614 
        if ftype == TType.I64:
14615 
          self.quantity = iprot.readI64();
14616 
        else:
14617 
          iprot.skip(ftype)
14618 
      elif fid == 4:
14619 
        if ftype == TType.I64:
14620 
          self.estimate = iprot.readI64();
14621 
        else:
14622 
          iprot.skip(ftype)
4369 rajveer 14623 
      elif fid == 5:
14624 
        if ftype == TType.BOOL:
14625 
          self.isReminder = iprot.readBool();
14626 
        else:
14627 
          iprot.skip(ftype)
4303 rajveer 14628 
      else:
14629 
        iprot.skip(ftype)
14630 
      iprot.readFieldEnd()
14631 
    iprot.readStructEnd()
14632 
 
14633 
  def write(self, oprot):
14634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14636 
      return
14637 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
14638 
    if self.vendorId is not None:
14639 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14640 
      oprot.writeI64(self.vendorId)
14641 
      oprot.writeFieldEnd()
14642 
    if self.itemId is not None:
14643 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14644 
      oprot.writeI64(self.itemId)
14645 
      oprot.writeFieldEnd()
14646 
    if self.quantity is not None:
14647 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14648 
      oprot.writeI64(self.quantity)
14649 
      oprot.writeFieldEnd()
14650 
    if self.estimate is not None:
14651 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14652 
      oprot.writeI64(self.estimate)
14653 
      oprot.writeFieldEnd()
4369 rajveer 14654 
    if self.isReminder is not None:
14655 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14656 
      oprot.writeBool(self.isReminder)
14657 
      oprot.writeFieldEnd()
4303 rajveer 14658 
    oprot.writeFieldStop()
14659 
    oprot.writeStructEnd()
14660 
 
14661 
  def validate(self):
14662 
    return
14663 
 
14664 
 
14665 
  def __repr__(self):
14666 
    L = ['%s=%r' % (key, value)
14667 
      for key, value in self.__dict__.iteritems()]
14668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14669 
 
14670 
  def __eq__(self, other):
14671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14672 
 
14673 
  def __ne__(self, other):
14674 
    return not (self == other)
14675 
 
14676 
class markOrdersAsNotAvailabke_result:
14677 
  """
14678 
  Attributes:
14679 
   - ex
14680 
  """
14681 
 
14682 
  thrift_spec = (
14683 
    None, # 0
14684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14685 
  )
14686 
 
14687 
  def __init__(self, ex=None,):
14688 
    self.ex = ex
14689 
 
14690 
  def read(self, iprot):
14691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14693 
      return
14694 
    iprot.readStructBegin()
14695 
    while True:
14696 
      (fname, ftype, fid) = iprot.readFieldBegin()
14697 
      if ftype == TType.STOP:
14698 
        break
14699 
      if fid == 1:
14700 
        if ftype == TType.STRUCT:
14701 
          self.ex = TransactionServiceException()
14702 
          self.ex.read(iprot)
14703 
        else:
14704 
          iprot.skip(ftype)
14705 
      else:
14706 
        iprot.skip(ftype)
14707 
      iprot.readFieldEnd()
14708 
    iprot.readStructEnd()
14709 
 
14710 
  def write(self, oprot):
14711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14713 
      return
14714 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
14715 
    if self.ex is not None:
14716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14717 
      self.ex.write(oprot)
14718 
      oprot.writeFieldEnd()
14719 
    oprot.writeFieldStop()
14720 
    oprot.writeStructEnd()
14721 
 
14722 
  def validate(self):
14723 
    return
14724 
 
14725 
 
14726 
  def __repr__(self):
14727 
    L = ['%s=%r' % (key, value)
14728 
      for key, value in self.__dict__.iteritems()]
14729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14730 
 
14731 
  def __eq__(self, other):
14732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14733 
 
14734 
  def __ne__(self, other):
14735 
    return not (self == other)
4369 rajveer 14736 
 
14737 
class markOrdersAsTimeout_args:
14738 
  """
14739 
  Attributes:
14740 
   - vendorId
14741 
  """
14742 
 
14743 
  thrift_spec = (
14744 
    None, # 0
14745 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14746 
  )
14747 
 
14748 
  def __init__(self, vendorId=None,):
14749 
    self.vendorId = vendorId
14750 
 
14751 
  def read(self, iprot):
14752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14754 
      return
14755 
    iprot.readStructBegin()
14756 
    while True:
14757 
      (fname, ftype, fid) = iprot.readFieldBegin()
14758 
      if ftype == TType.STOP:
14759 
        break
14760 
      if fid == 1:
14761 
        if ftype == TType.I64:
14762 
          self.vendorId = iprot.readI64();
14763 
        else:
14764 
          iprot.skip(ftype)
14765 
      else:
14766 
        iprot.skip(ftype)
14767 
      iprot.readFieldEnd()
14768 
    iprot.readStructEnd()
14769 
 
14770 
  def write(self, oprot):
14771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14773 
      return
14774 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
14775 
    if self.vendorId is not None:
14776 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14777 
      oprot.writeI64(self.vendorId)
14778 
      oprot.writeFieldEnd()
14779 
    oprot.writeFieldStop()
14780 
    oprot.writeStructEnd()
14781 
 
14782 
  def validate(self):
14783 
    return
14784 
 
14785 
 
14786 
  def __repr__(self):
14787 
    L = ['%s=%r' % (key, value)
14788 
      for key, value in self.__dict__.iteritems()]
14789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14790 
 
14791 
  def __eq__(self, other):
14792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14793 
 
14794 
  def __ne__(self, other):
14795 
    return not (self == other)
14796 
 
14797 
class markOrdersAsTimeout_result:
14798 
  """
14799 
  Attributes:
14800 
   - success
14801 
   - ex
14802 
  """
14803 
 
14804 
  thrift_spec = (
14805 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
14806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14807 
  )
14808 
 
14809 
  def __init__(self, success=None, ex=None,):
14810 
    self.success = success
14811 
    self.ex = ex
14812 
 
14813 
  def read(self, iprot):
14814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14816 
      return
14817 
    iprot.readStructBegin()
14818 
    while True:
14819 
      (fname, ftype, fid) = iprot.readFieldBegin()
14820 
      if ftype == TType.STOP:
14821 
        break
14822 
      if fid == 0:
14823 
        if ftype == TType.MAP:
14824 
          self.success = {}
14825 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
14826 
          for _i265 in xrange(_size261):
14827 
            _key266 = iprot.readI32();
14828 
            _val267 = TimeoutSummary()
14829 
            _val267.read(iprot)
14830 
            self.success[_key266] = _val267
14831 
          iprot.readMapEnd()
14832 
        else:
14833 
          iprot.skip(ftype)
14834 
      elif fid == 1:
14835 
        if ftype == TType.STRUCT:
14836 
          self.ex = TransactionServiceException()
14837 
          self.ex.read(iprot)
14838 
        else:
14839 
          iprot.skip(ftype)
14840 
      else:
14841 
        iprot.skip(ftype)
14842 
      iprot.readFieldEnd()
14843 
    iprot.readStructEnd()
14844 
 
14845 
  def write(self, oprot):
14846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14848 
      return
14849 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
14850 
    if self.success is not None:
14851 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14852 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
14853 
      for kiter268,viter269 in self.success.items():
14854 
        oprot.writeI32(kiter268)
14855 
        viter269.write(oprot)
14856 
      oprot.writeMapEnd()
14857 
      oprot.writeFieldEnd()
14858 
    if self.ex is not None:
14859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14860 
      self.ex.write(oprot)
14861 
      oprot.writeFieldEnd()
14862 
    oprot.writeFieldStop()
14863 
    oprot.writeStructEnd()
14864 
 
14865 
  def validate(self):
14866 
    return
14867 
 
14868 
 
14869 
  def __repr__(self):
14870 
    L = ['%s=%r' % (key, value)
14871 
      for key, value in self.__dict__.iteritems()]
14872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14873 
 
14874 
  def __eq__(self, other):
14875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14876 
 
14877 
  def __ne__(self, other):
14878 
    return not (self == other)
4386 anupam.sin 14879 
 
14880 
class getOrderForAwb_args:
14881 
  """
14882 
  Attributes:
14883 
   - awb
14884 
  """
14885 
 
14886 
  thrift_spec = (
14887 
    None, # 0
14888 
    (1, TType.STRING, 'awb', None, None, ), # 1
14889 
  )
14890 
 
14891 
  def __init__(self, awb=None,):
14892 
    self.awb = awb
14893 
 
14894 
  def read(self, iprot):
14895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14897 
      return
14898 
    iprot.readStructBegin()
14899 
    while True:
14900 
      (fname, ftype, fid) = iprot.readFieldBegin()
14901 
      if ftype == TType.STOP:
14902 
        break
14903 
      if fid == 1:
14904 
        if ftype == TType.STRING:
14905 
          self.awb = iprot.readString();
14906 
        else:
14907 
          iprot.skip(ftype)
14908 
      else:
14909 
        iprot.skip(ftype)
14910 
      iprot.readFieldEnd()
14911 
    iprot.readStructEnd()
14912 
 
14913 
  def write(self, oprot):
14914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14916 
      return
14917 
    oprot.writeStructBegin('getOrderForAwb_args')
14918 
    if self.awb is not None:
14919 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
14920 
      oprot.writeString(self.awb)
14921 
      oprot.writeFieldEnd()
14922 
    oprot.writeFieldStop()
14923 
    oprot.writeStructEnd()
14924 
 
14925 
  def validate(self):
14926 
    return
14927 
 
14928 
 
14929 
  def __repr__(self):
14930 
    L = ['%s=%r' % (key, value)
14931 
      for key, value in self.__dict__.iteritems()]
14932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14933 
 
14934 
  def __eq__(self, other):
14935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14936 
 
14937 
  def __ne__(self, other):
14938 
    return not (self == other)
14939 
 
14940 
class getOrderForAwb_result:
14941 
  """
14942 
  Attributes:
14943 
   - success
14944 
   - ex
14945 
  """
14946 
 
14947 
  thrift_spec = (
14948 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
14949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14950 
  )
14951 
 
14952 
  def __init__(self, success=None, ex=None,):
14953 
    self.success = success
14954 
    self.ex = ex
14955 
 
14956 
  def read(self, iprot):
14957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14959 
      return
14960 
    iprot.readStructBegin()
14961 
    while True:
14962 
      (fname, ftype, fid) = iprot.readFieldBegin()
14963 
      if ftype == TType.STOP:
14964 
        break
14965 
      if fid == 0:
14966 
        if ftype == TType.STRUCT:
14967 
          self.success = Order()
14968 
          self.success.read(iprot)
14969 
        else:
14970 
          iprot.skip(ftype)
14971 
      elif fid == 1:
14972 
        if ftype == TType.STRUCT:
14973 
          self.ex = TransactionServiceException()
14974 
          self.ex.read(iprot)
14975 
        else:
14976 
          iprot.skip(ftype)
14977 
      else:
14978 
        iprot.skip(ftype)
14979 
      iprot.readFieldEnd()
14980 
    iprot.readStructEnd()
14981 
 
14982 
  def write(self, oprot):
14983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14985 
      return
14986 
    oprot.writeStructBegin('getOrderForAwb_result')
14987 
    if self.success is not None:
14988 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14989 
      self.success.write(oprot)
14990 
      oprot.writeFieldEnd()
14991 
    if self.ex is not None:
14992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14993 
      self.ex.write(oprot)
14994 
      oprot.writeFieldEnd()
14995 
    oprot.writeFieldStop()
14996 
    oprot.writeStructEnd()
14997 
 
14998 
  def validate(self):
14999 
    return
15000 
 
15001 
 
15002 
  def __repr__(self):
15003 
    L = ['%s=%r' % (key, value)
15004 
      for key, value in self.__dict__.iteritems()]
15005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15006 
 
15007 
  def __eq__(self, other):
15008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15009 
 
15010 
  def __ne__(self, other):
15011 
    return not (self == other)