Subversion Repositories SmartDukaan

Rev

Rev 4452 | Rev 4479 | 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 
 
4454 rajveer 432 
  def markOrderDoaRequestReceived(self, orderId):
433 
    """
434 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
435 
 
436 
    Parameters:
437 
     - orderId
438 
    """
439 
    pass
440 
 
441 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
442 
    """
443 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
444 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
445 
 
446 
    Parameters:
447 
     - orderId
448 
     - isAuthorized
449 
    """
450 
    pass
451 
 
2536 chandransh 452 
  def requestPickupNumber(self, orderId):
453 
    """
454 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 455 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
456 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 457 
    For any other status, it returns false.
458 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 459 
 
2536 chandransh 460 
    Parameters:
461 
     - orderId
462 
    """
463 
    pass
464 
 
465 
  def authorizePickup(self, orderId, pickupNumber):
466 
    """
4452 rajveer 467 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 468 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
469 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
470 
    	3. Returns true
2591 chandransh 471 
    If the order is in any other status, it returns false.
2536 chandransh 472 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 473 
 
2536 chandransh 474 
    Parameters:
475 
     - orderId
476 
     - pickupNumber
477 
    """
478 
    pass
479 
 
2764 chandransh 480 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
481 
    """
482 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
483 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 484 
 
2764 chandransh 485 
    Parameters:
486 
     - providerId
487 
     - pickupDetails
488 
    """
489 
    pass
490 
 
2616 chandransh 491 
  def receiveReturn(self, orderId):
2591 chandransh 492 
    """
4452 rajveer 493 
    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 494 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 495 
    If the order is in any other state, it returns false.
496 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 497 
 
2591 chandransh 498 
    Parameters:
499 
     - orderId
500 
    """
501 
    pass
2536 chandransh 502 
 
2591 chandransh 503 
  def validateDoa(self, orderId, isValid):
504 
    """
4452 rajveer 505 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 506 
    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 507 
    If the order is in any other state, it returns false.
508 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 509 
 
2591 chandransh 510 
    Parameters:
511 
     - orderId
512 
     - isValid
513 
    """
514 
    pass
515 
 
2616 chandransh 516 
  def reshipOrder(self, orderId):
517 
    """
518 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
519 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
520 
    	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.
521 
 
522 
    If the order is in DOA_CERT_VALID state, it does the following:
523 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
524 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 525 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 526 
 
2616 chandransh 527 
    Returns the id of the newly created order.
3431 rajveer 528 
 
2616 chandransh 529 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 530 
 
2616 chandransh 531 
    Parameters:
532 
     - orderId
533 
    """
534 
    pass
2591 chandransh 535 
 
3226 chandransh 536 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 537 
    """
538 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
539 
    	1. Creates a refund request for batch processing.
540 
    	2. Creates a return order for the warehouse executive to return the shipped material.
541 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 542 
 
2616 chandransh 543 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
544 
    	1. Creates a refund request for batch processing.
3226 chandransh 545 
    	2. Cancels the reservation of the item in the warehouse.
546 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 547 
 
3226 chandransh 548 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
549 
    	1. Cancels the reservation of the item in the warehouse.
550 
    	2. Marks the current order as CANCELED.
551 
 
552 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
553 
 
2616 chandransh 554 
    Returns True if it is successful, False otherwise.
3431 rajveer 555 
 
2616 chandransh 556 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 557 
 
2616 chandransh 558 
    Parameters:
559 
     - orderId
3226 chandransh 560 
     - refundedBy
561 
     - reason
2616 chandransh 562 
    """
563 
    pass
564 
 
2690 chandransh 565 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
566 
    """
567 
    Get all return orders created between the from and to dates for the given warehouse.
568 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 569 
 
2690 chandransh 570 
    Parameters:
571 
     - warehouseId
572 
     - fromDate
573 
     - toDate
574 
    """
575 
    pass
2616 chandransh 576 
 
2700 chandransh 577 
  def getReturnOrder(self, id):
578 
    """
579 
    Returns the ReturnOrder corresponding to the given id.
580 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 581 
 
2700 chandransh 582 
    Parameters:
583 
     - id
584 
    """
585 
    pass
586 
 
2690 chandransh 587 
  def processReturn(self, returnOrderId):
588 
    """
589 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 590 
 
2690 chandransh 591 
    Parameters:
592 
     - returnOrderId
593 
    """
594 
    pass
595 
 
2819 chandransh 596 
  def createPurchaseOrder(self, warehouseId):
597 
    """
598 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 599 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 600 
 
2819 chandransh 601 
    Parameters:
602 
     - warehouseId
603 
    """
604 
    pass
2690 chandransh 605 
 
3451 chandransh 606 
  def updateWeight(self, orderId, weight):
607 
    """
608 
    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 609 
 
3451 chandransh 610 
    Parameters:
611 
     - orderId
612 
     - weight
613 
    """
614 
    pass
615 
 
3469 chandransh 616 
  def changeItem(self, orderId, itemId):
617 
    """
618 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
619 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 620 
 
3469 chandransh 621 
    Parameters:
622 
     - orderId
623 
     - itemId
624 
    """
625 
    pass
626 
 
627 
  def shiftToWarehouse(self, orderId, warehouseId):
628 
    """
629 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
630 
 
631 
    Parameters:
632 
     - orderId
633 
     - warehouseId
634 
    """
635 
    pass
636 
 
3986 chandransh 637 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 638 
    """
639 
    Adds the given delay reason to the given order.
3986 chandransh 640 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 641 
    Raises an exception if no order with the given id can be found.
3469 chandransh 642 
 
3553 chandransh 643 
    Parameters:
644 
     - orderId
645 
     - delayReason
3986 chandransh 646 
     - furtherDelay
3553 chandransh 647 
    """
648 
    pass
649 
 
3956 chandransh 650 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
651 
    """
652 
    Marks the COD orders with given AWB nos. as having been processed.
653 
    Updates the captured amount for the corresponding payment.
3553 chandransh 654 
 
3956 chandransh 655 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
656 
    1. There is no order corresponding to an AWB number.
657 
    2. The captured amount for a payment exceeds the total payment.
658 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
659 
 
660 
    Parameters:
661 
     - collectedAmountMap
662 
     - xferBy
663 
     - xferTxnId
664 
     - xferDate
665 
    """
666 
    pass
667 
 
4008 mandeep.dh 668 
  def getTransactionsRequiringExtraProcessing(self, category):
669 
    """
4065 mandeep.dh 670 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 671 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 672 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 673 
 
4008 mandeep.dh 674 
    Parameters:
675 
     - category
676 
    """
677 
    pass
678 
 
679 
  def markTransactionAsProcessed(self, transactionId, category):
680 
    """
681 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 682 
    It essentially deletes the transaction id record for a particular
683 
    processing type category (if present) from DB.
684 
    This is currently used by CRM application.
4008 mandeep.dh 685 
 
686 
    Parameters:
687 
     - transactionId
688 
     - category
689 
    """
690 
    pass
691 
 
4018 chandransh 692 
  def getItemWiseRiskyOrdersCount(self, ):
693 
    """
694 
    Returns a map containing the number of risky orders keyed by item id. A risky order
695 
    is defined as one whose shipping date is about to expire.
696 
    """
697 
    pass
4008 mandeep.dh 698 
 
4295 varun.gupt 699 
  def getOrdersForItemIds(self, itemIds):
700 
    """
701 
    Returns a list of all orders which have items with given id
702 
 
703 
    Parameters:
704 
     - itemIds
705 
    """
706 
    pass
707 
 
4247 rajveer 708 
  def markOrderCancellationRequestReceived(self, orderId):
709 
    """
710 
    Mark order as cancellation request received. If customer sends request of cancellation of
711 
    a particular order, this method will be called. It will just change status of the order
712 
    depending on its current status. It also records the previous status, so that we can move
713 
    back to that status if cancellation request is denied.
4018 chandransh 714 
 
4247 rajveer 715 
    Parameters:
716 
     - orderId
717 
    """
718 
    pass
719 
 
720 
  def markOrderCancellationRequestConfirmed(self, orderId):
721 
    """
722 
    If we decide to to cancel order, CRM will call this method to move the status of order to
723 
    cancellation request confirmed. After this OM will be able to cancel the order.
724 
 
725 
    Parameters:
726 
     - orderId
727 
    """
728 
    pass
729 
 
730 
  def markOrderCancellationRequestDenied(self, orderId):
731 
    """
732 
    If we decide to not to cancel order, we will move the order ro previous status.
733 
 
734 
    Parameters:
735 
     - orderId
736 
    """
737 
    pass
738 
 
4258 rajveer 739 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 740 
    """
4258 rajveer 741 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
742 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 743 
 
744 
    Parameters:
4258 rajveer 745 
     - transactionId
4247 rajveer 746 
    """
747 
    pass
748 
 
4259 anupam.sin 749 
  def refundTransaction(self, transactionId, refundedBy, reason):
750 
    """
751 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
752 
    need to be cancelled
4247 rajveer 753 
 
4259 anupam.sin 754 
    Parameters:
755 
     - transactionId
756 
     - refundedBy
757 
     - reason
758 
    """
759 
    pass
760 
 
4324 mandeep.dh 761 
  def updateShipmentAddress(self, orderId, addressId):
762 
    """
763 
    Updates shipment address of an order. Delivery and shipping date estimates
764 
    etc. are also updated here.
765 
 
766 
    Throws TransactionServiceException in case address change is not
767 
    possible due to certain reasons such as new pincode in address is
768 
    not serviceable etc.
769 
 
770 
    Parameters:
771 
     - orderId
772 
     - addressId
773 
    """
774 
    pass
775 
 
4285 rajveer 776 
  def acceptOrdersForItemId(self, itemId, inventory):
777 
    """
778 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
779 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 780 
 
4285 rajveer 781 
    Parameters:
782 
     - itemId
783 
     - inventory
784 
    """
785 
    pass
786 
 
4369 rajveer 787 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 788 
    """
789 
    Parameters:
790 
     - vendorId
791 
     - itemId
792 
     - quantity
793 
     - estimate
4369 rajveer 794 
     - isReminder
4303 rajveer 795 
    """
796 
    pass
4285 rajveer 797 
 
4369 rajveer 798 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 799 
    """
800 
    Parameters:
801 
     - vendorId
802 
     - itemId
803 
     - quantity
804 
     - estimate
4369 rajveer 805 
     - isReminder
4303 rajveer 806 
    """
807 
    pass
808 
 
4369 rajveer 809 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 810 
    """
811 
    Parameters:
812 
     - vendorId
813 
     - itemId
814 
     - quantity
815 
     - estimate
4369 rajveer 816 
     - isReminder
4303 rajveer 817 
    """
818 
    pass
819 
 
4369 rajveer 820 
  def markOrdersAsTimeout(self, vendorId):
821 
    """
822 
    Parameters:
823 
     - vendorId
824 
    """
825 
    pass
4303 rajveer 826 
 
4386 anupam.sin 827 
  def getOrderForAwb(self, awb):
828 
    """
829 
    Returns the order corresponding to an AWB number
4369 rajveer 830 
 
4386 anupam.sin 831 
    Parameters:
832 
     - awb
833 
    """
834 
    pass
835 
 
836 
 
3376 rajveer 837 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 838 
  def __init__(self, iprot, oprot=None):
3376 rajveer 839 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 840 
 
841 
  def createTransaction(self, transaction):
842 
    """
843 
    Parameters:
844 
     - transaction
845 
    """
846 
    self.send_createTransaction(transaction)
132 ashish 847 
    return self.recv_createTransaction()
94 ashish 848 
 
849 
  def send_createTransaction(self, transaction):
850 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
851 
    args = createTransaction_args()
852 
    args.transaction = transaction
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
857 
  def recv_createTransaction(self, ):
858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
864 
    result = createTransaction_result()
865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
3431 rajveer 867 
    if result.success is not None:
132 ashish 868 
      return result.success
3431 rajveer 869 
    if result.ex is not None:
94 ashish 870 
      raise result.ex
132 ashish 871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 872 
 
873 
  def getTransaction(self, id):
874 
    """
875 
    Parameters:
876 
     - id
877 
    """
878 
    self.send_getTransaction(id)
879 
    return self.recv_getTransaction()
880 
 
881 
  def send_getTransaction(self, id):
882 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
883 
    args = getTransaction_args()
884 
    args.id = id
885 
    args.write(self._oprot)
886 
    self._oprot.writeMessageEnd()
887 
    self._oprot.trans.flush()
888 
 
889 
  def recv_getTransaction(self, ):
890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
891 
    if mtype == TMessageType.EXCEPTION:
892 
      x = TApplicationException()
893 
      x.read(self._iprot)
894 
      self._iprot.readMessageEnd()
895 
      raise x
896 
    result = getTransaction_result()
897 
    result.read(self._iprot)
898 
    self._iprot.readMessageEnd()
3431 rajveer 899 
    if result.success is not None:
94 ashish 900 
      return result.success
3431 rajveer 901 
    if result.ex is not None:
94 ashish 902 
      raise result.ex
903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
904 
 
905 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
906 
    """
907 
    Parameters:
908 
     - customerId
909 
     - from_date
910 
     - to_date
911 
     - status
912 
    """
913 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
914 
    return self.recv_getTransactionsForCustomer()
915 
 
916 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
917 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
918 
    args = getTransactionsForCustomer_args()
919 
    args.customerId = customerId
920 
    args.from_date = from_date
921 
    args.to_date = to_date
922 
    args.status = status
923 
    args.write(self._oprot)
924 
    self._oprot.writeMessageEnd()
925 
    self._oprot.trans.flush()
926 
 
927 
  def recv_getTransactionsForCustomer(self, ):
928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
929 
    if mtype == TMessageType.EXCEPTION:
930 
      x = TApplicationException()
931 
      x.read(self._iprot)
932 
      self._iprot.readMessageEnd()
933 
      raise x
934 
    result = getTransactionsForCustomer_result()
935 
    result.read(self._iprot)
936 
    self._iprot.readMessageEnd()
3431 rajveer 937 
    if result.success is not None:
94 ashish 938 
      return result.success
3431 rajveer 939 
    if result.ex is not None:
94 ashish 940 
      raise result.ex
941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
942 
 
132 ashish 943 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
944 
    """
945 
    Parameters:
946 
     - shoppingCartId
947 
    """
948 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
949 
    return self.recv_getTransactionsForShoppingCartId()
950 
 
951 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
952 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
953 
    args = getTransactionsForShoppingCartId_args()
954 
    args.shoppingCartId = shoppingCartId
955 
    args.write(self._oprot)
956 
    self._oprot.writeMessageEnd()
957 
    self._oprot.trans.flush()
958 
 
959 
  def recv_getTransactionsForShoppingCartId(self, ):
960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
961 
    if mtype == TMessageType.EXCEPTION:
962 
      x = TApplicationException()
963 
      x.read(self._iprot)
964 
      self._iprot.readMessageEnd()
965 
      raise x
966 
    result = getTransactionsForShoppingCartId_result()
967 
    result.read(self._iprot)
968 
    self._iprot.readMessageEnd()
3431 rajveer 969 
    if result.success is not None:
132 ashish 970 
      return result.success
3431 rajveer 971 
    if result.ex is not None:
132 ashish 972 
      raise result.ex
973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
974 
 
94 ashish 975 
  def getTransactionStatus(self, transactionId):
976 
    """
977 
    Parameters:
978 
     - transactionId
979 
    """
980 
    self.send_getTransactionStatus(transactionId)
981 
    return self.recv_getTransactionStatus()
982 
 
983 
  def send_getTransactionStatus(self, transactionId):
984 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
985 
    args = getTransactionStatus_args()
986 
    args.transactionId = transactionId
987 
    args.write(self._oprot)
988 
    self._oprot.writeMessageEnd()
989 
    self._oprot.trans.flush()
990 
 
991 
  def recv_getTransactionStatus(self, ):
992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
993 
    if mtype == TMessageType.EXCEPTION:
994 
      x = TApplicationException()
995 
      x.read(self._iprot)
996 
      self._iprot.readMessageEnd()
997 
      raise x
998 
    result = getTransactionStatus_result()
999 
    result.read(self._iprot)
1000 
    self._iprot.readMessageEnd()
3431 rajveer 1001 
    if result.success is not None:
94 ashish 1002 
      return result.success
3431 rajveer 1003 
    if result.ex is not None:
94 ashish 1004 
      raise result.ex
1005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1006 
 
1007 
  def changeTransactionStatus(self, transactionId, status, description):
1008 
    """
1009 
    Parameters:
1010 
     - transactionId
1011 
     - status
1012 
     - description
1013 
    """
1014 
    self.send_changeTransactionStatus(transactionId, status, description)
1015 
    return self.recv_changeTransactionStatus()
1016 
 
1017 
  def send_changeTransactionStatus(self, transactionId, status, description):
1018 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1019 
    args = changeTransactionStatus_args()
1020 
    args.transactionId = transactionId
1021 
    args.status = status
1022 
    args.description = description
1023 
    args.write(self._oprot)
1024 
    self._oprot.writeMessageEnd()
1025 
    self._oprot.trans.flush()
1026 
 
1027 
  def recv_changeTransactionStatus(self, ):
1028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1029 
    if mtype == TMessageType.EXCEPTION:
1030 
      x = TApplicationException()
1031 
      x.read(self._iprot)
1032 
      self._iprot.readMessageEnd()
1033 
      raise x
1034 
    result = changeTransactionStatus_result()
1035 
    result.read(self._iprot)
1036 
    self._iprot.readMessageEnd()
3431 rajveer 1037 
    if result.success is not None:
94 ashish 1038 
      return result.success
3431 rajveer 1039 
    if result.ex is not None:
94 ashish 1040 
      raise result.ex
1041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1042 
 
1398 varun.gupt 1043 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1044 
    """
1045 
    Parameters:
1046 
     - transactionId
1047 
    """
1398 varun.gupt 1048 
    self.send_enqueueTransactionInfoEmail(transactionId)
1049 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1050 
 
1398 varun.gupt 1051 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1052 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1053 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1054 
    args.transactionId = transactionId
1055 
    args.write(self._oprot)
1056 
    self._oprot.writeMessageEnd()
1057 
    self._oprot.trans.flush()
1058 
 
1398 varun.gupt 1059 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1061 
    if mtype == TMessageType.EXCEPTION:
1062 
      x = TApplicationException()
1063 
      x.read(self._iprot)
1064 
      self._iprot.readMessageEnd()
1065 
      raise x
1398 varun.gupt 1066 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1067 
    result.read(self._iprot)
1068 
    self._iprot.readMessageEnd()
3431 rajveer 1069 
    if result.success is not None:
1382 varun.gupt 1070 
      return result.success
3431 rajveer 1071 
    if result.ex is not None:
1382 varun.gupt 1072 
      raise result.ex
1398 varun.gupt 1073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1074 
 
483 rajveer 1075 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1076 
    """
1077 
    Parameters:
483 rajveer 1078 
     - status
1079 
     - from_date
1080 
     - to_date
1081 
     - warehouse_id
94 ashish 1082 
    """
483 rajveer 1083 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1084 
    return self.recv_getAllOrders()
94 ashish 1085 
 
483 rajveer 1086 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1087 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1088 
    args = getAllOrders_args()
1089 
    args.status = status
1090 
    args.from_date = from_date
1091 
    args.to_date = to_date
1092 
    args.warehouse_id = warehouse_id
94 ashish 1093 
    args.write(self._oprot)
1094 
    self._oprot.writeMessageEnd()
1095 
    self._oprot.trans.flush()
1096 
 
483 rajveer 1097 
  def recv_getAllOrders(self, ):
94 ashish 1098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1099 
    if mtype == TMessageType.EXCEPTION:
1100 
      x = TApplicationException()
1101 
      x.read(self._iprot)
1102 
      self._iprot.readMessageEnd()
1103 
      raise x
483 rajveer 1104 
    result = getAllOrders_result()
94 ashish 1105 
    result.read(self._iprot)
1106 
    self._iprot.readMessageEnd()
3431 rajveer 1107 
    if result.success is not None:
94 ashish 1108 
      return result.success
3431 rajveer 1109 
    if result.ex is not None:
94 ashish 1110 
      raise result.ex
483 rajveer 1111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1112 
 
4133 chandransh 1113 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1114 
    """
1115 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1116 
    Pass the status as null and the limit as 0 to ignore them.
1117 
 
1118 
    Parameters:
1119 
     - statuses
1120 
     - offset
1121 
     - limit
1122 
     - warehouse_id
1123 
    """
1124 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1125 
    return self.recv_getOrdersInBatch()
1126 
 
1127 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1128 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1129 
    args = getOrdersInBatch_args()
1130 
    args.statuses = statuses
1131 
    args.offset = offset
1132 
    args.limit = limit
1133 
    args.warehouse_id = warehouse_id
1134 
    args.write(self._oprot)
1135 
    self._oprot.writeMessageEnd()
1136 
    self._oprot.trans.flush()
1137 
 
1138 
  def recv_getOrdersInBatch(self, ):
1139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1140 
    if mtype == TMessageType.EXCEPTION:
1141 
      x = TApplicationException()
1142 
      x.read(self._iprot)
1143 
      self._iprot.readMessageEnd()
1144 
      raise x
1145 
    result = getOrdersInBatch_result()
1146 
    result.read(self._iprot)
1147 
    self._iprot.readMessageEnd()
1148 
    if result.success is not None:
1149 
      return result.success
1150 
    if result.ex is not None:
1151 
      raise result.ex
1152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1153 
 
1154 
  def getOrderCount(self, statuses, warehouseId):
1155 
    """
1156 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1157 
 
1158 
    Parameters:
1159 
     - statuses
1160 
     - warehouseId
1161 
    """
1162 
    self.send_getOrderCount(statuses, warehouseId)
1163 
    return self.recv_getOrderCount()
1164 
 
1165 
  def send_getOrderCount(self, statuses, warehouseId):
1166 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1167 
    args = getOrderCount_args()
1168 
    args.statuses = statuses
1169 
    args.warehouseId = warehouseId
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_getOrderCount(self, ):
1175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1176 
    if mtype == TMessageType.EXCEPTION:
1177 
      x = TApplicationException()
1178 
      x.read(self._iprot)
1179 
      self._iprot.readMessageEnd()
1180 
      raise x
1181 
    result = getOrderCount_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
1184 
    if result.success is not None:
1185 
      return result.success
1186 
    if result.ex is not None:
1187 
      raise result.ex
1188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1189 
 
999 varun.gupt 1190 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1191 
    """
1132 chandransh 1192 
    Returns orders within a range of their billing dates
3431 rajveer 1193 
 
999 varun.gupt 1194 
    Parameters:
1195 
     - status
1196 
     - start_billing_date
1197 
     - end_billing_date
1198 
     - warehouse_id
1199 
    """
1200 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1201 
    return self.recv_getOrdersByBillingDate()
1202 
 
1203 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1204 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1205 
    args = getOrdersByBillingDate_args()
1206 
    args.status = status
1207 
    args.start_billing_date = start_billing_date
1208 
    args.end_billing_date = end_billing_date
1209 
    args.warehouse_id = warehouse_id
1210 
    args.write(self._oprot)
1211 
    self._oprot.writeMessageEnd()
1212 
    self._oprot.trans.flush()
1213 
 
1214 
  def recv_getOrdersByBillingDate(self, ):
1215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1216 
    if mtype == TMessageType.EXCEPTION:
1217 
      x = TApplicationException()
1218 
      x.read(self._iprot)
1219 
      self._iprot.readMessageEnd()
1220 
      raise x
1221 
    result = getOrdersByBillingDate_result()
1222 
    result.read(self._iprot)
1223 
    self._iprot.readMessageEnd()
3431 rajveer 1224 
    if result.success is not None:
999 varun.gupt 1225 
      return result.success
3431 rajveer 1226 
    if result.ex is not None:
999 varun.gupt 1227 
      raise result.ex
1228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1229 
 
3451 chandransh 1230 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1231 
    """
1232 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1233 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1234 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1235 
 
3427 chandransh 1236 
    Parameters:
1237 
     - fromShippingDate
1238 
     - toShippingDate
1239 
     - providerId
1240 
     - warehouseId
3451 chandransh 1241 
     - cod
3427 chandransh 1242 
    """
3451 chandransh 1243 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1244 
    return self.recv_getOrdersByShippingDate()
1245 
 
3451 chandransh 1246 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1247 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1248 
    args = getOrdersByShippingDate_args()
1249 
    args.fromShippingDate = fromShippingDate
1250 
    args.toShippingDate = toShippingDate
1251 
    args.providerId = providerId
1252 
    args.warehouseId = warehouseId
3451 chandransh 1253 
    args.cod = cod
3427 chandransh 1254 
    args.write(self._oprot)
1255 
    self._oprot.writeMessageEnd()
1256 
    self._oprot.trans.flush()
1257 
 
1258 
  def recv_getOrdersByShippingDate(self, ):
1259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1260 
    if mtype == TMessageType.EXCEPTION:
1261 
      x = TApplicationException()
1262 
      x.read(self._iprot)
1263 
      self._iprot.readMessageEnd()
1264 
      raise x
1265 
    result = getOrdersByShippingDate_result()
1266 
    result.read(self._iprot)
1267 
    self._iprot.readMessageEnd()
3431 rajveer 1268 
    if result.success is not None:
3427 chandransh 1269 
      return result.success
3431 rajveer 1270 
    if result.ex is not None:
3427 chandransh 1271 
      raise result.ex
1272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1273 
 
1382 varun.gupt 1274 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1275 
    """
1276 
    Returns order ids for orders which can be returned
3431 rajveer 1277 
 
1382 varun.gupt 1278 
    Parameters:
1279 
     - customer_id
1280 
     - limit
1281 
    """
1282 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1283 
    return self.recv_getReturnableOrdersForCustomer()
1284 
 
1285 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1286 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1287 
    args = getReturnableOrdersForCustomer_args()
1288 
    args.customer_id = customer_id
1289 
    args.limit = limit
1290 
    args.write(self._oprot)
1291 
    self._oprot.writeMessageEnd()
1292 
    self._oprot.trans.flush()
1293 
 
1294 
  def recv_getReturnableOrdersForCustomer(self, ):
1295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1296 
    if mtype == TMessageType.EXCEPTION:
1297 
      x = TApplicationException()
1298 
      x.read(self._iprot)
1299 
      self._iprot.readMessageEnd()
1300 
      raise x
1301 
    result = getReturnableOrdersForCustomer_result()
1302 
    result.read(self._iprot)
1303 
    self._iprot.readMessageEnd()
3431 rajveer 1304 
    if result.success is not None:
1382 varun.gupt 1305 
      return result.success
3431 rajveer 1306 
    if result.ex is not None:
1382 varun.gupt 1307 
      raise result.ex
1308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1309 
 
1310 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1311 
    """
1312 
    Returns order ids for orders which can be cancelled
3431 rajveer 1313 
 
1382 varun.gupt 1314 
    Parameters:
1315 
     - customer_id
1316 
     - limit
1317 
    """
1318 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1319 
    return self.recv_getCancellableOrdersForCustomer()
1320 
 
1321 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1322 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1323 
    args = getCancellableOrdersForCustomer_args()
1324 
    args.customer_id = customer_id
1325 
    args.limit = limit
1326 
    args.write(self._oprot)
1327 
    self._oprot.writeMessageEnd()
1328 
    self._oprot.trans.flush()
1329 
 
1330 
  def recv_getCancellableOrdersForCustomer(self, ):
1331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1332 
    if mtype == TMessageType.EXCEPTION:
1333 
      x = TApplicationException()
1334 
      x.read(self._iprot)
1335 
      self._iprot.readMessageEnd()
1336 
      raise x
1337 
    result = getCancellableOrdersForCustomer_result()
1338 
    result.read(self._iprot)
1339 
    self._iprot.readMessageEnd()
3431 rajveer 1340 
    if result.success is not None:
1382 varun.gupt 1341 
      return result.success
3431 rajveer 1342 
    if result.ex is not None:
1382 varun.gupt 1343 
      raise result.ex
1344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1345 
 
483 rajveer 1346 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1347 
    """
1348 
    Parameters:
483 rajveer 1349 
     - orderId
1350 
     - status
1351 
     - description
94 ashish 1352 
    """
483 rajveer 1353 
    self.send_changeOrderStatus(orderId, status, description)
1354 
    return self.recv_changeOrderStatus()
94 ashish 1355 
 
483 rajveer 1356 
  def send_changeOrderStatus(self, orderId, status, description):
1357 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1358 
    args = changeOrderStatus_args()
1359 
    args.orderId = orderId
1360 
    args.status = status
1361 
    args.description = description
94 ashish 1362 
    args.write(self._oprot)
1363 
    self._oprot.writeMessageEnd()
1364 
    self._oprot.trans.flush()
1365 
 
483 rajveer 1366 
  def recv_changeOrderStatus(self, ):
94 ashish 1367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1368 
    if mtype == TMessageType.EXCEPTION:
1369 
      x = TApplicationException()
1370 
      x.read(self._iprot)
1371 
      self._iprot.readMessageEnd()
1372 
      raise x
483 rajveer 1373 
    result = changeOrderStatus_result()
94 ashish 1374 
    result.read(self._iprot)
1375 
    self._iprot.readMessageEnd()
3431 rajveer 1376 
    if result.success is not None:
94 ashish 1377 
      return result.success
3431 rajveer 1378 
    if result.ex is not None:
94 ashish 1379 
      raise result.ex
483 rajveer 1380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1381 
 
1528 ankur.sing 1382 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1383 
    """
1528 ankur.sing 1384 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1385 
    only user who owns the transaction can view its order details.
3431 rajveer 1386 
 
94 ashish 1387 
    Parameters:
1388 
     - transactionId
1528 ankur.sing 1389 
     - customerId
94 ashish 1390 
    """
1528 ankur.sing 1391 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1392 
    return self.recv_getOrdersForTransaction()
94 ashish 1393 
 
1528 ankur.sing 1394 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1395 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1396 
    args = getOrdersForTransaction_args()
94 ashish 1397 
    args.transactionId = transactionId
1528 ankur.sing 1398 
    args.customerId = customerId
94 ashish 1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
483 rajveer 1403 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
483 rajveer 1410 
    result = getOrdersForTransaction_result()
94 ashish 1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
3431 rajveer 1413 
    if result.success is not None:
94 ashish 1414 
      return result.success
3431 rajveer 1415 
    if result.ex is not None:
94 ashish 1416 
      raise result.ex
483 rajveer 1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1418 
 
3014 chandransh 1419 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1420 
    """
3014 chandransh 1421 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1422 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1423 
 
94 ashish 1424 
    Parameters:
483 rajveer 1425 
     - customerId
1426 
     - from_date
1427 
     - to_date
3014 chandransh 1428 
     - statuses
94 ashish 1429 
    """
3014 chandransh 1430 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1431 
    return self.recv_getOrdersForCustomer()
94 ashish 1432 
 
3014 chandransh 1433 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1434 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1435 
    args = getOrdersForCustomer_args()
1436 
    args.customerId = customerId
1437 
    args.from_date = from_date
1438 
    args.to_date = to_date
3014 chandransh 1439 
    args.statuses = statuses
94 ashish 1440 
    args.write(self._oprot)
1441 
    self._oprot.writeMessageEnd()
1442 
    self._oprot.trans.flush()
1443 
 
483 rajveer 1444 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1446 
    if mtype == TMessageType.EXCEPTION:
1447 
      x = TApplicationException()
1448 
      x.read(self._iprot)
1449 
      self._iprot.readMessageEnd()
1450 
      raise x
483 rajveer 1451 
    result = getOrdersForCustomer_result()
94 ashish 1452 
    result.read(self._iprot)
1453 
    self._iprot.readMessageEnd()
3431 rajveer 1454 
    if result.success is not None:
94 ashish 1455 
      return result.success
3431 rajveer 1456 
    if result.ex is not None:
94 ashish 1457 
      raise result.ex
483 rajveer 1458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1459 
 
483 rajveer 1460 
  def createOrder(self, order):
94 ashish 1461 
    """
1462 
    Parameters:
483 rajveer 1463 
     - order
94 ashish 1464 
    """
483 rajveer 1465 
    self.send_createOrder(order)
1466 
    return self.recv_createOrder()
94 ashish 1467 
 
483 rajveer 1468 
  def send_createOrder(self, order):
1469 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1470 
    args = createOrder_args()
1471 
    args.order = order
94 ashish 1472 
    args.write(self._oprot)
1473 
    self._oprot.writeMessageEnd()
1474 
    self._oprot.trans.flush()
1475 
 
483 rajveer 1476 
  def recv_createOrder(self, ):
94 ashish 1477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1478 
    if mtype == TMessageType.EXCEPTION:
1479 
      x = TApplicationException()
1480 
      x.read(self._iprot)
1481 
      self._iprot.readMessageEnd()
1482 
      raise x
483 rajveer 1483 
    result = createOrder_result()
94 ashish 1484 
    result.read(self._iprot)
1485 
    self._iprot.readMessageEnd()
3431 rajveer 1486 
    if result.success is not None:
94 ashish 1487 
      return result.success
3431 rajveer 1488 
    if result.ex is not None:
94 ashish 1489 
      raise result.ex
483 rajveer 1490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1491 
 
483 rajveer 1492 
  def getOrder(self, id):
94 ashish 1493 
    """
1494 
    Parameters:
483 rajveer 1495 
     - id
94 ashish 1496 
    """
483 rajveer 1497 
    self.send_getOrder(id)
1498 
    return self.recv_getOrder()
94 ashish 1499 
 
483 rajveer 1500 
  def send_getOrder(self, id):
1501 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1502 
    args = getOrder_args()
1503 
    args.id = id
94 ashish 1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
483 rajveer 1508 
  def recv_getOrder(self, ):
94 ashish 1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
483 rajveer 1515 
    result = getOrder_result()
94 ashish 1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
3431 rajveer 1518 
    if result.success is not None:
94 ashish 1519 
      return result.success
3431 rajveer 1520 
    if result.ex is not None:
94 ashish 1521 
      raise result.ex
483 rajveer 1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1523 
 
483 rajveer 1524 
  def getLineItemsForOrder(self, orderId):
94 ashish 1525 
    """
1526 
    Parameters:
483 rajveer 1527 
     - orderId
94 ashish 1528 
    """
483 rajveer 1529 
    self.send_getLineItemsForOrder(orderId)
1530 
    return self.recv_getLineItemsForOrder()
94 ashish 1531 
 
483 rajveer 1532 
  def send_getLineItemsForOrder(self, orderId):
1533 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1534 
    args = getLineItemsForOrder_args()
1535 
    args.orderId = orderId
94 ashish 1536 
    args.write(self._oprot)
1537 
    self._oprot.writeMessageEnd()
1538 
    self._oprot.trans.flush()
1539 
 
483 rajveer 1540 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1542 
    if mtype == TMessageType.EXCEPTION:
1543 
      x = TApplicationException()
1544 
      x.read(self._iprot)
1545 
      self._iprot.readMessageEnd()
1546 
      raise x
483 rajveer 1547 
    result = getLineItemsForOrder_result()
94 ashish 1548 
    result.read(self._iprot)
1549 
    self._iprot.readMessageEnd()
3431 rajveer 1550 
    if result.success is not None:
94 ashish 1551 
      return result.success
3431 rajveer 1552 
    if result.ex is not None:
94 ashish 1553 
      raise result.ex
483 rajveer 1554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1555 
 
1528 ankur.sing 1556 
  def getOrderForCustomer(self, orderId, customerId):
1557 
    """
1558 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1559 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1560 
 
1528 ankur.sing 1561 
    Parameters:
1562 
     - orderId
1563 
     - customerId
1564 
    """
1565 
    self.send_getOrderForCustomer(orderId, customerId)
1566 
    return self.recv_getOrderForCustomer()
1567 
 
1568 
  def send_getOrderForCustomer(self, orderId, customerId):
1569 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1570 
    args = getOrderForCustomer_args()
1571 
    args.orderId = orderId
1572 
    args.customerId = customerId
1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
1577 
  def recv_getOrderForCustomer(self, ):
1578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1579 
    if mtype == TMessageType.EXCEPTION:
1580 
      x = TApplicationException()
1581 
      x.read(self._iprot)
1582 
      self._iprot.readMessageEnd()
1583 
      raise x
1584 
    result = getOrderForCustomer_result()
1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
3431 rajveer 1587 
    if result.success is not None:
1528 ankur.sing 1588 
      return result.success
3431 rajveer 1589 
    if result.ex is not None:
1528 ankur.sing 1590 
      raise result.ex
1591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1592 
 
4444 rajveer 1593 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1594 
    """
1595 
    Parameters:
4394 rajveer 1596 
     - type
4444 rajveer 1597 
     - warehouseId
4394 rajveer 1598 
     - status
1599 
     - timestamp
3064 chandransh 1600 
    """
4444 rajveer 1601 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1602 
    return self.recv_getAlerts()
1603 
 
4444 rajveer 1604 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1605 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1606 
    args = getAlerts_args()
4394 rajveer 1607 
    args.type = type
4444 rajveer 1608 
    args.warehouseId = warehouseId
4394 rajveer 1609 
    args.status = status
1610 
    args.timestamp = timestamp
3064 chandransh 1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
1615 
  def recv_getAlerts(self, ):
1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
1622 
    result = getAlerts_result()
1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
3431 rajveer 1625 
    if result.success is not None:
3064 chandransh 1626 
      return result.success
1627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1628 
 
4444 rajveer 1629 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1630 
    """
1631 
    Parameters:
1632 
     - type
4444 rajveer 1633 
     - warehouseId
4394 rajveer 1634 
     - description
3064 chandransh 1635 
    """
4444 rajveer 1636 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1637 
    self.recv_addAlert()
3064 chandransh 1638 
 
4444 rajveer 1639 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1640 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1641 
    args = addAlert_args()
3064 chandransh 1642 
    args.type = type
4444 rajveer 1643 
    args.warehouseId = warehouseId
4394 rajveer 1644 
    args.description = description
3064 chandransh 1645 
    args.write(self._oprot)
1646 
    self._oprot.writeMessageEnd()
1647 
    self._oprot.trans.flush()
1648 
 
4394 rajveer 1649 
  def recv_addAlert(self, ):
3064 chandransh 1650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1651 
    if mtype == TMessageType.EXCEPTION:
1652 
      x = TApplicationException()
1653 
      x.read(self._iprot)
1654 
      self._iprot.readMessageEnd()
1655 
      raise x
4394 rajveer 1656 
    result = addAlert_result()
3064 chandransh 1657 
    result.read(self._iprot)
1658 
    self._iprot.readMessageEnd()
1659 
    return
1660 
 
4444 rajveer 1661 
  def markAlertsAsSeen(self, warehouseId):
1662 
    """
1663 
    Parameters:
1664 
     - warehouseId
1665 
    """
1666 
    self.send_markAlertsAsSeen(warehouseId)
1667 
    self.recv_markAlertsAsSeen()
1668 
 
1669 
  def send_markAlertsAsSeen(self, warehouseId):
1670 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1671 
    args = markAlertsAsSeen_args()
1672 
    args.warehouseId = warehouseId
1673 
    args.write(self._oprot)
1674 
    self._oprot.writeMessageEnd()
1675 
    self._oprot.trans.flush()
1676 
 
1677 
  def recv_markAlertsAsSeen(self, ):
1678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1679 
    if mtype == TMessageType.EXCEPTION:
1680 
      x = TApplicationException()
1681 
      x.read(self._iprot)
1682 
      self._iprot.readMessageEnd()
1683 
      raise x
1684 
    result = markAlertsAsSeen_result()
1685 
    result.read(self._iprot)
1686 
    self._iprot.readMessageEnd()
1687 
    return
1688 
 
3064 chandransh 1689 
  def getValidOrderCount(self, ):
1690 
    """
1691 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1692 
    """
1693 
    self.send_getValidOrderCount()
1694 
    return self.recv_getValidOrderCount()
1695 
 
1696 
  def send_getValidOrderCount(self, ):
1697 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1698 
    args = getValidOrderCount_args()
1699 
    args.write(self._oprot)
1700 
    self._oprot.writeMessageEnd()
1701 
    self._oprot.trans.flush()
1702 
 
1703 
  def recv_getValidOrderCount(self, ):
1704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1705 
    if mtype == TMessageType.EXCEPTION:
1706 
      x = TApplicationException()
1707 
      x.read(self._iprot)
1708 
      self._iprot.readMessageEnd()
1709 
      raise x
1710 
    result = getValidOrderCount_result()
1711 
    result.read(self._iprot)
1712 
    self._iprot.readMessageEnd()
3431 rajveer 1713 
    if result.success is not None:
3064 chandransh 1714 
      return result.success
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1716 
 
1717 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1718 
    """
1719 
    Returns the number of distinct customers who have done successful transactions
1720 
    """
1721 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1722 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1723 
 
1724 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1725 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1726 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1727 
    args.write(self._oprot)
1728 
    self._oprot.writeMessageEnd()
1729 
    self._oprot.trans.flush()
1730 
 
1731 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1733 
    if mtype == TMessageType.EXCEPTION:
1734 
      x = TApplicationException()
1735 
      x.read(self._iprot)
1736 
      self._iprot.readMessageEnd()
1737 
      raise x
1738 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1739 
    result.read(self._iprot)
1740 
    self._iprot.readMessageEnd()
3431 rajveer 1741 
    if result.success is not None:
3064 chandransh 1742 
      return result.success
1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1744 
 
1745 
  def getValidOrdersAmountRange(self, ):
1746 
    """
1747 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1748 
    List contains two values, first minimum amount and second maximum amount.
1749 
    """
1750 
    self.send_getValidOrdersAmountRange()
1751 
    return self.recv_getValidOrdersAmountRange()
1752 
 
1753 
  def send_getValidOrdersAmountRange(self, ):
1754 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1755 
    args = getValidOrdersAmountRange_args()
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getValidOrdersAmountRange(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getValidOrdersAmountRange_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
3431 rajveer 1770 
    if result.success is not None:
3064 chandransh 1771 
      return result.success
1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1773 
 
1774 
  def getValidOrders(self, limit):
1775 
    """
1776 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1777 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1778 
 
3064 chandransh 1779 
    Parameters:
1780 
     - limit
1781 
    """
1782 
    self.send_getValidOrders(limit)
1783 
    return self.recv_getValidOrders()
1784 
 
1785 
  def send_getValidOrders(self, limit):
1786 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1787 
    args = getValidOrders_args()
1788 
    args.limit = limit
1789 
    args.write(self._oprot)
1790 
    self._oprot.writeMessageEnd()
1791 
    self._oprot.trans.flush()
1792 
 
1793 
  def recv_getValidOrders(self, ):
1794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1795 
    if mtype == TMessageType.EXCEPTION:
1796 
      x = TApplicationException()
1797 
      x.read(self._iprot)
1798 
      self._iprot.readMessageEnd()
1799 
      raise x
1800 
    result = getValidOrders_result()
1801 
    result.read(self._iprot)
1802 
    self._iprot.readMessageEnd()
3431 rajveer 1803 
    if result.success is not None:
3064 chandransh 1804 
      return result.success
1805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1806 
 
1220 chandransh 1807 
  def batchOrders(self, warehouseId):
1808 
    """
1809 
    Create a batch of all the pending orders for the given warehouse.
1810 
    The returned list is orderd by created_timestamp.
1811 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1812 
 
1220 chandransh 1813 
    Parameters:
1814 
     - warehouseId
1815 
    """
1816 
    self.send_batchOrders(warehouseId)
1817 
    return self.recv_batchOrders()
1818 
 
1819 
  def send_batchOrders(self, warehouseId):
1820 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1821 
    args = batchOrders_args()
1822 
    args.warehouseId = warehouseId
1823 
    args.write(self._oprot)
1824 
    self._oprot.writeMessageEnd()
1825 
    self._oprot.trans.flush()
1826 
 
1827 
  def recv_batchOrders(self, ):
1828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1829 
    if mtype == TMessageType.EXCEPTION:
1830 
      x = TApplicationException()
1831 
      x.read(self._iprot)
1832 
      self._iprot.readMessageEnd()
1833 
      raise x
1834 
    result = batchOrders_result()
1835 
    result.read(self._iprot)
1836 
    self._iprot.readMessageEnd()
3431 rajveer 1837 
    if result.success is not None:
1220 chandransh 1838 
      return result.success
3431 rajveer 1839 
    if result.ex is not None:
1220 chandransh 1840 
      raise result.ex
1841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1842 
 
1208 chandransh 1843 
  def markOrderAsOutOfStock(self, orderId):
1844 
    """
1845 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1846 
 
1208 chandransh 1847 
    Parameters:
1848 
     - orderId
1849 
    """
1850 
    self.send_markOrderAsOutOfStock(orderId)
1851 
    return self.recv_markOrderAsOutOfStock()
1852 
 
1853 
  def send_markOrderAsOutOfStock(self, orderId):
1854 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1855 
    args = markOrderAsOutOfStock_args()
1856 
    args.orderId = orderId
1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
1861 
  def recv_markOrderAsOutOfStock(self, ):
1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
1868 
    result = markOrderAsOutOfStock_result()
1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
3431 rajveer 1871 
    if result.success is not None:
1208 chandransh 1872 
      return result.success
3431 rajveer 1873 
    if result.ex is not None:
1208 chandransh 1874 
      raise result.ex
1875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1876 
 
3064 chandransh 1877 
  def verifyOrder(self, orderId):
759 chandransh 1878 
    """
3064 chandransh 1879 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1880 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1881 
    used for all other orders as well.
1882 
    Throws an exception if no such order exists.
3431 rajveer 1883 
 
759 chandransh 1884 
    Parameters:
3064 chandransh 1885 
     - orderId
759 chandransh 1886 
    """
3064 chandransh 1887 
    self.send_verifyOrder(orderId)
1888 
    return self.recv_verifyOrder()
759 chandransh 1889 
 
3064 chandransh 1890 
  def send_verifyOrder(self, orderId):
1891 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1892 
    args = verifyOrder_args()
1893 
    args.orderId = orderId
759 chandransh 1894 
    args.write(self._oprot)
1895 
    self._oprot.writeMessageEnd()
1896 
    self._oprot.trans.flush()
1897 
 
3064 chandransh 1898 
  def recv_verifyOrder(self, ):
759 chandransh 1899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1900 
    if mtype == TMessageType.EXCEPTION:
1901 
      x = TApplicationException()
1902 
      x.read(self._iprot)
1903 
      self._iprot.readMessageEnd()
1904 
      raise x
3064 chandransh 1905 
    result = verifyOrder_result()
759 chandransh 1906 
    result.read(self._iprot)
1907 
    self._iprot.readMessageEnd()
3431 rajveer 1908 
    if result.success is not None:
759 chandransh 1909 
      return result.success
3431 rajveer 1910 
    if result.ex is not None:
759 chandransh 1911 
      raise result.ex
3064 chandransh 1912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1913 
 
3064 chandransh 1914 
  def acceptOrder(self, orderId):
1113 chandransh 1915 
    """
3064 chandransh 1916 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1917 
    given order is not a COD order, it also captures the payment if the same has
1918 
    not been captured.
1919 
    Throws an exception if no such order exists.
3431 rajveer 1920 
 
1113 chandransh 1921 
    Parameters:
3064 chandransh 1922 
     - orderId
1113 chandransh 1923 
    """
3064 chandransh 1924 
    self.send_acceptOrder(orderId)
1925 
    return self.recv_acceptOrder()
1113 chandransh 1926 
 
3064 chandransh 1927 
  def send_acceptOrder(self, orderId):
1928 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1929 
    args = acceptOrder_args()
1930 
    args.orderId = orderId
1113 chandransh 1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
3064 chandransh 1935 
  def recv_acceptOrder(self, ):
1113 chandransh 1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
3064 chandransh 1942 
    result = acceptOrder_result()
1113 chandransh 1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
3431 rajveer 1945 
    if result.success is not None:
1113 chandransh 1946 
      return result.success
3431 rajveer 1947 
    if result.ex is not None:
1113 chandransh 1948 
      raise result.ex
3064 chandransh 1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1950 
 
4283 anupam.sin 1951 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1952 
    """
3064 chandransh 1953 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1954 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1955 
    the IMEI no. if a -1 is supplied.
1956 
    Also, it generates an invoice number for the order, marks the order as
1957 
    BILLED and sets the billing timestamp.
1958 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1959 
 
1135 chandransh 1960 
    Parameters:
3064 chandransh 1961 
     - orderId
1962 
     - invoice_number
4283 anupam.sin 1963 
     - imeiNumber
1964 
     - itemNumber
3064 chandransh 1965 
     - billed_by
4264 rajveer 1966 
     - jacketNumber
4283 anupam.sin 1967 
     - billingType
1968 
     - vendorId
1135 chandransh 1969 
    """
4283 anupam.sin 1970 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1971 
    return self.recv_addBillingDetails()
1135 chandransh 1972 
 
4283 anupam.sin 1973 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1974 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1975 
    args = addBillingDetails_args()
1976 
    args.orderId = orderId
1977 
    args.invoice_number = invoice_number
4283 anupam.sin 1978 
    args.imeiNumber = imeiNumber
1979 
    args.itemNumber = itemNumber
3064 chandransh 1980 
    args.billed_by = billed_by
4264 rajveer 1981 
    args.jacketNumber = jacketNumber
4283 anupam.sin 1982 
    args.billingType = billingType
1983 
    args.vendorId = vendorId
1135 chandransh 1984 
    args.write(self._oprot)
1985 
    self._oprot.writeMessageEnd()
1986 
    self._oprot.trans.flush()
1987 
 
3064 chandransh 1988 
  def recv_addBillingDetails(self, ):
1135 chandransh 1989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1990 
    if mtype == TMessageType.EXCEPTION:
1991 
      x = TApplicationException()
1992 
      x.read(self._iprot)
1993 
      self._iprot.readMessageEnd()
1994 
      raise x
3064 chandransh 1995 
    result = addBillingDetails_result()
1135 chandransh 1996 
    result.read(self._iprot)
1997 
    self._iprot.readMessageEnd()
3431 rajveer 1998 
    if result.success is not None:
3064 chandransh 1999 
      return result.success
3431 rajveer 2000 
    if result.ex is not None:
1135 chandransh 2001 
      raise result.ex
3064 chandransh 2002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2003 
 
3064 chandransh 2004 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2005 
    """
3064 chandransh 2006 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2007 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2008 
 
1408 ankur.sing 2009 
    Parameters:
3064 chandransh 2010 
     - warehouseId
1408 ankur.sing 2011 
     - providerId
3064 chandransh 2012 
     - cod
1408 ankur.sing 2013 
    """
3064 chandransh 2014 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2015 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2016 
 
3064 chandransh 2017 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2018 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2019 
    args = markOrdersAsManifested_args()
2020 
    args.warehouseId = warehouseId
1408 ankur.sing 2021 
    args.providerId = providerId
3064 chandransh 2022 
    args.cod = cod
1408 ankur.sing 2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
3064 chandransh 2027 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
3064 chandransh 2034 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
3431 rajveer 2037 
    if result.success is not None:
1408 ankur.sing 2038 
      return result.success
3431 rajveer 2039 
    if result.ex is not None:
3064 chandransh 2040 
      raise result.ex
2041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2042 
 
4410 rajveer 2043 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2044 
    """
2045 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2046 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2047 
 
2048 
    Parameters:
2049 
     - warehouseId
2050 
     - providerId
2051 
     - cod
2052 
    """
2053 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2054 
    return self.recv_markOrdersAsShippedFromWarehouse()
2055 
 
2056 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2057 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2058 
    args = markOrdersAsShippedFromWarehouse_args()
2059 
    args.warehouseId = warehouseId
2060 
    args.providerId = providerId
2061 
    args.cod = cod
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = markOrdersAsShippedFromWarehouse_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
2076 
    if result.success is not None:
2077 
      return result.success
2078 
    if result.ex is not None:
2079 
      raise result.ex
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2081 
 
3064 chandransh 2082 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2083 
    """
3064 chandransh 2084 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2085 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2086 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2087 
 
94 ashish 2088 
    Parameters:
3064 chandransh 2089 
     - providerId
2090 
     - pickupDetails
304 ashish 2091 
    """
3064 chandransh 2092 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2093 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2094 
 
3064 chandransh 2095 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2096 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2097 
    args = markOrdersAsPickedUp_args()
2098 
    args.providerId = providerId
2099 
    args.pickupDetails = pickupDetails
304 ashish 2100 
    args.write(self._oprot)
2101 
    self._oprot.writeMessageEnd()
2102 
    self._oprot.trans.flush()
2103 
 
3064 chandransh 2104 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2106 
    if mtype == TMessageType.EXCEPTION:
2107 
      x = TApplicationException()
2108 
      x.read(self._iprot)
2109 
      self._iprot.readMessageEnd()
2110 
      raise x
3064 chandransh 2111 
    result = markOrdersAsPickedUp_result()
304 ashish 2112 
    result.read(self._iprot)
2113 
    self._iprot.readMessageEnd()
3431 rajveer 2114 
    if result.success is not None:
304 ashish 2115 
      return result.success
3431 rajveer 2116 
    if result.ex is not None:
3064 chandransh 2117 
      raise result.ex
2118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2119 
 
3064 chandransh 2120 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2121 
    """
3064 chandransh 2122 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2123 
    the name of the receiver.
2124 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2125 
 
304 ashish 2126 
    Parameters:
3064 chandransh 2127 
     - providerId
2128 
     - deliveredOrders
304 ashish 2129 
    """
3064 chandransh 2130 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2131 
    self.recv_markOrdersAsDelivered()
304 ashish 2132 
 
3064 chandransh 2133 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2134 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2135 
    args = markOrdersAsDelivered_args()
2136 
    args.providerId = providerId
2137 
    args.deliveredOrders = deliveredOrders
304 ashish 2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
3064 chandransh 2142 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
3064 chandransh 2149 
    result = markOrdersAsDelivered_result()
304 ashish 2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
3431 rajveer 2152 
    if result.ex is not None:
3064 chandransh 2153 
      raise result.ex
304 ashish 2154 
    return
2155 
 
3064 chandransh 2156 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2157 
    """
3064 chandransh 2158 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2159 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2160 
 
3064 chandransh 2161 
    Parameters:
2162 
     - providerId
2163 
     - returnedOrders
1596 ankur.sing 2164 
    """
3064 chandransh 2165 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2166 
    self.recv_markOrdersAsFailed()
304 ashish 2167 
 
3064 chandransh 2168 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2169 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2170 
    args = markOrdersAsFailed_args()
2171 
    args.providerId = providerId
2172 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
3064 chandransh 2177 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
3064 chandransh 2184 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
3431 rajveer 2187 
    if result.ex is not None:
3064 chandransh 2188 
      raise result.ex
2189 
    return
1596 ankur.sing 2190 
 
3064 chandransh 2191 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2192 
    """
3064 chandransh 2193 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2194 
 
3064 chandransh 2195 
    Parameters:
2196 
     - providerId
2197 
     - undeliveredOrders
1627 ankur.sing 2198 
    """
3064 chandransh 2199 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2200 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2201 
 
3064 chandransh 2202 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2203 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2204 
    args = updateNonDeliveryReason_args()
2205 
    args.providerId = providerId
2206 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2207 
    args.write(self._oprot)
2208 
    self._oprot.writeMessageEnd()
2209 
    self._oprot.trans.flush()
2210 
 
3064 chandransh 2211 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2213 
    if mtype == TMessageType.EXCEPTION:
2214 
      x = TApplicationException()
2215 
      x.read(self._iprot)
2216 
      self._iprot.readMessageEnd()
2217 
      raise x
3064 chandransh 2218 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2219 
    result.read(self._iprot)
2220 
    self._iprot.readMessageEnd()
3431 rajveer 2221 
    if result.ex is not None:
3064 chandransh 2222 
      raise result.ex
2223 
    return
1627 ankur.sing 2224 
 
3064 chandransh 2225 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2226 
    """
3064 chandransh 2227 
    Returns the list of orders whose delivery time has passed but have not been
2228 
    delivered yet for the given provider and warehouse. To get a complete list of
2229 
    undelivered orders, pass them as -1.
2230 
    Returns an empty list if no such orders exist.
3431 rajveer 2231 
 
1886 ankur.sing 2232 
    Parameters:
3064 chandransh 2233 
     - providerId
2234 
     - warehouseId
1886 ankur.sing 2235 
    """
3064 chandransh 2236 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2237 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2238 
 
3064 chandransh 2239 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2240 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2241 
    args = getUndeliveredOrders_args()
2242 
    args.providerId = providerId
2243 
    args.warehouseId = warehouseId
1886 ankur.sing 2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
3064 chandransh 2248 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
3064 chandransh 2255 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
3431 rajveer 2258 
    if result.success is not None:
1886 ankur.sing 2259 
      return result.success
3064 chandransh 2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2261 
 
2536 chandransh 2262 
  def toggleDOAFlag(self, orderId):
2263 
    """
2264 
    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.
2265 
    Returns the final flag status.
2266 
    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 2267 
 
2536 chandransh 2268 
    Parameters:
2269 
     - orderId
2270 
    """
2271 
    self.send_toggleDOAFlag(orderId)
2272 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2273 
 
2536 chandransh 2274 
  def send_toggleDOAFlag(self, orderId):
2275 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2276 
    args = toggleDOAFlag_args()
2277 
    args.orderId = orderId
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_toggleDOAFlag(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = toggleDOAFlag_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
3431 rajveer 2292 
    if result.success is not None:
2536 chandransh 2293 
      return result.success
3431 rajveer 2294 
    if result.ex is not None:
2536 chandransh 2295 
      raise result.ex
2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2297 
 
4454 rajveer 2298 
  def markOrderDoaRequestReceived(self, orderId):
2299 
    """
2300 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2301 
 
2302 
    Parameters:
2303 
     - orderId
2304 
    """
2305 
    self.send_markOrderDoaRequestReceived(orderId)
2306 
    return self.recv_markOrderDoaRequestReceived()
2307 
 
2308 
  def send_markOrderDoaRequestReceived(self, orderId):
2309 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2310 
    args = markOrderDoaRequestReceived_args()
2311 
    args.orderId = orderId
2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
2316 
  def recv_markOrderDoaRequestReceived(self, ):
2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
2323 
    result = markOrderDoaRequestReceived_result()
2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
2326 
    if result.success is not None:
2327 
      return result.success
2328 
    if result.ex is not None:
2329 
      raise result.ex
2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2331 
 
2332 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2333 
    """
2334 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2335 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2336 
 
2337 
    Parameters:
2338 
     - orderId
2339 
     - isAuthorized
2340 
    """
2341 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2342 
    return self.recv_markOrderDoaRequestAuthorized()
2343 
 
2344 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2345 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2346 
    args = markOrderDoaRequestAuthorized_args()
2347 
    args.orderId = orderId
2348 
    args.isAuthorized = isAuthorized
2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
2353 
  def recv_markOrderDoaRequestAuthorized(self, ):
2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
2360 
    result = markOrderDoaRequestAuthorized_result()
2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
2363 
    if result.success is not None:
2364 
      return result.success
2365 
    if result.ex is not None:
2366 
      raise result.ex
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2368 
 
2536 chandransh 2369 
  def requestPickupNumber(self, orderId):
2370 
    """
2371 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2372 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2373 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2374 
    For any other status, it returns false.
2375 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2376 
 
2536 chandransh 2377 
    Parameters:
2378 
     - orderId
2379 
    """
2380 
    self.send_requestPickupNumber(orderId)
2381 
    return self.recv_requestPickupNumber()
2382 
 
2383 
  def send_requestPickupNumber(self, orderId):
2384 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2385 
    args = requestPickupNumber_args()
2386 
    args.orderId = orderId
2387 
    args.write(self._oprot)
2388 
    self._oprot.writeMessageEnd()
2389 
    self._oprot.trans.flush()
2390 
 
2391 
  def recv_requestPickupNumber(self, ):
2392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2393 
    if mtype == TMessageType.EXCEPTION:
2394 
      x = TApplicationException()
2395 
      x.read(self._iprot)
2396 
      self._iprot.readMessageEnd()
2397 
      raise x
2398 
    result = requestPickupNumber_result()
2399 
    result.read(self._iprot)
2400 
    self._iprot.readMessageEnd()
3431 rajveer 2401 
    if result.success is not None:
2536 chandransh 2402 
      return result.success
3431 rajveer 2403 
    if result.ex is not None:
2536 chandransh 2404 
      raise result.ex
2405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2406 
 
2407 
  def authorizePickup(self, orderId, pickupNumber):
2408 
    """
4452 rajveer 2409 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2410 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2411 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2412 
    	3. Returns true
2591 chandransh 2413 
    If the order is in any other status, it returns false.
2536 chandransh 2414 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2415 
 
2536 chandransh 2416 
    Parameters:
2417 
     - orderId
2418 
     - pickupNumber
2419 
    """
2420 
    self.send_authorizePickup(orderId, pickupNumber)
2421 
    return self.recv_authorizePickup()
2422 
 
2423 
  def send_authorizePickup(self, orderId, pickupNumber):
2424 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2425 
    args = authorizePickup_args()
2426 
    args.orderId = orderId
2427 
    args.pickupNumber = pickupNumber
2428 
    args.write(self._oprot)
2429 
    self._oprot.writeMessageEnd()
2430 
    self._oprot.trans.flush()
2431 
 
2432 
  def recv_authorizePickup(self, ):
2433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2434 
    if mtype == TMessageType.EXCEPTION:
2435 
      x = TApplicationException()
2436 
      x.read(self._iprot)
2437 
      self._iprot.readMessageEnd()
2438 
      raise x
2439 
    result = authorizePickup_result()
2440 
    result.read(self._iprot)
2441 
    self._iprot.readMessageEnd()
3431 rajveer 2442 
    if result.success is not None:
2536 chandransh 2443 
      return result.success
3431 rajveer 2444 
    if result.ex is not None:
2536 chandransh 2445 
      raise result.ex
2446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2447 
 
2764 chandransh 2448 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2449 
    """
2450 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2451 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2452 
 
2764 chandransh 2453 
    Parameters:
2454 
     - providerId
2455 
     - pickupDetails
2456 
    """
2457 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2458 
    return self.recv_markDoasAsPickedUp()
2459 
 
2460 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2461 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2462 
    args = markDoasAsPickedUp_args()
2463 
    args.providerId = providerId
2464 
    args.pickupDetails = pickupDetails
2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
2469 
  def recv_markDoasAsPickedUp(self, ):
2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
2476 
    result = markDoasAsPickedUp_result()
2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
3431 rajveer 2479 
    if result.success is not None:
2764 chandransh 2480 
      return result.success
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2482 
 
2616 chandransh 2483 
  def receiveReturn(self, orderId):
2591 chandransh 2484 
    """
4452 rajveer 2485 
    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 2486 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 2487 
    If the order is in any other state, it returns false.
2488 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2489 
 
2591 chandransh 2490 
    Parameters:
2491 
     - orderId
2492 
    """
2616 chandransh 2493 
    self.send_receiveReturn(orderId)
2494 
    return self.recv_receiveReturn()
2536 chandransh 2495 
 
2616 chandransh 2496 
  def send_receiveReturn(self, orderId):
2497 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2498 
    args = receiveReturn_args()
2591 chandransh 2499 
    args.orderId = orderId
2500 
    args.write(self._oprot)
2501 
    self._oprot.writeMessageEnd()
2502 
    self._oprot.trans.flush()
2503 
 
2616 chandransh 2504 
  def recv_receiveReturn(self, ):
2591 chandransh 2505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2506 
    if mtype == TMessageType.EXCEPTION:
2507 
      x = TApplicationException()
2508 
      x.read(self._iprot)
2509 
      self._iprot.readMessageEnd()
2510 
      raise x
2616 chandransh 2511 
    result = receiveReturn_result()
2591 chandransh 2512 
    result.read(self._iprot)
2513 
    self._iprot.readMessageEnd()
3431 rajveer 2514 
    if result.success is not None:
2591 chandransh 2515 
      return result.success
3431 rajveer 2516 
    if result.ex is not None:
2591 chandransh 2517 
      raise result.ex
2616 chandransh 2518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2519 
 
2520 
  def validateDoa(self, orderId, isValid):
2521 
    """
4452 rajveer 2522 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2523 
    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 2524 
    If the order is in any other state, it returns false.
2525 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2526 
 
2591 chandransh 2527 
    Parameters:
2528 
     - orderId
2529 
     - isValid
2530 
    """
2531 
    self.send_validateDoa(orderId, isValid)
2532 
    return self.recv_validateDoa()
2533 
 
2534 
  def send_validateDoa(self, orderId, isValid):
2535 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2536 
    args = validateDoa_args()
2537 
    args.orderId = orderId
2538 
    args.isValid = isValid
2539 
    args.write(self._oprot)
2540 
    self._oprot.writeMessageEnd()
2541 
    self._oprot.trans.flush()
2542 
 
2543 
  def recv_validateDoa(self, ):
2544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2545 
    if mtype == TMessageType.EXCEPTION:
2546 
      x = TApplicationException()
2547 
      x.read(self._iprot)
2548 
      self._iprot.readMessageEnd()
2549 
      raise x
2550 
    result = validateDoa_result()
2551 
    result.read(self._iprot)
2552 
    self._iprot.readMessageEnd()
3431 rajveer 2553 
    if result.success is not None:
2591 chandransh 2554 
      return result.success
3431 rajveer 2555 
    if result.ex is not None:
2591 chandransh 2556 
      raise result.ex
2557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2558 
 
2616 chandransh 2559 
  def reshipOrder(self, orderId):
2560 
    """
2561 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2562 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2563 
    	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.
2564 
 
2565 
    If the order is in DOA_CERT_VALID state, it does the following:
2566 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2567 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2568 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2569 
 
2616 chandransh 2570 
    Returns the id of the newly created order.
3431 rajveer 2571 
 
2616 chandransh 2572 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2573 
 
2616 chandransh 2574 
    Parameters:
2575 
     - orderId
2576 
    """
2577 
    self.send_reshipOrder(orderId)
2578 
    return self.recv_reshipOrder()
2591 chandransh 2579 
 
2616 chandransh 2580 
  def send_reshipOrder(self, orderId):
2581 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2582 
    args = reshipOrder_args()
2583 
    args.orderId = orderId
2584 
    args.write(self._oprot)
2585 
    self._oprot.writeMessageEnd()
2586 
    self._oprot.trans.flush()
2587 
 
2588 
  def recv_reshipOrder(self, ):
2589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2590 
    if mtype == TMessageType.EXCEPTION:
2591 
      x = TApplicationException()
2592 
      x.read(self._iprot)
2593 
      self._iprot.readMessageEnd()
2594 
      raise x
2595 
    result = reshipOrder_result()
2596 
    result.read(self._iprot)
2597 
    self._iprot.readMessageEnd()
3431 rajveer 2598 
    if result.success is not None:
2616 chandransh 2599 
      return result.success
3431 rajveer 2600 
    if result.ex is not None:
2616 chandransh 2601 
      raise result.ex
2602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2603 
 
3226 chandransh 2604 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2605 
    """
2606 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2607 
    	1. Creates a refund request for batch processing.
2608 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2609 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2610 
 
2616 chandransh 2611 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2612 
    	1. Creates a refund request for batch processing.
3226 chandransh 2613 
    	2. Cancels the reservation of the item in the warehouse.
2614 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2615 
 
3226 chandransh 2616 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2617 
    	1. Cancels the reservation of the item in the warehouse.
2618 
    	2. Marks the current order as CANCELED.
2619 
 
2620 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2621 
 
2616 chandransh 2622 
    Returns True if it is successful, False otherwise.
3431 rajveer 2623 
 
2616 chandransh 2624 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2625 
 
2616 chandransh 2626 
    Parameters:
2627 
     - orderId
3226 chandransh 2628 
     - refundedBy
2629 
     - reason
2616 chandransh 2630 
    """
3226 chandransh 2631 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2632 
    return self.recv_refundOrder()
2633 
 
3226 chandransh 2634 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2635 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2636 
    args = refundOrder_args()
2637 
    args.orderId = orderId
3226 chandransh 2638 
    args.refundedBy = refundedBy
2639 
    args.reason = reason
2616 chandransh 2640 
    args.write(self._oprot)
2641 
    self._oprot.writeMessageEnd()
2642 
    self._oprot.trans.flush()
2643 
 
2644 
  def recv_refundOrder(self, ):
2645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2646 
    if mtype == TMessageType.EXCEPTION:
2647 
      x = TApplicationException()
2648 
      x.read(self._iprot)
2649 
      self._iprot.readMessageEnd()
2650 
      raise x
2651 
    result = refundOrder_result()
2652 
    result.read(self._iprot)
2653 
    self._iprot.readMessageEnd()
3431 rajveer 2654 
    if result.success is not None:
2616 chandransh 2655 
      return result.success
3431 rajveer 2656 
    if result.ex is not None:
2616 chandransh 2657 
      raise result.ex
2658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2659 
 
2690 chandransh 2660 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2661 
    """
2662 
    Get all return orders created between the from and to dates for the given warehouse.
2663 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2664 
 
2690 chandransh 2665 
    Parameters:
2666 
     - warehouseId
2667 
     - fromDate
2668 
     - toDate
2669 
    """
2670 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2671 
    return self.recv_getReturnOrders()
2616 chandransh 2672 
 
2690 chandransh 2673 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2674 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2675 
    args = getReturnOrders_args()
2676 
    args.warehouseId = warehouseId
2677 
    args.fromDate = fromDate
2678 
    args.toDate = toDate
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_getReturnOrders(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = getReturnOrders_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
3431 rajveer 2693 
    if result.success is not None:
2690 chandransh 2694 
      return result.success
2695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2696 
 
2700 chandransh 2697 
  def getReturnOrder(self, id):
2698 
    """
2699 
    Returns the ReturnOrder corresponding to the given id.
2700 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2701 
 
2700 chandransh 2702 
    Parameters:
2703 
     - id
2704 
    """
2705 
    self.send_getReturnOrder(id)
2706 
    return self.recv_getReturnOrder()
2707 
 
2708 
  def send_getReturnOrder(self, id):
2709 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2710 
    args = getReturnOrder_args()
2711 
    args.id = id
2712 
    args.write(self._oprot)
2713 
    self._oprot.writeMessageEnd()
2714 
    self._oprot.trans.flush()
2715 
 
2716 
  def recv_getReturnOrder(self, ):
2717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2718 
    if mtype == TMessageType.EXCEPTION:
2719 
      x = TApplicationException()
2720 
      x.read(self._iprot)
2721 
      self._iprot.readMessageEnd()
2722 
      raise x
2723 
    result = getReturnOrder_result()
2724 
    result.read(self._iprot)
2725 
    self._iprot.readMessageEnd()
3431 rajveer 2726 
    if result.success is not None:
2700 chandransh 2727 
      return result.success
3431 rajveer 2728 
    if result.ex is not None:
2700 chandransh 2729 
      raise result.ex
2730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2731 
 
2690 chandransh 2732 
  def processReturn(self, returnOrderId):
2733 
    """
2734 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2735 
 
2690 chandransh 2736 
    Parameters:
2737 
     - returnOrderId
2738 
    """
2739 
    self.send_processReturn(returnOrderId)
2740 
    self.recv_processReturn()
2741 
 
2742 
  def send_processReturn(self, returnOrderId):
2743 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2744 
    args = processReturn_args()
2745 
    args.returnOrderId = returnOrderId
2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
2750 
  def recv_processReturn(self, ):
2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
2757 
    result = processReturn_result()
2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
3431 rajveer 2760 
    if result.ex is not None:
2690 chandransh 2761 
      raise result.ex
2762 
    return
2763 
 
2819 chandransh 2764 
  def createPurchaseOrder(self, warehouseId):
2765 
    """
2766 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2767 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2768 
 
2819 chandransh 2769 
    Parameters:
2770 
     - warehouseId
2771 
    """
2772 
    self.send_createPurchaseOrder(warehouseId)
2773 
    return self.recv_createPurchaseOrder()
2690 chandransh 2774 
 
2819 chandransh 2775 
  def send_createPurchaseOrder(self, warehouseId):
2776 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2777 
    args = createPurchaseOrder_args()
2778 
    args.warehouseId = warehouseId
2779 
    args.write(self._oprot)
2780 
    self._oprot.writeMessageEnd()
2781 
    self._oprot.trans.flush()
2782 
 
2783 
  def recv_createPurchaseOrder(self, ):
2784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2785 
    if mtype == TMessageType.EXCEPTION:
2786 
      x = TApplicationException()
2787 
      x.read(self._iprot)
2788 
      self._iprot.readMessageEnd()
2789 
      raise x
2790 
    result = createPurchaseOrder_result()
2791 
    result.read(self._iprot)
2792 
    self._iprot.readMessageEnd()
3431 rajveer 2793 
    if result.success is not None:
2819 chandransh 2794 
      return result.success
3431 rajveer 2795 
    if result.ex is not None:
2819 chandransh 2796 
      raise result.ex
2797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2798 
 
3451 chandransh 2799 
  def updateWeight(self, orderId, weight):
2800 
    """
2801 
    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 2802 
 
3451 chandransh 2803 
    Parameters:
2804 
     - orderId
2805 
     - weight
2806 
    """
2807 
    self.send_updateWeight(orderId, weight)
2808 
    return self.recv_updateWeight()
2809 
 
2810 
  def send_updateWeight(self, orderId, weight):
2811 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2812 
    args = updateWeight_args()
2813 
    args.orderId = orderId
2814 
    args.weight = weight
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_updateWeight(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = updateWeight_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
2829 
    if result.success is not None:
2830 
      return result.success
2831 
    if result.ex is not None:
2832 
      raise result.ex
2833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2834 
 
3469 chandransh 2835 
  def changeItem(self, orderId, itemId):
2836 
    """
2837 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2838 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2839 
 
3469 chandransh 2840 
    Parameters:
2841 
     - orderId
2842 
     - itemId
2843 
    """
2844 
    self.send_changeItem(orderId, itemId)
2845 
    return self.recv_changeItem()
2846 
 
2847 
  def send_changeItem(self, orderId, itemId):
2848 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2849 
    args = changeItem_args()
2850 
    args.orderId = orderId
2851 
    args.itemId = itemId
2852 
    args.write(self._oprot)
2853 
    self._oprot.writeMessageEnd()
2854 
    self._oprot.trans.flush()
2855 
 
2856 
  def recv_changeItem(self, ):
2857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2858 
    if mtype == TMessageType.EXCEPTION:
2859 
      x = TApplicationException()
2860 
      x.read(self._iprot)
2861 
      self._iprot.readMessageEnd()
2862 
      raise x
2863 
    result = changeItem_result()
2864 
    result.read(self._iprot)
2865 
    self._iprot.readMessageEnd()
2866 
    if result.success is not None:
2867 
      return result.success
2868 
    if result.ex is not None:
2869 
      raise result.ex
2870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2871 
 
2872 
  def shiftToWarehouse(self, orderId, warehouseId):
2873 
    """
2874 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2875 
 
2876 
    Parameters:
2877 
     - orderId
2878 
     - warehouseId
2879 
    """
2880 
    self.send_shiftToWarehouse(orderId, warehouseId)
2881 
    return self.recv_shiftToWarehouse()
2882 
 
2883 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2884 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2885 
    args = shiftToWarehouse_args()
2886 
    args.orderId = orderId
2887 
    args.warehouseId = warehouseId
2888 
    args.write(self._oprot)
2889 
    self._oprot.writeMessageEnd()
2890 
    self._oprot.trans.flush()
2891 
 
2892 
  def recv_shiftToWarehouse(self, ):
2893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2894 
    if mtype == TMessageType.EXCEPTION:
2895 
      x = TApplicationException()
2896 
      x.read(self._iprot)
2897 
      self._iprot.readMessageEnd()
2898 
      raise x
2899 
    result = shiftToWarehouse_result()
2900 
    result.read(self._iprot)
2901 
    self._iprot.readMessageEnd()
2902 
    if result.success is not None:
2903 
      return result.success
2904 
    if result.ex is not None:
2905 
      raise result.ex
2906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
2907 
 
3986 chandransh 2908 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2909 
    """
2910 
    Adds the given delay reason to the given order.
3986 chandransh 2911 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 2912 
    Raises an exception if no order with the given id can be found.
3469 chandransh 2913 
 
3553 chandransh 2914 
    Parameters:
2915 
     - orderId
2916 
     - delayReason
3986 chandransh 2917 
     - furtherDelay
3553 chandransh 2918 
    """
3986 chandransh 2919 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 2920 
    return self.recv_addDelayReason()
2921 
 
3986 chandransh 2922 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 2923 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
2924 
    args = addDelayReason_args()
2925 
    args.orderId = orderId
2926 
    args.delayReason = delayReason
3986 chandransh 2927 
    args.furtherDelay = furtherDelay
3553 chandransh 2928 
    args.write(self._oprot)
2929 
    self._oprot.writeMessageEnd()
2930 
    self._oprot.trans.flush()
2931 
 
2932 
  def recv_addDelayReason(self, ):
2933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2934 
    if mtype == TMessageType.EXCEPTION:
2935 
      x = TApplicationException()
2936 
      x.read(self._iprot)
2937 
      self._iprot.readMessageEnd()
2938 
      raise x
2939 
    result = addDelayReason_result()
2940 
    result.read(self._iprot)
2941 
    self._iprot.readMessageEnd()
2942 
    if result.success is not None:
2943 
      return result.success
2944 
    if result.ex is not None:
2945 
      raise result.ex
2946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
2947 
 
3956 chandransh 2948 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2949 
    """
2950 
    Marks the COD orders with given AWB nos. as having been processed.
2951 
    Updates the captured amount for the corresponding payment.
3553 chandransh 2952 
 
3956 chandransh 2953 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
2954 
    1. There is no order corresponding to an AWB number.
2955 
    2. The captured amount for a payment exceeds the total payment.
2956 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
2957 
 
2958 
    Parameters:
2959 
     - collectedAmountMap
2960 
     - xferBy
2961 
     - xferTxnId
2962 
     - xferDate
2963 
    """
2964 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
2965 
    return self.recv_reconcileCodCollection()
2966 
 
2967 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
2968 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
2969 
    args = reconcileCodCollection_args()
2970 
    args.collectedAmountMap = collectedAmountMap
2971 
    args.xferBy = xferBy
2972 
    args.xferTxnId = xferTxnId
2973 
    args.xferDate = xferDate
2974 
    args.write(self._oprot)
2975 
    self._oprot.writeMessageEnd()
2976 
    self._oprot.trans.flush()
2977 
 
2978 
  def recv_reconcileCodCollection(self, ):
2979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2980 
    if mtype == TMessageType.EXCEPTION:
2981 
      x = TApplicationException()
2982 
      x.read(self._iprot)
2983 
      self._iprot.readMessageEnd()
2984 
      raise x
2985 
    result = reconcileCodCollection_result()
2986 
    result.read(self._iprot)
2987 
    self._iprot.readMessageEnd()
2988 
    if result.success is not None:
2989 
      return result.success
2990 
    if result.ex is not None:
2991 
      raise result.ex
2992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
2993 
 
4008 mandeep.dh 2994 
  def getTransactionsRequiringExtraProcessing(self, category):
2995 
    """
4065 mandeep.dh 2996 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 2997 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 2998 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 2999 
 
4008 mandeep.dh 3000 
    Parameters:
3001 
     - category
3002 
    """
3003 
    self.send_getTransactionsRequiringExtraProcessing(category)
3004 
    return self.recv_getTransactionsRequiringExtraProcessing()
3005 
 
3006 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3007 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3008 
    args = getTransactionsRequiringExtraProcessing_args()
3009 
    args.category = category
3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = getTransactionsRequiringExtraProcessing_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    if result.success is not None:
3025 
      return result.success
3026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3027 
 
3028 
  def markTransactionAsProcessed(self, transactionId, category):
3029 
    """
3030 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3031 
    It essentially deletes the transaction id record for a particular
3032 
    processing type category (if present) from DB.
3033 
    This is currently used by CRM application.
4008 mandeep.dh 3034 
 
3035 
    Parameters:
3036 
     - transactionId
3037 
     - category
3038 
    """
3039 
    self.send_markTransactionAsProcessed(transactionId, category)
3040 
    self.recv_markTransactionAsProcessed()
3041 
 
3042 
  def send_markTransactionAsProcessed(self, transactionId, category):
3043 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3044 
    args = markTransactionAsProcessed_args()
3045 
    args.transactionId = transactionId
3046 
    args.category = category
3047 
    args.write(self._oprot)
3048 
    self._oprot.writeMessageEnd()
3049 
    self._oprot.trans.flush()
3050 
 
3051 
  def recv_markTransactionAsProcessed(self, ):
3052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3053 
    if mtype == TMessageType.EXCEPTION:
3054 
      x = TApplicationException()
3055 
      x.read(self._iprot)
3056 
      self._iprot.readMessageEnd()
3057 
      raise x
3058 
    result = markTransactionAsProcessed_result()
3059 
    result.read(self._iprot)
3060 
    self._iprot.readMessageEnd()
3061 
    return
3062 
 
4018 chandransh 3063 
  def getItemWiseRiskyOrdersCount(self, ):
3064 
    """
3065 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3066 
    is defined as one whose shipping date is about to expire.
3067 
    """
3068 
    self.send_getItemWiseRiskyOrdersCount()
3069 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3070 
 
4018 chandransh 3071 
  def send_getItemWiseRiskyOrdersCount(self, ):
3072 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3073 
    args = getItemWiseRiskyOrdersCount_args()
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = getItemWiseRiskyOrdersCount_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.success is not None:
3089 
      return result.success
3090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3091 
 
4295 varun.gupt 3092 
  def getOrdersForItemIds(self, itemIds):
3093 
    """
3094 
    Returns a list of all orders which have items with given id
3095 
 
3096 
    Parameters:
3097 
     - itemIds
3098 
    """
3099 
    self.send_getOrdersForItemIds(itemIds)
3100 
    return self.recv_getOrdersForItemIds()
3101 
 
3102 
  def send_getOrdersForItemIds(self, itemIds):
3103 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3104 
    args = getOrdersForItemIds_args()
3105 
    args.itemIds = itemIds
3106 
    args.write(self._oprot)
3107 
    self._oprot.writeMessageEnd()
3108 
    self._oprot.trans.flush()
3109 
 
3110 
  def recv_getOrdersForItemIds(self, ):
3111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3112 
    if mtype == TMessageType.EXCEPTION:
3113 
      x = TApplicationException()
3114 
      x.read(self._iprot)
3115 
      self._iprot.readMessageEnd()
3116 
      raise x
3117 
    result = getOrdersForItemIds_result()
3118 
    result.read(self._iprot)
3119 
    self._iprot.readMessageEnd()
3120 
    if result.success is not None:
3121 
      return result.success
3122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3123 
 
4247 rajveer 3124 
  def markOrderCancellationRequestReceived(self, orderId):
3125 
    """
3126 
    Mark order as cancellation request received. If customer sends request of cancellation of
3127 
    a particular order, this method will be called. It will just change status of the order
3128 
    depending on its current status. It also records the previous status, so that we can move
3129 
    back to that status if cancellation request is denied.
4018 chandransh 3130 
 
4247 rajveer 3131 
    Parameters:
3132 
     - orderId
3133 
    """
3134 
    self.send_markOrderCancellationRequestReceived(orderId)
3135 
    self.recv_markOrderCancellationRequestReceived()
3136 
 
3137 
  def send_markOrderCancellationRequestReceived(self, orderId):
3138 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3139 
    args = markOrderCancellationRequestReceived_args()
3140 
    args.orderId = orderId
3141 
    args.write(self._oprot)
3142 
    self._oprot.writeMessageEnd()
3143 
    self._oprot.trans.flush()
3144 
 
3145 
  def recv_markOrderCancellationRequestReceived(self, ):
3146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3147 
    if mtype == TMessageType.EXCEPTION:
3148 
      x = TApplicationException()
3149 
      x.read(self._iprot)
3150 
      self._iprot.readMessageEnd()
3151 
      raise x
3152 
    result = markOrderCancellationRequestReceived_result()
3153 
    result.read(self._iprot)
3154 
    self._iprot.readMessageEnd()
3155 
    if result.ex is not None:
3156 
      raise result.ex
3157 
    return
3158 
 
3159 
  def markOrderCancellationRequestConfirmed(self, orderId):
3160 
    """
3161 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3162 
    cancellation request confirmed. After this OM will be able to cancel the order.
3163 
 
3164 
    Parameters:
3165 
     - orderId
3166 
    """
3167 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3168 
    self.recv_markOrderCancellationRequestConfirmed()
3169 
 
3170 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3171 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3172 
    args = markOrderCancellationRequestConfirmed_args()
3173 
    args.orderId = orderId
3174 
    args.write(self._oprot)
3175 
    self._oprot.writeMessageEnd()
3176 
    self._oprot.trans.flush()
3177 
 
3178 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3180 
    if mtype == TMessageType.EXCEPTION:
3181 
      x = TApplicationException()
3182 
      x.read(self._iprot)
3183 
      self._iprot.readMessageEnd()
3184 
      raise x
3185 
    result = markOrderCancellationRequestConfirmed_result()
3186 
    result.read(self._iprot)
3187 
    self._iprot.readMessageEnd()
3188 
    if result.ex is not None:
3189 
      raise result.ex
3190 
    return
3191 
 
3192 
  def markOrderCancellationRequestDenied(self, orderId):
3193 
    """
3194 
    If we decide to not to cancel order, we will move the order ro previous status.
3195 
 
3196 
    Parameters:
3197 
     - orderId
3198 
    """
3199 
    self.send_markOrderCancellationRequestDenied(orderId)
3200 
    self.recv_markOrderCancellationRequestDenied()
3201 
 
3202 
  def send_markOrderCancellationRequestDenied(self, orderId):
3203 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3204 
    args = markOrderCancellationRequestDenied_args()
3205 
    args.orderId = orderId
3206 
    args.write(self._oprot)
3207 
    self._oprot.writeMessageEnd()
3208 
    self._oprot.trans.flush()
3209 
 
3210 
  def recv_markOrderCancellationRequestDenied(self, ):
3211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3212 
    if mtype == TMessageType.EXCEPTION:
3213 
      x = TApplicationException()
3214 
      x.read(self._iprot)
3215 
      self._iprot.readMessageEnd()
3216 
      raise x
3217 
    result = markOrderCancellationRequestDenied_result()
3218 
    result.read(self._iprot)
3219 
    self._iprot.readMessageEnd()
3220 
    if result.ex is not None:
3221 
      raise result.ex
3222 
    return
3223 
 
4258 rajveer 3224 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3225 
    """
4258 rajveer 3226 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3227 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3228 
 
3229 
    Parameters:
4258 rajveer 3230 
     - transactionId
4247 rajveer 3231 
    """
4258 rajveer 3232 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3233 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3234 
 
4258 rajveer 3235 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3236 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3237 
    args = markTransactionAsPaymentFlagRemoved_args()
3238 
    args.transactionId = transactionId
4247 rajveer 3239 
    args.write(self._oprot)
3240 
    self._oprot.writeMessageEnd()
3241 
    self._oprot.trans.flush()
3242 
 
4258 rajveer 3243 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3245 
    if mtype == TMessageType.EXCEPTION:
3246 
      x = TApplicationException()
3247 
      x.read(self._iprot)
3248 
      self._iprot.readMessageEnd()
3249 
      raise x
4258 rajveer 3250 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3251 
    result.read(self._iprot)
3252 
    self._iprot.readMessageEnd()
3253 
    if result.ex is not None:
3254 
      raise result.ex
3255 
    return
3256 
 
4259 anupam.sin 3257 
  def refundTransaction(self, transactionId, refundedBy, reason):
3258 
    """
3259 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3260 
    need to be cancelled
4247 rajveer 3261 
 
4259 anupam.sin 3262 
    Parameters:
3263 
     - transactionId
3264 
     - refundedBy
3265 
     - reason
3266 
    """
3267 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3268 
    self.recv_refundTransaction()
3269 
 
3270 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3271 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3272 
    args = refundTransaction_args()
3273 
    args.transactionId = transactionId
3274 
    args.refundedBy = refundedBy
3275 
    args.reason = reason
3276 
    args.write(self._oprot)
3277 
    self._oprot.writeMessageEnd()
3278 
    self._oprot.trans.flush()
3279 
 
3280 
  def recv_refundTransaction(self, ):
3281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3282 
    if mtype == TMessageType.EXCEPTION:
3283 
      x = TApplicationException()
3284 
      x.read(self._iprot)
3285 
      self._iprot.readMessageEnd()
3286 
      raise x
3287 
    result = refundTransaction_result()
3288 
    result.read(self._iprot)
3289 
    self._iprot.readMessageEnd()
3290 
    if result.ex is not None:
3291 
      raise result.ex
3292 
    return
3293 
 
4324 mandeep.dh 3294 
  def updateShipmentAddress(self, orderId, addressId):
3295 
    """
3296 
    Updates shipment address of an order. Delivery and shipping date estimates
3297 
    etc. are also updated here.
3298 
 
3299 
    Throws TransactionServiceException in case address change is not
3300 
    possible due to certain reasons such as new pincode in address is
3301 
    not serviceable etc.
3302 
 
3303 
    Parameters:
3304 
     - orderId
3305 
     - addressId
3306 
    """
3307 
    self.send_updateShipmentAddress(orderId, addressId)
3308 
    self.recv_updateShipmentAddress()
3309 
 
3310 
  def send_updateShipmentAddress(self, orderId, addressId):
3311 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3312 
    args = updateShipmentAddress_args()
3313 
    args.orderId = orderId
3314 
    args.addressId = addressId
3315 
    args.write(self._oprot)
3316 
    self._oprot.writeMessageEnd()
3317 
    self._oprot.trans.flush()
3318 
 
3319 
  def recv_updateShipmentAddress(self, ):
3320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3321 
    if mtype == TMessageType.EXCEPTION:
3322 
      x = TApplicationException()
3323 
      x.read(self._iprot)
3324 
      self._iprot.readMessageEnd()
3325 
      raise x
3326 
    result = updateShipmentAddress_result()
3327 
    result.read(self._iprot)
3328 
    self._iprot.readMessageEnd()
3329 
    if result.ex is not None:
3330 
      raise result.ex
3331 
    return
3332 
 
4285 rajveer 3333 
  def acceptOrdersForItemId(self, itemId, inventory):
3334 
    """
3335 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3336 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3337 
 
4285 rajveer 3338 
    Parameters:
3339 
     - itemId
3340 
     - inventory
3341 
    """
3342 
    self.send_acceptOrdersForItemId(itemId, inventory)
3343 
    return self.recv_acceptOrdersForItemId()
3344 
 
3345 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3346 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3347 
    args = acceptOrdersForItemId_args()
3348 
    args.itemId = itemId
3349 
    args.inventory = inventory
3350 
    args.write(self._oprot)
3351 
    self._oprot.writeMessageEnd()
3352 
    self._oprot.trans.flush()
3353 
 
3354 
  def recv_acceptOrdersForItemId(self, ):
3355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3356 
    if mtype == TMessageType.EXCEPTION:
3357 
      x = TApplicationException()
3358 
      x.read(self._iprot)
3359 
      self._iprot.readMessageEnd()
3360 
      raise x
3361 
    result = acceptOrdersForItemId_result()
3362 
    result.read(self._iprot)
3363 
    self._iprot.readMessageEnd()
3364 
    if result.success is not None:
3365 
      return result.success
3366 
    if result.ex is not None:
3367 
      raise result.ex
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3369 
 
4369 rajveer 3370 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3371 
    """
3372 
    Parameters:
3373 
     - vendorId
3374 
     - itemId
3375 
     - quantity
3376 
     - estimate
4369 rajveer 3377 
     - isReminder
4303 rajveer 3378 
    """
4369 rajveer 3379 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3380 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3381 
 
4369 rajveer 3382 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3383 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3384 
    args = markOrdersAsPORaised_args()
3385 
    args.vendorId = vendorId
3386 
    args.itemId = itemId
3387 
    args.quantity = quantity
3388 
    args.estimate = estimate
4369 rajveer 3389 
    args.isReminder = isReminder
4303 rajveer 3390 
    args.write(self._oprot)
3391 
    self._oprot.writeMessageEnd()
3392 
    self._oprot.trans.flush()
3393 
 
3394 
  def recv_markOrdersAsPORaised(self, ):
3395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3396 
    if mtype == TMessageType.EXCEPTION:
3397 
      x = TApplicationException()
3398 
      x.read(self._iprot)
3399 
      self._iprot.readMessageEnd()
3400 
      raise x
3401 
    result = markOrdersAsPORaised_result()
3402 
    result.read(self._iprot)
3403 
    self._iprot.readMessageEnd()
3404 
    if result.ex is not None:
3405 
      raise result.ex
3406 
    return
3407 
 
4369 rajveer 3408 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3409 
    """
3410 
    Parameters:
3411 
     - vendorId
3412 
     - itemId
3413 
     - quantity
3414 
     - estimate
4369 rajveer 3415 
     - isReminder
4303 rajveer 3416 
    """
4369 rajveer 3417 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3418 
    self.recv_markOrdersAsReversalInitiated()
3419 
 
4369 rajveer 3420 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3421 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3422 
    args = markOrdersAsReversalInitiated_args()
3423 
    args.vendorId = vendorId
3424 
    args.itemId = itemId
3425 
    args.quantity = quantity
3426 
    args.estimate = estimate
4369 rajveer 3427 
    args.isReminder = isReminder
4303 rajveer 3428 
    args.write(self._oprot)
3429 
    self._oprot.writeMessageEnd()
3430 
    self._oprot.trans.flush()
3431 
 
3432 
  def recv_markOrdersAsReversalInitiated(self, ):
3433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3434 
    if mtype == TMessageType.EXCEPTION:
3435 
      x = TApplicationException()
3436 
      x.read(self._iprot)
3437 
      self._iprot.readMessageEnd()
3438 
      raise x
3439 
    result = markOrdersAsReversalInitiated_result()
3440 
    result.read(self._iprot)
3441 
    self._iprot.readMessageEnd()
3442 
    if result.ex is not None:
3443 
      raise result.ex
3444 
    return
3445 
 
4369 rajveer 3446 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3447 
    """
3448 
    Parameters:
3449 
     - vendorId
3450 
     - itemId
3451 
     - quantity
3452 
     - estimate
4369 rajveer 3453 
     - isReminder
4303 rajveer 3454 
    """
4369 rajveer 3455 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3456 
    self.recv_markOrdersAsNotAvailabke()
3457 
 
4369 rajveer 3458 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3459 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3460 
    args = markOrdersAsNotAvailabke_args()
3461 
    args.vendorId = vendorId
3462 
    args.itemId = itemId
3463 
    args.quantity = quantity
3464 
    args.estimate = estimate
4369 rajveer 3465 
    args.isReminder = isReminder
4303 rajveer 3466 
    args.write(self._oprot)
3467 
    self._oprot.writeMessageEnd()
3468 
    self._oprot.trans.flush()
3469 
 
3470 
  def recv_markOrdersAsNotAvailabke(self, ):
3471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3472 
    if mtype == TMessageType.EXCEPTION:
3473 
      x = TApplicationException()
3474 
      x.read(self._iprot)
3475 
      self._iprot.readMessageEnd()
3476 
      raise x
3477 
    result = markOrdersAsNotAvailabke_result()
3478 
    result.read(self._iprot)
3479 
    self._iprot.readMessageEnd()
3480 
    if result.ex is not None:
3481 
      raise result.ex
3482 
    return
3483 
 
4369 rajveer 3484 
  def markOrdersAsTimeout(self, vendorId):
3485 
    """
3486 
    Parameters:
3487 
     - vendorId
3488 
    """
3489 
    self.send_markOrdersAsTimeout(vendorId)
3490 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3491 
 
4369 rajveer 3492 
  def send_markOrdersAsTimeout(self, vendorId):
3493 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3494 
    args = markOrdersAsTimeout_args()
3495 
    args.vendorId = vendorId
3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_markOrdersAsTimeout(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = markOrdersAsTimeout_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3510 
    if result.success is not None:
3511 
      return result.success
3512 
    if result.ex is not None:
3513 
      raise result.ex
3514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3515 
 
4386 anupam.sin 3516 
  def getOrderForAwb(self, awb):
3517 
    """
3518 
    Returns the order corresponding to an AWB number
4369 rajveer 3519 
 
4386 anupam.sin 3520 
    Parameters:
3521 
     - awb
3522 
    """
3523 
    self.send_getOrderForAwb(awb)
3524 
    return self.recv_getOrderForAwb()
3525 
 
3526 
  def send_getOrderForAwb(self, awb):
3527 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3528 
    args = getOrderForAwb_args()
3529 
    args.awb = awb
3530 
    args.write(self._oprot)
3531 
    self._oprot.writeMessageEnd()
3532 
    self._oprot.trans.flush()
3533 
 
3534 
  def recv_getOrderForAwb(self, ):
3535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3536 
    if mtype == TMessageType.EXCEPTION:
3537 
      x = TApplicationException()
3538 
      x.read(self._iprot)
3539 
      self._iprot.readMessageEnd()
3540 
      raise x
3541 
    result = getOrderForAwb_result()
3542 
    result.read(self._iprot)
3543 
    self._iprot.readMessageEnd()
3544 
    if result.success is not None:
3545 
      return result.success
3546 
    if result.ex is not None:
3547 
      raise result.ex
3548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3549 
 
3550 
 
3376 rajveer 3551 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3552 
  def __init__(self, handler):
3376 rajveer 3553 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3554 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3555 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3556 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3557 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3558 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3559 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3560 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3561 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3562 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3563 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3564 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3565 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3566 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3567 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3568 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3569 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3570 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3571 
    self._processMap["createOrder"] = Processor.process_createOrder
3572 
    self._processMap["getOrder"] = Processor.process_getOrder
3573 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3574 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3575 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3576 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3577 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3578 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3579 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3580 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3581 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3582 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3583 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3584 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3585 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3586 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3587 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3588 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3589 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3590 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3591 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3592 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3593 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3594 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3595 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3596 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
2536 chandransh 3597 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3598 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3599 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3600 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3601 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3602 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3603 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3604 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3605 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3606 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3607 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3608 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3609 
    self._processMap["changeItem"] = Processor.process_changeItem
3610 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3611 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3612 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3613 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3614 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3615 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3616 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3617 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3618 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3619 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3620 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3621 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3622 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3623 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3624 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3625 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3626 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3627 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3628 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3629 
 
3630 
  def process(self, iprot, oprot):
3631 
    (name, type, seqid) = iprot.readMessageBegin()
3632 
    if name not in self._processMap:
3633 
      iprot.skip(TType.STRUCT)
3634 
      iprot.readMessageEnd()
3635 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3636 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3637 
      x.write(oprot)
3638 
      oprot.writeMessageEnd()
3639 
      oprot.trans.flush()
3640 
      return
3641 
    else:
3642 
      self._processMap[name](self, seqid, iprot, oprot)
3643 
    return True
3644 
 
3645 
  def process_createTransaction(self, seqid, iprot, oprot):
3646 
    args = createTransaction_args()
3647 
    args.read(iprot)
3648 
    iprot.readMessageEnd()
3649 
    result = createTransaction_result()
3650 
    try:
132 ashish 3651 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3652 
    except TransactionServiceException, ex:
3653 
      result.ex = ex
3654 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3655 
    result.write(oprot)
3656 
    oprot.writeMessageEnd()
3657 
    oprot.trans.flush()
3658 
 
3659 
  def process_getTransaction(self, seqid, iprot, oprot):
3660 
    args = getTransaction_args()
3661 
    args.read(iprot)
3662 
    iprot.readMessageEnd()
3663 
    result = getTransaction_result()
3664 
    try:
3665 
      result.success = self._handler.getTransaction(args.id)
3666 
    except TransactionServiceException, ex:
3667 
      result.ex = ex
3668 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3669 
    result.write(oprot)
3670 
    oprot.writeMessageEnd()
3671 
    oprot.trans.flush()
3672 
 
3673 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3674 
    args = getTransactionsForCustomer_args()
3675 
    args.read(iprot)
3676 
    iprot.readMessageEnd()
3677 
    result = getTransactionsForCustomer_result()
3678 
    try:
3679 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3680 
    except TransactionServiceException, ex:
3681 
      result.ex = ex
3682 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3683 
    result.write(oprot)
3684 
    oprot.writeMessageEnd()
3685 
    oprot.trans.flush()
3686 
 
132 ashish 3687 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3688 
    args = getTransactionsForShoppingCartId_args()
3689 
    args.read(iprot)
3690 
    iprot.readMessageEnd()
3691 
    result = getTransactionsForShoppingCartId_result()
3692 
    try:
3693 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3694 
    except TransactionServiceException, ex:
3695 
      result.ex = ex
3696 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3697 
    result.write(oprot)
3698 
    oprot.writeMessageEnd()
3699 
    oprot.trans.flush()
3700 
 
94 ashish 3701 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3702 
    args = getTransactionStatus_args()
3703 
    args.read(iprot)
3704 
    iprot.readMessageEnd()
3705 
    result = getTransactionStatus_result()
3706 
    try:
3707 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3708 
    except TransactionServiceException, ex:
3709 
      result.ex = ex
3710 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3711 
    result.write(oprot)
3712 
    oprot.writeMessageEnd()
3713 
    oprot.trans.flush()
3714 
 
3715 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3716 
    args = changeTransactionStatus_args()
3717 
    args.read(iprot)
3718 
    iprot.readMessageEnd()
3719 
    result = changeTransactionStatus_result()
3720 
    try:
3721 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3722 
    except TransactionServiceException, ex:
3723 
      result.ex = ex
3724 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3725 
    result.write(oprot)
3726 
    oprot.writeMessageEnd()
3727 
    oprot.trans.flush()
3728 
 
1398 varun.gupt 3729 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3730 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3731 
    args.read(iprot)
3732 
    iprot.readMessageEnd()
1398 varun.gupt 3733 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3734 
    try:
1398 varun.gupt 3735 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3736 
    except TransactionServiceException, ex:
3737 
      result.ex = ex
1398 varun.gupt 3738 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3739 
    result.write(oprot)
3740 
    oprot.writeMessageEnd()
3741 
    oprot.trans.flush()
3742 
 
483 rajveer 3743 
  def process_getAllOrders(self, seqid, iprot, oprot):
3744 
    args = getAllOrders_args()
94 ashish 3745 
    args.read(iprot)
3746 
    iprot.readMessageEnd()
483 rajveer 3747 
    result = getAllOrders_result()
94 ashish 3748 
    try:
483 rajveer 3749 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3750 
    except TransactionServiceException, ex:
3751 
      result.ex = ex
483 rajveer 3752 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3753 
    result.write(oprot)
3754 
    oprot.writeMessageEnd()
3755 
    oprot.trans.flush()
3756 
 
4133 chandransh 3757 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3758 
    args = getOrdersInBatch_args()
3759 
    args.read(iprot)
3760 
    iprot.readMessageEnd()
3761 
    result = getOrdersInBatch_result()
3762 
    try:
3763 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3764 
    except TransactionServiceException, ex:
3765 
      result.ex = ex
3766 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3767 
    result.write(oprot)
3768 
    oprot.writeMessageEnd()
3769 
    oprot.trans.flush()
3770 
 
3771 
  def process_getOrderCount(self, seqid, iprot, oprot):
3772 
    args = getOrderCount_args()
3773 
    args.read(iprot)
3774 
    iprot.readMessageEnd()
3775 
    result = getOrderCount_result()
3776 
    try:
3777 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3778 
    except TransactionServiceException, ex:
3779 
      result.ex = ex
3780 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3781 
    result.write(oprot)
3782 
    oprot.writeMessageEnd()
3783 
    oprot.trans.flush()
3784 
 
999 varun.gupt 3785 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3786 
    args = getOrdersByBillingDate_args()
3787 
    args.read(iprot)
3788 
    iprot.readMessageEnd()
3789 
    result = getOrdersByBillingDate_result()
3790 
    try:
3791 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3792 
    except TransactionServiceException, ex:
3793 
      result.ex = ex
3794 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3795 
    result.write(oprot)
3796 
    oprot.writeMessageEnd()
3797 
    oprot.trans.flush()
3798 
 
3427 chandransh 3799 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3800 
    args = getOrdersByShippingDate_args()
3801 
    args.read(iprot)
3802 
    iprot.readMessageEnd()
3803 
    result = getOrdersByShippingDate_result()
3804 
    try:
3451 chandransh 3805 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3806 
    except TransactionServiceException, ex:
3807 
      result.ex = ex
3808 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3809 
    result.write(oprot)
3810 
    oprot.writeMessageEnd()
3811 
    oprot.trans.flush()
3812 
 
1382 varun.gupt 3813 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3814 
    args = getReturnableOrdersForCustomer_args()
3815 
    args.read(iprot)
3816 
    iprot.readMessageEnd()
3817 
    result = getReturnableOrdersForCustomer_result()
3818 
    try:
3819 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3820 
    except TransactionServiceException, ex:
3821 
      result.ex = ex
3822 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3823 
    result.write(oprot)
3824 
    oprot.writeMessageEnd()
3825 
    oprot.trans.flush()
3826 
 
3827 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3828 
    args = getCancellableOrdersForCustomer_args()
3829 
    args.read(iprot)
3830 
    iprot.readMessageEnd()
3831 
    result = getCancellableOrdersForCustomer_result()
3832 
    try:
3833 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3834 
    except TransactionServiceException, ex:
3835 
      result.ex = ex
3836 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3837 
    result.write(oprot)
3838 
    oprot.writeMessageEnd()
3839 
    oprot.trans.flush()
3840 
 
483 rajveer 3841 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3842 
    args = changeOrderStatus_args()
94 ashish 3843 
    args.read(iprot)
3844 
    iprot.readMessageEnd()
483 rajveer 3845 
    result = changeOrderStatus_result()
94 ashish 3846 
    try:
483 rajveer 3847 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3848 
    except TransactionServiceException, ex:
3849 
      result.ex = ex
483 rajveer 3850 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3851 
    result.write(oprot)
3852 
    oprot.writeMessageEnd()
3853 
    oprot.trans.flush()
3854 
 
483 rajveer 3855 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3856 
    args = getOrdersForTransaction_args()
94 ashish 3857 
    args.read(iprot)
3858 
    iprot.readMessageEnd()
483 rajveer 3859 
    result = getOrdersForTransaction_result()
94 ashish 3860 
    try:
1528 ankur.sing 3861 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3862 
    except TransactionServiceException, ex:
3863 
      result.ex = ex
483 rajveer 3864 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3865 
    result.write(oprot)
3866 
    oprot.writeMessageEnd()
3867 
    oprot.trans.flush()
3868 
 
483 rajveer 3869 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3870 
    args = getOrdersForCustomer_args()
94 ashish 3871 
    args.read(iprot)
3872 
    iprot.readMessageEnd()
483 rajveer 3873 
    result = getOrdersForCustomer_result()
94 ashish 3874 
    try:
3014 chandransh 3875 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3876 
    except TransactionServiceException, ex:
3877 
      result.ex = ex
483 rajveer 3878 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3879 
    result.write(oprot)
3880 
    oprot.writeMessageEnd()
3881 
    oprot.trans.flush()
3882 
 
483 rajveer 3883 
  def process_createOrder(self, seqid, iprot, oprot):
3884 
    args = createOrder_args()
94 ashish 3885 
    args.read(iprot)
3886 
    iprot.readMessageEnd()
483 rajveer 3887 
    result = createOrder_result()
94 ashish 3888 
    try:
483 rajveer 3889 
      result.success = self._handler.createOrder(args.order)
94 ashish 3890 
    except TransactionServiceException, ex:
3891 
      result.ex = ex
483 rajveer 3892 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3893 
    result.write(oprot)
3894 
    oprot.writeMessageEnd()
3895 
    oprot.trans.flush()
3896 
 
483 rajveer 3897 
  def process_getOrder(self, seqid, iprot, oprot):
3898 
    args = getOrder_args()
94 ashish 3899 
    args.read(iprot)
3900 
    iprot.readMessageEnd()
483 rajveer 3901 
    result = getOrder_result()
94 ashish 3902 
    try:
483 rajveer 3903 
      result.success = self._handler.getOrder(args.id)
94 ashish 3904 
    except TransactionServiceException, ex:
3905 
      result.ex = ex
483 rajveer 3906 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 3907 
    result.write(oprot)
3908 
    oprot.writeMessageEnd()
3909 
    oprot.trans.flush()
3910 
 
483 rajveer 3911 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
3912 
    args = getLineItemsForOrder_args()
94 ashish 3913 
    args.read(iprot)
3914 
    iprot.readMessageEnd()
483 rajveer 3915 
    result = getLineItemsForOrder_result()
94 ashish 3916 
    try:
483 rajveer 3917 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 3918 
    except TransactionServiceException, ex:
3919 
      result.ex = ex
483 rajveer 3920 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 3921 
    result.write(oprot)
3922 
    oprot.writeMessageEnd()
3923 
    oprot.trans.flush()
3924 
 
1528 ankur.sing 3925 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
3926 
    args = getOrderForCustomer_args()
3927 
    args.read(iprot)
3928 
    iprot.readMessageEnd()
3929 
    result = getOrderForCustomer_result()
3930 
    try:
3931 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
3932 
    except TransactionServiceException, ex:
3933 
      result.ex = ex
3934 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
3935 
    result.write(oprot)
3936 
    oprot.writeMessageEnd()
3937 
    oprot.trans.flush()
3938 
 
3064 chandransh 3939 
  def process_getAlerts(self, seqid, iprot, oprot):
3940 
    args = getAlerts_args()
3941 
    args.read(iprot)
3942 
    iprot.readMessageEnd()
3943 
    result = getAlerts_result()
4444 rajveer 3944 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 3945 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
3946 
    result.write(oprot)
3947 
    oprot.writeMessageEnd()
3948 
    oprot.trans.flush()
3949 
 
4394 rajveer 3950 
  def process_addAlert(self, seqid, iprot, oprot):
3951 
    args = addAlert_args()
3064 chandransh 3952 
    args.read(iprot)
3953 
    iprot.readMessageEnd()
4394 rajveer 3954 
    result = addAlert_result()
4444 rajveer 3955 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 3956 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
3960 
 
4444 rajveer 3961 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
3962 
    args = markAlertsAsSeen_args()
3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3965 
    result = markAlertsAsSeen_result()
3966 
    self._handler.markAlertsAsSeen(args.warehouseId)
3967 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
3968 
    result.write(oprot)
3969 
    oprot.writeMessageEnd()
3970 
    oprot.trans.flush()
3971 
 
3064 chandransh 3972 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
3973 
    args = getValidOrderCount_args()
3974 
    args.read(iprot)
3975 
    iprot.readMessageEnd()
3976 
    result = getValidOrderCount_result()
3977 
    result.success = self._handler.getValidOrderCount()
3978 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
3982 
 
3983 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
3984 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
3987 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
3988 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
3989 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
3990 
    result.write(oprot)
3991 
    oprot.writeMessageEnd()
3992 
    oprot.trans.flush()
3993 
 
3994 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
3995 
    args = getValidOrdersAmountRange_args()
3996 
    args.read(iprot)
3997 
    iprot.readMessageEnd()
3998 
    result = getValidOrdersAmountRange_result()
3999 
    result.success = self._handler.getValidOrdersAmountRange()
4000 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4001 
    result.write(oprot)
4002 
    oprot.writeMessageEnd()
4003 
    oprot.trans.flush()
4004 
 
4005 
  def process_getValidOrders(self, seqid, iprot, oprot):
4006 
    args = getValidOrders_args()
4007 
    args.read(iprot)
4008 
    iprot.readMessageEnd()
4009 
    result = getValidOrders_result()
4010 
    result.success = self._handler.getValidOrders(args.limit)
4011 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4012 
    result.write(oprot)
4013 
    oprot.writeMessageEnd()
4014 
    oprot.trans.flush()
4015 
 
1220 chandransh 4016 
  def process_batchOrders(self, seqid, iprot, oprot):
4017 
    args = batchOrders_args()
4018 
    args.read(iprot)
4019 
    iprot.readMessageEnd()
4020 
    result = batchOrders_result()
4021 
    try:
4022 
      result.success = self._handler.batchOrders(args.warehouseId)
4023 
    except TransactionServiceException, ex:
4024 
      result.ex = ex
4025 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4026 
    result.write(oprot)
4027 
    oprot.writeMessageEnd()
4028 
    oprot.trans.flush()
4029 
 
1208 chandransh 4030 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4031 
    args = markOrderAsOutOfStock_args()
4032 
    args.read(iprot)
4033 
    iprot.readMessageEnd()
4034 
    result = markOrderAsOutOfStock_result()
4035 
    try:
4036 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4037 
    except TransactionServiceException, ex:
4038 
      result.ex = ex
4039 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4040 
    result.write(oprot)
4041 
    oprot.writeMessageEnd()
4042 
    oprot.trans.flush()
4043 
 
3064 chandransh 4044 
  def process_verifyOrder(self, seqid, iprot, oprot):
4045 
    args = verifyOrder_args()
759 chandransh 4046 
    args.read(iprot)
4047 
    iprot.readMessageEnd()
3064 chandransh 4048 
    result = verifyOrder_result()
759 chandransh 4049 
    try:
3064 chandransh 4050 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4051 
    except TransactionServiceException, ex:
4052 
      result.ex = ex
3064 chandransh 4053 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4054 
    result.write(oprot)
4055 
    oprot.writeMessageEnd()
4056 
    oprot.trans.flush()
4057 
 
3064 chandransh 4058 
  def process_acceptOrder(self, seqid, iprot, oprot):
4059 
    args = acceptOrder_args()
1113 chandransh 4060 
    args.read(iprot)
4061 
    iprot.readMessageEnd()
3064 chandransh 4062 
    result = acceptOrder_result()
1113 chandransh 4063 
    try:
3064 chandransh 4064 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4065 
    except TransactionServiceException, ex:
4066 
      result.ex = ex
3064 chandransh 4067 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4068 
    result.write(oprot)
4069 
    oprot.writeMessageEnd()
4070 
    oprot.trans.flush()
4071 
 
3064 chandransh 4072 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4073 
    args = addBillingDetails_args()
1135 chandransh 4074 
    args.read(iprot)
4075 
    iprot.readMessageEnd()
3064 chandransh 4076 
    result = addBillingDetails_result()
1135 chandransh 4077 
    try:
4283 anupam.sin 4078 
      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 4079 
    except TransactionServiceException, ex:
4080 
      result.ex = ex
3064 chandransh 4081 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4082 
    result.write(oprot)
4083 
    oprot.writeMessageEnd()
4084 
    oprot.trans.flush()
4085 
 
3064 chandransh 4086 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4087 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4088 
    args.read(iprot)
4089 
    iprot.readMessageEnd()
3064 chandransh 4090 
    result = markOrdersAsManifested_result()
4091 
    try:
4092 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4093 
    except TransactionServiceException, ex:
4094 
      result.ex = ex
4095 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4096 
    result.write(oprot)
4097 
    oprot.writeMessageEnd()
4098 
    oprot.trans.flush()
4099 
 
4410 rajveer 4100 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4101 
    args = markOrdersAsShippedFromWarehouse_args()
4102 
    args.read(iprot)
4103 
    iprot.readMessageEnd()
4104 
    result = markOrdersAsShippedFromWarehouse_result()
4105 
    try:
4106 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4107 
    except TransactionServiceException, ex:
4108 
      result.ex = ex
4109 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4110 
    result.write(oprot)
4111 
    oprot.writeMessageEnd()
4112 
    oprot.trans.flush()
4113 
 
3064 chandransh 4114 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4115 
    args = markOrdersAsPickedUp_args()
304 ashish 4116 
    args.read(iprot)
4117 
    iprot.readMessageEnd()
3064 chandransh 4118 
    result = markOrdersAsPickedUp_result()
4119 
    try:
4120 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4121 
    except TransactionServiceException, ex:
4122 
      result.ex = ex
4123 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4124 
    result.write(oprot)
4125 
    oprot.writeMessageEnd()
4126 
    oprot.trans.flush()
94 ashish 4127 
 
3064 chandransh 4128 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4129 
    args = markOrdersAsDelivered_args()
304 ashish 4130 
    args.read(iprot)
4131 
    iprot.readMessageEnd()
3064 chandransh 4132 
    result = markOrdersAsDelivered_result()
4133 
    try:
4134 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4135 
    except TransactionServiceException, ex:
4136 
      result.ex = ex
4137 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4138 
    result.write(oprot)
4139 
    oprot.writeMessageEnd()
4140 
    oprot.trans.flush()
4141 
 
3064 chandransh 4142 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4143 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4144 
    args.read(iprot)
4145 
    iprot.readMessageEnd()
3064 chandransh 4146 
    result = markOrdersAsFailed_result()
4147 
    try:
4148 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4149 
    except TransactionServiceException, ex:
4150 
      result.ex = ex
4151 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4152 
    result.write(oprot)
4153 
    oprot.writeMessageEnd()
4154 
    oprot.trans.flush()
304 ashish 4155 
 
3064 chandransh 4156 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4157 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4158 
    args.read(iprot)
4159 
    iprot.readMessageEnd()
3064 chandransh 4160 
    result = updateNonDeliveryReason_result()
4161 
    try:
4162 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4163 
    except TransactionServiceException, ex:
4164 
      result.ex = ex
4165 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4166 
    result.write(oprot)
4167 
    oprot.writeMessageEnd()
4168 
    oprot.trans.flush()
1596 ankur.sing 4169 
 
3064 chandransh 4170 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4171 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4172 
    args.read(iprot)
4173 
    iprot.readMessageEnd()
3064 chandransh 4174 
    result = getUndeliveredOrders_result()
4175 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4176 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
2536 chandransh 4181 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4182 
    args = toggleDOAFlag_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = toggleDOAFlag_result()
4186 
    try:
4187 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4188 
    except TransactionServiceException, ex:
4189 
      result.ex = ex
4190 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
1886 ankur.sing 4194 
 
4454 rajveer 4195 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4196 
    args = markOrderDoaRequestReceived_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = markOrderDoaRequestReceived_result()
4200 
    try:
4201 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4202 
    except TransactionServiceException, ex:
4203 
      result.ex = ex
4204 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4205 
    result.write(oprot)
4206 
    oprot.writeMessageEnd()
4207 
    oprot.trans.flush()
4208 
 
4209 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4210 
    args = markOrderDoaRequestAuthorized_args()
4211 
    args.read(iprot)
4212 
    iprot.readMessageEnd()
4213 
    result = markOrderDoaRequestAuthorized_result()
4214 
    try:
4215 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4216 
    except TransactionServiceException, ex:
4217 
      result.ex = ex
4218 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
2536 chandransh 4223 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4224 
    args = requestPickupNumber_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = requestPickupNumber_result()
4228 
    try:
4229 
      result.success = self._handler.requestPickupNumber(args.orderId)
4230 
    except TransactionServiceException, ex:
4231 
      result.ex = ex
4232 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4236 
 
4237 
  def process_authorizePickup(self, seqid, iprot, oprot):
4238 
    args = authorizePickup_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = authorizePickup_result()
4242 
    try:
4243 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4244 
    except TransactionServiceException, ex:
4245 
      result.ex = ex
4246 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4247 
    result.write(oprot)
4248 
    oprot.writeMessageEnd()
4249 
    oprot.trans.flush()
4250 
 
2764 chandransh 4251 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4252 
    args = markDoasAsPickedUp_args()
4253 
    args.read(iprot)
4254 
    iprot.readMessageEnd()
4255 
    result = markDoasAsPickedUp_result()
4256 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4257 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4261 
 
2616 chandransh 4262 
  def process_receiveReturn(self, seqid, iprot, oprot):
4263 
    args = receiveReturn_args()
2591 chandransh 4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
2616 chandransh 4266 
    result = receiveReturn_result()
2591 chandransh 4267 
    try:
2616 chandransh 4268 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 4269 
    except TransactionServiceException, ex:
4270 
      result.ex = ex
2616 chandransh 4271 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
2536 chandransh 4275 
 
2591 chandransh 4276 
  def process_validateDoa(self, seqid, iprot, oprot):
4277 
    args = validateDoa_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = validateDoa_result()
4281 
    try:
4282 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4283 
    except TransactionServiceException, ex:
4284 
      result.ex = ex
4285 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
4289 
 
2616 chandransh 4290 
  def process_reshipOrder(self, seqid, iprot, oprot):
4291 
    args = reshipOrder_args()
4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4294 
    result = reshipOrder_result()
4295 
    try:
4296 
      result.success = self._handler.reshipOrder(args.orderId)
4297 
    except TransactionServiceException, ex:
4298 
      result.ex = ex
4299 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
2591 chandransh 4303 
 
2616 chandransh 4304 
  def process_refundOrder(self, seqid, iprot, oprot):
4305 
    args = refundOrder_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = refundOrder_result()
4309 
    try:
3226 chandransh 4310 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4311 
    except TransactionServiceException, ex:
4312 
      result.ex = ex
4313 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4314 
    result.write(oprot)
4315 
    oprot.writeMessageEnd()
4316 
    oprot.trans.flush()
4317 
 
2690 chandransh 4318 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4319 
    args = getReturnOrders_args()
4320 
    args.read(iprot)
4321 
    iprot.readMessageEnd()
4322 
    result = getReturnOrders_result()
4323 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4324 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4325 
    result.write(oprot)
4326 
    oprot.writeMessageEnd()
4327 
    oprot.trans.flush()
2616 chandransh 4328 
 
2700 chandransh 4329 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4330 
    args = getReturnOrder_args()
4331 
    args.read(iprot)
4332 
    iprot.readMessageEnd()
4333 
    result = getReturnOrder_result()
4334 
    try:
4335 
      result.success = self._handler.getReturnOrder(args.id)
4336 
    except TransactionServiceException, ex:
4337 
      result.ex = ex
4338 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4339 
    result.write(oprot)
4340 
    oprot.writeMessageEnd()
4341 
    oprot.trans.flush()
4342 
 
2690 chandransh 4343 
  def process_processReturn(self, seqid, iprot, oprot):
4344 
    args = processReturn_args()
4345 
    args.read(iprot)
4346 
    iprot.readMessageEnd()
4347 
    result = processReturn_result()
4348 
    try:
4349 
      self._handler.processReturn(args.returnOrderId)
4350 
    except TransactionServiceException, ex:
4351 
      result.ex = ex
4352 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4353 
    result.write(oprot)
4354 
    oprot.writeMessageEnd()
4355 
    oprot.trans.flush()
4356 
 
2819 chandransh 4357 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4358 
    args = createPurchaseOrder_args()
4359 
    args.read(iprot)
4360 
    iprot.readMessageEnd()
4361 
    result = createPurchaseOrder_result()
4362 
    try:
4363 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4364 
    except TransactionServiceException, ex:
4365 
      result.ex = ex
4366 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4367 
    result.write(oprot)
4368 
    oprot.writeMessageEnd()
4369 
    oprot.trans.flush()
2690 chandransh 4370 
 
3451 chandransh 4371 
  def process_updateWeight(self, seqid, iprot, oprot):
4372 
    args = updateWeight_args()
4373 
    args.read(iprot)
4374 
    iprot.readMessageEnd()
4375 
    result = updateWeight_result()
4376 
    try:
4377 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4378 
    except TransactionServiceException, ex:
4379 
      result.ex = ex
4380 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
2819 chandransh 4384 
 
3469 chandransh 4385 
  def process_changeItem(self, seqid, iprot, oprot):
4386 
    args = changeItem_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = changeItem_result()
4390 
    try:
4391 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4392 
    except TransactionServiceException, ex:
4393 
      result.ex = ex
4394 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
3451 chandransh 4398 
 
3469 chandransh 4399 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4400 
    args = shiftToWarehouse_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = shiftToWarehouse_result()
4404 
    try:
4405 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4406 
    except TransactionServiceException, ex:
4407 
      result.ex = ex
4408 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4412 
 
3553 chandransh 4413 
  def process_addDelayReason(self, seqid, iprot, oprot):
4414 
    args = addDelayReason_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = addDelayReason_result()
4418 
    try:
3986 chandransh 4419 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4420 
    except TransactionServiceException, ex:
4421 
      result.ex = ex
4422 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4423 
    result.write(oprot)
4424 
    oprot.writeMessageEnd()
4425 
    oprot.trans.flush()
3469 chandransh 4426 
 
3956 chandransh 4427 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4428 
    args = reconcileCodCollection_args()
4429 
    args.read(iprot)
4430 
    iprot.readMessageEnd()
4431 
    result = reconcileCodCollection_result()
4432 
    try:
4433 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4434 
    except TransactionServiceException, ex:
4435 
      result.ex = ex
4436 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
3553 chandransh 4440 
 
4008 mandeep.dh 4441 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4442 
    args = getTransactionsRequiringExtraProcessing_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = getTransactionsRequiringExtraProcessing_result()
4446 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4447 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4448 
    result.write(oprot)
4449 
    oprot.writeMessageEnd()
4450 
    oprot.trans.flush()
3956 chandransh 4451 
 
4008 mandeep.dh 4452 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4453 
    args = markTransactionAsProcessed_args()
4454 
    args.read(iprot)
4455 
    iprot.readMessageEnd()
4456 
    result = markTransactionAsProcessed_result()
4457 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4458 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
4018 chandransh 4463 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4464 
    args = getItemWiseRiskyOrdersCount_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = getItemWiseRiskyOrdersCount_result()
4468 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4469 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4470 
    result.write(oprot)
4471 
    oprot.writeMessageEnd()
4472 
    oprot.trans.flush()
4008 mandeep.dh 4473 
 
4295 varun.gupt 4474 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4475 
    args = getOrdersForItemIds_args()
4476 
    args.read(iprot)
4477 
    iprot.readMessageEnd()
4478 
    result = getOrdersForItemIds_result()
4479 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4480 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
4247 rajveer 4485 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4486 
    args = markOrderCancellationRequestReceived_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = markOrderCancellationRequestReceived_result()
4490 
    try:
4491 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4492 
    except TransactionServiceException, ex:
4493 
      result.ex = ex
4494 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4018 chandransh 4498 
 
4247 rajveer 4499 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4500 
    args = markOrderCancellationRequestConfirmed_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = markOrderCancellationRequestConfirmed_result()
4504 
    try:
4505 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4506 
    except TransactionServiceException, ex:
4507 
      result.ex = ex
4508 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
4513 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4514 
    args = markOrderCancellationRequestDenied_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = markOrderCancellationRequestDenied_result()
4518 
    try:
4519 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4520 
    except TransactionServiceException, ex:
4521 
      result.ex = ex
4522 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
4258 rajveer 4527 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4528 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4258 rajveer 4531 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4532 
    try:
4258 rajveer 4533 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4534 
    except TransactionServiceException, ex:
4535 
      result.ex = ex
4258 rajveer 4536 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
4259 anupam.sin 4541 
  def process_refundTransaction(self, seqid, iprot, oprot):
4542 
    args = refundTransaction_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = refundTransaction_result()
4546 
    try:
4547 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4548 
    except TransactionServiceException, ex:
4549 
      result.ex = ex
4550 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4247 rajveer 4554 
 
4324 mandeep.dh 4555 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4556 
    args = updateShipmentAddress_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = updateShipmentAddress_result()
4560 
    try:
4561 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4562 
    except TransactionServiceException, ex:
4563 
      result.ex = ex
4564 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4565 
    result.write(oprot)
4566 
    oprot.writeMessageEnd()
4567 
    oprot.trans.flush()
4568 
 
4285 rajveer 4569 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4570 
    args = acceptOrdersForItemId_args()
4571 
    args.read(iprot)
4572 
    iprot.readMessageEnd()
4573 
    result = acceptOrdersForItemId_result()
4574 
    try:
4575 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4576 
    except TransactionServiceException, ex:
4577 
      result.ex = ex
4578 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4579 
    result.write(oprot)
4580 
    oprot.writeMessageEnd()
4581 
    oprot.trans.flush()
4259 anupam.sin 4582 
 
4303 rajveer 4583 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4584 
    args = markOrdersAsPORaised_args()
4585 
    args.read(iprot)
4586 
    iprot.readMessageEnd()
4587 
    result = markOrdersAsPORaised_result()
4588 
    try:
4369 rajveer 4589 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4590 
    except TransactionServiceException, ex:
4591 
      result.ex = ex
4592 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4285 rajveer 4596 
 
4303 rajveer 4597 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4598 
    args = markOrdersAsReversalInitiated_args()
4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
4601 
    result = markOrdersAsReversalInitiated_result()
4602 
    try:
4369 rajveer 4603 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4604 
    except TransactionServiceException, ex:
4605 
      result.ex = ex
4606 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4612 
    args = markOrdersAsNotAvailabke_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = markOrdersAsNotAvailabke_result()
4616 
    try:
4369 rajveer 4617 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4618 
    except TransactionServiceException, ex:
4619 
      result.ex = ex
4620 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
4624 
 
4369 rajveer 4625 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4626 
    args = markOrdersAsTimeout_args()
4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
4629 
    result = markOrdersAsTimeout_result()
4630 
    try:
4631 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4632 
    except TransactionServiceException, ex:
4633 
      result.ex = ex
4634 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4303 rajveer 4638 
 
4386 anupam.sin 4639 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4640 
    args = getOrderForAwb_args()
4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
4643 
    result = getOrderForAwb_result()
4644 
    try:
4645 
      result.success = self._handler.getOrderForAwb(args.awb)
4646 
    except TransactionServiceException, ex:
4647 
      result.ex = ex
4648 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
4369 rajveer 4652 
 
4386 anupam.sin 4653 
 
94 ashish 4654 
# HELPER FUNCTIONS AND STRUCTURES
4655 
 
4656 
class createTransaction_args:
4657 
  """
4658 
  Attributes:
4659 
   - transaction
4660 
  """
4661 
 
4662 
  thrift_spec = (
4663 
    None, # 0
4664 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4665 
  )
4666 
 
4667 
  def __init__(self, transaction=None,):
4668 
    self.transaction = transaction
4669 
 
4670 
  def read(self, iprot):
4671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4673 
      return
4674 
    iprot.readStructBegin()
4675 
    while True:
4676 
      (fname, ftype, fid) = iprot.readFieldBegin()
4677 
      if ftype == TType.STOP:
4678 
        break
4679 
      if fid == 1:
4680 
        if ftype == TType.STRUCT:
4681 
          self.transaction = Transaction()
4682 
          self.transaction.read(iprot)
4683 
        else:
4684 
          iprot.skip(ftype)
4685 
      else:
4686 
        iprot.skip(ftype)
4687 
      iprot.readFieldEnd()
4688 
    iprot.readStructEnd()
4689 
 
4690 
  def write(self, oprot):
4691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4693 
      return
4694 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4695 
    if self.transaction is not None:
94 ashish 4696 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4697 
      self.transaction.write(oprot)
4698 
      oprot.writeFieldEnd()
4699 
    oprot.writeFieldStop()
4700 
    oprot.writeStructEnd()
4701 
 
3431 rajveer 4702 
  def validate(self):
4703 
    return
4704 
 
4705 
 
94 ashish 4706 
  def __repr__(self):
4707 
    L = ['%s=%r' % (key, value)
4708 
      for key, value in self.__dict__.iteritems()]
4709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4710 
 
4711 
  def __eq__(self, other):
4712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4713 
 
4714 
  def __ne__(self, other):
4715 
    return not (self == other)
4716 
 
4717 
class createTransaction_result:
4718 
  """
4719 
  Attributes:
132 ashish 4720 
   - success
94 ashish 4721 
   - ex
4722 
  """
4723 
 
4724 
  thrift_spec = (
132 ashish 4725 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4727 
  )
4728 
 
132 ashish 4729 
  def __init__(self, success=None, ex=None,):
4730 
    self.success = success
94 ashish 4731 
    self.ex = ex
4732 
 
4733 
  def read(self, iprot):
4734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4736 
      return
4737 
    iprot.readStructBegin()
4738 
    while True:
4739 
      (fname, ftype, fid) = iprot.readFieldBegin()
4740 
      if ftype == TType.STOP:
4741 
        break
132 ashish 4742 
      if fid == 0:
4743 
        if ftype == TType.I64:
4744 
          self.success = iprot.readI64();
4745 
        else:
4746 
          iprot.skip(ftype)
4747 
      elif fid == 1:
94 ashish 4748 
        if ftype == TType.STRUCT:
4749 
          self.ex = TransactionServiceException()
4750 
          self.ex.read(iprot)
4751 
        else:
4752 
          iprot.skip(ftype)
4753 
      else:
4754 
        iprot.skip(ftype)
4755 
      iprot.readFieldEnd()
4756 
    iprot.readStructEnd()
4757 
 
4758 
  def write(self, oprot):
4759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4761 
      return
4762 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4763 
    if self.success is not None:
132 ashish 4764 
      oprot.writeFieldBegin('success', TType.I64, 0)
4765 
      oprot.writeI64(self.success)
4766 
      oprot.writeFieldEnd()
3431 rajveer 4767 
    if self.ex is not None:
94 ashish 4768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4769 
      self.ex.write(oprot)
4770 
      oprot.writeFieldEnd()
4771 
    oprot.writeFieldStop()
4772 
    oprot.writeStructEnd()
4773 
 
3431 rajveer 4774 
  def validate(self):
4775 
    return
4776 
 
4777 
 
94 ashish 4778 
  def __repr__(self):
4779 
    L = ['%s=%r' % (key, value)
4780 
      for key, value in self.__dict__.iteritems()]
4781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4782 
 
4783 
  def __eq__(self, other):
4784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4785 
 
4786 
  def __ne__(self, other):
4787 
    return not (self == other)
4788 
 
4789 
class getTransaction_args:
4790 
  """
4791 
  Attributes:
4792 
   - id
4793 
  """
4794 
 
4795 
  thrift_spec = (
4796 
    None, # 0
4797 
    (1, TType.I64, 'id', None, None, ), # 1
4798 
  )
4799 
 
4800 
  def __init__(self, id=None,):
4801 
    self.id = id
4802 
 
4803 
  def read(self, iprot):
4804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4806 
      return
4807 
    iprot.readStructBegin()
4808 
    while True:
4809 
      (fname, ftype, fid) = iprot.readFieldBegin()
4810 
      if ftype == TType.STOP:
4811 
        break
4812 
      if fid == 1:
4813 
        if ftype == TType.I64:
4814 
          self.id = iprot.readI64();
4815 
        else:
4816 
          iprot.skip(ftype)
4817 
      else:
4818 
        iprot.skip(ftype)
4819 
      iprot.readFieldEnd()
4820 
    iprot.readStructEnd()
4821 
 
4822 
  def write(self, oprot):
4823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4825 
      return
4826 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4827 
    if self.id is not None:
94 ashish 4828 
      oprot.writeFieldBegin('id', TType.I64, 1)
4829 
      oprot.writeI64(self.id)
4830 
      oprot.writeFieldEnd()
4831 
    oprot.writeFieldStop()
4832 
    oprot.writeStructEnd()
4833 
 
3431 rajveer 4834 
  def validate(self):
4835 
    return
4836 
 
4837 
 
94 ashish 4838 
  def __repr__(self):
4839 
    L = ['%s=%r' % (key, value)
4840 
      for key, value in self.__dict__.iteritems()]
4841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4842 
 
4843 
  def __eq__(self, other):
4844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4845 
 
4846 
  def __ne__(self, other):
4847 
    return not (self == other)
4848 
 
4849 
class getTransaction_result:
4850 
  """
4851 
  Attributes:
4852 
   - success
4853 
   - ex
4854 
  """
4855 
 
4856 
  thrift_spec = (
4857 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4859 
  )
4860 
 
4861 
  def __init__(self, success=None, ex=None,):
4862 
    self.success = success
4863 
    self.ex = ex
4864 
 
4865 
  def read(self, iprot):
4866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4868 
      return
4869 
    iprot.readStructBegin()
4870 
    while True:
4871 
      (fname, ftype, fid) = iprot.readFieldBegin()
4872 
      if ftype == TType.STOP:
4873 
        break
4874 
      if fid == 0:
4875 
        if ftype == TType.STRUCT:
4876 
          self.success = Transaction()
4877 
          self.success.read(iprot)
4878 
        else:
4879 
          iprot.skip(ftype)
4880 
      elif fid == 1:
4881 
        if ftype == TType.STRUCT:
4882 
          self.ex = TransactionServiceException()
4883 
          self.ex.read(iprot)
4884 
        else:
4885 
          iprot.skip(ftype)
4886 
      else:
4887 
        iprot.skip(ftype)
4888 
      iprot.readFieldEnd()
4889 
    iprot.readStructEnd()
4890 
 
4891 
  def write(self, oprot):
4892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4894 
      return
4895 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 4896 
    if self.success is not None:
94 ashish 4897 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4898 
      self.success.write(oprot)
4899 
      oprot.writeFieldEnd()
3431 rajveer 4900 
    if self.ex is not None:
94 ashish 4901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4902 
      self.ex.write(oprot)
4903 
      oprot.writeFieldEnd()
4904 
    oprot.writeFieldStop()
4905 
    oprot.writeStructEnd()
4906 
 
3431 rajveer 4907 
  def validate(self):
4908 
    return
4909 
 
4910 
 
94 ashish 4911 
  def __repr__(self):
4912 
    L = ['%s=%r' % (key, value)
4913 
      for key, value in self.__dict__.iteritems()]
4914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4915 
 
4916 
  def __eq__(self, other):
4917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4918 
 
4919 
  def __ne__(self, other):
4920 
    return not (self == other)
4921 
 
4922 
class getTransactionsForCustomer_args:
4923 
  """
4924 
  Attributes:
4925 
   - customerId
4926 
   - from_date
4927 
   - to_date
4928 
   - status
4929 
  """
4930 
 
4931 
  thrift_spec = (
4932 
    None, # 0
4933 
    (1, TType.I64, 'customerId', None, None, ), # 1
4934 
    (2, TType.I64, 'from_date', None, None, ), # 2
4935 
    (3, TType.I64, 'to_date', None, None, ), # 3
4936 
    (4, TType.I32, 'status', None, None, ), # 4
4937 
  )
4938 
 
4939 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4940 
    self.customerId = customerId
4941 
    self.from_date = from_date
4942 
    self.to_date = to_date
4943 
    self.status = status
4944 
 
4945 
  def read(self, iprot):
4946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4948 
      return
4949 
    iprot.readStructBegin()
4950 
    while True:
4951 
      (fname, ftype, fid) = iprot.readFieldBegin()
4952 
      if ftype == TType.STOP:
4953 
        break
4954 
      if fid == 1:
4955 
        if ftype == TType.I64:
4956 
          self.customerId = iprot.readI64();
4957 
        else:
4958 
          iprot.skip(ftype)
4959 
      elif fid == 2:
4960 
        if ftype == TType.I64:
4961 
          self.from_date = iprot.readI64();
4962 
        else:
4963 
          iprot.skip(ftype)
4964 
      elif fid == 3:
4965 
        if ftype == TType.I64:
4966 
          self.to_date = iprot.readI64();
4967 
        else:
4968 
          iprot.skip(ftype)
4969 
      elif fid == 4:
4970 
        if ftype == TType.I32:
4971 
          self.status = iprot.readI32();
4972 
        else:
4973 
          iprot.skip(ftype)
4974 
      else:
4975 
        iprot.skip(ftype)
4976 
      iprot.readFieldEnd()
4977 
    iprot.readStructEnd()
4978 
 
4979 
  def write(self, oprot):
4980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4982 
      return
4983 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 4984 
    if self.customerId is not None:
94 ashish 4985 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4986 
      oprot.writeI64(self.customerId)
4987 
      oprot.writeFieldEnd()
3431 rajveer 4988 
    if self.from_date is not None:
94 ashish 4989 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4990 
      oprot.writeI64(self.from_date)
4991 
      oprot.writeFieldEnd()
3431 rajveer 4992 
    if self.to_date is not None:
94 ashish 4993 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4994 
      oprot.writeI64(self.to_date)
4995 
      oprot.writeFieldEnd()
3431 rajveer 4996 
    if self.status is not None:
94 ashish 4997 
      oprot.writeFieldBegin('status', TType.I32, 4)
4998 
      oprot.writeI32(self.status)
4999 
      oprot.writeFieldEnd()
5000 
    oprot.writeFieldStop()
5001 
    oprot.writeStructEnd()
5002 
 
3431 rajveer 5003 
  def validate(self):
5004 
    return
5005 
 
5006 
 
94 ashish 5007 
  def __repr__(self):
5008 
    L = ['%s=%r' % (key, value)
5009 
      for key, value in self.__dict__.iteritems()]
5010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5011 
 
5012 
  def __eq__(self, other):
5013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5014 
 
5015 
  def __ne__(self, other):
5016 
    return not (self == other)
5017 
 
5018 
class getTransactionsForCustomer_result:
5019 
  """
5020 
  Attributes:
5021 
   - success
5022 
   - ex
5023 
  """
5024 
 
5025 
  thrift_spec = (
5026 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5028 
  )
5029 
 
5030 
  def __init__(self, success=None, ex=None,):
5031 
    self.success = success
5032 
    self.ex = ex
5033 
 
5034 
  def read(self, iprot):
5035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5037 
      return
5038 
    iprot.readStructBegin()
5039 
    while True:
5040 
      (fname, ftype, fid) = iprot.readFieldBegin()
5041 
      if ftype == TType.STOP:
5042 
        break
5043 
      if fid == 0:
5044 
        if ftype == TType.LIST:
5045 
          self.success = []
685 chandransh 5046 
          (_etype17, _size14) = iprot.readListBegin()
5047 
          for _i18 in xrange(_size14):
5048 
            _elem19 = Transaction()
5049 
            _elem19.read(iprot)
5050 
            self.success.append(_elem19)
94 ashish 5051 
          iprot.readListEnd()
5052 
        else:
5053 
          iprot.skip(ftype)
5054 
      elif fid == 1:
5055 
        if ftype == TType.STRUCT:
5056 
          self.ex = TransactionServiceException()
5057 
          self.ex.read(iprot)
5058 
        else:
5059 
          iprot.skip(ftype)
5060 
      else:
5061 
        iprot.skip(ftype)
5062 
      iprot.readFieldEnd()
5063 
    iprot.readStructEnd()
5064 
 
5065 
  def write(self, oprot):
5066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5068 
      return
5069 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5070 
    if self.success is not None:
94 ashish 5071 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5072 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5073 
      for iter20 in self.success:
5074 
        iter20.write(oprot)
94 ashish 5075 
      oprot.writeListEnd()
5076 
      oprot.writeFieldEnd()
3431 rajveer 5077 
    if self.ex is not None:
94 ashish 5078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5079 
      self.ex.write(oprot)
5080 
      oprot.writeFieldEnd()
5081 
    oprot.writeFieldStop()
5082 
    oprot.writeStructEnd()
5083 
 
3431 rajveer 5084 
  def validate(self):
5085 
    return
5086 
 
5087 
 
94 ashish 5088 
  def __repr__(self):
5089 
    L = ['%s=%r' % (key, value)
5090 
      for key, value in self.__dict__.iteritems()]
5091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5092 
 
5093 
  def __eq__(self, other):
5094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5095 
 
5096 
  def __ne__(self, other):
5097 
    return not (self == other)
5098 
 
132 ashish 5099 
class getTransactionsForShoppingCartId_args:
5100 
  """
5101 
  Attributes:
5102 
   - shoppingCartId
5103 
  """
5104 
 
5105 
  thrift_spec = (
5106 
    None, # 0
5107 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5108 
  )
5109 
 
5110 
  def __init__(self, shoppingCartId=None,):
5111 
    self.shoppingCartId = shoppingCartId
5112 
 
5113 
  def read(self, iprot):
5114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5116 
      return
5117 
    iprot.readStructBegin()
5118 
    while True:
5119 
      (fname, ftype, fid) = iprot.readFieldBegin()
5120 
      if ftype == TType.STOP:
5121 
        break
5122 
      if fid == 1:
5123 
        if ftype == TType.I64:
5124 
          self.shoppingCartId = iprot.readI64();
5125 
        else:
5126 
          iprot.skip(ftype)
5127 
      else:
5128 
        iprot.skip(ftype)
5129 
      iprot.readFieldEnd()
5130 
    iprot.readStructEnd()
5131 
 
5132 
  def write(self, oprot):
5133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5135 
      return
5136 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5137 
    if self.shoppingCartId is not None:
132 ashish 5138 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5139 
      oprot.writeI64(self.shoppingCartId)
5140 
      oprot.writeFieldEnd()
5141 
    oprot.writeFieldStop()
5142 
    oprot.writeStructEnd()
5143 
 
3431 rajveer 5144 
  def validate(self):
5145 
    return
5146 
 
5147 
 
132 ashish 5148 
  def __repr__(self):
5149 
    L = ['%s=%r' % (key, value)
5150 
      for key, value in self.__dict__.iteritems()]
5151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5152 
 
5153 
  def __eq__(self, other):
5154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5155 
 
5156 
  def __ne__(self, other):
5157 
    return not (self == other)
5158 
 
5159 
class getTransactionsForShoppingCartId_result:
5160 
  """
5161 
  Attributes:
5162 
   - success
5163 
   - ex
5164 
  """
5165 
 
5166 
  thrift_spec = (
5167 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5169 
  )
5170 
 
5171 
  def __init__(self, success=None, ex=None,):
5172 
    self.success = success
5173 
    self.ex = ex
5174 
 
5175 
  def read(self, iprot):
5176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5178 
      return
5179 
    iprot.readStructBegin()
5180 
    while True:
5181 
      (fname, ftype, fid) = iprot.readFieldBegin()
5182 
      if ftype == TType.STOP:
5183 
        break
5184 
      if fid == 0:
5185 
        if ftype == TType.LIST:
5186 
          self.success = []
685 chandransh 5187 
          (_etype24, _size21) = iprot.readListBegin()
5188 
          for _i25 in xrange(_size21):
5189 
            _elem26 = Transaction()
5190 
            _elem26.read(iprot)
5191 
            self.success.append(_elem26)
132 ashish 5192 
          iprot.readListEnd()
5193 
        else:
5194 
          iprot.skip(ftype)
5195 
      elif fid == 1:
5196 
        if ftype == TType.STRUCT:
5197 
          self.ex = TransactionServiceException()
5198 
          self.ex.read(iprot)
5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      else:
5202 
        iprot.skip(ftype)
5203 
      iprot.readFieldEnd()
5204 
    iprot.readStructEnd()
5205 
 
5206 
  def write(self, oprot):
5207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5209 
      return
5210 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5211 
    if self.success is not None:
132 ashish 5212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5213 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5214 
      for iter27 in self.success:
5215 
        iter27.write(oprot)
132 ashish 5216 
      oprot.writeListEnd()
5217 
      oprot.writeFieldEnd()
3431 rajveer 5218 
    if self.ex is not None:
132 ashish 5219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5220 
      self.ex.write(oprot)
5221 
      oprot.writeFieldEnd()
5222 
    oprot.writeFieldStop()
5223 
    oprot.writeStructEnd()
5224 
 
3431 rajveer 5225 
  def validate(self):
5226 
    return
5227 
 
5228 
 
132 ashish 5229 
  def __repr__(self):
5230 
    L = ['%s=%r' % (key, value)
5231 
      for key, value in self.__dict__.iteritems()]
5232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5233 
 
5234 
  def __eq__(self, other):
5235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5236 
 
5237 
  def __ne__(self, other):
5238 
    return not (self == other)
5239 
 
94 ashish 5240 
class getTransactionStatus_args:
5241 
  """
5242 
  Attributes:
5243 
   - transactionId
5244 
  """
5245 
 
5246 
  thrift_spec = (
5247 
    None, # 0
5248 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5249 
  )
5250 
 
5251 
  def __init__(self, transactionId=None,):
5252 
    self.transactionId = transactionId
5253 
 
5254 
  def read(self, iprot):
5255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5257 
      return
5258 
    iprot.readStructBegin()
5259 
    while True:
5260 
      (fname, ftype, fid) = iprot.readFieldBegin()
5261 
      if ftype == TType.STOP:
5262 
        break
5263 
      if fid == 1:
5264 
        if ftype == TType.I64:
5265 
          self.transactionId = iprot.readI64();
5266 
        else:
5267 
          iprot.skip(ftype)
5268 
      else:
5269 
        iprot.skip(ftype)
5270 
      iprot.readFieldEnd()
5271 
    iprot.readStructEnd()
5272 
 
5273 
  def write(self, oprot):
5274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5276 
      return
5277 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5278 
    if self.transactionId is not None:
94 ashish 5279 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5280 
      oprot.writeI64(self.transactionId)
5281 
      oprot.writeFieldEnd()
5282 
    oprot.writeFieldStop()
5283 
    oprot.writeStructEnd()
5284 
 
3431 rajveer 5285 
  def validate(self):
5286 
    return
5287 
 
5288 
 
94 ashish 5289 
  def __repr__(self):
5290 
    L = ['%s=%r' % (key, value)
5291 
      for key, value in self.__dict__.iteritems()]
5292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5293 
 
5294 
  def __eq__(self, other):
5295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5296 
 
5297 
  def __ne__(self, other):
5298 
    return not (self == other)
5299 
 
5300 
class getTransactionStatus_result:
5301 
  """
5302 
  Attributes:
5303 
   - success
5304 
   - ex
5305 
  """
5306 
 
5307 
  thrift_spec = (
5308 
    (0, TType.I32, 'success', None, None, ), # 0
5309 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5310 
  )
5311 
 
5312 
  def __init__(self, success=None, ex=None,):
5313 
    self.success = success
5314 
    self.ex = ex
5315 
 
5316 
  def read(self, iprot):
5317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5319 
      return
5320 
    iprot.readStructBegin()
5321 
    while True:
5322 
      (fname, ftype, fid) = iprot.readFieldBegin()
5323 
      if ftype == TType.STOP:
5324 
        break
5325 
      if fid == 0:
5326 
        if ftype == TType.I32:
5327 
          self.success = iprot.readI32();
5328 
        else:
5329 
          iprot.skip(ftype)
5330 
      elif fid == 1:
5331 
        if ftype == TType.STRUCT:
5332 
          self.ex = TransactionServiceException()
5333 
          self.ex.read(iprot)
5334 
        else:
5335 
          iprot.skip(ftype)
5336 
      else:
5337 
        iprot.skip(ftype)
5338 
      iprot.readFieldEnd()
5339 
    iprot.readStructEnd()
5340 
 
5341 
  def write(self, oprot):
5342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5344 
      return
5345 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5346 
    if self.success is not None:
94 ashish 5347 
      oprot.writeFieldBegin('success', TType.I32, 0)
5348 
      oprot.writeI32(self.success)
5349 
      oprot.writeFieldEnd()
3431 rajveer 5350 
    if self.ex is not None:
94 ashish 5351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5352 
      self.ex.write(oprot)
5353 
      oprot.writeFieldEnd()
5354 
    oprot.writeFieldStop()
5355 
    oprot.writeStructEnd()
5356 
 
3431 rajveer 5357 
  def validate(self):
5358 
    return
5359 
 
5360 
 
94 ashish 5361 
  def __repr__(self):
5362 
    L = ['%s=%r' % (key, value)
5363 
      for key, value in self.__dict__.iteritems()]
5364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5365 
 
5366 
  def __eq__(self, other):
5367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5368 
 
5369 
  def __ne__(self, other):
5370 
    return not (self == other)
5371 
 
5372 
class changeTransactionStatus_args:
5373 
  """
5374 
  Attributes:
5375 
   - transactionId
5376 
   - status
5377 
   - description
5378 
  """
5379 
 
5380 
  thrift_spec = (
5381 
    None, # 0
5382 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5383 
    (2, TType.I32, 'status', None, None, ), # 2
5384 
    (3, TType.STRING, 'description', None, None, ), # 3
5385 
  )
5386 
 
5387 
  def __init__(self, transactionId=None, status=None, description=None,):
5388 
    self.transactionId = transactionId
5389 
    self.status = status
5390 
    self.description = description
5391 
 
5392 
  def read(self, iprot):
5393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5395 
      return
5396 
    iprot.readStructBegin()
5397 
    while True:
5398 
      (fname, ftype, fid) = iprot.readFieldBegin()
5399 
      if ftype == TType.STOP:
5400 
        break
5401 
      if fid == 1:
5402 
        if ftype == TType.I64:
5403 
          self.transactionId = iprot.readI64();
5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      elif fid == 2:
5407 
        if ftype == TType.I32:
5408 
          self.status = iprot.readI32();
5409 
        else:
5410 
          iprot.skip(ftype)
5411 
      elif fid == 3:
5412 
        if ftype == TType.STRING:
5413 
          self.description = iprot.readString();
5414 
        else:
5415 
          iprot.skip(ftype)
5416 
      else:
5417 
        iprot.skip(ftype)
5418 
      iprot.readFieldEnd()
5419 
    iprot.readStructEnd()
5420 
 
5421 
  def write(self, oprot):
5422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5424 
      return
5425 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5426 
    if self.transactionId is not None:
94 ashish 5427 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5428 
      oprot.writeI64(self.transactionId)
5429 
      oprot.writeFieldEnd()
3431 rajveer 5430 
    if self.status is not None:
94 ashish 5431 
      oprot.writeFieldBegin('status', TType.I32, 2)
5432 
      oprot.writeI32(self.status)
5433 
      oprot.writeFieldEnd()
3431 rajveer 5434 
    if self.description is not None:
94 ashish 5435 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5436 
      oprot.writeString(self.description)
5437 
      oprot.writeFieldEnd()
5438 
    oprot.writeFieldStop()
5439 
    oprot.writeStructEnd()
5440 
 
3431 rajveer 5441 
  def validate(self):
5442 
    return
5443 
 
5444 
 
94 ashish 5445 
  def __repr__(self):
5446 
    L = ['%s=%r' % (key, value)
5447 
      for key, value in self.__dict__.iteritems()]
5448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5449 
 
5450 
  def __eq__(self, other):
5451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5452 
 
5453 
  def __ne__(self, other):
5454 
    return not (self == other)
5455 
 
5456 
class changeTransactionStatus_result:
5457 
  """
5458 
  Attributes:
5459 
   - success
5460 
   - ex
5461 
  """
5462 
 
5463 
  thrift_spec = (
5464 
    (0, TType.BOOL, 'success', None, None, ), # 0
5465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5466 
  )
5467 
 
5468 
  def __init__(self, success=None, ex=None,):
5469 
    self.success = success
5470 
    self.ex = ex
5471 
 
5472 
  def read(self, iprot):
5473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5475 
      return
5476 
    iprot.readStructBegin()
5477 
    while True:
5478 
      (fname, ftype, fid) = iprot.readFieldBegin()
5479 
      if ftype == TType.STOP:
5480 
        break
5481 
      if fid == 0:
5482 
        if ftype == TType.BOOL:
5483 
          self.success = iprot.readBool();
5484 
        else:
5485 
          iprot.skip(ftype)
5486 
      elif fid == 1:
5487 
        if ftype == TType.STRUCT:
5488 
          self.ex = TransactionServiceException()
5489 
          self.ex.read(iprot)
5490 
        else:
5491 
          iprot.skip(ftype)
5492 
      else:
5493 
        iprot.skip(ftype)
5494 
      iprot.readFieldEnd()
5495 
    iprot.readStructEnd()
5496 
 
5497 
  def write(self, oprot):
5498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5500 
      return
5501 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5502 
    if self.success is not None:
94 ashish 5503 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5504 
      oprot.writeBool(self.success)
5505 
      oprot.writeFieldEnd()
3431 rajveer 5506 
    if self.ex is not None:
94 ashish 5507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5508 
      self.ex.write(oprot)
5509 
      oprot.writeFieldEnd()
5510 
    oprot.writeFieldStop()
5511 
    oprot.writeStructEnd()
5512 
 
3431 rajveer 5513 
  def validate(self):
5514 
    return
5515 
 
5516 
 
94 ashish 5517 
  def __repr__(self):
5518 
    L = ['%s=%r' % (key, value)
5519 
      for key, value in self.__dict__.iteritems()]
5520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5521 
 
5522 
  def __eq__(self, other):
5523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5524 
 
5525 
  def __ne__(self, other):
5526 
    return not (self == other)
5527 
 
1398 varun.gupt 5528 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5529 
  """
5530 
  Attributes:
5531 
   - transactionId
5532 
  """
5533 
 
5534 
  thrift_spec = (
5535 
    None, # 0
5536 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5537 
  )
5538 
 
5539 
  def __init__(self, transactionId=None,):
5540 
    self.transactionId = transactionId
5541 
 
5542 
  def read(self, iprot):
5543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5545 
      return
5546 
    iprot.readStructBegin()
5547 
    while True:
5548 
      (fname, ftype, fid) = iprot.readFieldBegin()
5549 
      if ftype == TType.STOP:
5550 
        break
5551 
      if fid == 1:
5552 
        if ftype == TType.I64:
5553 
          self.transactionId = iprot.readI64();
5554 
        else:
5555 
          iprot.skip(ftype)
5556 
      else:
5557 
        iprot.skip(ftype)
5558 
      iprot.readFieldEnd()
5559 
    iprot.readStructEnd()
5560 
 
5561 
  def write(self, oprot):
5562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5564 
      return
1398 varun.gupt 5565 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5566 
    if self.transactionId is not None:
1382 varun.gupt 5567 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5568 
      oprot.writeI64(self.transactionId)
5569 
      oprot.writeFieldEnd()
5570 
    oprot.writeFieldStop()
5571 
    oprot.writeStructEnd()
5572 
 
3431 rajveer 5573 
  def validate(self):
5574 
    return
5575 
 
5576 
 
1382 varun.gupt 5577 
  def __repr__(self):
5578 
    L = ['%s=%r' % (key, value)
5579 
      for key, value in self.__dict__.iteritems()]
5580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5581 
 
5582 
  def __eq__(self, other):
5583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5584 
 
5585 
  def __ne__(self, other):
5586 
    return not (self == other)
5587 
 
1398 varun.gupt 5588 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5589 
  """
5590 
  Attributes:
5591 
   - success
5592 
   - ex
5593 
  """
5594 
 
5595 
  thrift_spec = (
5596 
    (0, TType.BOOL, 'success', None, None, ), # 0
5597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5598 
  )
5599 
 
5600 
  def __init__(self, success=None, ex=None,):
5601 
    self.success = success
5602 
    self.ex = ex
5603 
 
5604 
  def read(self, iprot):
5605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5607 
      return
5608 
    iprot.readStructBegin()
5609 
    while True:
5610 
      (fname, ftype, fid) = iprot.readFieldBegin()
5611 
      if ftype == TType.STOP:
5612 
        break
5613 
      if fid == 0:
5614 
        if ftype == TType.BOOL:
5615 
          self.success = iprot.readBool();
5616 
        else:
5617 
          iprot.skip(ftype)
5618 
      elif fid == 1:
5619 
        if ftype == TType.STRUCT:
5620 
          self.ex = TransactionServiceException()
5621 
          self.ex.read(iprot)
5622 
        else:
5623 
          iprot.skip(ftype)
5624 
      else:
5625 
        iprot.skip(ftype)
5626 
      iprot.readFieldEnd()
5627 
    iprot.readStructEnd()
5628 
 
5629 
  def write(self, oprot):
5630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5632 
      return
1398 varun.gupt 5633 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5634 
    if self.success is not None:
1382 varun.gupt 5635 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5636 
      oprot.writeBool(self.success)
5637 
      oprot.writeFieldEnd()
3431 rajveer 5638 
    if self.ex is not None:
1382 varun.gupt 5639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5640 
      self.ex.write(oprot)
5641 
      oprot.writeFieldEnd()
5642 
    oprot.writeFieldStop()
5643 
    oprot.writeStructEnd()
5644 
 
3431 rajveer 5645 
  def validate(self):
5646 
    return
5647 
 
5648 
 
1382 varun.gupt 5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
483 rajveer 5660 
class getAllOrders_args:
94 ashish 5661 
  """
5662 
  Attributes:
483 rajveer 5663 
   - status
5664 
   - from_date
5665 
   - to_date
5666 
   - warehouse_id
94 ashish 5667 
  """
5668 
 
5669 
  thrift_spec = (
5670 
    None, # 0
483 rajveer 5671 
    (1, TType.I32, 'status', None, None, ), # 1
5672 
    (2, TType.I64, 'from_date', None, None, ), # 2
5673 
    (3, TType.I64, 'to_date', None, None, ), # 3
5674 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5675 
  )
5676 
 
483 rajveer 5677 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5678 
    self.status = status
5679 
    self.from_date = from_date
5680 
    self.to_date = to_date
5681 
    self.warehouse_id = warehouse_id
94 ashish 5682 
 
5683 
  def read(self, iprot):
5684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5686 
      return
5687 
    iprot.readStructBegin()
5688 
    while True:
5689 
      (fname, ftype, fid) = iprot.readFieldBegin()
5690 
      if ftype == TType.STOP:
5691 
        break
5692 
      if fid == 1:
483 rajveer 5693 
        if ftype == TType.I32:
5694 
          self.status = iprot.readI32();
94 ashish 5695 
        else:
5696 
          iprot.skip(ftype)
483 rajveer 5697 
      elif fid == 2:
5698 
        if ftype == TType.I64:
5699 
          self.from_date = iprot.readI64();
94 ashish 5700 
        else:
5701 
          iprot.skip(ftype)
483 rajveer 5702 
      elif fid == 3:
5703 
        if ftype == TType.I64:
5704 
          self.to_date = iprot.readI64();
94 ashish 5705 
        else:
5706 
          iprot.skip(ftype)
483 rajveer 5707 
      elif fid == 4:
94 ashish 5708 
        if ftype == TType.I64:
483 rajveer 5709 
          self.warehouse_id = iprot.readI64();
94 ashish 5710 
        else:
5711 
          iprot.skip(ftype)
5712 
      else:
5713 
        iprot.skip(ftype)
5714 
      iprot.readFieldEnd()
5715 
    iprot.readStructEnd()
5716 
 
5717 
  def write(self, oprot):
5718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5720 
      return
483 rajveer 5721 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5722 
    if self.status is not None:
483 rajveer 5723 
      oprot.writeFieldBegin('status', TType.I32, 1)
5724 
      oprot.writeI32(self.status)
94 ashish 5725 
      oprot.writeFieldEnd()
3431 rajveer 5726 
    if self.from_date is not None:
483 rajveer 5727 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5728 
      oprot.writeI64(self.from_date)
94 ashish 5729 
      oprot.writeFieldEnd()
3431 rajveer 5730 
    if self.to_date is not None:
483 rajveer 5731 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5732 
      oprot.writeI64(self.to_date)
94 ashish 5733 
      oprot.writeFieldEnd()
3431 rajveer 5734 
    if self.warehouse_id is not None:
483 rajveer 5735 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5736 
      oprot.writeI64(self.warehouse_id)
94 ashish 5737 
      oprot.writeFieldEnd()
5738 
    oprot.writeFieldStop()
5739 
    oprot.writeStructEnd()
5740 
 
3431 rajveer 5741 
  def validate(self):
5742 
    return
5743 
 
5744 
 
94 ashish 5745 
  def __repr__(self):
5746 
    L = ['%s=%r' % (key, value)
5747 
      for key, value in self.__dict__.iteritems()]
5748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5749 
 
5750 
  def __eq__(self, other):
5751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5752 
 
5753 
  def __ne__(self, other):
5754 
    return not (self == other)
5755 
 
483 rajveer 5756 
class getAllOrders_result:
94 ashish 5757 
  """
5758 
  Attributes:
5759 
   - success
5760 
   - ex
5761 
  """
5762 
 
5763 
  thrift_spec = (
483 rajveer 5764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5766 
  )
5767 
 
5768 
  def __init__(self, success=None, ex=None,):
5769 
    self.success = success
5770 
    self.ex = ex
5771 
 
5772 
  def read(self, iprot):
5773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5775 
      return
5776 
    iprot.readStructBegin()
5777 
    while True:
5778 
      (fname, ftype, fid) = iprot.readFieldBegin()
5779 
      if ftype == TType.STOP:
5780 
        break
5781 
      if fid == 0:
483 rajveer 5782 
        if ftype == TType.LIST:
5783 
          self.success = []
685 chandransh 5784 
          (_etype31, _size28) = iprot.readListBegin()
5785 
          for _i32 in xrange(_size28):
5786 
            _elem33 = Order()
5787 
            _elem33.read(iprot)
5788 
            self.success.append(_elem33)
483 rajveer 5789 
          iprot.readListEnd()
94 ashish 5790 
        else:
5791 
          iprot.skip(ftype)
5792 
      elif fid == 1:
5793 
        if ftype == TType.STRUCT:
5794 
          self.ex = TransactionServiceException()
5795 
          self.ex.read(iprot)
5796 
        else:
5797 
          iprot.skip(ftype)
5798 
      else:
5799 
        iprot.skip(ftype)
5800 
      iprot.readFieldEnd()
5801 
    iprot.readStructEnd()
5802 
 
5803 
  def write(self, oprot):
5804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5806 
      return
483 rajveer 5807 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5808 
    if self.success is not None:
483 rajveer 5809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5811 
      for iter34 in self.success:
5812 
        iter34.write(oprot)
483 rajveer 5813 
      oprot.writeListEnd()
94 ashish 5814 
      oprot.writeFieldEnd()
3431 rajveer 5815 
    if self.ex is not None:
94 ashish 5816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5817 
      self.ex.write(oprot)
5818 
      oprot.writeFieldEnd()
5819 
    oprot.writeFieldStop()
5820 
    oprot.writeStructEnd()
5821 
 
3431 rajveer 5822 
  def validate(self):
5823 
    return
5824 
 
5825 
 
94 ashish 5826 
  def __repr__(self):
5827 
    L = ['%s=%r' % (key, value)
5828 
      for key, value in self.__dict__.iteritems()]
5829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5830 
 
5831 
  def __eq__(self, other):
5832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5833 
 
5834 
  def __ne__(self, other):
5835 
    return not (self == other)
5836 
 
4133 chandransh 5837 
class getOrdersInBatch_args:
5838 
  """
5839 
  Attributes:
5840 
   - statuses
5841 
   - offset
5842 
   - limit
5843 
   - warehouse_id
5844 
  """
5845 
 
5846 
  thrift_spec = (
5847 
    None, # 0
5848 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5849 
    (2, TType.I64, 'offset', None, None, ), # 2
5850 
    (3, TType.I64, 'limit', None, None, ), # 3
5851 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5852 
  )
5853 
 
5854 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5855 
    self.statuses = statuses
5856 
    self.offset = offset
5857 
    self.limit = limit
5858 
    self.warehouse_id = warehouse_id
5859 
 
5860 
  def read(self, iprot):
5861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5863 
      return
5864 
    iprot.readStructBegin()
5865 
    while True:
5866 
      (fname, ftype, fid) = iprot.readFieldBegin()
5867 
      if ftype == TType.STOP:
5868 
        break
5869 
      if fid == 1:
5870 
        if ftype == TType.LIST:
5871 
          self.statuses = []
5872 
          (_etype38, _size35) = iprot.readListBegin()
5873 
          for _i39 in xrange(_size35):
5874 
            _elem40 = iprot.readI32();
5875 
            self.statuses.append(_elem40)
5876 
          iprot.readListEnd()
5877 
        else:
5878 
          iprot.skip(ftype)
5879 
      elif fid == 2:
5880 
        if ftype == TType.I64:
5881 
          self.offset = iprot.readI64();
5882 
        else:
5883 
          iprot.skip(ftype)
5884 
      elif fid == 3:
5885 
        if ftype == TType.I64:
5886 
          self.limit = iprot.readI64();
5887 
        else:
5888 
          iprot.skip(ftype)
5889 
      elif fid == 4:
5890 
        if ftype == TType.I64:
5891 
          self.warehouse_id = iprot.readI64();
5892 
        else:
5893 
          iprot.skip(ftype)
5894 
      else:
5895 
        iprot.skip(ftype)
5896 
      iprot.readFieldEnd()
5897 
    iprot.readStructEnd()
5898 
 
5899 
  def write(self, oprot):
5900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5902 
      return
5903 
    oprot.writeStructBegin('getOrdersInBatch_args')
5904 
    if self.statuses is not None:
5905 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
5906 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5907 
      for iter41 in self.statuses:
5908 
        oprot.writeI32(iter41)
5909 
      oprot.writeListEnd()
5910 
      oprot.writeFieldEnd()
5911 
    if self.offset is not None:
5912 
      oprot.writeFieldBegin('offset', TType.I64, 2)
5913 
      oprot.writeI64(self.offset)
5914 
      oprot.writeFieldEnd()
5915 
    if self.limit is not None:
5916 
      oprot.writeFieldBegin('limit', TType.I64, 3)
5917 
      oprot.writeI64(self.limit)
5918 
      oprot.writeFieldEnd()
5919 
    if self.warehouse_id is not None:
5920 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5921 
      oprot.writeI64(self.warehouse_id)
5922 
      oprot.writeFieldEnd()
5923 
    oprot.writeFieldStop()
5924 
    oprot.writeStructEnd()
5925 
 
5926 
  def validate(self):
5927 
    return
5928 
 
5929 
 
5930 
  def __repr__(self):
5931 
    L = ['%s=%r' % (key, value)
5932 
      for key, value in self.__dict__.iteritems()]
5933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5934 
 
5935 
  def __eq__(self, other):
5936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5937 
 
5938 
  def __ne__(self, other):
5939 
    return not (self == other)
5940 
 
5941 
class getOrdersInBatch_result:
5942 
  """
5943 
  Attributes:
5944 
   - success
5945 
   - ex
5946 
  """
5947 
 
5948 
  thrift_spec = (
5949 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5951 
  )
5952 
 
5953 
  def __init__(self, success=None, ex=None,):
5954 
    self.success = success
5955 
    self.ex = ex
5956 
 
5957 
  def read(self, iprot):
5958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5960 
      return
5961 
    iprot.readStructBegin()
5962 
    while True:
5963 
      (fname, ftype, fid) = iprot.readFieldBegin()
5964 
      if ftype == TType.STOP:
5965 
        break
5966 
      if fid == 0:
5967 
        if ftype == TType.LIST:
5968 
          self.success = []
5969 
          (_etype45, _size42) = iprot.readListBegin()
5970 
          for _i46 in xrange(_size42):
5971 
            _elem47 = Order()
5972 
            _elem47.read(iprot)
5973 
            self.success.append(_elem47)
5974 
          iprot.readListEnd()
5975 
        else:
5976 
          iprot.skip(ftype)
5977 
      elif fid == 1:
5978 
        if ftype == TType.STRUCT:
5979 
          self.ex = TransactionServiceException()
5980 
          self.ex.read(iprot)
5981 
        else:
5982 
          iprot.skip(ftype)
5983 
      else:
5984 
        iprot.skip(ftype)
5985 
      iprot.readFieldEnd()
5986 
    iprot.readStructEnd()
5987 
 
5988 
  def write(self, oprot):
5989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5991 
      return
5992 
    oprot.writeStructBegin('getOrdersInBatch_result')
5993 
    if self.success is not None:
5994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5996 
      for iter48 in self.success:
5997 
        iter48.write(oprot)
5998 
      oprot.writeListEnd()
5999 
      oprot.writeFieldEnd()
6000 
    if self.ex is not None:
6001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6002 
      self.ex.write(oprot)
6003 
      oprot.writeFieldEnd()
6004 
    oprot.writeFieldStop()
6005 
    oprot.writeStructEnd()
6006 
 
6007 
  def validate(self):
6008 
    return
6009 
 
6010 
 
6011 
  def __repr__(self):
6012 
    L = ['%s=%r' % (key, value)
6013 
      for key, value in self.__dict__.iteritems()]
6014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6015 
 
6016 
  def __eq__(self, other):
6017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6018 
 
6019 
  def __ne__(self, other):
6020 
    return not (self == other)
6021 
 
6022 
class getOrderCount_args:
6023 
  """
6024 
  Attributes:
6025 
   - statuses
6026 
   - warehouseId
6027 
  """
6028 
 
6029 
  thrift_spec = (
6030 
    None, # 0
6031 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6032 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6033 
  )
6034 
 
6035 
  def __init__(self, statuses=None, warehouseId=None,):
6036 
    self.statuses = statuses
6037 
    self.warehouseId = warehouseId
6038 
 
6039 
  def read(self, iprot):
6040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6042 
      return
6043 
    iprot.readStructBegin()
6044 
    while True:
6045 
      (fname, ftype, fid) = iprot.readFieldBegin()
6046 
      if ftype == TType.STOP:
6047 
        break
6048 
      if fid == 1:
6049 
        if ftype == TType.LIST:
6050 
          self.statuses = []
6051 
          (_etype52, _size49) = iprot.readListBegin()
6052 
          for _i53 in xrange(_size49):
6053 
            _elem54 = iprot.readI32();
6054 
            self.statuses.append(_elem54)
6055 
          iprot.readListEnd()
6056 
        else:
6057 
          iprot.skip(ftype)
6058 
      elif fid == 2:
6059 
        if ftype == TType.I64:
6060 
          self.warehouseId = iprot.readI64();
6061 
        else:
6062 
          iprot.skip(ftype)
6063 
      else:
6064 
        iprot.skip(ftype)
6065 
      iprot.readFieldEnd()
6066 
    iprot.readStructEnd()
6067 
 
6068 
  def write(self, oprot):
6069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6071 
      return
6072 
    oprot.writeStructBegin('getOrderCount_args')
6073 
    if self.statuses is not None:
6074 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6075 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6076 
      for iter55 in self.statuses:
6077 
        oprot.writeI32(iter55)
6078 
      oprot.writeListEnd()
6079 
      oprot.writeFieldEnd()
6080 
    if self.warehouseId is not None:
6081 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6082 
      oprot.writeI64(self.warehouseId)
6083 
      oprot.writeFieldEnd()
6084 
    oprot.writeFieldStop()
6085 
    oprot.writeStructEnd()
6086 
 
6087 
  def validate(self):
6088 
    return
6089 
 
6090 
 
6091 
  def __repr__(self):
6092 
    L = ['%s=%r' % (key, value)
6093 
      for key, value in self.__dict__.iteritems()]
6094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6095 
 
6096 
  def __eq__(self, other):
6097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6098 
 
6099 
  def __ne__(self, other):
6100 
    return not (self == other)
6101 
 
6102 
class getOrderCount_result:
6103 
  """
6104 
  Attributes:
6105 
   - success
6106 
   - ex
6107 
  """
6108 
 
6109 
  thrift_spec = (
6110 
    (0, TType.I32, 'success', None, None, ), # 0
6111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6112 
  )
6113 
 
6114 
  def __init__(self, success=None, ex=None,):
6115 
    self.success = success
6116 
    self.ex = ex
6117 
 
6118 
  def read(self, iprot):
6119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6121 
      return
6122 
    iprot.readStructBegin()
6123 
    while True:
6124 
      (fname, ftype, fid) = iprot.readFieldBegin()
6125 
      if ftype == TType.STOP:
6126 
        break
6127 
      if fid == 0:
6128 
        if ftype == TType.I32:
6129 
          self.success = iprot.readI32();
6130 
        else:
6131 
          iprot.skip(ftype)
6132 
      elif fid == 1:
6133 
        if ftype == TType.STRUCT:
6134 
          self.ex = TransactionServiceException()
6135 
          self.ex.read(iprot)
6136 
        else:
6137 
          iprot.skip(ftype)
6138 
      else:
6139 
        iprot.skip(ftype)
6140 
      iprot.readFieldEnd()
6141 
    iprot.readStructEnd()
6142 
 
6143 
  def write(self, oprot):
6144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6146 
      return
6147 
    oprot.writeStructBegin('getOrderCount_result')
6148 
    if self.success is not None:
6149 
      oprot.writeFieldBegin('success', TType.I32, 0)
6150 
      oprot.writeI32(self.success)
6151 
      oprot.writeFieldEnd()
6152 
    if self.ex is not None:
6153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6154 
      self.ex.write(oprot)
6155 
      oprot.writeFieldEnd()
6156 
    oprot.writeFieldStop()
6157 
    oprot.writeStructEnd()
6158 
 
6159 
  def validate(self):
6160 
    return
6161 
 
6162 
 
6163 
  def __repr__(self):
6164 
    L = ['%s=%r' % (key, value)
6165 
      for key, value in self.__dict__.iteritems()]
6166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6167 
 
6168 
  def __eq__(self, other):
6169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6170 
 
6171 
  def __ne__(self, other):
6172 
    return not (self == other)
6173 
 
999 varun.gupt 6174 
class getOrdersByBillingDate_args:
6175 
  """
6176 
  Attributes:
6177 
   - status
6178 
   - start_billing_date
6179 
   - end_billing_date
6180 
   - warehouse_id
6181 
  """
6182 
 
6183 
  thrift_spec = (
6184 
    None, # 0
6185 
    (1, TType.I32, 'status', None, None, ), # 1
6186 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6187 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6188 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6189 
  )
6190 
 
6191 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6192 
    self.status = status
6193 
    self.start_billing_date = start_billing_date
6194 
    self.end_billing_date = end_billing_date
6195 
    self.warehouse_id = warehouse_id
6196 
 
6197 
  def read(self, iprot):
6198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6200 
      return
6201 
    iprot.readStructBegin()
6202 
    while True:
6203 
      (fname, ftype, fid) = iprot.readFieldBegin()
6204 
      if ftype == TType.STOP:
6205 
        break
6206 
      if fid == 1:
6207 
        if ftype == TType.I32:
6208 
          self.status = iprot.readI32();
6209 
        else:
6210 
          iprot.skip(ftype)
6211 
      elif fid == 2:
6212 
        if ftype == TType.I64:
6213 
          self.start_billing_date = iprot.readI64();
6214 
        else:
6215 
          iprot.skip(ftype)
6216 
      elif fid == 3:
6217 
        if ftype == TType.I64:
6218 
          self.end_billing_date = iprot.readI64();
6219 
        else:
6220 
          iprot.skip(ftype)
6221 
      elif fid == 4:
6222 
        if ftype == TType.I64:
6223 
          self.warehouse_id = iprot.readI64();
6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      else:
6227 
        iprot.skip(ftype)
6228 
      iprot.readFieldEnd()
6229 
    iprot.readStructEnd()
6230 
 
6231 
  def write(self, oprot):
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6234 
      return
6235 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6236 
    if self.status is not None:
999 varun.gupt 6237 
      oprot.writeFieldBegin('status', TType.I32, 1)
6238 
      oprot.writeI32(self.status)
6239 
      oprot.writeFieldEnd()
3431 rajveer 6240 
    if self.start_billing_date is not None:
999 varun.gupt 6241 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6242 
      oprot.writeI64(self.start_billing_date)
6243 
      oprot.writeFieldEnd()
3431 rajveer 6244 
    if self.end_billing_date is not None:
999 varun.gupt 6245 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6246 
      oprot.writeI64(self.end_billing_date)
6247 
      oprot.writeFieldEnd()
3431 rajveer 6248 
    if self.warehouse_id is not None:
999 varun.gupt 6249 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6250 
      oprot.writeI64(self.warehouse_id)
6251 
      oprot.writeFieldEnd()
6252 
    oprot.writeFieldStop()
6253 
    oprot.writeStructEnd()
6254 
 
3431 rajveer 6255 
  def validate(self):
6256 
    return
6257 
 
6258 
 
999 varun.gupt 6259 
  def __repr__(self):
6260 
    L = ['%s=%r' % (key, value)
6261 
      for key, value in self.__dict__.iteritems()]
6262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6263 
 
6264 
  def __eq__(self, other):
6265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6266 
 
6267 
  def __ne__(self, other):
6268 
    return not (self == other)
6269 
 
6270 
class getOrdersByBillingDate_result:
6271 
  """
6272 
  Attributes:
6273 
   - success
6274 
   - ex
6275 
  """
6276 
 
6277 
  thrift_spec = (
6278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6280 
  )
6281 
 
6282 
  def __init__(self, success=None, ex=None,):
6283 
    self.success = success
6284 
    self.ex = ex
6285 
 
6286 
  def read(self, iprot):
6287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6289 
      return
6290 
    iprot.readStructBegin()
6291 
    while True:
6292 
      (fname, ftype, fid) = iprot.readFieldBegin()
6293 
      if ftype == TType.STOP:
6294 
        break
6295 
      if fid == 0:
6296 
        if ftype == TType.LIST:
6297 
          self.success = []
4133 chandransh 6298 
          (_etype59, _size56) = iprot.readListBegin()
6299 
          for _i60 in xrange(_size56):
6300 
            _elem61 = Order()
6301 
            _elem61.read(iprot)
6302 
            self.success.append(_elem61)
999 varun.gupt 6303 
          iprot.readListEnd()
6304 
        else:
6305 
          iprot.skip(ftype)
6306 
      elif fid == 1:
6307 
        if ftype == TType.STRUCT:
6308 
          self.ex = TransactionServiceException()
6309 
          self.ex.read(iprot)
6310 
        else:
6311 
          iprot.skip(ftype)
6312 
      else:
6313 
        iprot.skip(ftype)
6314 
      iprot.readFieldEnd()
6315 
    iprot.readStructEnd()
6316 
 
6317 
  def write(self, oprot):
6318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6320 
      return
6321 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6322 
    if self.success is not None:
999 varun.gupt 6323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6324 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6325 
      for iter62 in self.success:
6326 
        iter62.write(oprot)
999 varun.gupt 6327 
      oprot.writeListEnd()
6328 
      oprot.writeFieldEnd()
3431 rajveer 6329 
    if self.ex is not None:
999 varun.gupt 6330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6331 
      self.ex.write(oprot)
6332 
      oprot.writeFieldEnd()
6333 
    oprot.writeFieldStop()
6334 
    oprot.writeStructEnd()
6335 
 
3431 rajveer 6336 
  def validate(self):
6337 
    return
6338 
 
6339 
 
999 varun.gupt 6340 
  def __repr__(self):
6341 
    L = ['%s=%r' % (key, value)
6342 
      for key, value in self.__dict__.iteritems()]
6343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6344 
 
6345 
  def __eq__(self, other):
6346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6347 
 
6348 
  def __ne__(self, other):
6349 
    return not (self == other)
6350 
 
3427 chandransh 6351 
class getOrdersByShippingDate_args:
6352 
  """
6353 
  Attributes:
6354 
   - fromShippingDate
6355 
   - toShippingDate
6356 
   - providerId
6357 
   - warehouseId
3451 chandransh 6358 
   - cod
3427 chandransh 6359 
  """
6360 
 
6361 
  thrift_spec = (
6362 
    None, # 0
6363 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6364 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6365 
    (3, TType.I64, 'providerId', None, None, ), # 3
6366 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6367 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6368 
  )
6369 
 
3451 chandransh 6370 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6371 
    self.fromShippingDate = fromShippingDate
6372 
    self.toShippingDate = toShippingDate
6373 
    self.providerId = providerId
6374 
    self.warehouseId = warehouseId
3451 chandransh 6375 
    self.cod = cod
3427 chandransh 6376 
 
6377 
  def read(self, iprot):
6378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6380 
      return
6381 
    iprot.readStructBegin()
6382 
    while True:
6383 
      (fname, ftype, fid) = iprot.readFieldBegin()
6384 
      if ftype == TType.STOP:
6385 
        break
6386 
      if fid == 1:
6387 
        if ftype == TType.I64:
6388 
          self.fromShippingDate = iprot.readI64();
6389 
        else:
6390 
          iprot.skip(ftype)
6391 
      elif fid == 2:
6392 
        if ftype == TType.I64:
6393 
          self.toShippingDate = iprot.readI64();
6394 
        else:
6395 
          iprot.skip(ftype)
6396 
      elif fid == 3:
6397 
        if ftype == TType.I64:
6398 
          self.providerId = iprot.readI64();
6399 
        else:
6400 
          iprot.skip(ftype)
6401 
      elif fid == 4:
6402 
        if ftype == TType.I64:
6403 
          self.warehouseId = iprot.readI64();
6404 
        else:
6405 
          iprot.skip(ftype)
3451 chandransh 6406 
      elif fid == 5:
6407 
        if ftype == TType.BOOL:
6408 
          self.cod = iprot.readBool();
6409 
        else:
6410 
          iprot.skip(ftype)
3427 chandransh 6411 
      else:
6412 
        iprot.skip(ftype)
6413 
      iprot.readFieldEnd()
6414 
    iprot.readStructEnd()
6415 
 
6416 
  def write(self, oprot):
6417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6419 
      return
6420 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6421 
    if self.fromShippingDate is not None:
3427 chandransh 6422 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6423 
      oprot.writeI64(self.fromShippingDate)
6424 
      oprot.writeFieldEnd()
3431 rajveer 6425 
    if self.toShippingDate is not None:
3427 chandransh 6426 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6427 
      oprot.writeI64(self.toShippingDate)
6428 
      oprot.writeFieldEnd()
3431 rajveer 6429 
    if self.providerId is not None:
3427 chandransh 6430 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6431 
      oprot.writeI64(self.providerId)
6432 
      oprot.writeFieldEnd()
3431 rajveer 6433 
    if self.warehouseId is not None:
3427 chandransh 6434 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6435 
      oprot.writeI64(self.warehouseId)
6436 
      oprot.writeFieldEnd()
3451 chandransh 6437 
    if self.cod is not None:
6438 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6439 
      oprot.writeBool(self.cod)
6440 
      oprot.writeFieldEnd()
3427 chandransh 6441 
    oprot.writeFieldStop()
6442 
    oprot.writeStructEnd()
6443 
 
3431 rajveer 6444 
  def validate(self):
6445 
    return
6446 
 
6447 
 
3427 chandransh 6448 
  def __repr__(self):
6449 
    L = ['%s=%r' % (key, value)
6450 
      for key, value in self.__dict__.iteritems()]
6451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6452 
 
6453 
  def __eq__(self, other):
6454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6455 
 
6456 
  def __ne__(self, other):
6457 
    return not (self == other)
6458 
 
6459 
class getOrdersByShippingDate_result:
6460 
  """
6461 
  Attributes:
6462 
   - success
6463 
   - ex
6464 
  """
6465 
 
6466 
  thrift_spec = (
6467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6469 
  )
6470 
 
6471 
  def __init__(self, success=None, ex=None,):
6472 
    self.success = success
6473 
    self.ex = ex
6474 
 
6475 
  def read(self, iprot):
6476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6478 
      return
6479 
    iprot.readStructBegin()
6480 
    while True:
6481 
      (fname, ftype, fid) = iprot.readFieldBegin()
6482 
      if ftype == TType.STOP:
6483 
        break
6484 
      if fid == 0:
6485 
        if ftype == TType.LIST:
6486 
          self.success = []
4133 chandransh 6487 
          (_etype66, _size63) = iprot.readListBegin()
6488 
          for _i67 in xrange(_size63):
6489 
            _elem68 = Order()
6490 
            _elem68.read(iprot)
6491 
            self.success.append(_elem68)
3427 chandransh 6492 
          iprot.readListEnd()
6493 
        else:
6494 
          iprot.skip(ftype)
6495 
      elif fid == 1:
6496 
        if ftype == TType.STRUCT:
6497 
          self.ex = TransactionServiceException()
6498 
          self.ex.read(iprot)
6499 
        else:
6500 
          iprot.skip(ftype)
6501 
      else:
6502 
        iprot.skip(ftype)
6503 
      iprot.readFieldEnd()
6504 
    iprot.readStructEnd()
6505 
 
6506 
  def write(self, oprot):
6507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6509 
      return
6510 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6511 
    if self.success is not None:
3427 chandransh 6512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6513 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6514 
      for iter69 in self.success:
6515 
        iter69.write(oprot)
3427 chandransh 6516 
      oprot.writeListEnd()
6517 
      oprot.writeFieldEnd()
3431 rajveer 6518 
    if self.ex is not None:
3427 chandransh 6519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6520 
      self.ex.write(oprot)
6521 
      oprot.writeFieldEnd()
6522 
    oprot.writeFieldStop()
6523 
    oprot.writeStructEnd()
6524 
 
3431 rajveer 6525 
  def validate(self):
6526 
    return
6527 
 
6528 
 
3427 chandransh 6529 
  def __repr__(self):
6530 
    L = ['%s=%r' % (key, value)
6531 
      for key, value in self.__dict__.iteritems()]
6532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6533 
 
6534 
  def __eq__(self, other):
6535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6536 
 
6537 
  def __ne__(self, other):
6538 
    return not (self == other)
6539 
 
1382 varun.gupt 6540 
class getReturnableOrdersForCustomer_args:
6541 
  """
6542 
  Attributes:
6543 
   - customer_id
6544 
   - limit
6545 
  """
6546 
 
6547 
  thrift_spec = (
6548 
    None, # 0
6549 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6550 
    (2, TType.I64, 'limit', None, None, ), # 2
6551 
  )
6552 
 
6553 
  def __init__(self, customer_id=None, limit=None,):
6554 
    self.customer_id = customer_id
6555 
    self.limit = limit
6556 
 
6557 
  def read(self, iprot):
6558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6560 
      return
6561 
    iprot.readStructBegin()
6562 
    while True:
6563 
      (fname, ftype, fid) = iprot.readFieldBegin()
6564 
      if ftype == TType.STOP:
6565 
        break
6566 
      if fid == 1:
6567 
        if ftype == TType.I64:
6568 
          self.customer_id = iprot.readI64();
6569 
        else:
6570 
          iprot.skip(ftype)
6571 
      elif fid == 2:
6572 
        if ftype == TType.I64:
6573 
          self.limit = iprot.readI64();
6574 
        else:
6575 
          iprot.skip(ftype)
6576 
      else:
6577 
        iprot.skip(ftype)
6578 
      iprot.readFieldEnd()
6579 
    iprot.readStructEnd()
6580 
 
6581 
  def write(self, oprot):
6582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6584 
      return
6585 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6586 
    if self.customer_id is not None:
1382 varun.gupt 6587 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6588 
      oprot.writeI64(self.customer_id)
6589 
      oprot.writeFieldEnd()
3431 rajveer 6590 
    if self.limit is not None:
1382 varun.gupt 6591 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6592 
      oprot.writeI64(self.limit)
6593 
      oprot.writeFieldEnd()
6594 
    oprot.writeFieldStop()
6595 
    oprot.writeStructEnd()
6596 
 
3431 rajveer 6597 
  def validate(self):
6598 
    return
6599 
 
6600 
 
1382 varun.gupt 6601 
  def __repr__(self):
6602 
    L = ['%s=%r' % (key, value)
6603 
      for key, value in self.__dict__.iteritems()]
6604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6605 
 
6606 
  def __eq__(self, other):
6607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6608 
 
6609 
  def __ne__(self, other):
6610 
    return not (self == other)
6611 
 
6612 
class getReturnableOrdersForCustomer_result:
6613 
  """
6614 
  Attributes:
6615 
   - success
6616 
   - ex
6617 
  """
6618 
 
6619 
  thrift_spec = (
6620 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6622 
  )
6623 
 
6624 
  def __init__(self, success=None, ex=None,):
6625 
    self.success = success
6626 
    self.ex = ex
6627 
 
6628 
  def read(self, iprot):
6629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6631 
      return
6632 
    iprot.readStructBegin()
6633 
    while True:
6634 
      (fname, ftype, fid) = iprot.readFieldBegin()
6635 
      if ftype == TType.STOP:
6636 
        break
6637 
      if fid == 0:
6638 
        if ftype == TType.LIST:
6639 
          self.success = []
4133 chandransh 6640 
          (_etype73, _size70) = iprot.readListBegin()
6641 
          for _i74 in xrange(_size70):
6642 
            _elem75 = iprot.readI64();
6643 
            self.success.append(_elem75)
1382 varun.gupt 6644 
          iprot.readListEnd()
6645 
        else:
6646 
          iprot.skip(ftype)
6647 
      elif fid == 1:
6648 
        if ftype == TType.STRUCT:
6649 
          self.ex = TransactionServiceException()
6650 
          self.ex.read(iprot)
6651 
        else:
6652 
          iprot.skip(ftype)
6653 
      else:
6654 
        iprot.skip(ftype)
6655 
      iprot.readFieldEnd()
6656 
    iprot.readStructEnd()
6657 
 
6658 
  def write(self, oprot):
6659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6661 
      return
6662 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6663 
    if self.success is not None:
1382 varun.gupt 6664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6665 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6666 
      for iter76 in self.success:
6667 
        oprot.writeI64(iter76)
1382 varun.gupt 6668 
      oprot.writeListEnd()
6669 
      oprot.writeFieldEnd()
3431 rajveer 6670 
    if self.ex is not None:
1382 varun.gupt 6671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6672 
      self.ex.write(oprot)
6673 
      oprot.writeFieldEnd()
6674 
    oprot.writeFieldStop()
6675 
    oprot.writeStructEnd()
6676 
 
3431 rajveer 6677 
  def validate(self):
6678 
    return
6679 
 
6680 
 
1382 varun.gupt 6681 
  def __repr__(self):
6682 
    L = ['%s=%r' % (key, value)
6683 
      for key, value in self.__dict__.iteritems()]
6684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6685 
 
6686 
  def __eq__(self, other):
6687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6688 
 
6689 
  def __ne__(self, other):
6690 
    return not (self == other)
6691 
 
6692 
class getCancellableOrdersForCustomer_args:
6693 
  """
6694 
  Attributes:
6695 
   - customer_id
6696 
   - limit
6697 
  """
6698 
 
6699 
  thrift_spec = (
6700 
    None, # 0
6701 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6702 
    (2, TType.I64, 'limit', None, None, ), # 2
6703 
  )
6704 
 
6705 
  def __init__(self, customer_id=None, limit=None,):
6706 
    self.customer_id = customer_id
6707 
    self.limit = limit
6708 
 
6709 
  def read(self, iprot):
6710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6712 
      return
6713 
    iprot.readStructBegin()
6714 
    while True:
6715 
      (fname, ftype, fid) = iprot.readFieldBegin()
6716 
      if ftype == TType.STOP:
6717 
        break
6718 
      if fid == 1:
6719 
        if ftype == TType.I64:
6720 
          self.customer_id = iprot.readI64();
6721 
        else:
6722 
          iprot.skip(ftype)
6723 
      elif fid == 2:
6724 
        if ftype == TType.I64:
6725 
          self.limit = iprot.readI64();
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
6737 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6738 
    if self.customer_id is not None:
1382 varun.gupt 6739 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6740 
      oprot.writeI64(self.customer_id)
6741 
      oprot.writeFieldEnd()
3431 rajveer 6742 
    if self.limit is not None:
1382 varun.gupt 6743 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6744 
      oprot.writeI64(self.limit)
6745 
      oprot.writeFieldEnd()
6746 
    oprot.writeFieldStop()
6747 
    oprot.writeStructEnd()
6748 
 
3431 rajveer 6749 
  def validate(self):
6750 
    return
6751 
 
6752 
 
1382 varun.gupt 6753 
  def __repr__(self):
6754 
    L = ['%s=%r' % (key, value)
6755 
      for key, value in self.__dict__.iteritems()]
6756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6757 
 
6758 
  def __eq__(self, other):
6759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6760 
 
6761 
  def __ne__(self, other):
6762 
    return not (self == other)
6763 
 
6764 
class getCancellableOrdersForCustomer_result:
6765 
  """
6766 
  Attributes:
6767 
   - success
6768 
   - ex
6769 
  """
6770 
 
6771 
  thrift_spec = (
6772 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6774 
  )
6775 
 
6776 
  def __init__(self, success=None, ex=None,):
6777 
    self.success = success
6778 
    self.ex = ex
6779 
 
6780 
  def read(self, iprot):
6781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6783 
      return
6784 
    iprot.readStructBegin()
6785 
    while True:
6786 
      (fname, ftype, fid) = iprot.readFieldBegin()
6787 
      if ftype == TType.STOP:
6788 
        break
6789 
      if fid == 0:
6790 
        if ftype == TType.LIST:
6791 
          self.success = []
4133 chandransh 6792 
          (_etype80, _size77) = iprot.readListBegin()
6793 
          for _i81 in xrange(_size77):
6794 
            _elem82 = iprot.readI64();
6795 
            self.success.append(_elem82)
1382 varun.gupt 6796 
          iprot.readListEnd()
6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      elif fid == 1:
6800 
        if ftype == TType.STRUCT:
6801 
          self.ex = TransactionServiceException()
6802 
          self.ex.read(iprot)
6803 
        else:
6804 
          iprot.skip(ftype)
6805 
      else:
6806 
        iprot.skip(ftype)
6807 
      iprot.readFieldEnd()
6808 
    iprot.readStructEnd()
6809 
 
6810 
  def write(self, oprot):
6811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6813 
      return
6814 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6815 
    if self.success is not None:
1382 varun.gupt 6816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6817 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6818 
      for iter83 in self.success:
6819 
        oprot.writeI64(iter83)
1382 varun.gupt 6820 
      oprot.writeListEnd()
6821 
      oprot.writeFieldEnd()
3431 rajveer 6822 
    if self.ex is not None:
1382 varun.gupt 6823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6824 
      self.ex.write(oprot)
6825 
      oprot.writeFieldEnd()
6826 
    oprot.writeFieldStop()
6827 
    oprot.writeStructEnd()
6828 
 
3431 rajveer 6829 
  def validate(self):
6830 
    return
6831 
 
6832 
 
1382 varun.gupt 6833 
  def __repr__(self):
6834 
    L = ['%s=%r' % (key, value)
6835 
      for key, value in self.__dict__.iteritems()]
6836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6837 
 
6838 
  def __eq__(self, other):
6839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6840 
 
6841 
  def __ne__(self, other):
6842 
    return not (self == other)
6843 
 
483 rajveer 6844 
class changeOrderStatus_args:
94 ashish 6845 
  """
6846 
  Attributes:
483 rajveer 6847 
   - orderId
6848 
   - status
6849 
   - description
94 ashish 6850 
  """
6851 
 
6852 
  thrift_spec = (
6853 
    None, # 0
483 rajveer 6854 
    (1, TType.I64, 'orderId', None, None, ), # 1
6855 
    (2, TType.I32, 'status', None, None, ), # 2
6856 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6857 
  )
6858 
 
483 rajveer 6859 
  def __init__(self, orderId=None, status=None, description=None,):
6860 
    self.orderId = orderId
6861 
    self.status = status
6862 
    self.description = description
94 ashish 6863 
 
6864 
  def read(self, iprot):
6865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6867 
      return
6868 
    iprot.readStructBegin()
6869 
    while True:
6870 
      (fname, ftype, fid) = iprot.readFieldBegin()
6871 
      if ftype == TType.STOP:
6872 
        break
6873 
      if fid == 1:
6874 
        if ftype == TType.I64:
483 rajveer 6875 
          self.orderId = iprot.readI64();
94 ashish 6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      elif fid == 2:
483 rajveer 6879 
        if ftype == TType.I32:
6880 
          self.status = iprot.readI32();
94 ashish 6881 
        else:
6882 
          iprot.skip(ftype)
483 rajveer 6883 
      elif fid == 3:
6884 
        if ftype == TType.STRING:
6885 
          self.description = iprot.readString();
6886 
        else:
6887 
          iprot.skip(ftype)
94 ashish 6888 
      else:
6889 
        iprot.skip(ftype)
6890 
      iprot.readFieldEnd()
6891 
    iprot.readStructEnd()
6892 
 
6893 
  def write(self, oprot):
6894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6896 
      return
483 rajveer 6897 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 6898 
    if self.orderId is not None:
483 rajveer 6899 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6900 
      oprot.writeI64(self.orderId)
94 ashish 6901 
      oprot.writeFieldEnd()
3431 rajveer 6902 
    if self.status is not None:
483 rajveer 6903 
      oprot.writeFieldBegin('status', TType.I32, 2)
6904 
      oprot.writeI32(self.status)
94 ashish 6905 
      oprot.writeFieldEnd()
3431 rajveer 6906 
    if self.description is not None:
483 rajveer 6907 
      oprot.writeFieldBegin('description', TType.STRING, 3)
6908 
      oprot.writeString(self.description)
6909 
      oprot.writeFieldEnd()
94 ashish 6910 
    oprot.writeFieldStop()
6911 
    oprot.writeStructEnd()
6912 
 
3431 rajveer 6913 
  def validate(self):
6914 
    return
6915 
 
6916 
 
94 ashish 6917 
  def __repr__(self):
6918 
    L = ['%s=%r' % (key, value)
6919 
      for key, value in self.__dict__.iteritems()]
6920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6921 
 
6922 
  def __eq__(self, other):
6923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6924 
 
6925 
  def __ne__(self, other):
6926 
    return not (self == other)
6927 
 
483 rajveer 6928 
class changeOrderStatus_result:
94 ashish 6929 
  """
6930 
  Attributes:
6931 
   - success
6932 
   - ex
6933 
  """
6934 
 
6935 
  thrift_spec = (
6936 
    (0, TType.BOOL, 'success', None, None, ), # 0
6937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6938 
  )
6939 
 
6940 
  def __init__(self, success=None, ex=None,):
6941 
    self.success = success
6942 
    self.ex = ex
6943 
 
6944 
  def read(self, iprot):
6945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6947 
      return
6948 
    iprot.readStructBegin()
6949 
    while True:
6950 
      (fname, ftype, fid) = iprot.readFieldBegin()
6951 
      if ftype == TType.STOP:
6952 
        break
6953 
      if fid == 0:
6954 
        if ftype == TType.BOOL:
6955 
          self.success = iprot.readBool();
6956 
        else:
6957 
          iprot.skip(ftype)
6958 
      elif fid == 1:
6959 
        if ftype == TType.STRUCT:
6960 
          self.ex = TransactionServiceException()
6961 
          self.ex.read(iprot)
6962 
        else:
6963 
          iprot.skip(ftype)
6964 
      else:
6965 
        iprot.skip(ftype)
6966 
      iprot.readFieldEnd()
6967 
    iprot.readStructEnd()
6968 
 
6969 
  def write(self, oprot):
6970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6972 
      return
483 rajveer 6973 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 6974 
    if self.success is not None:
94 ashish 6975 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6976 
      oprot.writeBool(self.success)
6977 
      oprot.writeFieldEnd()
3431 rajveer 6978 
    if self.ex is not None:
94 ashish 6979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6980 
      self.ex.write(oprot)
6981 
      oprot.writeFieldEnd()
6982 
    oprot.writeFieldStop()
6983 
    oprot.writeStructEnd()
6984 
 
3431 rajveer 6985 
  def validate(self):
6986 
    return
6987 
 
6988 
 
94 ashish 6989 
  def __repr__(self):
6990 
    L = ['%s=%r' % (key, value)
6991 
      for key, value in self.__dict__.iteritems()]
6992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6993 
 
6994 
  def __eq__(self, other):
6995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6996 
 
6997 
  def __ne__(self, other):
6998 
    return not (self == other)
6999 
 
3064 chandransh 7000 
class getOrdersForTransaction_args:
494 rajveer 7001 
  """
7002 
  Attributes:
3064 chandransh 7003 
   - transactionId
7004 
   - customerId
494 rajveer 7005 
  """
7006 
 
7007 
  thrift_spec = (
7008 
    None, # 0
3064 chandransh 7009 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7010 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7011 
  )
7012 
 
3064 chandransh 7013 
  def __init__(self, transactionId=None, customerId=None,):
7014 
    self.transactionId = transactionId
7015 
    self.customerId = customerId
494 rajveer 7016 
 
7017 
  def read(self, iprot):
7018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7020 
      return
7021 
    iprot.readStructBegin()
7022 
    while True:
7023 
      (fname, ftype, fid) = iprot.readFieldBegin()
7024 
      if ftype == TType.STOP:
7025 
        break
7026 
      if fid == 1:
7027 
        if ftype == TType.I64:
3064 chandransh 7028 
          self.transactionId = iprot.readI64();
494 rajveer 7029 
        else:
7030 
          iprot.skip(ftype)
7031 
      elif fid == 2:
3064 chandransh 7032 
        if ftype == TType.I64:
7033 
          self.customerId = iprot.readI64();
494 rajveer 7034 
        else:
7035 
          iprot.skip(ftype)
7036 
      else:
7037 
        iprot.skip(ftype)
7038 
      iprot.readFieldEnd()
7039 
    iprot.readStructEnd()
7040 
 
7041 
  def write(self, oprot):
7042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7044 
      return
3064 chandransh 7045 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7046 
    if self.transactionId is not None:
3064 chandransh 7047 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7048 
      oprot.writeI64(self.transactionId)
494 rajveer 7049 
      oprot.writeFieldEnd()
3431 rajveer 7050 
    if self.customerId is not None:
3064 chandransh 7051 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7052 
      oprot.writeI64(self.customerId)
494 rajveer 7053 
      oprot.writeFieldEnd()
7054 
    oprot.writeFieldStop()
7055 
    oprot.writeStructEnd()
7056 
 
3431 rajveer 7057 
  def validate(self):
7058 
    return
7059 
 
7060 
 
494 rajveer 7061 
  def __repr__(self):
7062 
    L = ['%s=%r' % (key, value)
7063 
      for key, value in self.__dict__.iteritems()]
7064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7065 
 
7066 
  def __eq__(self, other):
7067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7068 
 
7069 
  def __ne__(self, other):
7070 
    return not (self == other)
7071 
 
3064 chandransh 7072 
class getOrdersForTransaction_result:
494 rajveer 7073 
  """
7074 
  Attributes:
7075 
   - success
7076 
   - ex
7077 
  """
7078 
 
7079 
  thrift_spec = (
3064 chandransh 7080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7082 
  )
7083 
 
7084 
  def __init__(self, success=None, ex=None,):
7085 
    self.success = success
7086 
    self.ex = ex
7087 
 
7088 
  def read(self, iprot):
7089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7091 
      return
7092 
    iprot.readStructBegin()
7093 
    while True:
7094 
      (fname, ftype, fid) = iprot.readFieldBegin()
7095 
      if ftype == TType.STOP:
7096 
        break
7097 
      if fid == 0:
3064 chandransh 7098 
        if ftype == TType.LIST:
7099 
          self.success = []
4133 chandransh 7100 
          (_etype87, _size84) = iprot.readListBegin()
7101 
          for _i88 in xrange(_size84):
7102 
            _elem89 = Order()
7103 
            _elem89.read(iprot)
7104 
            self.success.append(_elem89)
3064 chandransh 7105 
          iprot.readListEnd()
494 rajveer 7106 
        else:
7107 
          iprot.skip(ftype)
7108 
      elif fid == 1:
7109 
        if ftype == TType.STRUCT:
7110 
          self.ex = TransactionServiceException()
7111 
          self.ex.read(iprot)
7112 
        else:
7113 
          iprot.skip(ftype)
7114 
      else:
7115 
        iprot.skip(ftype)
7116 
      iprot.readFieldEnd()
7117 
    iprot.readStructEnd()
7118 
 
7119 
  def write(self, oprot):
7120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7122 
      return
3064 chandransh 7123 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7124 
    if self.success is not None:
3064 chandransh 7125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7127 
      for iter90 in self.success:
7128 
        iter90.write(oprot)
3064 chandransh 7129 
      oprot.writeListEnd()
494 rajveer 7130 
      oprot.writeFieldEnd()
3431 rajveer 7131 
    if self.ex is not None:
494 rajveer 7132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7133 
      self.ex.write(oprot)
7134 
      oprot.writeFieldEnd()
7135 
    oprot.writeFieldStop()
7136 
    oprot.writeStructEnd()
7137 
 
3431 rajveer 7138 
  def validate(self):
7139 
    return
7140 
 
7141 
 
494 rajveer 7142 
  def __repr__(self):
7143 
    L = ['%s=%r' % (key, value)
7144 
      for key, value in self.__dict__.iteritems()]
7145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7146 
 
7147 
  def __eq__(self, other):
7148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7149 
 
7150 
  def __ne__(self, other):
7151 
    return not (self == other)
7152 
 
3064 chandransh 7153 
class getOrdersForCustomer_args:
1149 chandransh 7154 
  """
7155 
  Attributes:
3064 chandransh 7156 
   - customerId
7157 
   - from_date
7158 
   - to_date
7159 
   - statuses
1149 chandransh 7160 
  """
7161 
 
7162 
  thrift_spec = (
7163 
    None, # 0
3064 chandransh 7164 
    (1, TType.I64, 'customerId', None, None, ), # 1
7165 
    (2, TType.I64, 'from_date', None, None, ), # 2
7166 
    (3, TType.I64, 'to_date', None, None, ), # 3
7167 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7168 
  )
7169 
 
3064 chandransh 7170 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7171 
    self.customerId = customerId
7172 
    self.from_date = from_date
7173 
    self.to_date = to_date
7174 
    self.statuses = statuses
1149 chandransh 7175 
 
7176 
  def read(self, iprot):
7177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7179 
      return
7180 
    iprot.readStructBegin()
7181 
    while True:
7182 
      (fname, ftype, fid) = iprot.readFieldBegin()
7183 
      if ftype == TType.STOP:
7184 
        break
7185 
      if fid == 1:
7186 
        if ftype == TType.I64:
3064 chandransh 7187 
          self.customerId = iprot.readI64();
1149 chandransh 7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      elif fid == 2:
7191 
        if ftype == TType.I64:
3064 chandransh 7192 
          self.from_date = iprot.readI64();
1149 chandransh 7193 
        else:
7194 
          iprot.skip(ftype)
2783 chandransh 7195 
      elif fid == 3:
7196 
        if ftype == TType.I64:
3064 chandransh 7197 
          self.to_date = iprot.readI64();
2783 chandransh 7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      elif fid == 4:
3064 chandransh 7201 
        if ftype == TType.LIST:
7202 
          self.statuses = []
4133 chandransh 7203 
          (_etype94, _size91) = iprot.readListBegin()
7204 
          for _i95 in xrange(_size91):
7205 
            _elem96 = iprot.readI32();
7206 
            self.statuses.append(_elem96)
3064 chandransh 7207 
          iprot.readListEnd()
2783 chandransh 7208 
        else:
7209 
          iprot.skip(ftype)
1149 chandransh 7210 
      else:
7211 
        iprot.skip(ftype)
7212 
      iprot.readFieldEnd()
7213 
    iprot.readStructEnd()
7214 
 
7215 
  def write(self, oprot):
7216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7218 
      return
3064 chandransh 7219 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7220 
    if self.customerId is not None:
3064 chandransh 7221 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7222 
      oprot.writeI64(self.customerId)
1149 chandransh 7223 
      oprot.writeFieldEnd()
3431 rajveer 7224 
    if self.from_date is not None:
3064 chandransh 7225 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7226 
      oprot.writeI64(self.from_date)
1149 chandransh 7227 
      oprot.writeFieldEnd()
3431 rajveer 7228 
    if self.to_date is not None:
3064 chandransh 7229 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7230 
      oprot.writeI64(self.to_date)
2783 chandransh 7231 
      oprot.writeFieldEnd()
3431 rajveer 7232 
    if self.statuses is not None:
3064 chandransh 7233 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7234 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7235 
      for iter97 in self.statuses:
7236 
        oprot.writeI32(iter97)
3064 chandransh 7237 
      oprot.writeListEnd()
2783 chandransh 7238 
      oprot.writeFieldEnd()
1149 chandransh 7239 
    oprot.writeFieldStop()
7240 
    oprot.writeStructEnd()
7241 
 
3431 rajveer 7242 
  def validate(self):
7243 
    return
7244 
 
7245 
 
1149 chandransh 7246 
  def __repr__(self):
7247 
    L = ['%s=%r' % (key, value)
7248 
      for key, value in self.__dict__.iteritems()]
7249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7250 
 
7251 
  def __eq__(self, other):
7252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7253 
 
7254 
  def __ne__(self, other):
7255 
    return not (self == other)
7256 
 
3064 chandransh 7257 
class getOrdersForCustomer_result:
1149 chandransh 7258 
  """
7259 
  Attributes:
7260 
   - success
7261 
   - ex
7262 
  """
7263 
 
7264 
  thrift_spec = (
3064 chandransh 7265 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7266 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7267 
  )
7268 
 
7269 
  def __init__(self, success=None, ex=None,):
7270 
    self.success = success
7271 
    self.ex = ex
7272 
 
7273 
  def read(self, iprot):
7274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7276 
      return
7277 
    iprot.readStructBegin()
7278 
    while True:
7279 
      (fname, ftype, fid) = iprot.readFieldBegin()
7280 
      if ftype == TType.STOP:
7281 
        break
7282 
      if fid == 0:
3064 chandransh 7283 
        if ftype == TType.LIST:
7284 
          self.success = []
4133 chandransh 7285 
          (_etype101, _size98) = iprot.readListBegin()
7286 
          for _i102 in xrange(_size98):
7287 
            _elem103 = Order()
7288 
            _elem103.read(iprot)
7289 
            self.success.append(_elem103)
3064 chandransh 7290 
          iprot.readListEnd()
1149 chandransh 7291 
        else:
7292 
          iprot.skip(ftype)
7293 
      elif fid == 1:
7294 
        if ftype == TType.STRUCT:
7295 
          self.ex = TransactionServiceException()
7296 
          self.ex.read(iprot)
7297 
        else:
7298 
          iprot.skip(ftype)
7299 
      else:
7300 
        iprot.skip(ftype)
7301 
      iprot.readFieldEnd()
7302 
    iprot.readStructEnd()
7303 
 
7304 
  def write(self, oprot):
7305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7307 
      return
3064 chandransh 7308 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7309 
    if self.success is not None:
3064 chandransh 7310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7312 
      for iter104 in self.success:
7313 
        iter104.write(oprot)
3064 chandransh 7314 
      oprot.writeListEnd()
1149 chandransh 7315 
      oprot.writeFieldEnd()
3431 rajveer 7316 
    if self.ex is not None:
1149 chandransh 7317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7318 
      self.ex.write(oprot)
7319 
      oprot.writeFieldEnd()
7320 
    oprot.writeFieldStop()
7321 
    oprot.writeStructEnd()
7322 
 
3431 rajveer 7323 
  def validate(self):
7324 
    return
7325 
 
7326 
 
1149 chandransh 7327 
  def __repr__(self):
7328 
    L = ['%s=%r' % (key, value)
7329 
      for key, value in self.__dict__.iteritems()]
7330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7331 
 
7332 
  def __eq__(self, other):
7333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7334 
 
7335 
  def __ne__(self, other):
7336 
    return not (self == other)
7337 
 
3064 chandransh 7338 
class createOrder_args:
921 rajveer 7339 
  """
7340 
  Attributes:
3064 chandransh 7341 
   - order
921 rajveer 7342 
  """
7343 
 
7344 
  thrift_spec = (
7345 
    None, # 0
3064 chandransh 7346 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7347 
  )
7348 
 
3064 chandransh 7349 
  def __init__(self, order=None,):
7350 
    self.order = order
921 rajveer 7351 
 
7352 
  def read(self, iprot):
7353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7355 
      return
7356 
    iprot.readStructBegin()
7357 
    while True:
7358 
      (fname, ftype, fid) = iprot.readFieldBegin()
7359 
      if ftype == TType.STOP:
7360 
        break
7361 
      if fid == 1:
3064 chandransh 7362 
        if ftype == TType.STRUCT:
7363 
          self.order = Order()
7364 
          self.order.read(iprot)
921 rajveer 7365 
        else:
7366 
          iprot.skip(ftype)
7367 
      else:
7368 
        iprot.skip(ftype)
7369 
      iprot.readFieldEnd()
7370 
    iprot.readStructEnd()
7371 
 
7372 
  def write(self, oprot):
7373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7375 
      return
3064 chandransh 7376 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7377 
    if self.order is not None:
3064 chandransh 7378 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7379 
      self.order.write(oprot)
921 rajveer 7380 
      oprot.writeFieldEnd()
7381 
    oprot.writeFieldStop()
7382 
    oprot.writeStructEnd()
7383 
 
3431 rajveer 7384 
  def validate(self):
7385 
    return
7386 
 
7387 
 
921 rajveer 7388 
  def __repr__(self):
7389 
    L = ['%s=%r' % (key, value)
7390 
      for key, value in self.__dict__.iteritems()]
7391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7392 
 
7393 
  def __eq__(self, other):
7394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7395 
 
7396 
  def __ne__(self, other):
7397 
    return not (self == other)
7398 
 
3064 chandransh 7399 
class createOrder_result:
921 rajveer 7400 
  """
7401 
  Attributes:
7402 
   - success
7403 
   - ex
7404 
  """
7405 
 
7406 
  thrift_spec = (
3064 chandransh 7407 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7409 
  )
7410 
 
7411 
  def __init__(self, success=None, ex=None,):
7412 
    self.success = success
7413 
    self.ex = ex
7414 
 
7415 
  def read(self, iprot):
7416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7418 
      return
7419 
    iprot.readStructBegin()
7420 
    while True:
7421 
      (fname, ftype, fid) = iprot.readFieldBegin()
7422 
      if ftype == TType.STOP:
7423 
        break
7424 
      if fid == 0:
3064 chandransh 7425 
        if ftype == TType.I64:
7426 
          self.success = iprot.readI64();
921 rajveer 7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      elif fid == 1:
7430 
        if ftype == TType.STRUCT:
7431 
          self.ex = TransactionServiceException()
7432 
          self.ex.read(iprot)
7433 
        else:
7434 
          iprot.skip(ftype)
7435 
      else:
7436 
        iprot.skip(ftype)
7437 
      iprot.readFieldEnd()
7438 
    iprot.readStructEnd()
7439 
 
7440 
  def write(self, oprot):
7441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7443 
      return
3064 chandransh 7444 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7445 
    if self.success is not None:
3064 chandransh 7446 
      oprot.writeFieldBegin('success', TType.I64, 0)
7447 
      oprot.writeI64(self.success)
921 rajveer 7448 
      oprot.writeFieldEnd()
3431 rajveer 7449 
    if self.ex is not None:
921 rajveer 7450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7451 
      self.ex.write(oprot)
7452 
      oprot.writeFieldEnd()
7453 
    oprot.writeFieldStop()
7454 
    oprot.writeStructEnd()
7455 
 
3431 rajveer 7456 
  def validate(self):
7457 
    return
7458 
 
7459 
 
921 rajveer 7460 
  def __repr__(self):
7461 
    L = ['%s=%r' % (key, value)
7462 
      for key, value in self.__dict__.iteritems()]
7463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7464 
 
7465 
  def __eq__(self, other):
7466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7467 
 
7468 
  def __ne__(self, other):
7469 
    return not (self == other)
7470 
 
3064 chandransh 7471 
class getOrder_args:
921 rajveer 7472 
  """
7473 
  Attributes:
3064 chandransh 7474 
   - id
921 rajveer 7475 
  """
7476 
 
7477 
  thrift_spec = (
7478 
    None, # 0
3064 chandransh 7479 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7480 
  )
7481 
 
3064 chandransh 7482 
  def __init__(self, id=None,):
7483 
    self.id = id
921 rajveer 7484 
 
7485 
  def read(self, iprot):
7486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7488 
      return
7489 
    iprot.readStructBegin()
7490 
    while True:
7491 
      (fname, ftype, fid) = iprot.readFieldBegin()
7492 
      if ftype == TType.STOP:
7493 
        break
7494 
      if fid == 1:
7495 
        if ftype == TType.I64:
3064 chandransh 7496 
          self.id = iprot.readI64();
921 rajveer 7497 
        else:
7498 
          iprot.skip(ftype)
7499 
      else:
7500 
        iprot.skip(ftype)
7501 
      iprot.readFieldEnd()
7502 
    iprot.readStructEnd()
7503 
 
7504 
  def write(self, oprot):
7505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7507 
      return
3064 chandransh 7508 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7509 
    if self.id is not None:
3064 chandransh 7510 
      oprot.writeFieldBegin('id', TType.I64, 1)
7511 
      oprot.writeI64(self.id)
921 rajveer 7512 
      oprot.writeFieldEnd()
7513 
    oprot.writeFieldStop()
7514 
    oprot.writeStructEnd()
7515 
 
3431 rajveer 7516 
  def validate(self):
7517 
    return
7518 
 
7519 
 
921 rajveer 7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
3064 chandransh 7531 
class getOrder_result:
921 rajveer 7532 
  """
7533 
  Attributes:
7534 
   - success
7535 
   - ex
7536 
  """
7537 
 
7538 
  thrift_spec = (
3064 chandransh 7539 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7541 
  )
7542 
 
7543 
  def __init__(self, success=None, ex=None,):
7544 
    self.success = success
7545 
    self.ex = ex
7546 
 
7547 
  def read(self, iprot):
7548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7550 
      return
7551 
    iprot.readStructBegin()
7552 
    while True:
7553 
      (fname, ftype, fid) = iprot.readFieldBegin()
7554 
      if ftype == TType.STOP:
7555 
        break
7556 
      if fid == 0:
3064 chandransh 7557 
        if ftype == TType.STRUCT:
7558 
          self.success = Order()
7559 
          self.success.read(iprot)
921 rajveer 7560 
        else:
7561 
          iprot.skip(ftype)
7562 
      elif fid == 1:
7563 
        if ftype == TType.STRUCT:
7564 
          self.ex = TransactionServiceException()
7565 
          self.ex.read(iprot)
7566 
        else:
7567 
          iprot.skip(ftype)
7568 
      else:
7569 
        iprot.skip(ftype)
7570 
      iprot.readFieldEnd()
7571 
    iprot.readStructEnd()
7572 
 
7573 
  def write(self, oprot):
7574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7576 
      return
3064 chandransh 7577 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7578 
    if self.success is not None:
3064 chandransh 7579 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7580 
      self.success.write(oprot)
921 rajveer 7581 
      oprot.writeFieldEnd()
3431 rajveer 7582 
    if self.ex is not None:
921 rajveer 7583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7584 
      self.ex.write(oprot)
7585 
      oprot.writeFieldEnd()
7586 
    oprot.writeFieldStop()
7587 
    oprot.writeStructEnd()
7588 
 
3431 rajveer 7589 
  def validate(self):
7590 
    return
7591 
 
7592 
 
921 rajveer 7593 
  def __repr__(self):
7594 
    L = ['%s=%r' % (key, value)
7595 
      for key, value in self.__dict__.iteritems()]
7596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7597 
 
7598 
  def __eq__(self, other):
7599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7600 
 
7601 
  def __ne__(self, other):
7602 
    return not (self == other)
7603 
 
3064 chandransh 7604 
class getLineItemsForOrder_args:
94 ashish 7605 
  """
7606 
  Attributes:
3064 chandransh 7607 
   - orderId
94 ashish 7608 
  """
7609 
 
7610 
  thrift_spec = (
7611 
    None, # 0
3064 chandransh 7612 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7613 
  )
7614 
 
3064 chandransh 7615 
  def __init__(self, orderId=None,):
7616 
    self.orderId = orderId
94 ashish 7617 
 
7618 
  def read(self, iprot):
7619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7621 
      return
7622 
    iprot.readStructBegin()
7623 
    while True:
7624 
      (fname, ftype, fid) = iprot.readFieldBegin()
7625 
      if ftype == TType.STOP:
7626 
        break
7627 
      if fid == 1:
7628 
        if ftype == TType.I64:
3064 chandransh 7629 
          self.orderId = iprot.readI64();
94 ashish 7630 
        else:
7631 
          iprot.skip(ftype)
7632 
      else:
7633 
        iprot.skip(ftype)
7634 
      iprot.readFieldEnd()
7635 
    iprot.readStructEnd()
7636 
 
7637 
  def write(self, oprot):
7638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7640 
      return
3064 chandransh 7641 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7642 
    if self.orderId is not None:
3064 chandransh 7643 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7644 
      oprot.writeI64(self.orderId)
94 ashish 7645 
      oprot.writeFieldEnd()
7646 
    oprot.writeFieldStop()
7647 
    oprot.writeStructEnd()
7648 
 
3431 rajveer 7649 
  def validate(self):
7650 
    return
7651 
 
7652 
 
94 ashish 7653 
  def __repr__(self):
7654 
    L = ['%s=%r' % (key, value)
7655 
      for key, value in self.__dict__.iteritems()]
7656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7657 
 
7658 
  def __eq__(self, other):
7659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7660 
 
7661 
  def __ne__(self, other):
7662 
    return not (self == other)
7663 
 
3064 chandransh 7664 
class getLineItemsForOrder_result:
94 ashish 7665 
  """
7666 
  Attributes:
7667 
   - success
7668 
   - ex
7669 
  """
7670 
 
7671 
  thrift_spec = (
3064 chandransh 7672 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7674 
  )
7675 
 
7676 
  def __init__(self, success=None, ex=None,):
7677 
    self.success = success
7678 
    self.ex = ex
7679 
 
7680 
  def read(self, iprot):
7681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7683 
      return
7684 
    iprot.readStructBegin()
7685 
    while True:
7686 
      (fname, ftype, fid) = iprot.readFieldBegin()
7687 
      if ftype == TType.STOP:
7688 
        break
7689 
      if fid == 0:
483 rajveer 7690 
        if ftype == TType.LIST:
7691 
          self.success = []
4133 chandransh 7692 
          (_etype108, _size105) = iprot.readListBegin()
7693 
          for _i109 in xrange(_size105):
7694 
            _elem110 = LineItem()
7695 
            _elem110.read(iprot)
7696 
            self.success.append(_elem110)
483 rajveer 7697 
          iprot.readListEnd()
94 ashish 7698 
        else:
7699 
          iprot.skip(ftype)
7700 
      elif fid == 1:
7701 
        if ftype == TType.STRUCT:
7702 
          self.ex = TransactionServiceException()
7703 
          self.ex.read(iprot)
7704 
        else:
7705 
          iprot.skip(ftype)
7706 
      else:
7707 
        iprot.skip(ftype)
7708 
      iprot.readFieldEnd()
7709 
    iprot.readStructEnd()
7710 
 
7711 
  def write(self, oprot):
7712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7714 
      return
3064 chandransh 7715 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7716 
    if self.success is not None:
483 rajveer 7717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7719 
      for iter111 in self.success:
7720 
        iter111.write(oprot)
483 rajveer 7721 
      oprot.writeListEnd()
94 ashish 7722 
      oprot.writeFieldEnd()
3431 rajveer 7723 
    if self.ex is not None:
94 ashish 7724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7725 
      self.ex.write(oprot)
7726 
      oprot.writeFieldEnd()
7727 
    oprot.writeFieldStop()
7728 
    oprot.writeStructEnd()
7729 
 
3431 rajveer 7730 
  def validate(self):
7731 
    return
7732 
 
7733 
 
94 ashish 7734 
  def __repr__(self):
7735 
    L = ['%s=%r' % (key, value)
7736 
      for key, value in self.__dict__.iteritems()]
7737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7738 
 
7739 
  def __eq__(self, other):
7740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7741 
 
7742 
  def __ne__(self, other):
7743 
    return not (self == other)
7744 
 
3064 chandransh 7745 
class getOrderForCustomer_args:
94 ashish 7746 
  """
7747 
  Attributes:
3064 chandransh 7748 
   - orderId
483 rajveer 7749 
   - customerId
94 ashish 7750 
  """
7751 
 
7752 
  thrift_spec = (
7753 
    None, # 0
3064 chandransh 7754 
    (1, TType.I64, 'orderId', None, None, ), # 1
7755 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7756 
  )
7757 
 
3064 chandransh 7758 
  def __init__(self, orderId=None, customerId=None,):
7759 
    self.orderId = orderId
483 rajveer 7760 
    self.customerId = customerId
94 ashish 7761 
 
7762 
  def read(self, iprot):
7763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7765 
      return
7766 
    iprot.readStructBegin()
7767 
    while True:
7768 
      (fname, ftype, fid) = iprot.readFieldBegin()
7769 
      if ftype == TType.STOP:
7770 
        break
7771 
      if fid == 1:
7772 
        if ftype == TType.I64:
3064 chandransh 7773 
          self.orderId = iprot.readI64();
94 ashish 7774 
        else:
7775 
          iprot.skip(ftype)
7776 
      elif fid == 2:
7777 
        if ftype == TType.I64:
3064 chandransh 7778 
          self.customerId = iprot.readI64();
94 ashish 7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      else:
7782 
        iprot.skip(ftype)
7783 
      iprot.readFieldEnd()
7784 
    iprot.readStructEnd()
7785 
 
7786 
  def write(self, oprot):
7787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7789 
      return
3064 chandransh 7790 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7791 
    if self.orderId is not None:
3064 chandransh 7792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7793 
      oprot.writeI64(self.orderId)
7794 
      oprot.writeFieldEnd()
3431 rajveer 7795 
    if self.customerId is not None:
3064 chandransh 7796 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7797 
      oprot.writeI64(self.customerId)
94 ashish 7798 
      oprot.writeFieldEnd()
7799 
    oprot.writeFieldStop()
7800 
    oprot.writeStructEnd()
7801 
 
3431 rajveer 7802 
  def validate(self):
7803 
    return
7804 
 
7805 
 
94 ashish 7806 
  def __repr__(self):
7807 
    L = ['%s=%r' % (key, value)
7808 
      for key, value in self.__dict__.iteritems()]
7809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7810 
 
7811 
  def __eq__(self, other):
7812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7813 
 
7814 
  def __ne__(self, other):
7815 
    return not (self == other)
7816 
 
3064 chandransh 7817 
class getOrderForCustomer_result:
94 ashish 7818 
  """
7819 
  Attributes:
7820 
   - success
7821 
   - ex
7822 
  """
7823 
 
7824 
  thrift_spec = (
3064 chandransh 7825 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7827 
  )
7828 
 
7829 
  def __init__(self, success=None, ex=None,):
7830 
    self.success = success
7831 
    self.ex = ex
7832 
 
7833 
  def read(self, iprot):
7834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7836 
      return
7837 
    iprot.readStructBegin()
7838 
    while True:
7839 
      (fname, ftype, fid) = iprot.readFieldBegin()
7840 
      if ftype == TType.STOP:
7841 
        break
7842 
      if fid == 0:
3064 chandransh 7843 
        if ftype == TType.STRUCT:
7844 
          self.success = Order()
7845 
          self.success.read(iprot)
94 ashish 7846 
        else:
7847 
          iprot.skip(ftype)
7848 
      elif fid == 1:
7849 
        if ftype == TType.STRUCT:
7850 
          self.ex = TransactionServiceException()
7851 
          self.ex.read(iprot)
7852 
        else:
7853 
          iprot.skip(ftype)
7854 
      else:
7855 
        iprot.skip(ftype)
7856 
      iprot.readFieldEnd()
7857 
    iprot.readStructEnd()
7858 
 
7859 
  def write(self, oprot):
7860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7862 
      return
3064 chandransh 7863 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7864 
    if self.success is not None:
3064 chandransh 7865 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7866 
      self.success.write(oprot)
94 ashish 7867 
      oprot.writeFieldEnd()
3431 rajveer 7868 
    if self.ex is not None:
94 ashish 7869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7870 
      self.ex.write(oprot)
7871 
      oprot.writeFieldEnd()
7872 
    oprot.writeFieldStop()
7873 
    oprot.writeStructEnd()
7874 
 
3431 rajveer 7875 
  def validate(self):
7876 
    return
7877 
 
7878 
 
94 ashish 7879 
  def __repr__(self):
7880 
    L = ['%s=%r' % (key, value)
7881 
      for key, value in self.__dict__.iteritems()]
7882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7883 
 
7884 
  def __eq__(self, other):
7885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7886 
 
7887 
  def __ne__(self, other):
7888 
    return not (self == other)
7889 
 
3064 chandransh 7890 
class getAlerts_args:
94 ashish 7891 
  """
7892 
  Attributes:
4394 rajveer 7893 
   - type
4444 rajveer 7894 
   - warehouseId
4394 rajveer 7895 
   - status
7896 
   - timestamp
94 ashish 7897 
  """
7898 
 
7899 
  thrift_spec = (
7900 
    None, # 0
4394 rajveer 7901 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 7902 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7903 
    (3, TType.I64, 'status', None, None, ), # 3
7904 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 7905 
  )
7906 
 
4444 rajveer 7907 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 7908 
    self.type = type
4444 rajveer 7909 
    self.warehouseId = warehouseId
4394 rajveer 7910 
    self.status = status
7911 
    self.timestamp = timestamp
94 ashish 7912 
 
7913 
  def read(self, iprot):
7914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7916 
      return
7917 
    iprot.readStructBegin()
7918 
    while True:
7919 
      (fname, ftype, fid) = iprot.readFieldBegin()
7920 
      if ftype == TType.STOP:
7921 
        break
7922 
      if fid == 1:
3064 chandransh 7923 
        if ftype == TType.I64:
4394 rajveer 7924 
          self.type = iprot.readI64();
94 ashish 7925 
        else:
7926 
          iprot.skip(ftype)
3064 chandransh 7927 
      elif fid == 2:
4394 rajveer 7928 
        if ftype == TType.I64:
4444 rajveer 7929 
          self.warehouseId = iprot.readI64();
3064 chandransh 7930 
        else:
7931 
          iprot.skip(ftype)
4394 rajveer 7932 
      elif fid == 3:
7933 
        if ftype == TType.I64:
4444 rajveer 7934 
          self.status = iprot.readI64();
7935 
        else:
7936 
          iprot.skip(ftype)
7937 
      elif fid == 4:
7938 
        if ftype == TType.I64:
4394 rajveer 7939 
          self.timestamp = iprot.readI64();
7940 
        else:
7941 
          iprot.skip(ftype)
94 ashish 7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
3064 chandransh 7951 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 7952 
    if self.type is not None:
7953 
      oprot.writeFieldBegin('type', TType.I64, 1)
7954 
      oprot.writeI64(self.type)
94 ashish 7955 
      oprot.writeFieldEnd()
4444 rajveer 7956 
    if self.warehouseId is not None:
7957 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7958 
      oprot.writeI64(self.warehouseId)
7959 
      oprot.writeFieldEnd()
4394 rajveer 7960 
    if self.status is not None:
4444 rajveer 7961 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 7962 
      oprot.writeI64(self.status)
3064 chandransh 7963 
      oprot.writeFieldEnd()
4394 rajveer 7964 
    if self.timestamp is not None:
4444 rajveer 7965 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 7966 
      oprot.writeI64(self.timestamp)
7967 
      oprot.writeFieldEnd()
94 ashish 7968 
    oprot.writeFieldStop()
7969 
    oprot.writeStructEnd()
7970 
 
3431 rajveer 7971 
  def validate(self):
7972 
    return
7973 
 
7974 
 
94 ashish 7975 
  def __repr__(self):
7976 
    L = ['%s=%r' % (key, value)
7977 
      for key, value in self.__dict__.iteritems()]
7978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7979 
 
7980 
  def __eq__(self, other):
7981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7982 
 
7983 
  def __ne__(self, other):
7984 
    return not (self == other)
7985 
 
3064 chandransh 7986 
class getAlerts_result:
94 ashish 7987 
  """
7988 
  Attributes:
7989 
   - success
7990 
  """
7991 
 
7992 
  thrift_spec = (
3064 chandransh 7993 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 7994 
  )
7995 
 
3064 chandransh 7996 
  def __init__(self, success=None,):
94 ashish 7997 
    self.success = success
7998 
 
7999 
  def read(self, iprot):
8000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8002 
      return
8003 
    iprot.readStructBegin()
8004 
    while True:
8005 
      (fname, ftype, fid) = iprot.readFieldBegin()
8006 
      if ftype == TType.STOP:
8007 
        break
8008 
      if fid == 0:
3064 chandransh 8009 
        if ftype == TType.LIST:
8010 
          self.success = []
4133 chandransh 8011 
          (_etype115, _size112) = iprot.readListBegin()
8012 
          for _i116 in xrange(_size112):
8013 
            _elem117 = Alert()
8014 
            _elem117.read(iprot)
8015 
            self.success.append(_elem117)
3064 chandransh 8016 
          iprot.readListEnd()
94 ashish 8017 
        else:
8018 
          iprot.skip(ftype)
8019 
      else:
8020 
        iprot.skip(ftype)
8021 
      iprot.readFieldEnd()
8022 
    iprot.readStructEnd()
8023 
 
8024 
  def write(self, oprot):
8025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8027 
      return
3064 chandransh 8028 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8029 
    if self.success is not None:
3064 chandransh 8030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8032 
      for iter118 in self.success:
8033 
        iter118.write(oprot)
3064 chandransh 8034 
      oprot.writeListEnd()
94 ashish 8035 
      oprot.writeFieldEnd()
8036 
    oprot.writeFieldStop()
8037 
    oprot.writeStructEnd()
8038 
 
3431 rajveer 8039 
  def validate(self):
8040 
    return
8041 
 
8042 
 
94 ashish 8043 
  def __repr__(self):
8044 
    L = ['%s=%r' % (key, value)
8045 
      for key, value in self.__dict__.iteritems()]
8046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8047 
 
8048 
  def __eq__(self, other):
8049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8050 
 
8051 
  def __ne__(self, other):
8052 
    return not (self == other)
8053 
 
4394 rajveer 8054 
class addAlert_args:
94 ashish 8055 
  """
8056 
  Attributes:
3064 chandransh 8057 
   - type
4444 rajveer 8058 
   - warehouseId
4394 rajveer 8059 
   - description
94 ashish 8060 
  """
8061 
 
8062 
  thrift_spec = (
8063 
    None, # 0
4394 rajveer 8064 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8065 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8066 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8067 
  )
8068 
 
4444 rajveer 8069 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8070 
    self.type = type
4444 rajveer 8071 
    self.warehouseId = warehouseId
4394 rajveer 8072 
    self.description = description
94 ashish 8073 
 
8074 
  def read(self, iprot):
8075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8077 
      return
8078 
    iprot.readStructBegin()
8079 
    while True:
8080 
      (fname, ftype, fid) = iprot.readFieldBegin()
8081 
      if ftype == TType.STOP:
8082 
        break
8083 
      if fid == 1:
8084 
        if ftype == TType.I64:
4394 rajveer 8085 
          self.type = iprot.readI64();
94 ashish 8086 
        else:
8087 
          iprot.skip(ftype)
3064 chandransh 8088 
      elif fid == 2:
4444 rajveer 8089 
        if ftype == TType.I64:
8090 
          self.warehouseId = iprot.readI64();
8091 
        else:
8092 
          iprot.skip(ftype)
8093 
      elif fid == 3:
3064 chandransh 8094 
        if ftype == TType.STRING:
4394 rajveer 8095 
          self.description = iprot.readString();
3064 chandransh 8096 
        else:
8097 
          iprot.skip(ftype)
94 ashish 8098 
      else:
8099 
        iprot.skip(ftype)
8100 
      iprot.readFieldEnd()
8101 
    iprot.readStructEnd()
8102 
 
8103 
  def write(self, oprot):
8104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8106 
      return
4394 rajveer 8107 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8108 
    if self.type is not None:
4394 rajveer 8109 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8110 
      oprot.writeI64(self.type)
8111 
      oprot.writeFieldEnd()
4444 rajveer 8112 
    if self.warehouseId is not None:
8113 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8114 
      oprot.writeI64(self.warehouseId)
8115 
      oprot.writeFieldEnd()
4394 rajveer 8116 
    if self.description is not None:
4444 rajveer 8117 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8118 
      oprot.writeString(self.description)
3064 chandransh 8119 
      oprot.writeFieldEnd()
94 ashish 8120 
    oprot.writeFieldStop()
8121 
    oprot.writeStructEnd()
8122 
 
3431 rajveer 8123 
  def validate(self):
8124 
    return
8125 
 
8126 
 
94 ashish 8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
4394 rajveer 8138 
class addAlert_result:
3064 chandransh 8139 
 
8140 
  thrift_spec = (
8141 
  )
8142 
 
8143 
  def read(self, iprot):
8144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8146 
      return
8147 
    iprot.readStructBegin()
8148 
    while True:
8149 
      (fname, ftype, fid) = iprot.readFieldBegin()
8150 
      if ftype == TType.STOP:
8151 
        break
8152 
      else:
8153 
        iprot.skip(ftype)
8154 
      iprot.readFieldEnd()
8155 
    iprot.readStructEnd()
8156 
 
8157 
  def write(self, oprot):
8158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8160 
      return
4394 rajveer 8161 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8162 
    oprot.writeFieldStop()
8163 
    oprot.writeStructEnd()
8164 
 
3431 rajveer 8165 
  def validate(self):
8166 
    return
8167 
 
8168 
 
3064 chandransh 8169 
  def __repr__(self):
8170 
    L = ['%s=%r' % (key, value)
8171 
      for key, value in self.__dict__.iteritems()]
8172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8173 
 
8174 
  def __eq__(self, other):
8175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8176 
 
8177 
  def __ne__(self, other):
8178 
    return not (self == other)
8179 
 
4444 rajveer 8180 
class markAlertsAsSeen_args:
8181 
  """
8182 
  Attributes:
8183 
   - warehouseId
8184 
  """
8185 
 
8186 
  thrift_spec = (
8187 
    None, # 0
8188 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8189 
  )
8190 
 
8191 
  def __init__(self, warehouseId=None,):
8192 
    self.warehouseId = warehouseId
8193 
 
8194 
  def read(self, iprot):
8195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8197 
      return
8198 
    iprot.readStructBegin()
8199 
    while True:
8200 
      (fname, ftype, fid) = iprot.readFieldBegin()
8201 
      if ftype == TType.STOP:
8202 
        break
8203 
      if fid == 1:
8204 
        if ftype == TType.I64:
8205 
          self.warehouseId = iprot.readI64();
8206 
        else:
8207 
          iprot.skip(ftype)
8208 
      else:
8209 
        iprot.skip(ftype)
8210 
      iprot.readFieldEnd()
8211 
    iprot.readStructEnd()
8212 
 
8213 
  def write(self, oprot):
8214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8216 
      return
8217 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8218 
    if self.warehouseId is not None:
8219 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8220 
      oprot.writeI64(self.warehouseId)
8221 
      oprot.writeFieldEnd()
8222 
    oprot.writeFieldStop()
8223 
    oprot.writeStructEnd()
8224 
 
8225 
  def validate(self):
8226 
    return
8227 
 
8228 
 
8229 
  def __repr__(self):
8230 
    L = ['%s=%r' % (key, value)
8231 
      for key, value in self.__dict__.iteritems()]
8232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8233 
 
8234 
  def __eq__(self, other):
8235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8236 
 
8237 
  def __ne__(self, other):
8238 
    return not (self == other)
8239 
 
8240 
class markAlertsAsSeen_result:
8241 
 
8242 
  thrift_spec = (
8243 
  )
8244 
 
8245 
  def read(self, iprot):
8246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8248 
      return
8249 
    iprot.readStructBegin()
8250 
    while True:
8251 
      (fname, ftype, fid) = iprot.readFieldBegin()
8252 
      if ftype == TType.STOP:
8253 
        break
8254 
      else:
8255 
        iprot.skip(ftype)
8256 
      iprot.readFieldEnd()
8257 
    iprot.readStructEnd()
8258 
 
8259 
  def write(self, oprot):
8260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8262 
      return
8263 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8264 
    oprot.writeFieldStop()
8265 
    oprot.writeStructEnd()
8266 
 
8267 
  def validate(self):
8268 
    return
8269 
 
8270 
 
8271 
  def __repr__(self):
8272 
    L = ['%s=%r' % (key, value)
8273 
      for key, value in self.__dict__.iteritems()]
8274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8275 
 
8276 
  def __eq__(self, other):
8277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8278 
 
8279 
  def __ne__(self, other):
8280 
    return not (self == other)
8281 
 
3064 chandransh 8282 
class getValidOrderCount_args:
8283 
 
8284 
  thrift_spec = (
8285 
  )
8286 
 
8287 
  def read(self, iprot):
8288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8290 
      return
8291 
    iprot.readStructBegin()
8292 
    while True:
8293 
      (fname, ftype, fid) = iprot.readFieldBegin()
8294 
      if ftype == TType.STOP:
8295 
        break
8296 
      else:
8297 
        iprot.skip(ftype)
8298 
      iprot.readFieldEnd()
8299 
    iprot.readStructEnd()
8300 
 
8301 
  def write(self, oprot):
8302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8304 
      return
8305 
    oprot.writeStructBegin('getValidOrderCount_args')
8306 
    oprot.writeFieldStop()
8307 
    oprot.writeStructEnd()
8308 
 
3431 rajveer 8309 
  def validate(self):
8310 
    return
8311 
 
8312 
 
3064 chandransh 8313 
  def __repr__(self):
8314 
    L = ['%s=%r' % (key, value)
8315 
      for key, value in self.__dict__.iteritems()]
8316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8317 
 
8318 
  def __eq__(self, other):
8319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8320 
 
8321 
  def __ne__(self, other):
8322 
    return not (self == other)
8323 
 
8324 
class getValidOrderCount_result:
94 ashish 8325 
  """
8326 
  Attributes:
8327 
   - success
8328 
  """
8329 
 
8330 
  thrift_spec = (
3064 chandransh 8331 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8332 
  )
8333 
 
3064 chandransh 8334 
  def __init__(self, success=None,):
94 ashish 8335 
    self.success = success
8336 
 
8337 
  def read(self, iprot):
8338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8340 
      return
8341 
    iprot.readStructBegin()
8342 
    while True:
8343 
      (fname, ftype, fid) = iprot.readFieldBegin()
8344 
      if ftype == TType.STOP:
8345 
        break
8346 
      if fid == 0:
3064 chandransh 8347 
        if ftype == TType.I64:
8348 
          self.success = iprot.readI64();
94 ashish 8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
3064 chandransh 8360 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8361 
    if self.success is not None:
3064 chandransh 8362 
      oprot.writeFieldBegin('success', TType.I64, 0)
8363 
      oprot.writeI64(self.success)
94 ashish 8364 
      oprot.writeFieldEnd()
8365 
    oprot.writeFieldStop()
8366 
    oprot.writeStructEnd()
8367 
 
3431 rajveer 8368 
  def validate(self):
8369 
    return
8370 
 
8371 
 
94 ashish 8372 
  def __repr__(self):
8373 
    L = ['%s=%r' % (key, value)
8374 
      for key, value in self.__dict__.iteritems()]
8375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8376 
 
8377 
  def __eq__(self, other):
8378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8379 
 
8380 
  def __ne__(self, other):
8381 
    return not (self == other)
8382 
 
3064 chandransh 8383 
class getNoOfCustomersWithSuccessfulTransaction_args:
8384 
 
8385 
  thrift_spec = (
8386 
  )
8387 
 
8388 
  def read(self, iprot):
8389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8391 
      return
8392 
    iprot.readStructBegin()
8393 
    while True:
8394 
      (fname, ftype, fid) = iprot.readFieldBegin()
8395 
      if ftype == TType.STOP:
8396 
        break
8397 
      else:
8398 
        iprot.skip(ftype)
8399 
      iprot.readFieldEnd()
8400 
    iprot.readStructEnd()
8401 
 
8402 
  def write(self, oprot):
8403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8405 
      return
8406 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8407 
    oprot.writeFieldStop()
8408 
    oprot.writeStructEnd()
8409 
 
3431 rajveer 8410 
  def validate(self):
8411 
    return
8412 
 
8413 
 
3064 chandransh 8414 
  def __repr__(self):
8415 
    L = ['%s=%r' % (key, value)
8416 
      for key, value in self.__dict__.iteritems()]
8417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8418 
 
8419 
  def __eq__(self, other):
8420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8421 
 
8422 
  def __ne__(self, other):
8423 
    return not (self == other)
8424 
 
8425 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8426 
  """
8427 
  Attributes:
3064 chandransh 8428 
   - success
94 ashish 8429 
  """
8430 
 
8431 
  thrift_spec = (
3064 chandransh 8432 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8433 
  )
8434 
 
3064 chandransh 8435 
  def __init__(self, success=None,):
8436 
    self.success = success
94 ashish 8437 
 
8438 
  def read(self, iprot):
8439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8441 
      return
8442 
    iprot.readStructBegin()
8443 
    while True:
8444 
      (fname, ftype, fid) = iprot.readFieldBegin()
8445 
      if ftype == TType.STOP:
8446 
        break
3064 chandransh 8447 
      if fid == 0:
94 ashish 8448 
        if ftype == TType.I64:
3064 chandransh 8449 
          self.success = iprot.readI64();
94 ashish 8450 
        else:
8451 
          iprot.skip(ftype)
8452 
      else:
8453 
        iprot.skip(ftype)
8454 
      iprot.readFieldEnd()
8455 
    iprot.readStructEnd()
8456 
 
8457 
  def write(self, oprot):
8458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8460 
      return
3064 chandransh 8461 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8462 
    if self.success is not None:
3064 chandransh 8463 
      oprot.writeFieldBegin('success', TType.I64, 0)
8464 
      oprot.writeI64(self.success)
94 ashish 8465 
      oprot.writeFieldEnd()
8466 
    oprot.writeFieldStop()
8467 
    oprot.writeStructEnd()
8468 
 
3431 rajveer 8469 
  def validate(self):
8470 
    return
8471 
 
8472 
 
94 ashish 8473 
  def __repr__(self):
8474 
    L = ['%s=%r' % (key, value)
8475 
      for key, value in self.__dict__.iteritems()]
8476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8477 
 
8478 
  def __eq__(self, other):
8479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8480 
 
8481 
  def __ne__(self, other):
8482 
    return not (self == other)
8483 
 
3064 chandransh 8484 
class getValidOrdersAmountRange_args:
8485 
 
8486 
  thrift_spec = (
8487 
  )
8488 
 
8489 
  def read(self, iprot):
8490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8492 
      return
8493 
    iprot.readStructBegin()
8494 
    while True:
8495 
      (fname, ftype, fid) = iprot.readFieldBegin()
8496 
      if ftype == TType.STOP:
8497 
        break
8498 
      else:
8499 
        iprot.skip(ftype)
8500 
      iprot.readFieldEnd()
8501 
    iprot.readStructEnd()
8502 
 
8503 
  def write(self, oprot):
8504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8506 
      return
8507 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8508 
    oprot.writeFieldStop()
8509 
    oprot.writeStructEnd()
8510 
 
3431 rajveer 8511 
  def validate(self):
8512 
    return
8513 
 
8514 
 
3064 chandransh 8515 
  def __repr__(self):
8516 
    L = ['%s=%r' % (key, value)
8517 
      for key, value in self.__dict__.iteritems()]
8518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8519 
 
8520 
  def __eq__(self, other):
8521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8522 
 
8523 
  def __ne__(self, other):
8524 
    return not (self == other)
8525 
 
8526 
class getValidOrdersAmountRange_result:
94 ashish 8527 
  """
8528 
  Attributes:
8529 
   - success
8530 
  """
8531 
 
8532 
  thrift_spec = (
3064 chandransh 8533 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8534 
  )
8535 
 
3064 chandransh 8536 
  def __init__(self, success=None,):
94 ashish 8537 
    self.success = success
8538 
 
8539 
  def read(self, iprot):
8540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8542 
      return
8543 
    iprot.readStructBegin()
8544 
    while True:
8545 
      (fname, ftype, fid) = iprot.readFieldBegin()
8546 
      if ftype == TType.STOP:
8547 
        break
8548 
      if fid == 0:
483 rajveer 8549 
        if ftype == TType.LIST:
8550 
          self.success = []
4133 chandransh 8551 
          (_etype122, _size119) = iprot.readListBegin()
8552 
          for _i123 in xrange(_size119):
8553 
            _elem124 = iprot.readDouble();
8554 
            self.success.append(_elem124)
483 rajveer 8555 
          iprot.readListEnd()
94 ashish 8556 
        else:
8557 
          iprot.skip(ftype)
8558 
      else:
8559 
        iprot.skip(ftype)
8560 
      iprot.readFieldEnd()
8561 
    iprot.readStructEnd()
8562 
 
8563 
  def write(self, oprot):
8564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8566 
      return
3064 chandransh 8567 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8568 
    if self.success is not None:
483 rajveer 8569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8570 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8571 
      for iter125 in self.success:
8572 
        oprot.writeDouble(iter125)
483 rajveer 8573 
      oprot.writeListEnd()
94 ashish 8574 
      oprot.writeFieldEnd()
8575 
    oprot.writeFieldStop()
8576 
    oprot.writeStructEnd()
8577 
 
3431 rajveer 8578 
  def validate(self):
8579 
    return
8580 
 
8581 
 
94 ashish 8582 
  def __repr__(self):
8583 
    L = ['%s=%r' % (key, value)
8584 
      for key, value in self.__dict__.iteritems()]
8585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8586 
 
8587 
  def __eq__(self, other):
8588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8589 
 
8590 
  def __ne__(self, other):
8591 
    return not (self == other)
8592 
 
3064 chandransh 8593 
class getValidOrders_args:
1528 ankur.sing 8594 
  """
8595 
  Attributes:
3064 chandransh 8596 
   - limit
1528 ankur.sing 8597 
  """
8598 
 
8599 
  thrift_spec = (
8600 
    None, # 0
3064 chandransh 8601 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8602 
  )
8603 
 
3064 chandransh 8604 
  def __init__(self, limit=None,):
8605 
    self.limit = limit
1528 ankur.sing 8606 
 
8607 
  def read(self, iprot):
8608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8610 
      return
8611 
    iprot.readStructBegin()
8612 
    while True:
8613 
      (fname, ftype, fid) = iprot.readFieldBegin()
8614 
      if ftype == TType.STOP:
8615 
        break
8616 
      if fid == 1:
8617 
        if ftype == TType.I64:
3064 chandransh 8618 
          self.limit = iprot.readI64();
1528 ankur.sing 8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      else:
8622 
        iprot.skip(ftype)
8623 
      iprot.readFieldEnd()
8624 
    iprot.readStructEnd()
8625 
 
8626 
  def write(self, oprot):
8627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8629 
      return
3064 chandransh 8630 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8631 
    if self.limit is not None:
3064 chandransh 8632 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8633 
      oprot.writeI64(self.limit)
1528 ankur.sing 8634 
      oprot.writeFieldEnd()
8635 
    oprot.writeFieldStop()
8636 
    oprot.writeStructEnd()
8637 
 
3431 rajveer 8638 
  def validate(self):
8639 
    return
8640 
 
8641 
 
1528 ankur.sing 8642 
  def __repr__(self):
8643 
    L = ['%s=%r' % (key, value)
8644 
      for key, value in self.__dict__.iteritems()]
8645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8646 
 
8647 
  def __eq__(self, other):
8648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8649 
 
8650 
  def __ne__(self, other):
8651 
    return not (self == other)
8652 
 
3064 chandransh 8653 
class getValidOrders_result:
1528 ankur.sing 8654 
  """
8655 
  Attributes:
8656 
   - success
8657 
  """
8658 
 
8659 
  thrift_spec = (
3064 chandransh 8660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8661 
  )
8662 
 
3064 chandransh 8663 
  def __init__(self, success=None,):
1528 ankur.sing 8664 
    self.success = success
8665 
 
8666 
  def read(self, iprot):
8667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8669 
      return
8670 
    iprot.readStructBegin()
8671 
    while True:
8672 
      (fname, ftype, fid) = iprot.readFieldBegin()
8673 
      if ftype == TType.STOP:
8674 
        break
8675 
      if fid == 0:
3064 chandransh 8676 
        if ftype == TType.LIST:
8677 
          self.success = []
4133 chandransh 8678 
          (_etype129, _size126) = iprot.readListBegin()
8679 
          for _i130 in xrange(_size126):
8680 
            _elem131 = Order()
8681 
            _elem131.read(iprot)
8682 
            self.success.append(_elem131)
3064 chandransh 8683 
          iprot.readListEnd()
1528 ankur.sing 8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      else:
8687 
        iprot.skip(ftype)
8688 
      iprot.readFieldEnd()
8689 
    iprot.readStructEnd()
8690 
 
8691 
  def write(self, oprot):
8692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8694 
      return
3064 chandransh 8695 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8696 
    if self.success is not None:
3064 chandransh 8697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8699 
      for iter132 in self.success:
8700 
        iter132.write(oprot)
3064 chandransh 8701 
      oprot.writeListEnd()
1528 ankur.sing 8702 
      oprot.writeFieldEnd()
8703 
    oprot.writeFieldStop()
8704 
    oprot.writeStructEnd()
8705 
 
3431 rajveer 8706 
  def validate(self):
8707 
    return
8708 
 
8709 
 
1528 ankur.sing 8710 
  def __repr__(self):
8711 
    L = ['%s=%r' % (key, value)
8712 
      for key, value in self.__dict__.iteritems()]
8713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8714 
 
8715 
  def __eq__(self, other):
8716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8717 
 
8718 
  def __ne__(self, other):
8719 
    return not (self == other)
8720 
 
1220 chandransh 8721 
class batchOrders_args:
8722 
  """
8723 
  Attributes:
8724 
   - warehouseId
8725 
  """
8726 
 
8727 
  thrift_spec = (
8728 
    None, # 0
8729 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8730 
  )
8731 
 
8732 
  def __init__(self, warehouseId=None,):
8733 
    self.warehouseId = warehouseId
8734 
 
8735 
  def read(self, iprot):
8736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8738 
      return
8739 
    iprot.readStructBegin()
8740 
    while True:
8741 
      (fname, ftype, fid) = iprot.readFieldBegin()
8742 
      if ftype == TType.STOP:
8743 
        break
8744 
      if fid == 1:
8745 
        if ftype == TType.I64:
8746 
          self.warehouseId = iprot.readI64();
8747 
        else:
8748 
          iprot.skip(ftype)
8749 
      else:
8750 
        iprot.skip(ftype)
8751 
      iprot.readFieldEnd()
8752 
    iprot.readStructEnd()
8753 
 
8754 
  def write(self, oprot):
8755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8757 
      return
8758 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8759 
    if self.warehouseId is not None:
1220 chandransh 8760 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8761 
      oprot.writeI64(self.warehouseId)
8762 
      oprot.writeFieldEnd()
8763 
    oprot.writeFieldStop()
8764 
    oprot.writeStructEnd()
8765 
 
3431 rajveer 8766 
  def validate(self):
8767 
    return
8768 
 
8769 
 
1220 chandransh 8770 
  def __repr__(self):
8771 
    L = ['%s=%r' % (key, value)
8772 
      for key, value in self.__dict__.iteritems()]
8773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8774 
 
8775 
  def __eq__(self, other):
8776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8777 
 
8778 
  def __ne__(self, other):
8779 
    return not (self == other)
8780 
 
8781 
class batchOrders_result:
8782 
  """
8783 
  Attributes:
8784 
   - success
8785 
   - ex
8786 
  """
8787 
 
8788 
  thrift_spec = (
8789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8791 
  )
8792 
 
8793 
  def __init__(self, success=None, ex=None,):
8794 
    self.success = success
8795 
    self.ex = ex
8796 
 
8797 
  def read(self, iprot):
8798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8800 
      return
8801 
    iprot.readStructBegin()
8802 
    while True:
8803 
      (fname, ftype, fid) = iprot.readFieldBegin()
8804 
      if ftype == TType.STOP:
8805 
        break
8806 
      if fid == 0:
8807 
        if ftype == TType.LIST:
8808 
          self.success = []
4133 chandransh 8809 
          (_etype136, _size133) = iprot.readListBegin()
8810 
          for _i137 in xrange(_size133):
8811 
            _elem138 = Order()
8812 
            _elem138.read(iprot)
8813 
            self.success.append(_elem138)
1220 chandransh 8814 
          iprot.readListEnd()
8815 
        else:
8816 
          iprot.skip(ftype)
8817 
      elif fid == 1:
8818 
        if ftype == TType.STRUCT:
8819 
          self.ex = TransactionServiceException()
8820 
          self.ex.read(iprot)
8821 
        else:
8822 
          iprot.skip(ftype)
8823 
      else:
8824 
        iprot.skip(ftype)
8825 
      iprot.readFieldEnd()
8826 
    iprot.readStructEnd()
8827 
 
8828 
  def write(self, oprot):
8829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8831 
      return
8832 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8833 
    if self.success is not None:
1220 chandransh 8834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8836 
      for iter139 in self.success:
8837 
        iter139.write(oprot)
1220 chandransh 8838 
      oprot.writeListEnd()
8839 
      oprot.writeFieldEnd()
3431 rajveer 8840 
    if self.ex is not None:
1220 chandransh 8841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8842 
      self.ex.write(oprot)
8843 
      oprot.writeFieldEnd()
8844 
    oprot.writeFieldStop()
8845 
    oprot.writeStructEnd()
8846 
 
3431 rajveer 8847 
  def validate(self):
8848 
    return
8849 
 
8850 
 
1220 chandransh 8851 
  def __repr__(self):
8852 
    L = ['%s=%r' % (key, value)
8853 
      for key, value in self.__dict__.iteritems()]
8854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8855 
 
8856 
  def __eq__(self, other):
8857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8858 
 
8859 
  def __ne__(self, other):
8860 
    return not (self == other)
8861 
 
1208 chandransh 8862 
class markOrderAsOutOfStock_args:
8863 
  """
8864 
  Attributes:
8865 
   - orderId
8866 
  """
8867 
 
8868 
  thrift_spec = (
8869 
    None, # 0
8870 
    (1, TType.I64, 'orderId', None, None, ), # 1
8871 
  )
8872 
 
8873 
  def __init__(self, orderId=None,):
8874 
    self.orderId = orderId
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      if fid == 1:
8886 
        if ftype == TType.I64:
8887 
          self.orderId = iprot.readI64();
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      else:
8891 
        iprot.skip(ftype)
8892 
      iprot.readFieldEnd()
8893 
    iprot.readStructEnd()
8894 
 
8895 
  def write(self, oprot):
8896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8898 
      return
8899 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 8900 
    if self.orderId is not None:
1208 chandransh 8901 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8902 
      oprot.writeI64(self.orderId)
8903 
      oprot.writeFieldEnd()
8904 
    oprot.writeFieldStop()
8905 
    oprot.writeStructEnd()
8906 
 
3431 rajveer 8907 
  def validate(self):
8908 
    return
8909 
 
8910 
 
1208 chandransh 8911 
  def __repr__(self):
8912 
    L = ['%s=%r' % (key, value)
8913 
      for key, value in self.__dict__.iteritems()]
8914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8915 
 
8916 
  def __eq__(self, other):
8917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8918 
 
8919 
  def __ne__(self, other):
8920 
    return not (self == other)
8921 
 
8922 
class markOrderAsOutOfStock_result:
8923 
  """
8924 
  Attributes:
8925 
   - success
8926 
   - ex
8927 
  """
8928 
 
8929 
  thrift_spec = (
8930 
    (0, TType.BOOL, 'success', None, None, ), # 0
8931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8932 
  )
8933 
 
8934 
  def __init__(self, success=None, ex=None,):
8935 
    self.success = success
8936 
    self.ex = ex
8937 
 
8938 
  def read(self, iprot):
8939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8941 
      return
8942 
    iprot.readStructBegin()
8943 
    while True:
8944 
      (fname, ftype, fid) = iprot.readFieldBegin()
8945 
      if ftype == TType.STOP:
8946 
        break
8947 
      if fid == 0:
8948 
        if ftype == TType.BOOL:
8949 
          self.success = iprot.readBool();
8950 
        else:
8951 
          iprot.skip(ftype)
8952 
      elif fid == 1:
8953 
        if ftype == TType.STRUCT:
8954 
          self.ex = TransactionServiceException()
8955 
          self.ex.read(iprot)
8956 
        else:
8957 
          iprot.skip(ftype)
8958 
      else:
8959 
        iprot.skip(ftype)
8960 
      iprot.readFieldEnd()
8961 
    iprot.readStructEnd()
8962 
 
8963 
  def write(self, oprot):
8964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8966 
      return
8967 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 8968 
    if self.success is not None:
1208 chandransh 8969 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8970 
      oprot.writeBool(self.success)
8971 
      oprot.writeFieldEnd()
3431 rajveer 8972 
    if self.ex is not None:
1208 chandransh 8973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8974 
      self.ex.write(oprot)
8975 
      oprot.writeFieldEnd()
8976 
    oprot.writeFieldStop()
8977 
    oprot.writeStructEnd()
8978 
 
3431 rajveer 8979 
  def validate(self):
8980 
    return
8981 
 
8982 
 
1208 chandransh 8983 
  def __repr__(self):
8984 
    L = ['%s=%r' % (key, value)
8985 
      for key, value in self.__dict__.iteritems()]
8986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8987 
 
8988 
  def __eq__(self, other):
8989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8990 
 
8991 
  def __ne__(self, other):
8992 
    return not (self == other)
8993 
 
3064 chandransh 8994 
class verifyOrder_args:
759 chandransh 8995 
  """
8996 
  Attributes:
3064 chandransh 8997 
   - orderId
759 chandransh 8998 
  """
8999 
 
9000 
  thrift_spec = (
9001 
    None, # 0
3064 chandransh 9002 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9003 
  )
9004 
 
3064 chandransh 9005 
  def __init__(self, orderId=None,):
9006 
    self.orderId = orderId
759 chandransh 9007 
 
9008 
  def read(self, iprot):
9009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9011 
      return
9012 
    iprot.readStructBegin()
9013 
    while True:
9014 
      (fname, ftype, fid) = iprot.readFieldBegin()
9015 
      if ftype == TType.STOP:
9016 
        break
9017 
      if fid == 1:
9018 
        if ftype == TType.I64:
3064 chandransh 9019 
          self.orderId = iprot.readI64();
759 chandransh 9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      else:
9023 
        iprot.skip(ftype)
9024 
      iprot.readFieldEnd()
9025 
    iprot.readStructEnd()
9026 
 
9027 
  def write(self, oprot):
9028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9030 
      return
3064 chandransh 9031 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9032 
    if self.orderId is not None:
3064 chandransh 9033 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9034 
      oprot.writeI64(self.orderId)
759 chandransh 9035 
      oprot.writeFieldEnd()
9036 
    oprot.writeFieldStop()
9037 
    oprot.writeStructEnd()
9038 
 
3431 rajveer 9039 
  def validate(self):
9040 
    return
9041 
 
9042 
 
759 chandransh 9043 
  def __repr__(self):
9044 
    L = ['%s=%r' % (key, value)
9045 
      for key, value in self.__dict__.iteritems()]
9046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9047 
 
9048 
  def __eq__(self, other):
9049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9050 
 
9051 
  def __ne__(self, other):
9052 
    return not (self == other)
9053 
 
3064 chandransh 9054 
class verifyOrder_result:
759 chandransh 9055 
  """
9056 
  Attributes:
9057 
   - success
9058 
   - ex
9059 
  """
9060 
 
9061 
  thrift_spec = (
9062 
    (0, TType.BOOL, 'success', None, None, ), # 0
9063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9064 
  )
9065 
 
9066 
  def __init__(self, success=None, ex=None,):
9067 
    self.success = success
9068 
    self.ex = ex
9069 
 
9070 
  def read(self, iprot):
9071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9073 
      return
9074 
    iprot.readStructBegin()
9075 
    while True:
9076 
      (fname, ftype, fid) = iprot.readFieldBegin()
9077 
      if ftype == TType.STOP:
9078 
        break
9079 
      if fid == 0:
9080 
        if ftype == TType.BOOL:
9081 
          self.success = iprot.readBool();
9082 
        else:
9083 
          iprot.skip(ftype)
9084 
      elif fid == 1:
9085 
        if ftype == TType.STRUCT:
9086 
          self.ex = TransactionServiceException()
9087 
          self.ex.read(iprot)
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
3064 chandransh 9099 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9100 
    if self.success is not None:
759 chandransh 9101 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9102 
      oprot.writeBool(self.success)
9103 
      oprot.writeFieldEnd()
3431 rajveer 9104 
    if self.ex is not None:
759 chandransh 9105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9106 
      self.ex.write(oprot)
9107 
      oprot.writeFieldEnd()
9108 
    oprot.writeFieldStop()
9109 
    oprot.writeStructEnd()
9110 
 
3431 rajveer 9111 
  def validate(self):
9112 
    return
9113 
 
9114 
 
759 chandransh 9115 
  def __repr__(self):
9116 
    L = ['%s=%r' % (key, value)
9117 
      for key, value in self.__dict__.iteritems()]
9118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9119 
 
9120 
  def __eq__(self, other):
9121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9122 
 
9123 
  def __ne__(self, other):
9124 
    return not (self == other)
9125 
 
3064 chandransh 9126 
class acceptOrder_args:
1113 chandransh 9127 
  """
9128 
  Attributes:
3064 chandransh 9129 
   - orderId
1113 chandransh 9130 
  """
9131 
 
9132 
  thrift_spec = (
9133 
    None, # 0
3064 chandransh 9134 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9135 
  )
9136 
 
3064 chandransh 9137 
  def __init__(self, orderId=None,):
9138 
    self.orderId = orderId
1113 chandransh 9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 1:
9150 
        if ftype == TType.I64:
3064 chandransh 9151 
          self.orderId = iprot.readI64();
1113 chandransh 9152 
        else:
9153 
          iprot.skip(ftype)
9154 
      else:
9155 
        iprot.skip(ftype)
9156 
      iprot.readFieldEnd()
9157 
    iprot.readStructEnd()
9158 
 
9159 
  def write(self, oprot):
9160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9162 
      return
3064 chandransh 9163 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9164 
    if self.orderId is not None:
3064 chandransh 9165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9166 
      oprot.writeI64(self.orderId)
1113 chandransh 9167 
      oprot.writeFieldEnd()
9168 
    oprot.writeFieldStop()
9169 
    oprot.writeStructEnd()
9170 
 
3431 rajveer 9171 
  def validate(self):
9172 
    return
9173 
 
9174 
 
1113 chandransh 9175 
  def __repr__(self):
9176 
    L = ['%s=%r' % (key, value)
9177 
      for key, value in self.__dict__.iteritems()]
9178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9179 
 
9180 
  def __eq__(self, other):
9181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9182 
 
9183 
  def __ne__(self, other):
9184 
    return not (self == other)
9185 
 
3064 chandransh 9186 
class acceptOrder_result:
1113 chandransh 9187 
  """
9188 
  Attributes:
9189 
   - success
9190 
   - ex
9191 
  """
9192 
 
9193 
  thrift_spec = (
3064 chandransh 9194 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9196 
  )
9197 
 
9198 
  def __init__(self, success=None, ex=None,):
9199 
    self.success = success
9200 
    self.ex = ex
9201 
 
9202 
  def read(self, iprot):
9203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9205 
      return
9206 
    iprot.readStructBegin()
9207 
    while True:
9208 
      (fname, ftype, fid) = iprot.readFieldBegin()
9209 
      if ftype == TType.STOP:
9210 
        break
9211 
      if fid == 0:
3064 chandransh 9212 
        if ftype == TType.BOOL:
9213 
          self.success = iprot.readBool();
1113 chandransh 9214 
        else:
9215 
          iprot.skip(ftype)
9216 
      elif fid == 1:
9217 
        if ftype == TType.STRUCT:
9218 
          self.ex = TransactionServiceException()
9219 
          self.ex.read(iprot)
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      else:
9223 
        iprot.skip(ftype)
9224 
      iprot.readFieldEnd()
9225 
    iprot.readStructEnd()
9226 
 
9227 
  def write(self, oprot):
9228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9230 
      return
3064 chandransh 9231 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9232 
    if self.success is not None:
3064 chandransh 9233 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9234 
      oprot.writeBool(self.success)
1113 chandransh 9235 
      oprot.writeFieldEnd()
3431 rajveer 9236 
    if self.ex is not None:
1113 chandransh 9237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9238 
      self.ex.write(oprot)
9239 
      oprot.writeFieldEnd()
9240 
    oprot.writeFieldStop()
9241 
    oprot.writeStructEnd()
9242 
 
3431 rajveer 9243 
  def validate(self):
9244 
    return
9245 
 
9246 
 
1113 chandransh 9247 
  def __repr__(self):
9248 
    L = ['%s=%r' % (key, value)
9249 
      for key, value in self.__dict__.iteritems()]
9250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9251 
 
9252 
  def __eq__(self, other):
9253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9254 
 
9255 
  def __ne__(self, other):
9256 
    return not (self == other)
9257 
 
3064 chandransh 9258 
class addBillingDetails_args:
1135 chandransh 9259 
  """
9260 
  Attributes:
3064 chandransh 9261 
   - orderId
9262 
   - invoice_number
4283 anupam.sin 9263 
   - imeiNumber
9264 
   - itemNumber
3064 chandransh 9265 
   - billed_by
4264 rajveer 9266 
   - jacketNumber
4283 anupam.sin 9267 
   - billingType
9268 
   - vendorId
1135 chandransh 9269 
  """
9270 
 
9271 
  thrift_spec = (
9272 
    None, # 0
3064 chandransh 9273 
    (1, TType.I64, 'orderId', None, None, ), # 1
9274 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9275 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9276 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9277 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9278 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9279 
    (7, TType.I64, 'billingType', None, None, ), # 7
9280 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9281 
  )
9282 
 
4283 anupam.sin 9283 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9284 
    self.orderId = orderId
9285 
    self.invoice_number = invoice_number
4283 anupam.sin 9286 
    self.imeiNumber = imeiNumber
9287 
    self.itemNumber = itemNumber
3064 chandransh 9288 
    self.billed_by = billed_by
4264 rajveer 9289 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9290 
    self.billingType = billingType
9291 
    self.vendorId = vendorId
1135 chandransh 9292 
 
9293 
  def read(self, iprot):
9294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9296 
      return
9297 
    iprot.readStructBegin()
9298 
    while True:
9299 
      (fname, ftype, fid) = iprot.readFieldBegin()
9300 
      if ftype == TType.STOP:
9301 
        break
9302 
      if fid == 1:
9303 
        if ftype == TType.I64:
3064 chandransh 9304 
          self.orderId = iprot.readI64();
1135 chandransh 9305 
        else:
9306 
          iprot.skip(ftype)
9307 
      elif fid == 2:
3064 chandransh 9308 
        if ftype == TType.STRING:
9309 
          self.invoice_number = iprot.readString();
1135 chandransh 9310 
        else:
9311 
          iprot.skip(ftype)
3064 chandransh 9312 
      elif fid == 3:
4264 rajveer 9313 
        if ftype == TType.I64:
3064 chandransh 9314 
          self.imeiNumber = iprot.readI64();
9315 
        else:
9316 
          iprot.skip(ftype)
9317 
      elif fid == 4:
9318 
        if ftype == TType.STRING:
9319 
          self.itemNumber = iprot.readString();
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      elif fid == 5:
9323 
        if ftype == TType.STRING:
4283 anupam.sin 9324 
          self.billed_by = iprot.readString();
3064 chandransh 9325 
        else:
9326 
          iprot.skip(ftype)
9327 
      elif fid == 6:
9328 
        if ftype == TType.I64:
4283 anupam.sin 9329 
          self.jacketNumber = iprot.readI64();
9330 
        else:
9331 
          iprot.skip(ftype)
9332 
      elif fid == 7:
9333 
        if ftype == TType.I64:
3064 chandransh 9334 
          self.billingType = iprot.readI64();
9335 
        else:
9336 
          iprot.skip(ftype)
4283 anupam.sin 9337 
      elif fid == 8:
9338 
        if ftype == TType.I64:
9339 
          self.vendorId = iprot.readI64();
9340 
        else:
9341 
          iprot.skip(ftype)
1246 chandransh 9342 
      else:
9343 
        iprot.skip(ftype)
9344 
      iprot.readFieldEnd()
9345 
    iprot.readStructEnd()
9346 
 
9347 
  def write(self, oprot):
9348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9350 
      return
4283 anupam.sin 9351 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9352 
    if self.orderId is not None:
3064 chandransh 9353 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9354 
      oprot.writeI64(self.orderId)
1246 chandransh 9355 
      oprot.writeFieldEnd()
4283 anupam.sin 9356 
    if self.invoice_number is not None:
9357 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9358 
      oprot.writeString(self.invoice_number)
1246 chandransh 9359 
      oprot.writeFieldEnd()
3431 rajveer 9360 
    if self.imeiNumber is not None:
3064 chandransh 9361 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9362 
      oprot.writeI64(self.imeiNumber)
9363 
      oprot.writeFieldEnd()
3431 rajveer 9364 
    if self.itemNumber is not None:
3064 chandransh 9365 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9366 
      oprot.writeString(self.itemNumber)
9367 
      oprot.writeFieldEnd()
4283 anupam.sin 9368 
    if self.billed_by is not None:
9369 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9370 
      oprot.writeString(self.billed_by)
3064 chandransh 9371 
      oprot.writeFieldEnd()
4283 anupam.sin 9372 
    if self.jacketNumber is not None:
9373 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9374 
      oprot.writeI64(self.jacketNumber)
9375 
      oprot.writeFieldEnd()
3431 rajveer 9376 
    if self.billingType is not None:
4283 anupam.sin 9377 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9378 
      oprot.writeI64(self.billingType)
9379 
      oprot.writeFieldEnd()
4283 anupam.sin 9380 
    if self.vendorId is not None:
9381 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9382 
      oprot.writeI64(self.vendorId)
9383 
      oprot.writeFieldEnd()
1246 chandransh 9384 
    oprot.writeFieldStop()
9385 
    oprot.writeStructEnd()
9386 
 
3431 rajveer 9387 
  def validate(self):
9388 
    return
9389 
 
9390 
 
1246 chandransh 9391 
  def __repr__(self):
9392 
    L = ['%s=%r' % (key, value)
9393 
      for key, value in self.__dict__.iteritems()]
9394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9395 
 
9396 
  def __eq__(self, other):
9397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9398 
 
9399 
  def __ne__(self, other):
9400 
    return not (self == other)
9401 
 
4283 anupam.sin 9402 
class addBillingDetails_result:
1246 chandransh 9403 
  """
9404 
  Attributes:
3064 chandransh 9405 
   - success
1246 chandransh 9406 
   - ex
9407 
  """
9408 
 
9409 
  thrift_spec = (
3064 chandransh 9410 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9412 
  )
9413 
 
3064 chandransh 9414 
  def __init__(self, success=None, ex=None,):
9415 
    self.success = success
1246 chandransh 9416 
    self.ex = ex
9417 
 
9418 
  def read(self, iprot):
9419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9421 
      return
9422 
    iprot.readStructBegin()
9423 
    while True:
9424 
      (fname, ftype, fid) = iprot.readFieldBegin()
9425 
      if ftype == TType.STOP:
9426 
        break
3064 chandransh 9427 
      if fid == 0:
9428 
        if ftype == TType.BOOL:
9429 
          self.success = iprot.readBool();
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      elif fid == 1:
1246 chandransh 9433 
        if ftype == TType.STRUCT:
9434 
          self.ex = TransactionServiceException()
9435 
          self.ex.read(iprot)
9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      else:
9439 
        iprot.skip(ftype)
9440 
      iprot.readFieldEnd()
9441 
    iprot.readStructEnd()
9442 
 
9443 
  def write(self, oprot):
9444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9446 
      return
4283 anupam.sin 9447 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9448 
    if self.success is not None:
3064 chandransh 9449 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9450 
      oprot.writeBool(self.success)
9451 
      oprot.writeFieldEnd()
3431 rajveer 9452 
    if self.ex is not None:
1246 chandransh 9453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9454 
      self.ex.write(oprot)
9455 
      oprot.writeFieldEnd()
9456 
    oprot.writeFieldStop()
9457 
    oprot.writeStructEnd()
9458 
 
3431 rajveer 9459 
  def validate(self):
9460 
    return
9461 
 
9462 
 
1246 chandransh 9463 
  def __repr__(self):
9464 
    L = ['%s=%r' % (key, value)
9465 
      for key, value in self.__dict__.iteritems()]
9466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9467 
 
9468 
  def __eq__(self, other):
9469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9470 
 
9471 
  def __ne__(self, other):
9472 
    return not (self == other)
9473 
 
3064 chandransh 9474 
class markOrdersAsManifested_args:
1408 ankur.sing 9475 
  """
9476 
  Attributes:
3064 chandransh 9477 
   - warehouseId
1408 ankur.sing 9478 
   - providerId
3064 chandransh 9479 
   - cod
1408 ankur.sing 9480 
  """
9481 
 
9482 
  thrift_spec = (
9483 
    None, # 0
3064 chandransh 9484 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9485 
    (2, TType.I64, 'providerId', None, None, ), # 2
9486 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9487 
  )
9488 
 
3064 chandransh 9489 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9490 
    self.warehouseId = warehouseId
1408 ankur.sing 9491 
    self.providerId = providerId
3064 chandransh 9492 
    self.cod = cod
1408 ankur.sing 9493 
 
9494 
  def read(self, iprot):
9495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9497 
      return
9498 
    iprot.readStructBegin()
9499 
    while True:
9500 
      (fname, ftype, fid) = iprot.readFieldBegin()
9501 
      if ftype == TType.STOP:
9502 
        break
9503 
      if fid == 1:
9504 
        if ftype == TType.I64:
3064 chandransh 9505 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 2:
9509 
        if ftype == TType.I64:
3064 chandransh 9510 
          self.providerId = iprot.readI64();
1408 ankur.sing 9511 
        else:
9512 
          iprot.skip(ftype)
3064 chandransh 9513 
      elif fid == 3:
9514 
        if ftype == TType.BOOL:
9515 
          self.cod = iprot.readBool();
9516 
        else:
9517 
          iprot.skip(ftype)
1408 ankur.sing 9518 
      else:
9519 
        iprot.skip(ftype)
9520 
      iprot.readFieldEnd()
9521 
    iprot.readStructEnd()
9522 
 
9523 
  def write(self, oprot):
9524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9526 
      return
3064 chandransh 9527 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9528 
    if self.warehouseId is not None:
3064 chandransh 9529 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9530 
      oprot.writeI64(self.warehouseId)
9531 
      oprot.writeFieldEnd()
3431 rajveer 9532 
    if self.providerId is not None:
3064 chandransh 9533 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9534 
      oprot.writeI64(self.providerId)
9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.cod is not None:
3064 chandransh 9537 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9538 
      oprot.writeBool(self.cod)
1408 ankur.sing 9539 
      oprot.writeFieldEnd()
9540 
    oprot.writeFieldStop()
9541 
    oprot.writeStructEnd()
9542 
 
3431 rajveer 9543 
  def validate(self):
9544 
    return
9545 
 
9546 
 
1408 ankur.sing 9547 
  def __repr__(self):
9548 
    L = ['%s=%r' % (key, value)
9549 
      for key, value in self.__dict__.iteritems()]
9550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9551 
 
9552 
  def __eq__(self, other):
9553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9554 
 
9555 
  def __ne__(self, other):
9556 
    return not (self == other)
9557 
 
3064 chandransh 9558 
class markOrdersAsManifested_result:
1408 ankur.sing 9559 
  """
9560 
  Attributes:
9561 
   - success
3064 chandransh 9562 
   - ex
1408 ankur.sing 9563 
  """
9564 
 
9565 
  thrift_spec = (
3064 chandransh 9566 
    (0, TType.BOOL, 'success', None, None, ), # 0
9567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9568 
  )
9569 
 
3064 chandransh 9570 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9571 
    self.success = success
3064 chandransh 9572 
    self.ex = ex
1408 ankur.sing 9573 
 
9574 
  def read(self, iprot):
9575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9577 
      return
9578 
    iprot.readStructBegin()
9579 
    while True:
9580 
      (fname, ftype, fid) = iprot.readFieldBegin()
9581 
      if ftype == TType.STOP:
9582 
        break
9583 
      if fid == 0:
3064 chandransh 9584 
        if ftype == TType.BOOL:
9585 
          self.success = iprot.readBool();
1408 ankur.sing 9586 
        else:
9587 
          iprot.skip(ftype)
3064 chandransh 9588 
      elif fid == 1:
9589 
        if ftype == TType.STRUCT:
9590 
          self.ex = TransactionServiceException()
9591 
          self.ex.read(iprot)
9592 
        else:
9593 
          iprot.skip(ftype)
1408 ankur.sing 9594 
      else:
9595 
        iprot.skip(ftype)
9596 
      iprot.readFieldEnd()
9597 
    iprot.readStructEnd()
9598 
 
9599 
  def write(self, oprot):
9600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9602 
      return
3064 chandransh 9603 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9604 
    if self.success is not None:
3064 chandransh 9605 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9606 
      oprot.writeBool(self.success)
1408 ankur.sing 9607 
      oprot.writeFieldEnd()
3431 rajveer 9608 
    if self.ex is not None:
3064 chandransh 9609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9610 
      self.ex.write(oprot)
9611 
      oprot.writeFieldEnd()
1408 ankur.sing 9612 
    oprot.writeFieldStop()
9613 
    oprot.writeStructEnd()
9614 
 
3431 rajveer 9615 
  def validate(self):
9616 
    return
9617 
 
9618 
 
1408 ankur.sing 9619 
  def __repr__(self):
9620 
    L = ['%s=%r' % (key, value)
9621 
      for key, value in self.__dict__.iteritems()]
9622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9623 
 
9624 
  def __eq__(self, other):
9625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9626 
 
9627 
  def __ne__(self, other):
9628 
    return not (self == other)
9629 
 
4410 rajveer 9630 
class markOrdersAsShippedFromWarehouse_args:
9631 
  """
9632 
  Attributes:
9633 
   - warehouseId
9634 
   - providerId
9635 
   - cod
9636 
  """
9637 
 
9638 
  thrift_spec = (
9639 
    None, # 0
9640 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9641 
    (2, TType.I64, 'providerId', None, None, ), # 2
9642 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9643 
  )
9644 
 
9645 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9646 
    self.warehouseId = warehouseId
9647 
    self.providerId = providerId
9648 
    self.cod = cod
9649 
 
9650 
  def read(self, iprot):
9651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9653 
      return
9654 
    iprot.readStructBegin()
9655 
    while True:
9656 
      (fname, ftype, fid) = iprot.readFieldBegin()
9657 
      if ftype == TType.STOP:
9658 
        break
9659 
      if fid == 1:
9660 
        if ftype == TType.I64:
9661 
          self.warehouseId = iprot.readI64();
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 2:
9665 
        if ftype == TType.I64:
9666 
          self.providerId = iprot.readI64();
9667 
        else:
9668 
          iprot.skip(ftype)
9669 
      elif fid == 3:
9670 
        if ftype == TType.BOOL:
9671 
          self.cod = iprot.readBool();
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      else:
9675 
        iprot.skip(ftype)
9676 
      iprot.readFieldEnd()
9677 
    iprot.readStructEnd()
9678 
 
9679 
  def write(self, oprot):
9680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9682 
      return
9683 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9684 
    if self.warehouseId is not None:
9685 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9686 
      oprot.writeI64(self.warehouseId)
9687 
      oprot.writeFieldEnd()
9688 
    if self.providerId is not None:
9689 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9690 
      oprot.writeI64(self.providerId)
9691 
      oprot.writeFieldEnd()
9692 
    if self.cod is not None:
9693 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9694 
      oprot.writeBool(self.cod)
9695 
      oprot.writeFieldEnd()
9696 
    oprot.writeFieldStop()
9697 
    oprot.writeStructEnd()
9698 
 
9699 
  def validate(self):
9700 
    return
9701 
 
9702 
 
9703 
  def __repr__(self):
9704 
    L = ['%s=%r' % (key, value)
9705 
      for key, value in self.__dict__.iteritems()]
9706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9707 
 
9708 
  def __eq__(self, other):
9709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9710 
 
9711 
  def __ne__(self, other):
9712 
    return not (self == other)
9713 
 
9714 
class markOrdersAsShippedFromWarehouse_result:
9715 
  """
9716 
  Attributes:
9717 
   - success
9718 
   - ex
9719 
  """
9720 
 
9721 
  thrift_spec = (
9722 
    (0, TType.BOOL, 'success', None, None, ), # 0
9723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9724 
  )
9725 
 
9726 
  def __init__(self, success=None, ex=None,):
9727 
    self.success = success
9728 
    self.ex = ex
9729 
 
9730 
  def read(self, iprot):
9731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9733 
      return
9734 
    iprot.readStructBegin()
9735 
    while True:
9736 
      (fname, ftype, fid) = iprot.readFieldBegin()
9737 
      if ftype == TType.STOP:
9738 
        break
9739 
      if fid == 0:
9740 
        if ftype == TType.BOOL:
9741 
          self.success = iprot.readBool();
9742 
        else:
9743 
          iprot.skip(ftype)
9744 
      elif fid == 1:
9745 
        if ftype == TType.STRUCT:
9746 
          self.ex = TransactionServiceException()
9747 
          self.ex.read(iprot)
9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      else:
9751 
        iprot.skip(ftype)
9752 
      iprot.readFieldEnd()
9753 
    iprot.readStructEnd()
9754 
 
9755 
  def write(self, oprot):
9756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9758 
      return
9759 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9760 
    if self.success is not None:
9761 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9762 
      oprot.writeBool(self.success)
9763 
      oprot.writeFieldEnd()
9764 
    if self.ex is not None:
9765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9766 
      self.ex.write(oprot)
9767 
      oprot.writeFieldEnd()
9768 
    oprot.writeFieldStop()
9769 
    oprot.writeStructEnd()
9770 
 
9771 
  def validate(self):
9772 
    return
9773 
 
9774 
 
9775 
  def __repr__(self):
9776 
    L = ['%s=%r' % (key, value)
9777 
      for key, value in self.__dict__.iteritems()]
9778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9779 
 
9780 
  def __eq__(self, other):
9781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9782 
 
9783 
  def __ne__(self, other):
9784 
    return not (self == other)
9785 
 
3064 chandransh 9786 
class markOrdersAsPickedUp_args:
304 ashish 9787 
  """
9788 
  Attributes:
3064 chandransh 9789 
   - providerId
9790 
   - pickupDetails
304 ashish 9791 
  """
94 ashish 9792 
 
304 ashish 9793 
  thrift_spec = (
9794 
    None, # 0
3064 chandransh 9795 
    (1, TType.I64, 'providerId', None, None, ), # 1
9796 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9797 
  )
9798 
 
3064 chandransh 9799 
  def __init__(self, providerId=None, pickupDetails=None,):
9800 
    self.providerId = providerId
9801 
    self.pickupDetails = pickupDetails
304 ashish 9802 
 
9803 
  def read(self, iprot):
9804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9806 
      return
9807 
    iprot.readStructBegin()
9808 
    while True:
9809 
      (fname, ftype, fid) = iprot.readFieldBegin()
9810 
      if ftype == TType.STOP:
9811 
        break
9812 
      if fid == 1:
9813 
        if ftype == TType.I64:
3064 chandransh 9814 
          self.providerId = iprot.readI64();
304 ashish 9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      elif fid == 2:
3064 chandransh 9818 
        if ftype == TType.MAP:
9819 
          self.pickupDetails = {}
4133 chandransh 9820 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9821 
          for _i144 in xrange(_size140):
9822 
            _key145 = iprot.readString();
9823 
            _val146 = iprot.readString();
9824 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9825 
          iprot.readMapEnd()
304 ashish 9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      else:
9829 
        iprot.skip(ftype)
9830 
      iprot.readFieldEnd()
9831 
    iprot.readStructEnd()
9832 
 
9833 
  def write(self, oprot):
9834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9836 
      return
3064 chandransh 9837 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9838 
    if self.providerId is not None:
3064 chandransh 9839 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9840 
      oprot.writeI64(self.providerId)
304 ashish 9841 
      oprot.writeFieldEnd()
3431 rajveer 9842 
    if self.pickupDetails is not None:
3064 chandransh 9843 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9844 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9845 
      for kiter147,viter148 in self.pickupDetails.items():
9846 
        oprot.writeString(kiter147)
9847 
        oprot.writeString(viter148)
3064 chandransh 9848 
      oprot.writeMapEnd()
304 ashish 9849 
      oprot.writeFieldEnd()
9850 
    oprot.writeFieldStop()
9851 
    oprot.writeStructEnd()
9852 
 
3431 rajveer 9853 
  def validate(self):
9854 
    return
9855 
 
9856 
 
304 ashish 9857 
  def __repr__(self):
9858 
    L = ['%s=%r' % (key, value)
9859 
      for key, value in self.__dict__.iteritems()]
9860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9861 
 
9862 
  def __eq__(self, other):
9863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9864 
 
9865 
  def __ne__(self, other):
9866 
    return not (self == other)
9867 
 
3064 chandransh 9868 
class markOrdersAsPickedUp_result:
304 ashish 9869 
  """
9870 
  Attributes:
9871 
   - success
3064 chandransh 9872 
   - ex
304 ashish 9873 
  """
9874 
 
9875 
  thrift_spec = (
3064 chandransh 9876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 9878 
  )
9879 
 
3064 chandransh 9880 
  def __init__(self, success=None, ex=None,):
304 ashish 9881 
    self.success = success
3064 chandransh 9882 
    self.ex = ex
304 ashish 9883 
 
9884 
  def read(self, iprot):
9885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9887 
      return
9888 
    iprot.readStructBegin()
9889 
    while True:
9890 
      (fname, ftype, fid) = iprot.readFieldBegin()
9891 
      if ftype == TType.STOP:
9892 
        break
9893 
      if fid == 0:
9894 
        if ftype == TType.LIST:
9895 
          self.success = []
4133 chandransh 9896 
          (_etype152, _size149) = iprot.readListBegin()
9897 
          for _i153 in xrange(_size149):
9898 
            _elem154 = Order()
9899 
            _elem154.read(iprot)
9900 
            self.success.append(_elem154)
304 ashish 9901 
          iprot.readListEnd()
9902 
        else:
9903 
          iprot.skip(ftype)
3064 chandransh 9904 
      elif fid == 1:
9905 
        if ftype == TType.STRUCT:
9906 
          self.ex = TransactionServiceException()
9907 
          self.ex.read(iprot)
9908 
        else:
9909 
          iprot.skip(ftype)
304 ashish 9910 
      else:
9911 
        iprot.skip(ftype)
9912 
      iprot.readFieldEnd()
9913 
    iprot.readStructEnd()
9914 
 
9915 
  def write(self, oprot):
9916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9918 
      return
3064 chandransh 9919 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 9920 
    if self.success is not None:
304 ashish 9921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9922 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 9923 
      for iter155 in self.success:
9924 
        iter155.write(oprot)
304 ashish 9925 
      oprot.writeListEnd()
9926 
      oprot.writeFieldEnd()
3431 rajveer 9927 
    if self.ex is not None:
3064 chandransh 9928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9929 
      self.ex.write(oprot)
9930 
      oprot.writeFieldEnd()
304 ashish 9931 
    oprot.writeFieldStop()
9932 
    oprot.writeStructEnd()
9933 
 
3431 rajveer 9934 
  def validate(self):
9935 
    return
9936 
 
9937 
 
304 ashish 9938 
  def __repr__(self):
9939 
    L = ['%s=%r' % (key, value)
9940 
      for key, value in self.__dict__.iteritems()]
9941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9942 
 
9943 
  def __eq__(self, other):
9944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9945 
 
9946 
  def __ne__(self, other):
9947 
    return not (self == other)
9948 
 
3064 chandransh 9949 
class markOrdersAsDelivered_args:
304 ashish 9950 
  """
9951 
  Attributes:
3064 chandransh 9952 
   - providerId
9953 
   - deliveredOrders
304 ashish 9954 
  """
9955 
 
9956 
  thrift_spec = (
9957 
    None, # 0
3064 chandransh 9958 
    (1, TType.I64, 'providerId', None, None, ), # 1
9959 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9960 
  )
9961 
 
3064 chandransh 9962 
  def __init__(self, providerId=None, deliveredOrders=None,):
9963 
    self.providerId = providerId
9964 
    self.deliveredOrders = deliveredOrders
304 ashish 9965 
 
9966 
  def read(self, iprot):
9967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9969 
      return
9970 
    iprot.readStructBegin()
9971 
    while True:
9972 
      (fname, ftype, fid) = iprot.readFieldBegin()
9973 
      if ftype == TType.STOP:
9974 
        break
9975 
      if fid == 1:
9976 
        if ftype == TType.I64:
3064 chandransh 9977 
          self.providerId = iprot.readI64();
304 ashish 9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      elif fid == 2:
3064 chandransh 9981 
        if ftype == TType.MAP:
9982 
          self.deliveredOrders = {}
4133 chandransh 9983 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9984 
          for _i160 in xrange(_size156):
9985 
            _key161 = iprot.readString();
9986 
            _val162 = iprot.readString();
9987 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 9988 
          iprot.readMapEnd()
304 ashish 9989 
        else:
9990 
          iprot.skip(ftype)
9991 
      else:
9992 
        iprot.skip(ftype)
9993 
      iprot.readFieldEnd()
9994 
    iprot.readStructEnd()
9995 
 
9996 
  def write(self, oprot):
9997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9999 
      return
3064 chandransh 10000 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10001 
    if self.providerId is not None:
3064 chandransh 10002 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10003 
      oprot.writeI64(self.providerId)
304 ashish 10004 
      oprot.writeFieldEnd()
3431 rajveer 10005 
    if self.deliveredOrders is not None:
3064 chandransh 10006 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10007 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10008 
      for kiter163,viter164 in self.deliveredOrders.items():
10009 
        oprot.writeString(kiter163)
10010 
        oprot.writeString(viter164)
3064 chandransh 10011 
      oprot.writeMapEnd()
304 ashish 10012 
      oprot.writeFieldEnd()
10013 
    oprot.writeFieldStop()
10014 
    oprot.writeStructEnd()
10015 
 
3431 rajveer 10016 
  def validate(self):
10017 
    return
10018 
 
10019 
 
304 ashish 10020 
  def __repr__(self):
10021 
    L = ['%s=%r' % (key, value)
10022 
      for key, value in self.__dict__.iteritems()]
10023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10024 
 
10025 
  def __eq__(self, other):
10026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10027 
 
10028 
  def __ne__(self, other):
10029 
    return not (self == other)
10030 
 
3064 chandransh 10031 
class markOrdersAsDelivered_result:
10032 
  """
10033 
  Attributes:
10034 
   - ex
10035 
  """
304 ashish 10036 
 
10037 
  thrift_spec = (
3064 chandransh 10038 
    None, # 0
10039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10040 
  )
10041 
 
3064 chandransh 10042 
  def __init__(self, ex=None,):
10043 
    self.ex = ex
304 ashish 10044 
 
1596 ankur.sing 10045 
  def read(self, iprot):
10046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10048 
      return
10049 
    iprot.readStructBegin()
10050 
    while True:
10051 
      (fname, ftype, fid) = iprot.readFieldBegin()
10052 
      if ftype == TType.STOP:
10053 
        break
3064 chandransh 10054 
      if fid == 1:
10055 
        if ftype == TType.STRUCT:
10056 
          self.ex = TransactionServiceException()
10057 
          self.ex.read(iprot)
10058 
        else:
10059 
          iprot.skip(ftype)
1596 ankur.sing 10060 
      else:
10061 
        iprot.skip(ftype)
10062 
      iprot.readFieldEnd()
10063 
    iprot.readStructEnd()
10064 
 
10065 
  def write(self, oprot):
10066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10068 
      return
3064 chandransh 10069 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10070 
    if self.ex is not None:
3064 chandransh 10071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10072 
      self.ex.write(oprot)
10073 
      oprot.writeFieldEnd()
1596 ankur.sing 10074 
    oprot.writeFieldStop()
10075 
    oprot.writeStructEnd()
10076 
 
3431 rajveer 10077 
  def validate(self):
10078 
    return
10079 
 
10080 
 
1596 ankur.sing 10081 
  def __repr__(self):
10082 
    L = ['%s=%r' % (key, value)
10083 
      for key, value in self.__dict__.iteritems()]
10084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10085 
 
10086 
  def __eq__(self, other):
10087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10088 
 
10089 
  def __ne__(self, other):
10090 
    return not (self == other)
10091 
 
3064 chandransh 10092 
class markOrdersAsFailed_args:
1596 ankur.sing 10093 
  """
10094 
  Attributes:
3064 chandransh 10095 
   - providerId
10096 
   - returnedOrders
1596 ankur.sing 10097 
  """
10098 
 
10099 
  thrift_spec = (
3064 chandransh 10100 
    None, # 0
10101 
    (1, TType.I64, 'providerId', None, None, ), # 1
10102 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10103 
  )
10104 
 
3064 chandransh 10105 
  def __init__(self, providerId=None, returnedOrders=None,):
10106 
    self.providerId = providerId
10107 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10108 
 
10109 
  def read(self, iprot):
10110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10112 
      return
10113 
    iprot.readStructBegin()
10114 
    while True:
10115 
      (fname, ftype, fid) = iprot.readFieldBegin()
10116 
      if ftype == TType.STOP:
10117 
        break
3064 chandransh 10118 
      if fid == 1:
1596 ankur.sing 10119 
        if ftype == TType.I64:
3064 chandransh 10120 
          self.providerId = iprot.readI64();
1596 ankur.sing 10121 
        else:
10122 
          iprot.skip(ftype)
3064 chandransh 10123 
      elif fid == 2:
10124 
        if ftype == TType.MAP:
10125 
          self.returnedOrders = {}
4133 chandransh 10126 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10127 
          for _i169 in xrange(_size165):
10128 
            _key170 = iprot.readString();
10129 
            _val171 = iprot.readString();
10130 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10131 
          iprot.readMapEnd()
10132 
        else:
10133 
          iprot.skip(ftype)
1596 ankur.sing 10134 
      else:
10135 
        iprot.skip(ftype)
10136 
      iprot.readFieldEnd()
10137 
    iprot.readStructEnd()
10138 
 
10139 
  def write(self, oprot):
10140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10142 
      return
3064 chandransh 10143 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10144 
    if self.providerId is not None:
3064 chandransh 10145 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10146 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10147 
      oprot.writeFieldEnd()
3431 rajveer 10148 
    if self.returnedOrders is not None:
3064 chandransh 10149 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10150 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10151 
      for kiter172,viter173 in self.returnedOrders.items():
10152 
        oprot.writeString(kiter172)
10153 
        oprot.writeString(viter173)
3064 chandransh 10154 
      oprot.writeMapEnd()
10155 
      oprot.writeFieldEnd()
1596 ankur.sing 10156 
    oprot.writeFieldStop()
10157 
    oprot.writeStructEnd()
10158 
 
3431 rajveer 10159 
  def validate(self):
10160 
    return
10161 
 
10162 
 
1596 ankur.sing 10163 
  def __repr__(self):
10164 
    L = ['%s=%r' % (key, value)
10165 
      for key, value in self.__dict__.iteritems()]
10166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10167 
 
10168 
  def __eq__(self, other):
10169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10170 
 
10171 
  def __ne__(self, other):
10172 
    return not (self == other)
10173 
 
3064 chandransh 10174 
class markOrdersAsFailed_result:
10175 
  """
10176 
  Attributes:
10177 
   - ex
10178 
  """
1596 ankur.sing 10179 
 
1627 ankur.sing 10180 
  thrift_spec = (
3064 chandransh 10181 
    None, # 0
10182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10183 
  )
10184 
 
3064 chandransh 10185 
  def __init__(self, ex=None,):
10186 
    self.ex = ex
10187 
 
1627 ankur.sing 10188 
  def read(self, iprot):
10189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10191 
      return
10192 
    iprot.readStructBegin()
10193 
    while True:
10194 
      (fname, ftype, fid) = iprot.readFieldBegin()
10195 
      if ftype == TType.STOP:
10196 
        break
3064 chandransh 10197 
      if fid == 1:
10198 
        if ftype == TType.STRUCT:
10199 
          self.ex = TransactionServiceException()
10200 
          self.ex.read(iprot)
10201 
        else:
10202 
          iprot.skip(ftype)
1627 ankur.sing 10203 
      else:
10204 
        iprot.skip(ftype)
10205 
      iprot.readFieldEnd()
10206 
    iprot.readStructEnd()
10207 
 
10208 
  def write(self, oprot):
10209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10211 
      return
3064 chandransh 10212 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10213 
    if self.ex is not None:
3064 chandransh 10214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10215 
      self.ex.write(oprot)
10216 
      oprot.writeFieldEnd()
1627 ankur.sing 10217 
    oprot.writeFieldStop()
10218 
    oprot.writeStructEnd()
10219 
 
3431 rajveer 10220 
  def validate(self):
10221 
    return
10222 
 
10223 
 
1627 ankur.sing 10224 
  def __repr__(self):
10225 
    L = ['%s=%r' % (key, value)
10226 
      for key, value in self.__dict__.iteritems()]
10227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10228 
 
10229 
  def __eq__(self, other):
10230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10231 
 
10232 
  def __ne__(self, other):
10233 
    return not (self == other)
10234 
 
3064 chandransh 10235 
class updateNonDeliveryReason_args:
1627 ankur.sing 10236 
  """
10237 
  Attributes:
3064 chandransh 10238 
   - providerId
10239 
   - undeliveredOrders
1627 ankur.sing 10240 
  """
10241 
 
10242 
  thrift_spec = (
3064 chandransh 10243 
    None, # 0
10244 
    (1, TType.I64, 'providerId', None, None, ), # 1
10245 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10246 
  )
10247 
 
3064 chandransh 10248 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10249 
    self.providerId = providerId
10250 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10251 
 
10252 
  def read(self, iprot):
10253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10255 
      return
10256 
    iprot.readStructBegin()
10257 
    while True:
10258 
      (fname, ftype, fid) = iprot.readFieldBegin()
10259 
      if ftype == TType.STOP:
10260 
        break
3064 chandransh 10261 
      if fid == 1:
1627 ankur.sing 10262 
        if ftype == TType.I64:
3064 chandransh 10263 
          self.providerId = iprot.readI64();
1627 ankur.sing 10264 
        else:
10265 
          iprot.skip(ftype)
3064 chandransh 10266 
      elif fid == 2:
10267 
        if ftype == TType.MAP:
10268 
          self.undeliveredOrders = {}
4133 chandransh 10269 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10270 
          for _i178 in xrange(_size174):
10271 
            _key179 = iprot.readString();
10272 
            _val180 = iprot.readString();
10273 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10274 
          iprot.readMapEnd()
10275 
        else:
10276 
          iprot.skip(ftype)
1627 ankur.sing 10277 
      else:
10278 
        iprot.skip(ftype)
10279 
      iprot.readFieldEnd()
10280 
    iprot.readStructEnd()
10281 
 
10282 
  def write(self, oprot):
10283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10285 
      return
3064 chandransh 10286 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10287 
    if self.providerId is not None:
3064 chandransh 10288 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10289 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10290 
      oprot.writeFieldEnd()
3431 rajveer 10291 
    if self.undeliveredOrders is not None:
3064 chandransh 10292 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10293 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10294 
      for kiter181,viter182 in self.undeliveredOrders.items():
10295 
        oprot.writeString(kiter181)
10296 
        oprot.writeString(viter182)
3064 chandransh 10297 
      oprot.writeMapEnd()
10298 
      oprot.writeFieldEnd()
1627 ankur.sing 10299 
    oprot.writeFieldStop()
10300 
    oprot.writeStructEnd()
10301 
 
3431 rajveer 10302 
  def validate(self):
10303 
    return
10304 
 
10305 
 
1627 ankur.sing 10306 
  def __repr__(self):
10307 
    L = ['%s=%r' % (key, value)
10308 
      for key, value in self.__dict__.iteritems()]
10309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10310 
 
10311 
  def __eq__(self, other):
10312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10313 
 
10314 
  def __ne__(self, other):
10315 
    return not (self == other)
10316 
 
3064 chandransh 10317 
class updateNonDeliveryReason_result:
1627 ankur.sing 10318 
  """
10319 
  Attributes:
3064 chandransh 10320 
   - ex
1627 ankur.sing 10321 
  """
10322 
 
10323 
  thrift_spec = (
3064 chandransh 10324 
    None, # 0
10325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10326 
  )
10327 
 
3064 chandransh 10328 
  def __init__(self, ex=None,):
10329 
    self.ex = ex
1627 ankur.sing 10330 
 
10331 
  def read(self, iprot):
10332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10334 
      return
10335 
    iprot.readStructBegin()
10336 
    while True:
10337 
      (fname, ftype, fid) = iprot.readFieldBegin()
10338 
      if ftype == TType.STOP:
10339 
        break
3064 chandransh 10340 
      if fid == 1:
10341 
        if ftype == TType.STRUCT:
10342 
          self.ex = TransactionServiceException()
10343 
          self.ex.read(iprot)
1627 ankur.sing 10344 
        else:
10345 
          iprot.skip(ftype)
10346 
      else:
10347 
        iprot.skip(ftype)
10348 
      iprot.readFieldEnd()
10349 
    iprot.readStructEnd()
10350 
 
10351 
  def write(self, oprot):
10352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10354 
      return
3064 chandransh 10355 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10356 
    if self.ex is not None:
3064 chandransh 10357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10358 
      self.ex.write(oprot)
1627 ankur.sing 10359 
      oprot.writeFieldEnd()
10360 
    oprot.writeFieldStop()
10361 
    oprot.writeStructEnd()
10362 
 
3431 rajveer 10363 
  def validate(self):
10364 
    return
10365 
 
10366 
 
1627 ankur.sing 10367 
  def __repr__(self):
10368 
    L = ['%s=%r' % (key, value)
10369 
      for key, value in self.__dict__.iteritems()]
10370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10371 
 
10372 
  def __eq__(self, other):
10373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10374 
 
10375 
  def __ne__(self, other):
10376 
    return not (self == other)
10377 
 
3064 chandransh 10378 
class getUndeliveredOrders_args:
1886 ankur.sing 10379 
  """
10380 
  Attributes:
3064 chandransh 10381 
   - providerId
10382 
   - warehouseId
1886 ankur.sing 10383 
  """
1627 ankur.sing 10384 
 
1886 ankur.sing 10385 
  thrift_spec = (
10386 
    None, # 0
3064 chandransh 10387 
    (1, TType.I64, 'providerId', None, None, ), # 1
10388 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10389 
  )
10390 
 
3064 chandransh 10391 
  def __init__(self, providerId=None, warehouseId=None,):
10392 
    self.providerId = providerId
10393 
    self.warehouseId = warehouseId
1886 ankur.sing 10394 
 
10395 
  def read(self, iprot):
10396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10398 
      return
10399 
    iprot.readStructBegin()
10400 
    while True:
10401 
      (fname, ftype, fid) = iprot.readFieldBegin()
10402 
      if ftype == TType.STOP:
10403 
        break
10404 
      if fid == 1:
10405 
        if ftype == TType.I64:
3064 chandransh 10406 
          self.providerId = iprot.readI64();
1886 ankur.sing 10407 
        else:
10408 
          iprot.skip(ftype)
3064 chandransh 10409 
      elif fid == 2:
10410 
        if ftype == TType.I64:
10411 
          self.warehouseId = iprot.readI64();
10412 
        else:
10413 
          iprot.skip(ftype)
1886 ankur.sing 10414 
      else:
10415 
        iprot.skip(ftype)
10416 
      iprot.readFieldEnd()
10417 
    iprot.readStructEnd()
10418 
 
10419 
  def write(self, oprot):
10420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10422 
      return
3064 chandransh 10423 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10424 
    if self.providerId is not None:
3064 chandransh 10425 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10426 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10427 
      oprot.writeFieldEnd()
3431 rajveer 10428 
    if self.warehouseId is not None:
3064 chandransh 10429 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10430 
      oprot.writeI64(self.warehouseId)
10431 
      oprot.writeFieldEnd()
1886 ankur.sing 10432 
    oprot.writeFieldStop()
10433 
    oprot.writeStructEnd()
10434 
 
3431 rajveer 10435 
  def validate(self):
10436 
    return
10437 
 
10438 
 
1886 ankur.sing 10439 
  def __repr__(self):
10440 
    L = ['%s=%r' % (key, value)
10441 
      for key, value in self.__dict__.iteritems()]
10442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10443 
 
10444 
  def __eq__(self, other):
10445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10446 
 
10447 
  def __ne__(self, other):
10448 
    return not (self == other)
10449 
 
3064 chandransh 10450 
class getUndeliveredOrders_result:
1886 ankur.sing 10451 
  """
10452 
  Attributes:
10453 
   - success
10454 
  """
10455 
 
10456 
  thrift_spec = (
10457 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10458 
  )
10459 
 
10460 
  def __init__(self, success=None,):
10461 
    self.success = success
10462 
 
10463 
  def read(self, iprot):
10464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10466 
      return
10467 
    iprot.readStructBegin()
10468 
    while True:
10469 
      (fname, ftype, fid) = iprot.readFieldBegin()
10470 
      if ftype == TType.STOP:
10471 
        break
10472 
      if fid == 0:
10473 
        if ftype == TType.LIST:
10474 
          self.success = []
4133 chandransh 10475 
          (_etype186, _size183) = iprot.readListBegin()
10476 
          for _i187 in xrange(_size183):
10477 
            _elem188 = Order()
10478 
            _elem188.read(iprot)
10479 
            self.success.append(_elem188)
1886 ankur.sing 10480 
          iprot.readListEnd()
10481 
        else:
10482 
          iprot.skip(ftype)
10483 
      else:
10484 
        iprot.skip(ftype)
10485 
      iprot.readFieldEnd()
10486 
    iprot.readStructEnd()
10487 
 
10488 
  def write(self, oprot):
10489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10491 
      return
3064 chandransh 10492 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10493 
    if self.success is not None:
1886 ankur.sing 10494 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10495 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10496 
      for iter189 in self.success:
10497 
        iter189.write(oprot)
1886 ankur.sing 10498 
      oprot.writeListEnd()
10499 
      oprot.writeFieldEnd()
10500 
    oprot.writeFieldStop()
10501 
    oprot.writeStructEnd()
10502 
 
3431 rajveer 10503 
  def validate(self):
10504 
    return
10505 
 
10506 
 
1886 ankur.sing 10507 
  def __repr__(self):
10508 
    L = ['%s=%r' % (key, value)
10509 
      for key, value in self.__dict__.iteritems()]
10510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10511 
 
10512 
  def __eq__(self, other):
10513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10514 
 
10515 
  def __ne__(self, other):
10516 
    return not (self == other)
10517 
 
2536 chandransh 10518 
class toggleDOAFlag_args:
10519 
  """
10520 
  Attributes:
10521 
   - orderId
10522 
  """
1886 ankur.sing 10523 
 
2536 chandransh 10524 
  thrift_spec = (
10525 
    None, # 0
10526 
    (1, TType.I64, 'orderId', None, None, ), # 1
10527 
  )
10528 
 
10529 
  def __init__(self, orderId=None,):
10530 
    self.orderId = orderId
10531 
 
10532 
  def read(self, iprot):
10533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10535 
      return
10536 
    iprot.readStructBegin()
10537 
    while True:
10538 
      (fname, ftype, fid) = iprot.readFieldBegin()
10539 
      if ftype == TType.STOP:
10540 
        break
10541 
      if fid == 1:
10542 
        if ftype == TType.I64:
10543 
          self.orderId = iprot.readI64();
10544 
        else:
10545 
          iprot.skip(ftype)
10546 
      else:
10547 
        iprot.skip(ftype)
10548 
      iprot.readFieldEnd()
10549 
    iprot.readStructEnd()
10550 
 
10551 
  def write(self, oprot):
10552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10554 
      return
10555 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10556 
    if self.orderId is not None:
2536 chandransh 10557 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10558 
      oprot.writeI64(self.orderId)
10559 
      oprot.writeFieldEnd()
10560 
    oprot.writeFieldStop()
10561 
    oprot.writeStructEnd()
10562 
 
3431 rajveer 10563 
  def validate(self):
10564 
    return
10565 
 
10566 
 
2536 chandransh 10567 
  def __repr__(self):
10568 
    L = ['%s=%r' % (key, value)
10569 
      for key, value in self.__dict__.iteritems()]
10570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10571 
 
10572 
  def __eq__(self, other):
10573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10574 
 
10575 
  def __ne__(self, other):
10576 
    return not (self == other)
10577 
 
10578 
class toggleDOAFlag_result:
10579 
  """
10580 
  Attributes:
10581 
   - success
10582 
   - ex
10583 
  """
10584 
 
10585 
  thrift_spec = (
10586 
    (0, TType.BOOL, 'success', None, None, ), # 0
10587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10588 
  )
10589 
 
10590 
  def __init__(self, success=None, ex=None,):
10591 
    self.success = success
10592 
    self.ex = ex
10593 
 
10594 
  def read(self, iprot):
10595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10597 
      return
10598 
    iprot.readStructBegin()
10599 
    while True:
10600 
      (fname, ftype, fid) = iprot.readFieldBegin()
10601 
      if ftype == TType.STOP:
10602 
        break
10603 
      if fid == 0:
10604 
        if ftype == TType.BOOL:
10605 
          self.success = iprot.readBool();
10606 
        else:
10607 
          iprot.skip(ftype)
10608 
      elif fid == 1:
10609 
        if ftype == TType.STRUCT:
10610 
          self.ex = TransactionServiceException()
10611 
          self.ex.read(iprot)
10612 
        else:
10613 
          iprot.skip(ftype)
10614 
      else:
10615 
        iprot.skip(ftype)
10616 
      iprot.readFieldEnd()
10617 
    iprot.readStructEnd()
10618 
 
10619 
  def write(self, oprot):
10620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10622 
      return
10623 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10624 
    if self.success is not None:
2536 chandransh 10625 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10626 
      oprot.writeBool(self.success)
10627 
      oprot.writeFieldEnd()
3431 rajveer 10628 
    if self.ex is not None:
2536 chandransh 10629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10630 
      self.ex.write(oprot)
10631 
      oprot.writeFieldEnd()
10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
3431 rajveer 10635 
  def validate(self):
10636 
    return
10637 
 
10638 
 
2536 chandransh 10639 
  def __repr__(self):
10640 
    L = ['%s=%r' % (key, value)
10641 
      for key, value in self.__dict__.iteritems()]
10642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10643 
 
10644 
  def __eq__(self, other):
10645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10646 
 
10647 
  def __ne__(self, other):
10648 
    return not (self == other)
10649 
 
4454 rajveer 10650 
class markOrderDoaRequestReceived_args:
10651 
  """
10652 
  Attributes:
10653 
   - orderId
10654 
  """
10655 
 
10656 
  thrift_spec = (
10657 
    None, # 0
10658 
    (1, TType.I64, 'orderId', None, None, ), # 1
10659 
  )
10660 
 
10661 
  def __init__(self, orderId=None,):
10662 
    self.orderId = orderId
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 1:
10674 
        if ftype == TType.I64:
10675 
          self.orderId = iprot.readI64();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      else:
10679 
        iprot.skip(ftype)
10680 
      iprot.readFieldEnd()
10681 
    iprot.readStructEnd()
10682 
 
10683 
  def write(self, oprot):
10684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10686 
      return
10687 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
10688 
    if self.orderId is not None:
10689 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10690 
      oprot.writeI64(self.orderId)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
10710 
class markOrderDoaRequestReceived_result:
10711 
  """
10712 
  Attributes:
10713 
   - success
10714 
   - ex
10715 
  """
10716 
 
10717 
  thrift_spec = (
10718 
    (0, TType.BOOL, 'success', None, None, ), # 0
10719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10720 
  )
10721 
 
10722 
  def __init__(self, success=None, ex=None,):
10723 
    self.success = success
10724 
    self.ex = ex
10725 
 
10726 
  def read(self, iprot):
10727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10729 
      return
10730 
    iprot.readStructBegin()
10731 
    while True:
10732 
      (fname, ftype, fid) = iprot.readFieldBegin()
10733 
      if ftype == TType.STOP:
10734 
        break
10735 
      if fid == 0:
10736 
        if ftype == TType.BOOL:
10737 
          self.success = iprot.readBool();
10738 
        else:
10739 
          iprot.skip(ftype)
10740 
      elif fid == 1:
10741 
        if ftype == TType.STRUCT:
10742 
          self.ex = TransactionServiceException()
10743 
          self.ex.read(iprot)
10744 
        else:
10745 
          iprot.skip(ftype)
10746 
      else:
10747 
        iprot.skip(ftype)
10748 
      iprot.readFieldEnd()
10749 
    iprot.readStructEnd()
10750 
 
10751 
  def write(self, oprot):
10752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10754 
      return
10755 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
10756 
    if self.success is not None:
10757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10758 
      oprot.writeBool(self.success)
10759 
      oprot.writeFieldEnd()
10760 
    if self.ex is not None:
10761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10762 
      self.ex.write(oprot)
10763 
      oprot.writeFieldEnd()
10764 
    oprot.writeFieldStop()
10765 
    oprot.writeStructEnd()
10766 
 
10767 
  def validate(self):
10768 
    return
10769 
 
10770 
 
10771 
  def __repr__(self):
10772 
    L = ['%s=%r' % (key, value)
10773 
      for key, value in self.__dict__.iteritems()]
10774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10775 
 
10776 
  def __eq__(self, other):
10777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10778 
 
10779 
  def __ne__(self, other):
10780 
    return not (self == other)
10781 
 
10782 
class markOrderDoaRequestAuthorized_args:
10783 
  """
10784 
  Attributes:
10785 
   - orderId
10786 
   - isAuthorized
10787 
  """
10788 
 
10789 
  thrift_spec = (
10790 
    None, # 0
10791 
    (1, TType.I64, 'orderId', None, None, ), # 1
10792 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
10793 
  )
10794 
 
10795 
  def __init__(self, orderId=None, isAuthorized=None,):
10796 
    self.orderId = orderId
10797 
    self.isAuthorized = isAuthorized
10798 
 
10799 
  def read(self, iprot):
10800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10802 
      return
10803 
    iprot.readStructBegin()
10804 
    while True:
10805 
      (fname, ftype, fid) = iprot.readFieldBegin()
10806 
      if ftype == TType.STOP:
10807 
        break
10808 
      if fid == 1:
10809 
        if ftype == TType.I64:
10810 
          self.orderId = iprot.readI64();
10811 
        else:
10812 
          iprot.skip(ftype)
10813 
      elif fid == 2:
10814 
        if ftype == TType.BOOL:
10815 
          self.isAuthorized = iprot.readBool();
10816 
        else:
10817 
          iprot.skip(ftype)
10818 
      else:
10819 
        iprot.skip(ftype)
10820 
      iprot.readFieldEnd()
10821 
    iprot.readStructEnd()
10822 
 
10823 
  def write(self, oprot):
10824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10826 
      return
10827 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
10828 
    if self.orderId is not None:
10829 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10830 
      oprot.writeI64(self.orderId)
10831 
      oprot.writeFieldEnd()
10832 
    if self.isAuthorized is not None:
10833 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
10834 
      oprot.writeBool(self.isAuthorized)
10835 
      oprot.writeFieldEnd()
10836 
    oprot.writeFieldStop()
10837 
    oprot.writeStructEnd()
10838 
 
10839 
  def validate(self):
10840 
    return
10841 
 
10842 
 
10843 
  def __repr__(self):
10844 
    L = ['%s=%r' % (key, value)
10845 
      for key, value in self.__dict__.iteritems()]
10846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10847 
 
10848 
  def __eq__(self, other):
10849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10850 
 
10851 
  def __ne__(self, other):
10852 
    return not (self == other)
10853 
 
10854 
class markOrderDoaRequestAuthorized_result:
10855 
  """
10856 
  Attributes:
10857 
   - success
10858 
   - ex
10859 
  """
10860 
 
10861 
  thrift_spec = (
10862 
    (0, TType.BOOL, 'success', None, None, ), # 0
10863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10864 
  )
10865 
 
10866 
  def __init__(self, success=None, ex=None,):
10867 
    self.success = success
10868 
    self.ex = ex
10869 
 
10870 
  def read(self, iprot):
10871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10873 
      return
10874 
    iprot.readStructBegin()
10875 
    while True:
10876 
      (fname, ftype, fid) = iprot.readFieldBegin()
10877 
      if ftype == TType.STOP:
10878 
        break
10879 
      if fid == 0:
10880 
        if ftype == TType.BOOL:
10881 
          self.success = iprot.readBool();
10882 
        else:
10883 
          iprot.skip(ftype)
10884 
      elif fid == 1:
10885 
        if ftype == TType.STRUCT:
10886 
          self.ex = TransactionServiceException()
10887 
          self.ex.read(iprot)
10888 
        else:
10889 
          iprot.skip(ftype)
10890 
      else:
10891 
        iprot.skip(ftype)
10892 
      iprot.readFieldEnd()
10893 
    iprot.readStructEnd()
10894 
 
10895 
  def write(self, oprot):
10896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10898 
      return
10899 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
10900 
    if self.success is not None:
10901 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10902 
      oprot.writeBool(self.success)
10903 
      oprot.writeFieldEnd()
10904 
    if self.ex is not None:
10905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10906 
      self.ex.write(oprot)
10907 
      oprot.writeFieldEnd()
10908 
    oprot.writeFieldStop()
10909 
    oprot.writeStructEnd()
10910 
 
10911 
  def validate(self):
10912 
    return
10913 
 
10914 
 
10915 
  def __repr__(self):
10916 
    L = ['%s=%r' % (key, value)
10917 
      for key, value in self.__dict__.iteritems()]
10918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10919 
 
10920 
  def __eq__(self, other):
10921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10922 
 
10923 
  def __ne__(self, other):
10924 
    return not (self == other)
10925 
 
2536 chandransh 10926 
class requestPickupNumber_args:
10927 
  """
10928 
  Attributes:
10929 
   - orderId
10930 
  """
10931 
 
10932 
  thrift_spec = (
10933 
    None, # 0
10934 
    (1, TType.I64, 'orderId', None, None, ), # 1
10935 
  )
10936 
 
10937 
  def __init__(self, orderId=None,):
10938 
    self.orderId = orderId
10939 
 
10940 
  def read(self, iprot):
10941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10943 
      return
10944 
    iprot.readStructBegin()
10945 
    while True:
10946 
      (fname, ftype, fid) = iprot.readFieldBegin()
10947 
      if ftype == TType.STOP:
10948 
        break
10949 
      if fid == 1:
10950 
        if ftype == TType.I64:
10951 
          self.orderId = iprot.readI64();
10952 
        else:
10953 
          iprot.skip(ftype)
10954 
      else:
10955 
        iprot.skip(ftype)
10956 
      iprot.readFieldEnd()
10957 
    iprot.readStructEnd()
10958 
 
10959 
  def write(self, oprot):
10960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10962 
      return
10963 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 10964 
    if self.orderId is not None:
2536 chandransh 10965 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10966 
      oprot.writeI64(self.orderId)
10967 
      oprot.writeFieldEnd()
10968 
    oprot.writeFieldStop()
10969 
    oprot.writeStructEnd()
10970 
 
3431 rajveer 10971 
  def validate(self):
10972 
    return
10973 
 
10974 
 
2536 chandransh 10975 
  def __repr__(self):
10976 
    L = ['%s=%r' % (key, value)
10977 
      for key, value in self.__dict__.iteritems()]
10978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10979 
 
10980 
  def __eq__(self, other):
10981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10982 
 
10983 
  def __ne__(self, other):
10984 
    return not (self == other)
10985 
 
10986 
class requestPickupNumber_result:
10987 
  """
10988 
  Attributes:
10989 
   - success
10990 
   - ex
10991 
  """
10992 
 
10993 
  thrift_spec = (
10994 
    (0, TType.BOOL, 'success', None, None, ), # 0
10995 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10996 
  )
10997 
 
10998 
  def __init__(self, success=None, ex=None,):
10999 
    self.success = success
11000 
    self.ex = ex
11001 
 
11002 
  def read(self, iprot):
11003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11005 
      return
11006 
    iprot.readStructBegin()
11007 
    while True:
11008 
      (fname, ftype, fid) = iprot.readFieldBegin()
11009 
      if ftype == TType.STOP:
11010 
        break
11011 
      if fid == 0:
11012 
        if ftype == TType.BOOL:
11013 
          self.success = iprot.readBool();
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      elif fid == 1:
11017 
        if ftype == TType.STRUCT:
11018 
          self.ex = TransactionServiceException()
11019 
          self.ex.read(iprot)
11020 
        else:
11021 
          iprot.skip(ftype)
11022 
      else:
11023 
        iprot.skip(ftype)
11024 
      iprot.readFieldEnd()
11025 
    iprot.readStructEnd()
11026 
 
11027 
  def write(self, oprot):
11028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11030 
      return
11031 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11032 
    if self.success is not None:
2536 chandransh 11033 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11034 
      oprot.writeBool(self.success)
11035 
      oprot.writeFieldEnd()
3431 rajveer 11036 
    if self.ex is not None:
2536 chandransh 11037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11038 
      self.ex.write(oprot)
11039 
      oprot.writeFieldEnd()
11040 
    oprot.writeFieldStop()
11041 
    oprot.writeStructEnd()
11042 
 
3431 rajveer 11043 
  def validate(self):
11044 
    return
11045 
 
11046 
 
2536 chandransh 11047 
  def __repr__(self):
11048 
    L = ['%s=%r' % (key, value)
11049 
      for key, value in self.__dict__.iteritems()]
11050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11051 
 
11052 
  def __eq__(self, other):
11053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11054 
 
11055 
  def __ne__(self, other):
11056 
    return not (self == other)
11057 
 
11058 
class authorizePickup_args:
11059 
  """
11060 
  Attributes:
11061 
   - orderId
11062 
   - pickupNumber
11063 
  """
11064 
 
11065 
  thrift_spec = (
11066 
    None, # 0
11067 
    (1, TType.I64, 'orderId', None, None, ), # 1
11068 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11069 
  )
11070 
 
11071 
  def __init__(self, orderId=None, pickupNumber=None,):
11072 
    self.orderId = orderId
11073 
    self.pickupNumber = pickupNumber
11074 
 
11075 
  def read(self, iprot):
11076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11078 
      return
11079 
    iprot.readStructBegin()
11080 
    while True:
11081 
      (fname, ftype, fid) = iprot.readFieldBegin()
11082 
      if ftype == TType.STOP:
11083 
        break
11084 
      if fid == 1:
11085 
        if ftype == TType.I64:
11086 
          self.orderId = iprot.readI64();
11087 
        else:
11088 
          iprot.skip(ftype)
11089 
      elif fid == 2:
11090 
        if ftype == TType.STRING:
11091 
          self.pickupNumber = iprot.readString();
11092 
        else:
11093 
          iprot.skip(ftype)
11094 
      else:
11095 
        iprot.skip(ftype)
11096 
      iprot.readFieldEnd()
11097 
    iprot.readStructEnd()
11098 
 
11099 
  def write(self, oprot):
11100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11102 
      return
11103 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11104 
    if self.orderId is not None:
2536 chandransh 11105 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11106 
      oprot.writeI64(self.orderId)
11107 
      oprot.writeFieldEnd()
3431 rajveer 11108 
    if self.pickupNumber is not None:
2536 chandransh 11109 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11110 
      oprot.writeString(self.pickupNumber)
11111 
      oprot.writeFieldEnd()
11112 
    oprot.writeFieldStop()
11113 
    oprot.writeStructEnd()
11114 
 
3431 rajveer 11115 
  def validate(self):
11116 
    return
11117 
 
11118 
 
2536 chandransh 11119 
  def __repr__(self):
11120 
    L = ['%s=%r' % (key, value)
11121 
      for key, value in self.__dict__.iteritems()]
11122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11123 
 
11124 
  def __eq__(self, other):
11125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11126 
 
11127 
  def __ne__(self, other):
11128 
    return not (self == other)
11129 
 
11130 
class authorizePickup_result:
11131 
  """
11132 
  Attributes:
11133 
   - success
11134 
   - ex
11135 
  """
11136 
 
11137 
  thrift_spec = (
11138 
    (0, TType.BOOL, 'success', None, None, ), # 0
11139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11140 
  )
11141 
 
11142 
  def __init__(self, success=None, ex=None,):
11143 
    self.success = success
11144 
    self.ex = ex
11145 
 
11146 
  def read(self, iprot):
11147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11149 
      return
11150 
    iprot.readStructBegin()
11151 
    while True:
11152 
      (fname, ftype, fid) = iprot.readFieldBegin()
11153 
      if ftype == TType.STOP:
11154 
        break
11155 
      if fid == 0:
11156 
        if ftype == TType.BOOL:
11157 
          self.success = iprot.readBool();
11158 
        else:
11159 
          iprot.skip(ftype)
11160 
      elif fid == 1:
11161 
        if ftype == TType.STRUCT:
11162 
          self.ex = TransactionServiceException()
11163 
          self.ex.read(iprot)
11164 
        else:
11165 
          iprot.skip(ftype)
11166 
      else:
11167 
        iprot.skip(ftype)
11168 
      iprot.readFieldEnd()
11169 
    iprot.readStructEnd()
11170 
 
11171 
  def write(self, oprot):
11172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11174 
      return
11175 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11176 
    if self.success is not None:
2536 chandransh 11177 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11178 
      oprot.writeBool(self.success)
11179 
      oprot.writeFieldEnd()
3431 rajveer 11180 
    if self.ex is not None:
2536 chandransh 11181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11182 
      self.ex.write(oprot)
11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
3431 rajveer 11187 
  def validate(self):
11188 
    return
11189 
 
11190 
 
2536 chandransh 11191 
  def __repr__(self):
11192 
    L = ['%s=%r' % (key, value)
11193 
      for key, value in self.__dict__.iteritems()]
11194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11195 
 
11196 
  def __eq__(self, other):
11197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11198 
 
11199 
  def __ne__(self, other):
11200 
    return not (self == other)
11201 
 
2764 chandransh 11202 
class markDoasAsPickedUp_args:
11203 
  """
11204 
  Attributes:
11205 
   - providerId
11206 
   - pickupDetails
11207 
  """
11208 
 
11209 
  thrift_spec = (
11210 
    None, # 0
11211 
    (1, TType.I64, 'providerId', None, None, ), # 1
11212 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11213 
  )
11214 
 
11215 
  def __init__(self, providerId=None, pickupDetails=None,):
11216 
    self.providerId = providerId
11217 
    self.pickupDetails = pickupDetails
11218 
 
11219 
  def read(self, iprot):
11220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11222 
      return
11223 
    iprot.readStructBegin()
11224 
    while True:
11225 
      (fname, ftype, fid) = iprot.readFieldBegin()
11226 
      if ftype == TType.STOP:
11227 
        break
11228 
      if fid == 1:
11229 
        if ftype == TType.I64:
11230 
          self.providerId = iprot.readI64();
11231 
        else:
11232 
          iprot.skip(ftype)
11233 
      elif fid == 2:
11234 
        if ftype == TType.MAP:
11235 
          self.pickupDetails = {}
4133 chandransh 11236 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11237 
          for _i194 in xrange(_size190):
11238 
            _key195 = iprot.readString();
11239 
            _val196 = iprot.readString();
11240 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11241 
          iprot.readMapEnd()
11242 
        else:
11243 
          iprot.skip(ftype)
11244 
      else:
11245 
        iprot.skip(ftype)
11246 
      iprot.readFieldEnd()
11247 
    iprot.readStructEnd()
11248 
 
11249 
  def write(self, oprot):
11250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11252 
      return
11253 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11254 
    if self.providerId is not None:
2764 chandransh 11255 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11256 
      oprot.writeI64(self.providerId)
11257 
      oprot.writeFieldEnd()
3431 rajveer 11258 
    if self.pickupDetails is not None:
2764 chandransh 11259 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11260 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11261 
      for kiter197,viter198 in self.pickupDetails.items():
11262 
        oprot.writeString(kiter197)
11263 
        oprot.writeString(viter198)
2764 chandransh 11264 
      oprot.writeMapEnd()
11265 
      oprot.writeFieldEnd()
11266 
    oprot.writeFieldStop()
11267 
    oprot.writeStructEnd()
11268 
 
3431 rajveer 11269 
  def validate(self):
11270 
    return
11271 
 
11272 
 
2764 chandransh 11273 
  def __repr__(self):
11274 
    L = ['%s=%r' % (key, value)
11275 
      for key, value in self.__dict__.iteritems()]
11276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11277 
 
11278 
  def __eq__(self, other):
11279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11280 
 
11281 
  def __ne__(self, other):
11282 
    return not (self == other)
11283 
 
11284 
class markDoasAsPickedUp_result:
11285 
  """
11286 
  Attributes:
11287 
   - success
11288 
  """
11289 
 
11290 
  thrift_spec = (
11291 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11292 
  )
11293 
 
11294 
  def __init__(self, success=None,):
11295 
    self.success = success
11296 
 
11297 
  def read(self, iprot):
11298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11300 
      return
11301 
    iprot.readStructBegin()
11302 
    while True:
11303 
      (fname, ftype, fid) = iprot.readFieldBegin()
11304 
      if ftype == TType.STOP:
11305 
        break
11306 
      if fid == 0:
11307 
        if ftype == TType.LIST:
11308 
          self.success = []
4133 chandransh 11309 
          (_etype202, _size199) = iprot.readListBegin()
11310 
          for _i203 in xrange(_size199):
11311 
            _elem204 = Order()
11312 
            _elem204.read(iprot)
11313 
            self.success.append(_elem204)
2764 chandransh 11314 
          iprot.readListEnd()
11315 
        else:
11316 
          iprot.skip(ftype)
11317 
      else:
11318 
        iprot.skip(ftype)
11319 
      iprot.readFieldEnd()
11320 
    iprot.readStructEnd()
11321 
 
11322 
  def write(self, oprot):
11323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11325 
      return
11326 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 11327 
    if self.success is not None:
2764 chandransh 11328 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11329 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11330 
      for iter205 in self.success:
11331 
        iter205.write(oprot)
2764 chandransh 11332 
      oprot.writeListEnd()
11333 
      oprot.writeFieldEnd()
11334 
    oprot.writeFieldStop()
11335 
    oprot.writeStructEnd()
11336 
 
3431 rajveer 11337 
  def validate(self):
11338 
    return
11339 
 
11340 
 
2764 chandransh 11341 
  def __repr__(self):
11342 
    L = ['%s=%r' % (key, value)
11343 
      for key, value in self.__dict__.iteritems()]
11344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11345 
 
11346 
  def __eq__(self, other):
11347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11348 
 
11349 
  def __ne__(self, other):
11350 
    return not (self == other)
11351 
 
2616 chandransh 11352 
class receiveReturn_args:
2591 chandransh 11353 
  """
11354 
  Attributes:
11355 
   - orderId
11356 
  """
2536 chandransh 11357 
 
2591 chandransh 11358 
  thrift_spec = (
11359 
    None, # 0
11360 
    (1, TType.I64, 'orderId', None, None, ), # 1
11361 
  )
11362 
 
11363 
  def __init__(self, orderId=None,):
11364 
    self.orderId = orderId
11365 
 
11366 
  def read(self, iprot):
11367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11369 
      return
11370 
    iprot.readStructBegin()
11371 
    while True:
11372 
      (fname, ftype, fid) = iprot.readFieldBegin()
11373 
      if ftype == TType.STOP:
11374 
        break
11375 
      if fid == 1:
11376 
        if ftype == TType.I64:
11377 
          self.orderId = iprot.readI64();
11378 
        else:
11379 
          iprot.skip(ftype)
11380 
      else:
11381 
        iprot.skip(ftype)
11382 
      iprot.readFieldEnd()
11383 
    iprot.readStructEnd()
11384 
 
11385 
  def write(self, oprot):
11386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11388 
      return
2616 chandransh 11389 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 11390 
    if self.orderId is not None:
2591 chandransh 11391 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11392 
      oprot.writeI64(self.orderId)
11393 
      oprot.writeFieldEnd()
11394 
    oprot.writeFieldStop()
11395 
    oprot.writeStructEnd()
11396 
 
3431 rajveer 11397 
  def validate(self):
11398 
    return
11399 
 
11400 
 
2591 chandransh 11401 
  def __repr__(self):
11402 
    L = ['%s=%r' % (key, value)
11403 
      for key, value in self.__dict__.iteritems()]
11404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11405 
 
11406 
  def __eq__(self, other):
11407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11408 
 
11409 
  def __ne__(self, other):
11410 
    return not (self == other)
11411 
 
2616 chandransh 11412 
class receiveReturn_result:
2591 chandransh 11413 
  """
11414 
  Attributes:
11415 
   - success
11416 
   - ex
11417 
  """
11418 
 
11419 
  thrift_spec = (
11420 
    (0, TType.BOOL, 'success', None, None, ), # 0
11421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11422 
  )
11423 
 
11424 
  def __init__(self, success=None, ex=None,):
11425 
    self.success = success
11426 
    self.ex = ex
11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      if fid == 0:
11438 
        if ftype == TType.BOOL:
11439 
          self.success = iprot.readBool();
11440 
        else:
11441 
          iprot.skip(ftype)
11442 
      elif fid == 1:
11443 
        if ftype == TType.STRUCT:
11444 
          self.ex = TransactionServiceException()
11445 
          self.ex.read(iprot)
11446 
        else:
11447 
          iprot.skip(ftype)
11448 
      else:
11449 
        iprot.skip(ftype)
11450 
      iprot.readFieldEnd()
11451 
    iprot.readStructEnd()
11452 
 
11453 
  def write(self, oprot):
11454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11456 
      return
2616 chandransh 11457 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11458 
    if self.success is not None:
2591 chandransh 11459 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11460 
      oprot.writeBool(self.success)
11461 
      oprot.writeFieldEnd()
3431 rajveer 11462 
    if self.ex is not None:
2591 chandransh 11463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11464 
      self.ex.write(oprot)
11465 
      oprot.writeFieldEnd()
11466 
    oprot.writeFieldStop()
11467 
    oprot.writeStructEnd()
11468 
 
3431 rajveer 11469 
  def validate(self):
11470 
    return
11471 
 
11472 
 
2591 chandransh 11473 
  def __repr__(self):
11474 
    L = ['%s=%r' % (key, value)
11475 
      for key, value in self.__dict__.iteritems()]
11476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11477 
 
11478 
  def __eq__(self, other):
11479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11480 
 
11481 
  def __ne__(self, other):
11482 
    return not (self == other)
11483 
 
11484 
class validateDoa_args:
11485 
  """
11486 
  Attributes:
11487 
   - orderId
11488 
   - isValid
11489 
  """
11490 
 
11491 
  thrift_spec = (
11492 
    None, # 0
11493 
    (1, TType.I64, 'orderId', None, None, ), # 1
11494 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
11495 
  )
11496 
 
11497 
  def __init__(self, orderId=None, isValid=None,):
11498 
    self.orderId = orderId
11499 
    self.isValid = isValid
11500 
 
11501 
  def read(self, iprot):
11502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11504 
      return
11505 
    iprot.readStructBegin()
11506 
    while True:
11507 
      (fname, ftype, fid) = iprot.readFieldBegin()
11508 
      if ftype == TType.STOP:
11509 
        break
11510 
      if fid == 1:
11511 
        if ftype == TType.I64:
11512 
          self.orderId = iprot.readI64();
11513 
        else:
11514 
          iprot.skip(ftype)
11515 
      elif fid == 2:
11516 
        if ftype == TType.BOOL:
11517 
          self.isValid = iprot.readBool();
11518 
        else:
11519 
          iprot.skip(ftype)
11520 
      else:
11521 
        iprot.skip(ftype)
11522 
      iprot.readFieldEnd()
11523 
    iprot.readStructEnd()
11524 
 
11525 
  def write(self, oprot):
11526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11528 
      return
11529 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 11530 
    if self.orderId is not None:
2591 chandransh 11531 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11532 
      oprot.writeI64(self.orderId)
11533 
      oprot.writeFieldEnd()
3431 rajveer 11534 
    if self.isValid is not None:
2591 chandransh 11535 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
11536 
      oprot.writeBool(self.isValid)
11537 
      oprot.writeFieldEnd()
11538 
    oprot.writeFieldStop()
11539 
    oprot.writeStructEnd()
11540 
 
3431 rajveer 11541 
  def validate(self):
11542 
    return
11543 
 
11544 
 
2591 chandransh 11545 
  def __repr__(self):
11546 
    L = ['%s=%r' % (key, value)
11547 
      for key, value in self.__dict__.iteritems()]
11548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11549 
 
11550 
  def __eq__(self, other):
11551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11552 
 
11553 
  def __ne__(self, other):
11554 
    return not (self == other)
11555 
 
11556 
class validateDoa_result:
11557 
  """
11558 
  Attributes:
11559 
   - success
11560 
   - ex
11561 
  """
11562 
 
11563 
  thrift_spec = (
11564 
    (0, TType.BOOL, 'success', None, None, ), # 0
11565 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11566 
  )
11567 
 
11568 
  def __init__(self, success=None, ex=None,):
11569 
    self.success = success
11570 
    self.ex = ex
11571 
 
11572 
  def read(self, iprot):
11573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11575 
      return
11576 
    iprot.readStructBegin()
11577 
    while True:
11578 
      (fname, ftype, fid) = iprot.readFieldBegin()
11579 
      if ftype == TType.STOP:
11580 
        break
11581 
      if fid == 0:
11582 
        if ftype == TType.BOOL:
11583 
          self.success = iprot.readBool();
11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      elif fid == 1:
11587 
        if ftype == TType.STRUCT:
11588 
          self.ex = TransactionServiceException()
11589 
          self.ex.read(iprot)
11590 
        else:
11591 
          iprot.skip(ftype)
11592 
      else:
11593 
        iprot.skip(ftype)
11594 
      iprot.readFieldEnd()
11595 
    iprot.readStructEnd()
11596 
 
11597 
  def write(self, oprot):
11598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11600 
      return
11601 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 11602 
    if self.success is not None:
2591 chandransh 11603 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11604 
      oprot.writeBool(self.success)
11605 
      oprot.writeFieldEnd()
3431 rajveer 11606 
    if self.ex is not None:
2591 chandransh 11607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11608 
      self.ex.write(oprot)
11609 
      oprot.writeFieldEnd()
11610 
    oprot.writeFieldStop()
11611 
    oprot.writeStructEnd()
11612 
 
3431 rajveer 11613 
  def validate(self):
11614 
    return
11615 
 
11616 
 
2591 chandransh 11617 
  def __repr__(self):
11618 
    L = ['%s=%r' % (key, value)
11619 
      for key, value in self.__dict__.iteritems()]
11620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11621 
 
11622 
  def __eq__(self, other):
11623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11624 
 
11625 
  def __ne__(self, other):
11626 
    return not (self == other)
11627 
 
2616 chandransh 11628 
class reshipOrder_args:
11629 
  """
11630 
  Attributes:
11631 
   - orderId
11632 
  """
2591 chandransh 11633 
 
2616 chandransh 11634 
  thrift_spec = (
11635 
    None, # 0
11636 
    (1, TType.I64, 'orderId', None, None, ), # 1
11637 
  )
11638 
 
11639 
  def __init__(self, orderId=None,):
11640 
    self.orderId = orderId
11641 
 
11642 
  def read(self, iprot):
11643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11645 
      return
11646 
    iprot.readStructBegin()
11647 
    while True:
11648 
      (fname, ftype, fid) = iprot.readFieldBegin()
11649 
      if ftype == TType.STOP:
11650 
        break
11651 
      if fid == 1:
11652 
        if ftype == TType.I64:
11653 
          self.orderId = iprot.readI64();
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      else:
11657 
        iprot.skip(ftype)
11658 
      iprot.readFieldEnd()
11659 
    iprot.readStructEnd()
11660 
 
11661 
  def write(self, oprot):
11662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11664 
      return
11665 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 11666 
    if self.orderId is not None:
2616 chandransh 11667 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11668 
      oprot.writeI64(self.orderId)
11669 
      oprot.writeFieldEnd()
11670 
    oprot.writeFieldStop()
11671 
    oprot.writeStructEnd()
11672 
 
3431 rajveer 11673 
  def validate(self):
11674 
    return
11675 
 
11676 
 
2616 chandransh 11677 
  def __repr__(self):
11678 
    L = ['%s=%r' % (key, value)
11679 
      for key, value in self.__dict__.iteritems()]
11680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11681 
 
11682 
  def __eq__(self, other):
11683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11684 
 
11685 
  def __ne__(self, other):
11686 
    return not (self == other)
11687 
 
11688 
class reshipOrder_result:
11689 
  """
11690 
  Attributes:
11691 
   - success
11692 
   - ex
11693 
  """
11694 
 
11695 
  thrift_spec = (
11696 
    (0, TType.I64, 'success', None, None, ), # 0
11697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11698 
  )
11699 
 
11700 
  def __init__(self, success=None, ex=None,):
11701 
    self.success = success
11702 
    self.ex = ex
11703 
 
11704 
  def read(self, iprot):
11705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11707 
      return
11708 
    iprot.readStructBegin()
11709 
    while True:
11710 
      (fname, ftype, fid) = iprot.readFieldBegin()
11711 
      if ftype == TType.STOP:
11712 
        break
11713 
      if fid == 0:
11714 
        if ftype == TType.I64:
11715 
          self.success = iprot.readI64();
11716 
        else:
11717 
          iprot.skip(ftype)
11718 
      elif fid == 1:
11719 
        if ftype == TType.STRUCT:
11720 
          self.ex = TransactionServiceException()
11721 
          self.ex.read(iprot)
11722 
        else:
11723 
          iprot.skip(ftype)
11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
11733 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 11734 
    if self.success is not None:
2616 chandransh 11735 
      oprot.writeFieldBegin('success', TType.I64, 0)
11736 
      oprot.writeI64(self.success)
11737 
      oprot.writeFieldEnd()
3431 rajveer 11738 
    if self.ex is not None:
2616 chandransh 11739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11740 
      self.ex.write(oprot)
11741 
      oprot.writeFieldEnd()
11742 
    oprot.writeFieldStop()
11743 
    oprot.writeStructEnd()
11744 
 
3431 rajveer 11745 
  def validate(self):
11746 
    return
11747 
 
11748 
 
2616 chandransh 11749 
  def __repr__(self):
11750 
    L = ['%s=%r' % (key, value)
11751 
      for key, value in self.__dict__.iteritems()]
11752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11753 
 
11754 
  def __eq__(self, other):
11755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11756 
 
11757 
  def __ne__(self, other):
11758 
    return not (self == other)
11759 
 
11760 
class refundOrder_args:
11761 
  """
11762 
  Attributes:
11763 
   - orderId
3226 chandransh 11764 
   - refundedBy
11765 
   - reason
2616 chandransh 11766 
  """
11767 
 
11768 
  thrift_spec = (
11769 
    None, # 0
11770 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 11771 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
11772 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 11773 
  )
11774 
 
3226 chandransh 11775 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 11776 
    self.orderId = orderId
3226 chandransh 11777 
    self.refundedBy = refundedBy
11778 
    self.reason = reason
2616 chandransh 11779 
 
11780 
  def read(self, iprot):
11781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11783 
      return
11784 
    iprot.readStructBegin()
11785 
    while True:
11786 
      (fname, ftype, fid) = iprot.readFieldBegin()
11787 
      if ftype == TType.STOP:
11788 
        break
11789 
      if fid == 1:
11790 
        if ftype == TType.I64:
11791 
          self.orderId = iprot.readI64();
11792 
        else:
11793 
          iprot.skip(ftype)
3226 chandransh 11794 
      elif fid == 2:
11795 
        if ftype == TType.STRING:
11796 
          self.refundedBy = iprot.readString();
11797 
        else:
11798 
          iprot.skip(ftype)
11799 
      elif fid == 3:
11800 
        if ftype == TType.STRING:
11801 
          self.reason = iprot.readString();
11802 
        else:
11803 
          iprot.skip(ftype)
2616 chandransh 11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
11813 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 11814 
    if self.orderId is not None:
2616 chandransh 11815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11816 
      oprot.writeI64(self.orderId)
11817 
      oprot.writeFieldEnd()
3431 rajveer 11818 
    if self.refundedBy is not None:
3226 chandransh 11819 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
11820 
      oprot.writeString(self.refundedBy)
11821 
      oprot.writeFieldEnd()
3431 rajveer 11822 
    if self.reason is not None:
3226 chandransh 11823 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
11824 
      oprot.writeString(self.reason)
11825 
      oprot.writeFieldEnd()
2616 chandransh 11826 
    oprot.writeFieldStop()
11827 
    oprot.writeStructEnd()
11828 
 
3431 rajveer 11829 
  def validate(self):
11830 
    return
11831 
 
11832 
 
2616 chandransh 11833 
  def __repr__(self):
11834 
    L = ['%s=%r' % (key, value)
11835 
      for key, value in self.__dict__.iteritems()]
11836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11837 
 
11838 
  def __eq__(self, other):
11839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11840 
 
11841 
  def __ne__(self, other):
11842 
    return not (self == other)
11843 
 
11844 
class refundOrder_result:
11845 
  """
11846 
  Attributes:
11847 
   - success
11848 
   - ex
11849 
  """
11850 
 
11851 
  thrift_spec = (
11852 
    (0, TType.BOOL, 'success', None, None, ), # 0
11853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11854 
  )
11855 
 
11856 
  def __init__(self, success=None, ex=None,):
11857 
    self.success = success
11858 
    self.ex = ex
11859 
 
11860 
  def read(self, iprot):
11861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11863 
      return
11864 
    iprot.readStructBegin()
11865 
    while True:
11866 
      (fname, ftype, fid) = iprot.readFieldBegin()
11867 
      if ftype == TType.STOP:
11868 
        break
11869 
      if fid == 0:
11870 
        if ftype == TType.BOOL:
11871 
          self.success = iprot.readBool();
11872 
        else:
11873 
          iprot.skip(ftype)
11874 
      elif fid == 1:
11875 
        if ftype == TType.STRUCT:
11876 
          self.ex = TransactionServiceException()
11877 
          self.ex.read(iprot)
11878 
        else:
11879 
          iprot.skip(ftype)
11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
11889 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 11890 
    if self.success is not None:
2616 chandransh 11891 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11892 
      oprot.writeBool(self.success)
11893 
      oprot.writeFieldEnd()
3431 rajveer 11894 
    if self.ex is not None:
2616 chandransh 11895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11896 
      self.ex.write(oprot)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
3431 rajveer 11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
2616 chandransh 11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
2690 chandransh 11916 
class getReturnOrders_args:
11917 
  """
11918 
  Attributes:
11919 
   - warehouseId
11920 
   - fromDate
11921 
   - toDate
11922 
  """
2616 chandransh 11923 
 
2690 chandransh 11924 
  thrift_spec = (
11925 
    None, # 0
11926 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11927 
    (2, TType.I64, 'fromDate', None, None, ), # 2
11928 
    (3, TType.I64, 'toDate', None, None, ), # 3
11929 
  )
11930 
 
11931 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
11932 
    self.warehouseId = warehouseId
11933 
    self.fromDate = fromDate
11934 
    self.toDate = toDate
11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
11945 
      if fid == 1:
11946 
        if ftype == TType.I64:
11947 
          self.warehouseId = iprot.readI64();
11948 
        else:
11949 
          iprot.skip(ftype)
11950 
      elif fid == 2:
11951 
        if ftype == TType.I64:
11952 
          self.fromDate = iprot.readI64();
11953 
        else:
11954 
          iprot.skip(ftype)
11955 
      elif fid == 3:
11956 
        if ftype == TType.I64:
11957 
          self.toDate = iprot.readI64();
11958 
        else:
11959 
          iprot.skip(ftype)
11960 
      else:
11961 
        iprot.skip(ftype)
11962 
      iprot.readFieldEnd()
11963 
    iprot.readStructEnd()
11964 
 
11965 
  def write(self, oprot):
11966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11968 
      return
11969 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 11970 
    if self.warehouseId is not None:
2690 chandransh 11971 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11972 
      oprot.writeI64(self.warehouseId)
11973 
      oprot.writeFieldEnd()
3431 rajveer 11974 
    if self.fromDate is not None:
2690 chandransh 11975 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
11976 
      oprot.writeI64(self.fromDate)
11977 
      oprot.writeFieldEnd()
3431 rajveer 11978 
    if self.toDate is not None:
2690 chandransh 11979 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
11980 
      oprot.writeI64(self.toDate)
11981 
      oprot.writeFieldEnd()
11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
3431 rajveer 11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
2690 chandransh 11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
12000 
class getReturnOrders_result:
12001 
  """
12002 
  Attributes:
12003 
   - success
12004 
  """
12005 
 
12006 
  thrift_spec = (
12007 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12008 
  )
12009 
 
12010 
  def __init__(self, success=None,):
12011 
    self.success = success
12012 
 
12013 
  def read(self, iprot):
12014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12016 
      return
12017 
    iprot.readStructBegin()
12018 
    while True:
12019 
      (fname, ftype, fid) = iprot.readFieldBegin()
12020 
      if ftype == TType.STOP:
12021 
        break
12022 
      if fid == 0:
12023 
        if ftype == TType.LIST:
12024 
          self.success = []
4133 chandransh 12025 
          (_etype209, _size206) = iprot.readListBegin()
12026 
          for _i210 in xrange(_size206):
12027 
            _elem211 = ReturnOrder()
12028 
            _elem211.read(iprot)
12029 
            self.success.append(_elem211)
2690 chandransh 12030 
          iprot.readListEnd()
12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      else:
12034 
        iprot.skip(ftype)
12035 
      iprot.readFieldEnd()
12036 
    iprot.readStructEnd()
12037 
 
12038 
  def write(self, oprot):
12039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12041 
      return
12042 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12043 
    if self.success is not None:
2690 chandransh 12044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12046 
      for iter212 in self.success:
12047 
        iter212.write(oprot)
2690 chandransh 12048 
      oprot.writeListEnd()
12049 
      oprot.writeFieldEnd()
12050 
    oprot.writeFieldStop()
12051 
    oprot.writeStructEnd()
12052 
 
3431 rajveer 12053 
  def validate(self):
12054 
    return
12055 
 
12056 
 
2690 chandransh 12057 
  def __repr__(self):
12058 
    L = ['%s=%r' % (key, value)
12059 
      for key, value in self.__dict__.iteritems()]
12060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12061 
 
12062 
  def __eq__(self, other):
12063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12064 
 
12065 
  def __ne__(self, other):
12066 
    return not (self == other)
12067 
 
2700 chandransh 12068 
class getReturnOrder_args:
12069 
  """
12070 
  Attributes:
12071 
   - id
12072 
  """
12073 
 
12074 
  thrift_spec = (
12075 
    None, # 0
12076 
    (1, TType.I64, 'id', None, None, ), # 1
12077 
  )
12078 
 
12079 
  def __init__(self, id=None,):
12080 
    self.id = id
12081 
 
12082 
  def read(self, iprot):
12083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12085 
      return
12086 
    iprot.readStructBegin()
12087 
    while True:
12088 
      (fname, ftype, fid) = iprot.readFieldBegin()
12089 
      if ftype == TType.STOP:
12090 
        break
12091 
      if fid == 1:
12092 
        if ftype == TType.I64:
12093 
          self.id = iprot.readI64();
12094 
        else:
12095 
          iprot.skip(ftype)
12096 
      else:
12097 
        iprot.skip(ftype)
12098 
      iprot.readFieldEnd()
12099 
    iprot.readStructEnd()
12100 
 
12101 
  def write(self, oprot):
12102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12104 
      return
12105 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12106 
    if self.id is not None:
2700 chandransh 12107 
      oprot.writeFieldBegin('id', TType.I64, 1)
12108 
      oprot.writeI64(self.id)
12109 
      oprot.writeFieldEnd()
12110 
    oprot.writeFieldStop()
12111 
    oprot.writeStructEnd()
12112 
 
3431 rajveer 12113 
  def validate(self):
12114 
    return
12115 
 
12116 
 
2700 chandransh 12117 
  def __repr__(self):
12118 
    L = ['%s=%r' % (key, value)
12119 
      for key, value in self.__dict__.iteritems()]
12120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12121 
 
12122 
  def __eq__(self, other):
12123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12124 
 
12125 
  def __ne__(self, other):
12126 
    return not (self == other)
12127 
 
12128 
class getReturnOrder_result:
12129 
  """
12130 
  Attributes:
12131 
   - success
12132 
   - ex
12133 
  """
12134 
 
12135 
  thrift_spec = (
12136 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
12137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12138 
  )
12139 
 
12140 
  def __init__(self, success=None, ex=None,):
12141 
    self.success = success
12142 
    self.ex = ex
12143 
 
12144 
  def read(self, iprot):
12145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12147 
      return
12148 
    iprot.readStructBegin()
12149 
    while True:
12150 
      (fname, ftype, fid) = iprot.readFieldBegin()
12151 
      if ftype == TType.STOP:
12152 
        break
12153 
      if fid == 0:
12154 
        if ftype == TType.STRUCT:
12155 
          self.success = ReturnOrder()
12156 
          self.success.read(iprot)
12157 
        else:
12158 
          iprot.skip(ftype)
12159 
      elif fid == 1:
12160 
        if ftype == TType.STRUCT:
12161 
          self.ex = TransactionServiceException()
12162 
          self.ex.read(iprot)
12163 
        else:
12164 
          iprot.skip(ftype)
12165 
      else:
12166 
        iprot.skip(ftype)
12167 
      iprot.readFieldEnd()
12168 
    iprot.readStructEnd()
12169 
 
12170 
  def write(self, oprot):
12171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12173 
      return
12174 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 12175 
    if self.success is not None:
2700 chandransh 12176 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12177 
      self.success.write(oprot)
12178 
      oprot.writeFieldEnd()
3431 rajveer 12179 
    if self.ex is not None:
2700 chandransh 12180 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12181 
      self.ex.write(oprot)
12182 
      oprot.writeFieldEnd()
12183 
    oprot.writeFieldStop()
12184 
    oprot.writeStructEnd()
12185 
 
3431 rajveer 12186 
  def validate(self):
12187 
    return
12188 
 
12189 
 
2700 chandransh 12190 
  def __repr__(self):
12191 
    L = ['%s=%r' % (key, value)
12192 
      for key, value in self.__dict__.iteritems()]
12193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12194 
 
12195 
  def __eq__(self, other):
12196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12197 
 
12198 
  def __ne__(self, other):
12199 
    return not (self == other)
12200 
 
2690 chandransh 12201 
class processReturn_args:
12202 
  """
12203 
  Attributes:
12204 
   - returnOrderId
12205 
  """
12206 
 
12207 
  thrift_spec = (
12208 
    None, # 0
12209 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
12210 
  )
12211 
 
12212 
  def __init__(self, returnOrderId=None,):
12213 
    self.returnOrderId = returnOrderId
12214 
 
12215 
  def read(self, iprot):
12216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12218 
      return
12219 
    iprot.readStructBegin()
12220 
    while True:
12221 
      (fname, ftype, fid) = iprot.readFieldBegin()
12222 
      if ftype == TType.STOP:
12223 
        break
12224 
      if fid == 1:
12225 
        if ftype == TType.I64:
12226 
          self.returnOrderId = iprot.readI64();
12227 
        else:
12228 
          iprot.skip(ftype)
12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
12238 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 12239 
    if self.returnOrderId is not None:
2690 chandransh 12240 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
12241 
      oprot.writeI64(self.returnOrderId)
12242 
      oprot.writeFieldEnd()
12243 
    oprot.writeFieldStop()
12244 
    oprot.writeStructEnd()
12245 
 
3431 rajveer 12246 
  def validate(self):
12247 
    return
12248 
 
12249 
 
2690 chandransh 12250 
  def __repr__(self):
12251 
    L = ['%s=%r' % (key, value)
12252 
      for key, value in self.__dict__.iteritems()]
12253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12254 
 
12255 
  def __eq__(self, other):
12256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12257 
 
12258 
  def __ne__(self, other):
12259 
    return not (self == other)
12260 
 
12261 
class processReturn_result:
12262 
  """
12263 
  Attributes:
12264 
   - ex
12265 
  """
12266 
 
12267 
  thrift_spec = (
12268 
    None, # 0
12269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12270 
  )
12271 
 
12272 
  def __init__(self, ex=None,):
12273 
    self.ex = ex
12274 
 
12275 
  def read(self, iprot):
12276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12278 
      return
12279 
    iprot.readStructBegin()
12280 
    while True:
12281 
      (fname, ftype, fid) = iprot.readFieldBegin()
12282 
      if ftype == TType.STOP:
12283 
        break
12284 
      if fid == 1:
12285 
        if ftype == TType.STRUCT:
12286 
          self.ex = TransactionServiceException()
12287 
          self.ex.read(iprot)
12288 
        else:
12289 
          iprot.skip(ftype)
12290 
      else:
12291 
        iprot.skip(ftype)
12292 
      iprot.readFieldEnd()
12293 
    iprot.readStructEnd()
12294 
 
12295 
  def write(self, oprot):
12296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12298 
      return
12299 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 12300 
    if self.ex is not None:
2690 chandransh 12301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12302 
      self.ex.write(oprot)
12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
3431 rajveer 12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
2690 chandransh 12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
2819 chandransh 12322 
class createPurchaseOrder_args:
12323 
  """
12324 
  Attributes:
12325 
   - warehouseId
12326 
  """
2690 chandransh 12327 
 
2819 chandransh 12328 
  thrift_spec = (
12329 
    None, # 0
12330 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12331 
  )
12332 
 
12333 
  def __init__(self, warehouseId=None,):
12334 
    self.warehouseId = warehouseId
12335 
 
12336 
  def read(self, iprot):
12337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12339 
      return
12340 
    iprot.readStructBegin()
12341 
    while True:
12342 
      (fname, ftype, fid) = iprot.readFieldBegin()
12343 
      if ftype == TType.STOP:
12344 
        break
12345 
      if fid == 1:
12346 
        if ftype == TType.I64:
12347 
          self.warehouseId = iprot.readI64();
12348 
        else:
12349 
          iprot.skip(ftype)
12350 
      else:
12351 
        iprot.skip(ftype)
12352 
      iprot.readFieldEnd()
12353 
    iprot.readStructEnd()
12354 
 
12355 
  def write(self, oprot):
12356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12358 
      return
12359 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 12360 
    if self.warehouseId is not None:
2819 chandransh 12361 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12362 
      oprot.writeI64(self.warehouseId)
12363 
      oprot.writeFieldEnd()
12364 
    oprot.writeFieldStop()
12365 
    oprot.writeStructEnd()
12366 
 
3431 rajveer 12367 
  def validate(self):
12368 
    return
12369 
 
12370 
 
2819 chandransh 12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
12382 
class createPurchaseOrder_result:
12383 
  """
12384 
  Attributes:
12385 
   - success
12386 
   - ex
12387 
  """
12388 
 
12389 
  thrift_spec = (
12390 
    (0, TType.I64, 'success', None, None, ), # 0
12391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12392 
  )
12393 
 
12394 
  def __init__(self, success=None, ex=None,):
12395 
    self.success = success
12396 
    self.ex = ex
12397 
 
12398 
  def read(self, iprot):
12399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12401 
      return
12402 
    iprot.readStructBegin()
12403 
    while True:
12404 
      (fname, ftype, fid) = iprot.readFieldBegin()
12405 
      if ftype == TType.STOP:
12406 
        break
12407 
      if fid == 0:
12408 
        if ftype == TType.I64:
12409 
          self.success = iprot.readI64();
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      elif fid == 1:
12413 
        if ftype == TType.STRUCT:
12414 
          self.ex = TransactionServiceException()
12415 
          self.ex.read(iprot)
12416 
        else:
12417 
          iprot.skip(ftype)
12418 
      else:
12419 
        iprot.skip(ftype)
12420 
      iprot.readFieldEnd()
12421 
    iprot.readStructEnd()
12422 
 
12423 
  def write(self, oprot):
12424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12426 
      return
12427 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 12428 
    if self.success is not None:
2819 chandransh 12429 
      oprot.writeFieldBegin('success', TType.I64, 0)
12430 
      oprot.writeI64(self.success)
12431 
      oprot.writeFieldEnd()
3431 rajveer 12432 
    if self.ex is not None:
2819 chandransh 12433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12434 
      self.ex.write(oprot)
12435 
      oprot.writeFieldEnd()
12436 
    oprot.writeFieldStop()
12437 
    oprot.writeStructEnd()
12438 
 
3431 rajveer 12439 
  def validate(self):
12440 
    return
12441 
 
12442 
 
2819 chandransh 12443 
  def __repr__(self):
12444 
    L = ['%s=%r' % (key, value)
12445 
      for key, value in self.__dict__.iteritems()]
12446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12447 
 
12448 
  def __eq__(self, other):
12449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12450 
 
12451 
  def __ne__(self, other):
12452 
    return not (self == other)
3451 chandransh 12453 
 
12454 
class updateWeight_args:
12455 
  """
12456 
  Attributes:
12457 
   - orderId
12458 
   - weight
12459 
  """
12460 
 
12461 
  thrift_spec = (
12462 
    None, # 0
12463 
    (1, TType.I64, 'orderId', None, None, ), # 1
12464 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
12465 
  )
12466 
 
12467 
  def __init__(self, orderId=None, weight=None,):
12468 
    self.orderId = orderId
12469 
    self.weight = weight
12470 
 
12471 
  def read(self, iprot):
12472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12474 
      return
12475 
    iprot.readStructBegin()
12476 
    while True:
12477 
      (fname, ftype, fid) = iprot.readFieldBegin()
12478 
      if ftype == TType.STOP:
12479 
        break
12480 
      if fid == 1:
12481 
        if ftype == TType.I64:
12482 
          self.orderId = iprot.readI64();
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      elif fid == 2:
12486 
        if ftype == TType.DOUBLE:
12487 
          self.weight = iprot.readDouble();
12488 
        else:
12489 
          iprot.skip(ftype)
12490 
      else:
12491 
        iprot.skip(ftype)
12492 
      iprot.readFieldEnd()
12493 
    iprot.readStructEnd()
12494 
 
12495 
  def write(self, oprot):
12496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12498 
      return
12499 
    oprot.writeStructBegin('updateWeight_args')
12500 
    if self.orderId is not None:
12501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12502 
      oprot.writeI64(self.orderId)
12503 
      oprot.writeFieldEnd()
12504 
    if self.weight is not None:
12505 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
12506 
      oprot.writeDouble(self.weight)
12507 
      oprot.writeFieldEnd()
12508 
    oprot.writeFieldStop()
12509 
    oprot.writeStructEnd()
12510 
 
12511 
  def validate(self):
12512 
    return
12513 
 
12514 
 
12515 
  def __repr__(self):
12516 
    L = ['%s=%r' % (key, value)
12517 
      for key, value in self.__dict__.iteritems()]
12518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12519 
 
12520 
  def __eq__(self, other):
12521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12522 
 
12523 
  def __ne__(self, other):
12524 
    return not (self == other)
12525 
 
12526 
class updateWeight_result:
12527 
  """
12528 
  Attributes:
12529 
   - success
12530 
   - ex
12531 
  """
12532 
 
12533 
  thrift_spec = (
12534 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12536 
  )
12537 
 
12538 
  def __init__(self, success=None, ex=None,):
12539 
    self.success = success
12540 
    self.ex = ex
12541 
 
12542 
  def read(self, iprot):
12543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12545 
      return
12546 
    iprot.readStructBegin()
12547 
    while True:
12548 
      (fname, ftype, fid) = iprot.readFieldBegin()
12549 
      if ftype == TType.STOP:
12550 
        break
12551 
      if fid == 0:
12552 
        if ftype == TType.STRUCT:
12553 
          self.success = Order()
12554 
          self.success.read(iprot)
12555 
        else:
12556 
          iprot.skip(ftype)
12557 
      elif fid == 1:
12558 
        if ftype == TType.STRUCT:
12559 
          self.ex = TransactionServiceException()
12560 
          self.ex.read(iprot)
12561 
        else:
12562 
          iprot.skip(ftype)
12563 
      else:
12564 
        iprot.skip(ftype)
12565 
      iprot.readFieldEnd()
12566 
    iprot.readStructEnd()
12567 
 
12568 
  def write(self, oprot):
12569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12571 
      return
12572 
    oprot.writeStructBegin('updateWeight_result')
12573 
    if self.success is not None:
12574 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12575 
      self.success.write(oprot)
12576 
      oprot.writeFieldEnd()
12577 
    if self.ex is not None:
12578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12579 
      self.ex.write(oprot)
12580 
      oprot.writeFieldEnd()
12581 
    oprot.writeFieldStop()
12582 
    oprot.writeStructEnd()
12583 
 
12584 
  def validate(self):
12585 
    return
12586 
 
12587 
 
12588 
  def __repr__(self):
12589 
    L = ['%s=%r' % (key, value)
12590 
      for key, value in self.__dict__.iteritems()]
12591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12592 
 
12593 
  def __eq__(self, other):
12594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12595 
 
12596 
  def __ne__(self, other):
12597 
    return not (self == other)
3469 chandransh 12598 
 
12599 
class changeItem_args:
12600 
  """
12601 
  Attributes:
12602 
   - orderId
12603 
   - itemId
12604 
  """
12605 
 
12606 
  thrift_spec = (
12607 
    None, # 0
12608 
    (1, TType.I64, 'orderId', None, None, ), # 1
12609 
    (2, TType.I64, 'itemId', None, None, ), # 2
12610 
  )
12611 
 
12612 
  def __init__(self, orderId=None, itemId=None,):
12613 
    self.orderId = orderId
12614 
    self.itemId = itemId
12615 
 
12616 
  def read(self, iprot):
12617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12619 
      return
12620 
    iprot.readStructBegin()
12621 
    while True:
12622 
      (fname, ftype, fid) = iprot.readFieldBegin()
12623 
      if ftype == TType.STOP:
12624 
        break
12625 
      if fid == 1:
12626 
        if ftype == TType.I64:
12627 
          self.orderId = iprot.readI64();
12628 
        else:
12629 
          iprot.skip(ftype)
12630 
      elif fid == 2:
12631 
        if ftype == TType.I64:
12632 
          self.itemId = iprot.readI64();
12633 
        else:
12634 
          iprot.skip(ftype)
12635 
      else:
12636 
        iprot.skip(ftype)
12637 
      iprot.readFieldEnd()
12638 
    iprot.readStructEnd()
12639 
 
12640 
  def write(self, oprot):
12641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12643 
      return
12644 
    oprot.writeStructBegin('changeItem_args')
12645 
    if self.orderId is not None:
12646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12647 
      oprot.writeI64(self.orderId)
12648 
      oprot.writeFieldEnd()
12649 
    if self.itemId is not None:
12650 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12651 
      oprot.writeI64(self.itemId)
12652 
      oprot.writeFieldEnd()
12653 
    oprot.writeFieldStop()
12654 
    oprot.writeStructEnd()
12655 
 
12656 
  def validate(self):
12657 
    return
12658 
 
12659 
 
12660 
  def __repr__(self):
12661 
    L = ['%s=%r' % (key, value)
12662 
      for key, value in self.__dict__.iteritems()]
12663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12664 
 
12665 
  def __eq__(self, other):
12666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12667 
 
12668 
  def __ne__(self, other):
12669 
    return not (self == other)
12670 
 
12671 
class changeItem_result:
12672 
  """
12673 
  Attributes:
12674 
   - success
12675 
   - ex
12676 
  """
12677 
 
12678 
  thrift_spec = (
12679 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12680 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12681 
  )
12682 
 
12683 
  def __init__(self, success=None, ex=None,):
12684 
    self.success = success
12685 
    self.ex = ex
12686 
 
12687 
  def read(self, iprot):
12688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12690 
      return
12691 
    iprot.readStructBegin()
12692 
    while True:
12693 
      (fname, ftype, fid) = iprot.readFieldBegin()
12694 
      if ftype == TType.STOP:
12695 
        break
12696 
      if fid == 0:
12697 
        if ftype == TType.STRUCT:
12698 
          self.success = Order()
12699 
          self.success.read(iprot)
12700 
        else:
12701 
          iprot.skip(ftype)
12702 
      elif fid == 1:
12703 
        if ftype == TType.STRUCT:
12704 
          self.ex = TransactionServiceException()
12705 
          self.ex.read(iprot)
12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
12717 
    oprot.writeStructBegin('changeItem_result')
12718 
    if self.success is not None:
12719 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12720 
      self.success.write(oprot)
12721 
      oprot.writeFieldEnd()
12722 
    if self.ex is not None:
12723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12724 
      self.ex.write(oprot)
12725 
      oprot.writeFieldEnd()
12726 
    oprot.writeFieldStop()
12727 
    oprot.writeStructEnd()
12728 
 
12729 
  def validate(self):
12730 
    return
12731 
 
12732 
 
12733 
  def __repr__(self):
12734 
    L = ['%s=%r' % (key, value)
12735 
      for key, value in self.__dict__.iteritems()]
12736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12737 
 
12738 
  def __eq__(self, other):
12739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12740 
 
12741 
  def __ne__(self, other):
12742 
    return not (self == other)
12743 
 
12744 
class shiftToWarehouse_args:
12745 
  """
12746 
  Attributes:
12747 
   - orderId
12748 
   - warehouseId
12749 
  """
12750 
 
12751 
  thrift_spec = (
12752 
    None, # 0
12753 
    (1, TType.I64, 'orderId', None, None, ), # 1
12754 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12755 
  )
12756 
 
12757 
  def __init__(self, orderId=None, warehouseId=None,):
12758 
    self.orderId = orderId
12759 
    self.warehouseId = warehouseId
12760 
 
12761 
  def read(self, iprot):
12762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12764 
      return
12765 
    iprot.readStructBegin()
12766 
    while True:
12767 
      (fname, ftype, fid) = iprot.readFieldBegin()
12768 
      if ftype == TType.STOP:
12769 
        break
12770 
      if fid == 1:
12771 
        if ftype == TType.I64:
12772 
          self.orderId = iprot.readI64();
12773 
        else:
12774 
          iprot.skip(ftype)
12775 
      elif fid == 2:
12776 
        if ftype == TType.I64:
12777 
          self.warehouseId = iprot.readI64();
12778 
        else:
12779 
          iprot.skip(ftype)
12780 
      else:
12781 
        iprot.skip(ftype)
12782 
      iprot.readFieldEnd()
12783 
    iprot.readStructEnd()
12784 
 
12785 
  def write(self, oprot):
12786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12788 
      return
12789 
    oprot.writeStructBegin('shiftToWarehouse_args')
12790 
    if self.orderId is not None:
12791 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12792 
      oprot.writeI64(self.orderId)
12793 
      oprot.writeFieldEnd()
12794 
    if self.warehouseId is not None:
12795 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12796 
      oprot.writeI64(self.warehouseId)
12797 
      oprot.writeFieldEnd()
12798 
    oprot.writeFieldStop()
12799 
    oprot.writeStructEnd()
12800 
 
12801 
  def validate(self):
12802 
    return
12803 
 
12804 
 
12805 
  def __repr__(self):
12806 
    L = ['%s=%r' % (key, value)
12807 
      for key, value in self.__dict__.iteritems()]
12808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12809 
 
12810 
  def __eq__(self, other):
12811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12812 
 
12813 
  def __ne__(self, other):
12814 
    return not (self == other)
12815 
 
12816 
class shiftToWarehouse_result:
12817 
  """
12818 
  Attributes:
12819 
   - success
12820 
   - ex
12821 
  """
12822 
 
12823 
  thrift_spec = (
12824 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12826 
  )
12827 
 
12828 
  def __init__(self, success=None, ex=None,):
12829 
    self.success = success
12830 
    self.ex = ex
12831 
 
12832 
  def read(self, iprot):
12833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12835 
      return
12836 
    iprot.readStructBegin()
12837 
    while True:
12838 
      (fname, ftype, fid) = iprot.readFieldBegin()
12839 
      if ftype == TType.STOP:
12840 
        break
12841 
      if fid == 0:
12842 
        if ftype == TType.STRUCT:
12843 
          self.success = Order()
12844 
          self.success.read(iprot)
12845 
        else:
12846 
          iprot.skip(ftype)
12847 
      elif fid == 1:
12848 
        if ftype == TType.STRUCT:
12849 
          self.ex = TransactionServiceException()
12850 
          self.ex.read(iprot)
12851 
        else:
12852 
          iprot.skip(ftype)
12853 
      else:
12854 
        iprot.skip(ftype)
12855 
      iprot.readFieldEnd()
12856 
    iprot.readStructEnd()
12857 
 
12858 
  def write(self, oprot):
12859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12861 
      return
12862 
    oprot.writeStructBegin('shiftToWarehouse_result')
12863 
    if self.success is not None:
12864 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12865 
      self.success.write(oprot)
12866 
      oprot.writeFieldEnd()
12867 
    if self.ex is not None:
12868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12869 
      self.ex.write(oprot)
12870 
      oprot.writeFieldEnd()
12871 
    oprot.writeFieldStop()
12872 
    oprot.writeStructEnd()
12873 
 
12874 
  def validate(self):
12875 
    return
12876 
 
12877 
 
12878 
  def __repr__(self):
12879 
    L = ['%s=%r' % (key, value)
12880 
      for key, value in self.__dict__.iteritems()]
12881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12882 
 
12883 
  def __eq__(self, other):
12884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12885 
 
12886 
  def __ne__(self, other):
12887 
    return not (self == other)
3553 chandransh 12888 
 
12889 
class addDelayReason_args:
12890 
  """
12891 
  Attributes:
12892 
   - orderId
12893 
   - delayReason
3986 chandransh 12894 
   - furtherDelay
3553 chandransh 12895 
  """
12896 
 
12897 
  thrift_spec = (
12898 
    None, # 0
12899 
    (1, TType.I64, 'orderId', None, None, ), # 1
12900 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 12901 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 12902 
  )
12903 
 
3986 chandransh 12904 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 12905 
    self.orderId = orderId
12906 
    self.delayReason = delayReason
3986 chandransh 12907 
    self.furtherDelay = furtherDelay
3553 chandransh 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 == 1:
12919 
        if ftype == TType.I64:
12920 
          self.orderId = iprot.readI64();
12921 
        else:
12922 
          iprot.skip(ftype)
12923 
      elif fid == 2:
12924 
        if ftype == TType.I32:
12925 
          self.delayReason = iprot.readI32();
12926 
        else:
12927 
          iprot.skip(ftype)
3986 chandransh 12928 
      elif fid == 3:
12929 
        if ftype == TType.I64:
12930 
          self.furtherDelay = iprot.readI64();
12931 
        else:
12932 
          iprot.skip(ftype)
3553 chandransh 12933 
      else:
12934 
        iprot.skip(ftype)
12935 
      iprot.readFieldEnd()
12936 
    iprot.readStructEnd()
12937 
 
12938 
  def write(self, oprot):
12939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12941 
      return
12942 
    oprot.writeStructBegin('addDelayReason_args')
12943 
    if self.orderId is not None:
12944 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12945 
      oprot.writeI64(self.orderId)
12946 
      oprot.writeFieldEnd()
12947 
    if self.delayReason is not None:
12948 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
12949 
      oprot.writeI32(self.delayReason)
12950 
      oprot.writeFieldEnd()
3986 chandransh 12951 
    if self.furtherDelay is not None:
12952 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
12953 
      oprot.writeI64(self.furtherDelay)
12954 
      oprot.writeFieldEnd()
3553 chandransh 12955 
    oprot.writeFieldStop()
12956 
    oprot.writeStructEnd()
12957 
 
12958 
  def validate(self):
12959 
    return
12960 
 
12961 
 
12962 
  def __repr__(self):
12963 
    L = ['%s=%r' % (key, value)
12964 
      for key, value in self.__dict__.iteritems()]
12965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12966 
 
12967 
  def __eq__(self, other):
12968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12969 
 
12970 
  def __ne__(self, other):
12971 
    return not (self == other)
12972 
 
12973 
class addDelayReason_result:
12974 
  """
12975 
  Attributes:
12976 
   - success
12977 
   - ex
12978 
  """
12979 
 
12980 
  thrift_spec = (
12981 
    (0, TType.BOOL, 'success', None, None, ), # 0
12982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12983 
  )
12984 
 
12985 
  def __init__(self, success=None, ex=None,):
12986 
    self.success = success
12987 
    self.ex = ex
12988 
 
12989 
  def read(self, iprot):
12990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12992 
      return
12993 
    iprot.readStructBegin()
12994 
    while True:
12995 
      (fname, ftype, fid) = iprot.readFieldBegin()
12996 
      if ftype == TType.STOP:
12997 
        break
12998 
      if fid == 0:
12999 
        if ftype == TType.BOOL:
13000 
          self.success = iprot.readBool();
13001 
        else:
13002 
          iprot.skip(ftype)
13003 
      elif fid == 1:
13004 
        if ftype == TType.STRUCT:
13005 
          self.ex = TransactionServiceException()
13006 
          self.ex.read(iprot)
13007 
        else:
13008 
          iprot.skip(ftype)
13009 
      else:
13010 
        iprot.skip(ftype)
13011 
      iprot.readFieldEnd()
13012 
    iprot.readStructEnd()
13013 
 
13014 
  def write(self, oprot):
13015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13017 
      return
13018 
    oprot.writeStructBegin('addDelayReason_result')
13019 
    if self.success is not None:
13020 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13021 
      oprot.writeBool(self.success)
13022 
      oprot.writeFieldEnd()
13023 
    if self.ex is not None:
13024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13025 
      self.ex.write(oprot)
13026 
      oprot.writeFieldEnd()
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
3956 chandransh 13044 
 
13045 
class reconcileCodCollection_args:
13046 
  """
13047 
  Attributes:
13048 
   - collectedAmountMap
13049 
   - xferBy
13050 
   - xferTxnId
13051 
   - xferDate
13052 
  """
13053 
 
13054 
  thrift_spec = (
13055 
    None, # 0
13056 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13057 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13058 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13059 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13060 
  )
13061 
 
13062 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13063 
    self.collectedAmountMap = collectedAmountMap
13064 
    self.xferBy = xferBy
13065 
    self.xferTxnId = xferTxnId
13066 
    self.xferDate = xferDate
13067 
 
13068 
  def read(self, iprot):
13069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13071 
      return
13072 
    iprot.readStructBegin()
13073 
    while True:
13074 
      (fname, ftype, fid) = iprot.readFieldBegin()
13075 
      if ftype == TType.STOP:
13076 
        break
13077 
      if fid == 1:
13078 
        if ftype == TType.MAP:
13079 
          self.collectedAmountMap = {}
4133 chandransh 13080 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13081 
          for _i217 in xrange(_size213):
13082 
            _key218 = iprot.readString();
13083 
            _val219 = iprot.readDouble();
13084 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13085 
          iprot.readMapEnd()
13086 
        else:
13087 
          iprot.skip(ftype)
13088 
      elif fid == 2:
13089 
        if ftype == TType.STRING:
13090 
          self.xferBy = iprot.readString();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      elif fid == 3:
13094 
        if ftype == TType.STRING:
13095 
          self.xferTxnId = iprot.readString();
13096 
        else:
13097 
          iprot.skip(ftype)
13098 
      elif fid == 4:
13099 
        if ftype == TType.I64:
13100 
          self.xferDate = iprot.readI64();
13101 
        else:
13102 
          iprot.skip(ftype)
13103 
      else:
13104 
        iprot.skip(ftype)
13105 
      iprot.readFieldEnd()
13106 
    iprot.readStructEnd()
13107 
 
13108 
  def write(self, oprot):
13109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13111 
      return
13112 
    oprot.writeStructBegin('reconcileCodCollection_args')
13113 
    if self.collectedAmountMap is not None:
13114 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13115 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13116 
      for kiter220,viter221 in self.collectedAmountMap.items():
13117 
        oprot.writeString(kiter220)
13118 
        oprot.writeDouble(viter221)
3956 chandransh 13119 
      oprot.writeMapEnd()
13120 
      oprot.writeFieldEnd()
13121 
    if self.xferBy is not None:
13122 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
13123 
      oprot.writeString(self.xferBy)
13124 
      oprot.writeFieldEnd()
13125 
    if self.xferTxnId is not None:
13126 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
13127 
      oprot.writeString(self.xferTxnId)
13128 
      oprot.writeFieldEnd()
13129 
    if self.xferDate is not None:
13130 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
13131 
      oprot.writeI64(self.xferDate)
13132 
      oprot.writeFieldEnd()
13133 
    oprot.writeFieldStop()
13134 
    oprot.writeStructEnd()
13135 
 
13136 
  def validate(self):
13137 
    return
13138 
 
13139 
 
13140 
  def __repr__(self):
13141 
    L = ['%s=%r' % (key, value)
13142 
      for key, value in self.__dict__.iteritems()]
13143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13144 
 
13145 
  def __eq__(self, other):
13146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13147 
 
13148 
  def __ne__(self, other):
13149 
    return not (self == other)
13150 
 
13151 
class reconcileCodCollection_result:
13152 
  """
13153 
  Attributes:
13154 
   - success
13155 
   - ex
13156 
  """
13157 
 
13158 
  thrift_spec = (
13159 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
13160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13161 
  )
13162 
 
13163 
  def __init__(self, success=None, ex=None,):
13164 
    self.success = success
13165 
    self.ex = ex
13166 
 
13167 
  def read(self, iprot):
13168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13170 
      return
13171 
    iprot.readStructBegin()
13172 
    while True:
13173 
      (fname, ftype, fid) = iprot.readFieldBegin()
13174 
      if ftype == TType.STOP:
13175 
        break
13176 
      if fid == 0:
13177 
        if ftype == TType.MAP:
13178 
          self.success = {}
4133 chandransh 13179 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
13180 
          for _i226 in xrange(_size222):
13181 
            _key227 = iprot.readString();
13182 
            _val228 = iprot.readString();
13183 
            self.success[_key227] = _val228
3956 chandransh 13184 
          iprot.readMapEnd()
13185 
        else:
13186 
          iprot.skip(ftype)
13187 
      elif fid == 1:
13188 
        if ftype == TType.STRUCT:
13189 
          self.ex = TransactionServiceException()
13190 
          self.ex.read(iprot)
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      else:
13194 
        iprot.skip(ftype)
13195 
      iprot.readFieldEnd()
13196 
    iprot.readStructEnd()
13197 
 
13198 
  def write(self, oprot):
13199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13201 
      return
13202 
    oprot.writeStructBegin('reconcileCodCollection_result')
13203 
    if self.success is not None:
13204 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13205 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 13206 
      for kiter229,viter230 in self.success.items():
13207 
        oprot.writeString(kiter229)
13208 
        oprot.writeString(viter230)
3956 chandransh 13209 
      oprot.writeMapEnd()
13210 
      oprot.writeFieldEnd()
13211 
    if self.ex is not None:
13212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13213 
      self.ex.write(oprot)
13214 
      oprot.writeFieldEnd()
13215 
    oprot.writeFieldStop()
13216 
    oprot.writeStructEnd()
13217 
 
13218 
  def validate(self):
13219 
    return
13220 
 
13221 
 
13222 
  def __repr__(self):
13223 
    L = ['%s=%r' % (key, value)
13224 
      for key, value in self.__dict__.iteritems()]
13225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13226 
 
13227 
  def __eq__(self, other):
13228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13229 
 
13230 
  def __ne__(self, other):
13231 
    return not (self == other)
4008 mandeep.dh 13232 
 
13233 
class getTransactionsRequiringExtraProcessing_args:
13234 
  """
13235 
  Attributes:
13236 
   - category
13237 
  """
13238 
 
13239 
  thrift_spec = (
13240 
    None, # 0
13241 
    (1, TType.I32, 'category', None, None, ), # 1
13242 
  )
13243 
 
13244 
  def __init__(self, category=None,):
13245 
    self.category = category
13246 
 
13247 
  def read(self, iprot):
13248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13250 
      return
13251 
    iprot.readStructBegin()
13252 
    while True:
13253 
      (fname, ftype, fid) = iprot.readFieldBegin()
13254 
      if ftype == TType.STOP:
13255 
        break
13256 
      if fid == 1:
13257 
        if ftype == TType.I32:
13258 
          self.category = iprot.readI32();
13259 
        else:
13260 
          iprot.skip(ftype)
13261 
      else:
13262 
        iprot.skip(ftype)
13263 
      iprot.readFieldEnd()
13264 
    iprot.readStructEnd()
13265 
 
13266 
  def write(self, oprot):
13267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13269 
      return
13270 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
13271 
    if self.category is not None:
13272 
      oprot.writeFieldBegin('category', TType.I32, 1)
13273 
      oprot.writeI32(self.category)
13274 
      oprot.writeFieldEnd()
13275 
    oprot.writeFieldStop()
13276 
    oprot.writeStructEnd()
13277 
 
13278 
  def validate(self):
13279 
    return
13280 
 
13281 
 
13282 
  def __repr__(self):
13283 
    L = ['%s=%r' % (key, value)
13284 
      for key, value in self.__dict__.iteritems()]
13285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13286 
 
13287 
  def __eq__(self, other):
13288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13289 
 
13290 
  def __ne__(self, other):
13291 
    return not (self == other)
13292 
 
13293 
class getTransactionsRequiringExtraProcessing_result:
13294 
  """
13295 
  Attributes:
13296 
   - success
13297 
  """
13298 
 
13299 
  thrift_spec = (
13300 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13301 
  )
13302 
 
13303 
  def __init__(self, success=None,):
13304 
    self.success = success
13305 
 
13306 
  def read(self, iprot):
13307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13309 
      return
13310 
    iprot.readStructBegin()
13311 
    while True:
13312 
      (fname, ftype, fid) = iprot.readFieldBegin()
13313 
      if ftype == TType.STOP:
13314 
        break
13315 
      if fid == 0:
13316 
        if ftype == TType.LIST:
13317 
          self.success = []
4133 chandransh 13318 
          (_etype234, _size231) = iprot.readListBegin()
13319 
          for _i235 in xrange(_size231):
13320 
            _elem236 = iprot.readI64();
13321 
            self.success.append(_elem236)
4008 mandeep.dh 13322 
          iprot.readListEnd()
13323 
        else:
13324 
          iprot.skip(ftype)
13325 
      else:
13326 
        iprot.skip(ftype)
13327 
      iprot.readFieldEnd()
13328 
    iprot.readStructEnd()
13329 
 
13330 
  def write(self, oprot):
13331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13333 
      return
13334 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
13335 
    if self.success is not None:
13336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13337 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 13338 
      for iter237 in self.success:
13339 
        oprot.writeI64(iter237)
4008 mandeep.dh 13340 
      oprot.writeListEnd()
13341 
      oprot.writeFieldEnd()
13342 
    oprot.writeFieldStop()
13343 
    oprot.writeStructEnd()
13344 
 
13345 
  def validate(self):
13346 
    return
13347 
 
13348 
 
13349 
  def __repr__(self):
13350 
    L = ['%s=%r' % (key, value)
13351 
      for key, value in self.__dict__.iteritems()]
13352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13353 
 
13354 
  def __eq__(self, other):
13355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13356 
 
13357 
  def __ne__(self, other):
13358 
    return not (self == other)
13359 
 
13360 
class markTransactionAsProcessed_args:
13361 
  """
13362 
  Attributes:
13363 
   - transactionId
13364 
   - category
13365 
  """
13366 
 
13367 
  thrift_spec = (
13368 
    None, # 0
13369 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13370 
    (2, TType.I32, 'category', None, None, ), # 2
13371 
  )
13372 
 
13373 
  def __init__(self, transactionId=None, category=None,):
13374 
    self.transactionId = transactionId
13375 
    self.category = category
13376 
 
13377 
  def read(self, iprot):
13378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13380 
      return
13381 
    iprot.readStructBegin()
13382 
    while True:
13383 
      (fname, ftype, fid) = iprot.readFieldBegin()
13384 
      if ftype == TType.STOP:
13385 
        break
13386 
      if fid == 1:
13387 
        if ftype == TType.I64:
13388 
          self.transactionId = iprot.readI64();
13389 
        else:
13390 
          iprot.skip(ftype)
13391 
      elif fid == 2:
13392 
        if ftype == TType.I32:
13393 
          self.category = iprot.readI32();
13394 
        else:
13395 
          iprot.skip(ftype)
13396 
      else:
13397 
        iprot.skip(ftype)
13398 
      iprot.readFieldEnd()
13399 
    iprot.readStructEnd()
13400 
 
13401 
  def write(self, oprot):
13402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13404 
      return
13405 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
13406 
    if self.transactionId is not None:
13407 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13408 
      oprot.writeI64(self.transactionId)
13409 
      oprot.writeFieldEnd()
13410 
    if self.category is not None:
13411 
      oprot.writeFieldBegin('category', TType.I32, 2)
13412 
      oprot.writeI32(self.category)
13413 
      oprot.writeFieldEnd()
13414 
    oprot.writeFieldStop()
13415 
    oprot.writeStructEnd()
13416 
 
13417 
  def validate(self):
13418 
    return
13419 
 
13420 
 
13421 
  def __repr__(self):
13422 
    L = ['%s=%r' % (key, value)
13423 
      for key, value in self.__dict__.iteritems()]
13424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13425 
 
13426 
  def __eq__(self, other):
13427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13428 
 
13429 
  def __ne__(self, other):
13430 
    return not (self == other)
13431 
 
13432 
class markTransactionAsProcessed_result:
13433 
 
13434 
  thrift_spec = (
13435 
  )
13436 
 
13437 
  def read(self, iprot):
13438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13440 
      return
13441 
    iprot.readStructBegin()
13442 
    while True:
13443 
      (fname, ftype, fid) = iprot.readFieldBegin()
13444 
      if ftype == TType.STOP:
13445 
        break
13446 
      else:
13447 
        iprot.skip(ftype)
13448 
      iprot.readFieldEnd()
13449 
    iprot.readStructEnd()
13450 
 
13451 
  def write(self, oprot):
13452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13454 
      return
13455 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
13456 
    oprot.writeFieldStop()
13457 
    oprot.writeStructEnd()
13458 
 
13459 
  def validate(self):
13460 
    return
13461 
 
13462 
 
13463 
  def __repr__(self):
13464 
    L = ['%s=%r' % (key, value)
13465 
      for key, value in self.__dict__.iteritems()]
13466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13467 
 
13468 
  def __eq__(self, other):
13469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13470 
 
13471 
  def __ne__(self, other):
13472 
    return not (self == other)
4018 chandransh 13473 
 
13474 
class getItemWiseRiskyOrdersCount_args:
13475 
 
13476 
  thrift_spec = (
13477 
  )
13478 
 
13479 
  def read(self, iprot):
13480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13482 
      return
13483 
    iprot.readStructBegin()
13484 
    while True:
13485 
      (fname, ftype, fid) = iprot.readFieldBegin()
13486 
      if ftype == TType.STOP:
13487 
        break
13488 
      else:
13489 
        iprot.skip(ftype)
13490 
      iprot.readFieldEnd()
13491 
    iprot.readStructEnd()
13492 
 
13493 
  def write(self, oprot):
13494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13496 
      return
13497 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
13498 
    oprot.writeFieldStop()
13499 
    oprot.writeStructEnd()
13500 
 
13501 
  def validate(self):
13502 
    return
13503 
 
13504 
 
13505 
  def __repr__(self):
13506 
    L = ['%s=%r' % (key, value)
13507 
      for key, value in self.__dict__.iteritems()]
13508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13509 
 
13510 
  def __eq__(self, other):
13511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13512 
 
13513 
  def __ne__(self, other):
13514 
    return not (self == other)
13515 
 
13516 
class getItemWiseRiskyOrdersCount_result:
13517 
  """
13518 
  Attributes:
13519 
   - success
13520 
  """
13521 
 
13522 
  thrift_spec = (
13523 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
13524 
  )
13525 
 
13526 
  def __init__(self, success=None,):
13527 
    self.success = success
13528 
 
13529 
  def read(self, iprot):
13530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13532 
      return
13533 
    iprot.readStructBegin()
13534 
    while True:
13535 
      (fname, ftype, fid) = iprot.readFieldBegin()
13536 
      if ftype == TType.STOP:
13537 
        break
13538 
      if fid == 0:
13539 
        if ftype == TType.MAP:
13540 
          self.success = {}
4133 chandransh 13541 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
13542 
          for _i242 in xrange(_size238):
13543 
            _key243 = iprot.readI64();
13544 
            _val244 = iprot.readI64();
13545 
            self.success[_key243] = _val244
4018 chandransh 13546 
          iprot.readMapEnd()
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
13558 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
13559 
    if self.success is not None:
13560 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13561 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 13562 
      for kiter245,viter246 in self.success.items():
13563 
        oprot.writeI64(kiter245)
13564 
        oprot.writeI64(viter246)
4018 chandransh 13565 
      oprot.writeMapEnd()
13566 
      oprot.writeFieldEnd()
13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
4247 rajveer 13584 
 
4295 varun.gupt 13585 
class getOrdersForItemIds_args:
13586 
  """
13587 
  Attributes:
13588 
   - itemIds
13589 
  """
13590 
 
13591 
  thrift_spec = (
13592 
    None, # 0
13593 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
13594 
  )
13595 
 
13596 
  def __init__(self, itemIds=None,):
13597 
    self.itemIds = itemIds
13598 
 
13599 
  def read(self, iprot):
13600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13602 
      return
13603 
    iprot.readStructBegin()
13604 
    while True:
13605 
      (fname, ftype, fid) = iprot.readFieldBegin()
13606 
      if ftype == TType.STOP:
13607 
        break
13608 
      if fid == 1:
13609 
        if ftype == TType.LIST:
13610 
          self.itemIds = []
13611 
          (_etype250, _size247) = iprot.readListBegin()
13612 
          for _i251 in xrange(_size247):
13613 
            _elem252 = iprot.readI64();
13614 
            self.itemIds.append(_elem252)
13615 
          iprot.readListEnd()
13616 
        else:
13617 
          iprot.skip(ftype)
13618 
      else:
13619 
        iprot.skip(ftype)
13620 
      iprot.readFieldEnd()
13621 
    iprot.readStructEnd()
13622 
 
13623 
  def write(self, oprot):
13624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13626 
      return
13627 
    oprot.writeStructBegin('getOrdersForItemIds_args')
13628 
    if self.itemIds is not None:
13629 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
13630 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13631 
      for iter253 in self.itemIds:
13632 
        oprot.writeI64(iter253)
13633 
      oprot.writeListEnd()
13634 
      oprot.writeFieldEnd()
13635 
    oprot.writeFieldStop()
13636 
    oprot.writeStructEnd()
13637 
 
13638 
  def validate(self):
13639 
    return
13640 
 
13641 
 
13642 
  def __repr__(self):
13643 
    L = ['%s=%r' % (key, value)
13644 
      for key, value in self.__dict__.iteritems()]
13645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13646 
 
13647 
  def __eq__(self, other):
13648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13649 
 
13650 
  def __ne__(self, other):
13651 
    return not (self == other)
13652 
 
13653 
class getOrdersForItemIds_result:
13654 
  """
13655 
  Attributes:
13656 
   - success
13657 
  """
13658 
 
13659 
  thrift_spec = (
13660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13661 
  )
13662 
 
13663 
  def __init__(self, success=None,):
13664 
    self.success = success
13665 
 
13666 
  def read(self, iprot):
13667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13669 
      return
13670 
    iprot.readStructBegin()
13671 
    while True:
13672 
      (fname, ftype, fid) = iprot.readFieldBegin()
13673 
      if ftype == TType.STOP:
13674 
        break
13675 
      if fid == 0:
13676 
        if ftype == TType.LIST:
13677 
          self.success = []
13678 
          (_etype257, _size254) = iprot.readListBegin()
13679 
          for _i258 in xrange(_size254):
13680 
            _elem259 = Order()
13681 
            _elem259.read(iprot)
13682 
            self.success.append(_elem259)
13683 
          iprot.readListEnd()
13684 
        else:
13685 
          iprot.skip(ftype)
13686 
      else:
13687 
        iprot.skip(ftype)
13688 
      iprot.readFieldEnd()
13689 
    iprot.readStructEnd()
13690 
 
13691 
  def write(self, oprot):
13692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13694 
      return
13695 
    oprot.writeStructBegin('getOrdersForItemIds_result')
13696 
    if self.success is not None:
13697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13699 
      for iter260 in self.success:
13700 
        iter260.write(oprot)
13701 
      oprot.writeListEnd()
13702 
      oprot.writeFieldEnd()
13703 
    oprot.writeFieldStop()
13704 
    oprot.writeStructEnd()
13705 
 
13706 
  def validate(self):
13707 
    return
13708 
 
13709 
 
13710 
  def __repr__(self):
13711 
    L = ['%s=%r' % (key, value)
13712 
      for key, value in self.__dict__.iteritems()]
13713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13714 
 
13715 
  def __eq__(self, other):
13716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13717 
 
13718 
  def __ne__(self, other):
13719 
    return not (self == other)
13720 
 
4247 rajveer 13721 
class markOrderCancellationRequestReceived_args:
13722 
  """
13723 
  Attributes:
13724 
   - orderId
13725 
  """
13726 
 
13727 
  thrift_spec = (
13728 
    None, # 0
13729 
    (1, TType.I64, 'orderId', None, None, ), # 1
13730 
  )
13731 
 
13732 
  def __init__(self, orderId=None,):
13733 
    self.orderId = orderId
13734 
 
13735 
  def read(self, iprot):
13736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13738 
      return
13739 
    iprot.readStructBegin()
13740 
    while True:
13741 
      (fname, ftype, fid) = iprot.readFieldBegin()
13742 
      if ftype == TType.STOP:
13743 
        break
13744 
      if fid == 1:
13745 
        if ftype == TType.I64:
13746 
          self.orderId = iprot.readI64();
13747 
        else:
13748 
          iprot.skip(ftype)
13749 
      else:
13750 
        iprot.skip(ftype)
13751 
      iprot.readFieldEnd()
13752 
    iprot.readStructEnd()
13753 
 
13754 
  def write(self, oprot):
13755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13757 
      return
13758 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
13759 
    if self.orderId is not None:
13760 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13761 
      oprot.writeI64(self.orderId)
13762 
      oprot.writeFieldEnd()
13763 
    oprot.writeFieldStop()
13764 
    oprot.writeStructEnd()
13765 
 
13766 
  def validate(self):
13767 
    return
13768 
 
13769 
 
13770 
  def __repr__(self):
13771 
    L = ['%s=%r' % (key, value)
13772 
      for key, value in self.__dict__.iteritems()]
13773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13774 
 
13775 
  def __eq__(self, other):
13776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13777 
 
13778 
  def __ne__(self, other):
13779 
    return not (self == other)
13780 
 
13781 
class markOrderCancellationRequestReceived_result:
13782 
  """
13783 
  Attributes:
13784 
   - ex
13785 
  """
13786 
 
13787 
  thrift_spec = (
13788 
    None, # 0
13789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13790 
  )
13791 
 
13792 
  def __init__(self, ex=None,):
13793 
    self.ex = ex
13794 
 
13795 
  def read(self, iprot):
13796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13798 
      return
13799 
    iprot.readStructBegin()
13800 
    while True:
13801 
      (fname, ftype, fid) = iprot.readFieldBegin()
13802 
      if ftype == TType.STOP:
13803 
        break
13804 
      if fid == 1:
13805 
        if ftype == TType.STRUCT:
13806 
          self.ex = TransactionServiceException()
13807 
          self.ex.read(iprot)
13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      else:
13811 
        iprot.skip(ftype)
13812 
      iprot.readFieldEnd()
13813 
    iprot.readStructEnd()
13814 
 
13815 
  def write(self, oprot):
13816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13818 
      return
13819 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
13820 
    if self.ex is not None:
13821 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13822 
      self.ex.write(oprot)
13823 
      oprot.writeFieldEnd()
13824 
    oprot.writeFieldStop()
13825 
    oprot.writeStructEnd()
13826 
 
13827 
  def validate(self):
13828 
    return
13829 
 
13830 
 
13831 
  def __repr__(self):
13832 
    L = ['%s=%r' % (key, value)
13833 
      for key, value in self.__dict__.iteritems()]
13834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13835 
 
13836 
  def __eq__(self, other):
13837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13838 
 
13839 
  def __ne__(self, other):
13840 
    return not (self == other)
13841 
 
13842 
class markOrderCancellationRequestConfirmed_args:
13843 
  """
13844 
  Attributes:
13845 
   - orderId
13846 
  """
13847 
 
13848 
  thrift_spec = (
13849 
    None, # 0
13850 
    (1, TType.I64, 'orderId', None, None, ), # 1
13851 
  )
13852 
 
13853 
  def __init__(self, orderId=None,):
13854 
    self.orderId = orderId
13855 
 
13856 
  def read(self, iprot):
13857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13859 
      return
13860 
    iprot.readStructBegin()
13861 
    while True:
13862 
      (fname, ftype, fid) = iprot.readFieldBegin()
13863 
      if ftype == TType.STOP:
13864 
        break
13865 
      if fid == 1:
13866 
        if ftype == TType.I64:
13867 
          self.orderId = iprot.readI64();
13868 
        else:
13869 
          iprot.skip(ftype)
13870 
      else:
13871 
        iprot.skip(ftype)
13872 
      iprot.readFieldEnd()
13873 
    iprot.readStructEnd()
13874 
 
13875 
  def write(self, oprot):
13876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13878 
      return
13879 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
13880 
    if self.orderId is not None:
13881 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13882 
      oprot.writeI64(self.orderId)
13883 
      oprot.writeFieldEnd()
13884 
    oprot.writeFieldStop()
13885 
    oprot.writeStructEnd()
13886 
 
13887 
  def validate(self):
13888 
    return
13889 
 
13890 
 
13891 
  def __repr__(self):
13892 
    L = ['%s=%r' % (key, value)
13893 
      for key, value in self.__dict__.iteritems()]
13894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13895 
 
13896 
  def __eq__(self, other):
13897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13898 
 
13899 
  def __ne__(self, other):
13900 
    return not (self == other)
13901 
 
13902 
class markOrderCancellationRequestConfirmed_result:
13903 
  """
13904 
  Attributes:
13905 
   - ex
13906 
  """
13907 
 
13908 
  thrift_spec = (
13909 
    None, # 0
13910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13911 
  )
13912 
 
13913 
  def __init__(self, ex=None,):
13914 
    self.ex = ex
13915 
 
13916 
  def read(self, iprot):
13917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13919 
      return
13920 
    iprot.readStructBegin()
13921 
    while True:
13922 
      (fname, ftype, fid) = iprot.readFieldBegin()
13923 
      if ftype == TType.STOP:
13924 
        break
13925 
      if fid == 1:
13926 
        if ftype == TType.STRUCT:
13927 
          self.ex = TransactionServiceException()
13928 
          self.ex.read(iprot)
13929 
        else:
13930 
          iprot.skip(ftype)
13931 
      else:
13932 
        iprot.skip(ftype)
13933 
      iprot.readFieldEnd()
13934 
    iprot.readStructEnd()
13935 
 
13936 
  def write(self, oprot):
13937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13939 
      return
13940 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
13941 
    if self.ex is not None:
13942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13943 
      self.ex.write(oprot)
13944 
      oprot.writeFieldEnd()
13945 
    oprot.writeFieldStop()
13946 
    oprot.writeStructEnd()
13947 
 
13948 
  def validate(self):
13949 
    return
13950 
 
13951 
 
13952 
  def __repr__(self):
13953 
    L = ['%s=%r' % (key, value)
13954 
      for key, value in self.__dict__.iteritems()]
13955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13956 
 
13957 
  def __eq__(self, other):
13958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13959 
 
13960 
  def __ne__(self, other):
13961 
    return not (self == other)
13962 
 
13963 
class markOrderCancellationRequestDenied_args:
13964 
  """
13965 
  Attributes:
13966 
   - orderId
13967 
  """
13968 
 
13969 
  thrift_spec = (
13970 
    None, # 0
13971 
    (1, TType.I64, 'orderId', None, None, ), # 1
13972 
  )
13973 
 
13974 
  def __init__(self, orderId=None,):
13975 
    self.orderId = orderId
13976 
 
13977 
  def read(self, iprot):
13978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13980 
      return
13981 
    iprot.readStructBegin()
13982 
    while True:
13983 
      (fname, ftype, fid) = iprot.readFieldBegin()
13984 
      if ftype == TType.STOP:
13985 
        break
13986 
      if fid == 1:
13987 
        if ftype == TType.I64:
13988 
          self.orderId = iprot.readI64();
13989 
        else:
13990 
          iprot.skip(ftype)
13991 
      else:
13992 
        iprot.skip(ftype)
13993 
      iprot.readFieldEnd()
13994 
    iprot.readStructEnd()
13995 
 
13996 
  def write(self, oprot):
13997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13999 
      return
14000 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14001 
    if self.orderId is not None:
14002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14003 
      oprot.writeI64(self.orderId)
14004 
      oprot.writeFieldEnd()
14005 
    oprot.writeFieldStop()
14006 
    oprot.writeStructEnd()
14007 
 
14008 
  def validate(self):
14009 
    return
14010 
 
14011 
 
14012 
  def __repr__(self):
14013 
    L = ['%s=%r' % (key, value)
14014 
      for key, value in self.__dict__.iteritems()]
14015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14016 
 
14017 
  def __eq__(self, other):
14018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14019 
 
14020 
  def __ne__(self, other):
14021 
    return not (self == other)
14022 
 
14023 
class markOrderCancellationRequestDenied_result:
14024 
  """
14025 
  Attributes:
14026 
   - ex
14027 
  """
14028 
 
14029 
  thrift_spec = (
14030 
    None, # 0
14031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14032 
  )
14033 
 
14034 
  def __init__(self, ex=None,):
14035 
    self.ex = ex
14036 
 
14037 
  def read(self, iprot):
14038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14040 
      return
14041 
    iprot.readStructBegin()
14042 
    while True:
14043 
      (fname, ftype, fid) = iprot.readFieldBegin()
14044 
      if ftype == TType.STOP:
14045 
        break
14046 
      if fid == 1:
14047 
        if ftype == TType.STRUCT:
14048 
          self.ex = TransactionServiceException()
14049 
          self.ex.read(iprot)
14050 
        else:
14051 
          iprot.skip(ftype)
14052 
      else:
14053 
        iprot.skip(ftype)
14054 
      iprot.readFieldEnd()
14055 
    iprot.readStructEnd()
14056 
 
14057 
  def write(self, oprot):
14058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14060 
      return
14061 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14062 
    if self.ex is not None:
14063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14064 
      self.ex.write(oprot)
14065 
      oprot.writeFieldEnd()
14066 
    oprot.writeFieldStop()
14067 
    oprot.writeStructEnd()
14068 
 
14069 
  def validate(self):
14070 
    return
14071 
 
14072 
 
14073 
  def __repr__(self):
14074 
    L = ['%s=%r' % (key, value)
14075 
      for key, value in self.__dict__.iteritems()]
14076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14077 
 
14078 
  def __eq__(self, other):
14079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14080 
 
14081 
  def __ne__(self, other):
14082 
    return not (self == other)
14083 
 
4258 rajveer 14084 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14085 
  """
14086 
  Attributes:
4258 rajveer 14087 
   - transactionId
4247 rajveer 14088 
  """
14089 
 
14090 
  thrift_spec = (
14091 
    None, # 0
4258 rajveer 14092 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14093 
  )
14094 
 
4258 rajveer 14095 
  def __init__(self, transactionId=None,):
14096 
    self.transactionId = transactionId
4247 rajveer 14097 
 
14098 
  def read(self, iprot):
14099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14101 
      return
14102 
    iprot.readStructBegin()
14103 
    while True:
14104 
      (fname, ftype, fid) = iprot.readFieldBegin()
14105 
      if ftype == TType.STOP:
14106 
        break
14107 
      if fid == 1:
14108 
        if ftype == TType.I64:
4258 rajveer 14109 
          self.transactionId = iprot.readI64();
4247 rajveer 14110 
        else:
14111 
          iprot.skip(ftype)
14112 
      else:
14113 
        iprot.skip(ftype)
14114 
      iprot.readFieldEnd()
14115 
    iprot.readStructEnd()
14116 
 
14117 
  def write(self, oprot):
14118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14120 
      return
4258 rajveer 14121 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
14122 
    if self.transactionId is not None:
14123 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14124 
      oprot.writeI64(self.transactionId)
4247 rajveer 14125 
      oprot.writeFieldEnd()
14126 
    oprot.writeFieldStop()
14127 
    oprot.writeStructEnd()
14128 
 
14129 
  def validate(self):
14130 
    return
14131 
 
14132 
 
14133 
  def __repr__(self):
14134 
    L = ['%s=%r' % (key, value)
14135 
      for key, value in self.__dict__.iteritems()]
14136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14137 
 
14138 
  def __eq__(self, other):
14139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14140 
 
14141 
  def __ne__(self, other):
14142 
    return not (self == other)
14143 
 
4258 rajveer 14144 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 14145 
  """
14146 
  Attributes:
14147 
   - ex
14148 
  """
14149 
 
14150 
  thrift_spec = (
14151 
    None, # 0
14152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14153 
  )
14154 
 
14155 
  def __init__(self, ex=None,):
14156 
    self.ex = ex
14157 
 
14158 
  def read(self, iprot):
14159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14161 
      return
14162 
    iprot.readStructBegin()
14163 
    while True:
14164 
      (fname, ftype, fid) = iprot.readFieldBegin()
14165 
      if ftype == TType.STOP:
14166 
        break
14167 
      if fid == 1:
14168 
        if ftype == TType.STRUCT:
14169 
          self.ex = TransactionServiceException()
14170 
          self.ex.read(iprot)
14171 
        else:
14172 
          iprot.skip(ftype)
14173 
      else:
14174 
        iprot.skip(ftype)
14175 
      iprot.readFieldEnd()
14176 
    iprot.readStructEnd()
14177 
 
14178 
  def write(self, oprot):
14179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14181 
      return
4258 rajveer 14182 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 14183 
    if self.ex is not None:
14184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14185 
      self.ex.write(oprot)
14186 
      oprot.writeFieldEnd()
14187 
    oprot.writeFieldStop()
14188 
    oprot.writeStructEnd()
14189 
 
14190 
  def validate(self):
14191 
    return
14192 
 
14193 
 
14194 
  def __repr__(self):
14195 
    L = ['%s=%r' % (key, value)
14196 
      for key, value in self.__dict__.iteritems()]
14197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14198 
 
14199 
  def __eq__(self, other):
14200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14201 
 
14202 
  def __ne__(self, other):
14203 
    return not (self == other)
4259 anupam.sin 14204 
 
14205 
class refundTransaction_args:
14206 
  """
14207 
  Attributes:
14208 
   - transactionId
14209 
   - refundedBy
14210 
   - reason
14211 
  """
14212 
 
14213 
  thrift_spec = (
14214 
    None, # 0
14215 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14216 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14217 
    (3, TType.STRING, 'reason', None, None, ), # 3
14218 
  )
14219 
 
14220 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
14221 
    self.transactionId = transactionId
14222 
    self.refundedBy = refundedBy
14223 
    self.reason = reason
14224 
 
14225 
  def read(self, iprot):
14226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14228 
      return
14229 
    iprot.readStructBegin()
14230 
    while True:
14231 
      (fname, ftype, fid) = iprot.readFieldBegin()
14232 
      if ftype == TType.STOP:
14233 
        break
14234 
      if fid == 1:
14235 
        if ftype == TType.I64:
14236 
          self.transactionId = iprot.readI64();
14237 
        else:
14238 
          iprot.skip(ftype)
14239 
      elif fid == 2:
14240 
        if ftype == TType.STRING:
14241 
          self.refundedBy = iprot.readString();
14242 
        else:
14243 
          iprot.skip(ftype)
14244 
      elif fid == 3:
14245 
        if ftype == TType.STRING:
14246 
          self.reason = iprot.readString();
14247 
        else:
14248 
          iprot.skip(ftype)
14249 
      else:
14250 
        iprot.skip(ftype)
14251 
      iprot.readFieldEnd()
14252 
    iprot.readStructEnd()
14253 
 
14254 
  def write(self, oprot):
14255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14257 
      return
14258 
    oprot.writeStructBegin('refundTransaction_args')
14259 
    if self.transactionId is not None:
14260 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14261 
      oprot.writeI64(self.transactionId)
14262 
      oprot.writeFieldEnd()
14263 
    if self.refundedBy is not None:
14264 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14265 
      oprot.writeString(self.refundedBy)
14266 
      oprot.writeFieldEnd()
14267 
    if self.reason is not None:
14268 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14269 
      oprot.writeString(self.reason)
14270 
      oprot.writeFieldEnd()
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class refundTransaction_result:
14290 
  """
14291 
  Attributes:
14292 
   - ex
14293 
  """
14294 
 
14295 
  thrift_spec = (
14296 
    None, # 0
14297 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14298 
  )
14299 
 
14300 
  def __init__(self, ex=None,):
14301 
    self.ex = ex
14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 1:
14313 
        if ftype == TType.STRUCT:
14314 
          self.ex = TransactionServiceException()
14315 
          self.ex.read(iprot)
14316 
        else:
14317 
          iprot.skip(ftype)
14318 
      else:
14319 
        iprot.skip(ftype)
14320 
      iprot.readFieldEnd()
14321 
    iprot.readStructEnd()
14322 
 
14323 
  def write(self, oprot):
14324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14326 
      return
14327 
    oprot.writeStructBegin('refundTransaction_result')
14328 
    if self.ex is not None:
14329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14330 
      self.ex.write(oprot)
14331 
      oprot.writeFieldEnd()
14332 
    oprot.writeFieldStop()
14333 
    oprot.writeStructEnd()
14334 
 
14335 
  def validate(self):
14336 
    return
14337 
 
14338 
 
14339 
  def __repr__(self):
14340 
    L = ['%s=%r' % (key, value)
14341 
      for key, value in self.__dict__.iteritems()]
14342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14343 
 
14344 
  def __eq__(self, other):
14345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14346 
 
14347 
  def __ne__(self, other):
14348 
    return not (self == other)
4285 rajveer 14349 
 
4324 mandeep.dh 14350 
class updateShipmentAddress_args:
14351 
  """
14352 
  Attributes:
14353 
   - orderId
14354 
   - addressId
14355 
  """
14356 
 
14357 
  thrift_spec = (
14358 
    None, # 0
14359 
    (1, TType.I64, 'orderId', None, None, ), # 1
14360 
    (2, TType.I64, 'addressId', None, None, ), # 2
14361 
  )
14362 
 
14363 
  def __init__(self, orderId=None, addressId=None,):
14364 
    self.orderId = orderId
14365 
    self.addressId = addressId
14366 
 
14367 
  def read(self, iprot):
14368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14370 
      return
14371 
    iprot.readStructBegin()
14372 
    while True:
14373 
      (fname, ftype, fid) = iprot.readFieldBegin()
14374 
      if ftype == TType.STOP:
14375 
        break
14376 
      if fid == 1:
14377 
        if ftype == TType.I64:
14378 
          self.orderId = iprot.readI64();
14379 
        else:
14380 
          iprot.skip(ftype)
14381 
      elif fid == 2:
14382 
        if ftype == TType.I64:
14383 
          self.addressId = iprot.readI64();
14384 
        else:
14385 
          iprot.skip(ftype)
14386 
      else:
14387 
        iprot.skip(ftype)
14388 
      iprot.readFieldEnd()
14389 
    iprot.readStructEnd()
14390 
 
14391 
  def write(self, oprot):
14392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14394 
      return
14395 
    oprot.writeStructBegin('updateShipmentAddress_args')
14396 
    if self.orderId is not None:
14397 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14398 
      oprot.writeI64(self.orderId)
14399 
      oprot.writeFieldEnd()
14400 
    if self.addressId is not None:
14401 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
14402 
      oprot.writeI64(self.addressId)
14403 
      oprot.writeFieldEnd()
14404 
    oprot.writeFieldStop()
14405 
    oprot.writeStructEnd()
14406 
 
14407 
  def validate(self):
14408 
    return
14409 
 
14410 
 
14411 
  def __repr__(self):
14412 
    L = ['%s=%r' % (key, value)
14413 
      for key, value in self.__dict__.iteritems()]
14414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14415 
 
14416 
  def __eq__(self, other):
14417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14418 
 
14419 
  def __ne__(self, other):
14420 
    return not (self == other)
14421 
 
14422 
class updateShipmentAddress_result:
14423 
  """
14424 
  Attributes:
14425 
   - ex
14426 
  """
14427 
 
14428 
  thrift_spec = (
14429 
    None, # 0
14430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14431 
  )
14432 
 
14433 
  def __init__(self, ex=None,):
14434 
    self.ex = ex
14435 
 
14436 
  def read(self, iprot):
14437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14439 
      return
14440 
    iprot.readStructBegin()
14441 
    while True:
14442 
      (fname, ftype, fid) = iprot.readFieldBegin()
14443 
      if ftype == TType.STOP:
14444 
        break
14445 
      if fid == 1:
14446 
        if ftype == TType.STRUCT:
14447 
          self.ex = TransactionServiceException()
14448 
          self.ex.read(iprot)
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      else:
14452 
        iprot.skip(ftype)
14453 
      iprot.readFieldEnd()
14454 
    iprot.readStructEnd()
14455 
 
14456 
  def write(self, oprot):
14457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14459 
      return
14460 
    oprot.writeStructBegin('updateShipmentAddress_result')
14461 
    if self.ex is not None:
14462 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14463 
      self.ex.write(oprot)
14464 
      oprot.writeFieldEnd()
14465 
    oprot.writeFieldStop()
14466 
    oprot.writeStructEnd()
14467 
 
14468 
  def validate(self):
14469 
    return
14470 
 
14471 
 
14472 
  def __repr__(self):
14473 
    L = ['%s=%r' % (key, value)
14474 
      for key, value in self.__dict__.iteritems()]
14475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14476 
 
14477 
  def __eq__(self, other):
14478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14479 
 
14480 
  def __ne__(self, other):
14481 
    return not (self == other)
14482 
 
4285 rajveer 14483 
class acceptOrdersForItemId_args:
14484 
  """
14485 
  Attributes:
14486 
   - itemId
14487 
   - inventory
14488 
  """
14489 
 
14490 
  thrift_spec = (
14491 
    None, # 0
14492 
    (1, TType.I64, 'itemId', None, None, ), # 1
14493 
    (2, TType.I64, 'inventory', None, None, ), # 2
14494 
  )
14495 
 
14496 
  def __init__(self, itemId=None, inventory=None,):
14497 
    self.itemId = itemId
14498 
    self.inventory = inventory
14499 
 
14500 
  def read(self, iprot):
14501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14503 
      return
14504 
    iprot.readStructBegin()
14505 
    while True:
14506 
      (fname, ftype, fid) = iprot.readFieldBegin()
14507 
      if ftype == TType.STOP:
14508 
        break
14509 
      if fid == 1:
14510 
        if ftype == TType.I64:
14511 
          self.itemId = iprot.readI64();
14512 
        else:
14513 
          iprot.skip(ftype)
14514 
      elif fid == 2:
14515 
        if ftype == TType.I64:
14516 
          self.inventory = iprot.readI64();
14517 
        else:
14518 
          iprot.skip(ftype)
14519 
      else:
14520 
        iprot.skip(ftype)
14521 
      iprot.readFieldEnd()
14522 
    iprot.readStructEnd()
14523 
 
14524 
  def write(self, oprot):
14525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14527 
      return
14528 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
14529 
    if self.itemId is not None:
14530 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14531 
      oprot.writeI64(self.itemId)
14532 
      oprot.writeFieldEnd()
14533 
    if self.inventory is not None:
14534 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
14535 
      oprot.writeI64(self.inventory)
14536 
      oprot.writeFieldEnd()
14537 
    oprot.writeFieldStop()
14538 
    oprot.writeStructEnd()
14539 
 
14540 
  def validate(self):
14541 
    return
14542 
 
14543 
 
14544 
  def __repr__(self):
14545 
    L = ['%s=%r' % (key, value)
14546 
      for key, value in self.__dict__.iteritems()]
14547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14548 
 
14549 
  def __eq__(self, other):
14550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14551 
 
14552 
  def __ne__(self, other):
14553 
    return not (self == other)
14554 
 
14555 
class acceptOrdersForItemId_result:
14556 
  """
14557 
  Attributes:
14558 
   - success
14559 
   - ex
14560 
  """
14561 
 
14562 
  thrift_spec = (
14563 
    (0, TType.BOOL, 'success', None, None, ), # 0
14564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14565 
  )
14566 
 
14567 
  def __init__(self, success=None, ex=None,):
14568 
    self.success = success
14569 
    self.ex = ex
14570 
 
14571 
  def read(self, iprot):
14572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14574 
      return
14575 
    iprot.readStructBegin()
14576 
    while True:
14577 
      (fname, ftype, fid) = iprot.readFieldBegin()
14578 
      if ftype == TType.STOP:
14579 
        break
14580 
      if fid == 0:
14581 
        if ftype == TType.BOOL:
14582 
          self.success = iprot.readBool();
14583 
        else:
14584 
          iprot.skip(ftype)
14585 
      elif fid == 1:
14586 
        if ftype == TType.STRUCT:
14587 
          self.ex = TransactionServiceException()
14588 
          self.ex.read(iprot)
14589 
        else:
14590 
          iprot.skip(ftype)
14591 
      else:
14592 
        iprot.skip(ftype)
14593 
      iprot.readFieldEnd()
14594 
    iprot.readStructEnd()
14595 
 
14596 
  def write(self, oprot):
14597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14599 
      return
14600 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
14601 
    if self.success is not None:
14602 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14603 
      oprot.writeBool(self.success)
14604 
      oprot.writeFieldEnd()
14605 
    if self.ex is not None:
14606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14607 
      self.ex.write(oprot)
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
4303 rajveer 14626 
 
14627 
class markOrdersAsPORaised_args:
14628 
  """
14629 
  Attributes:
14630 
   - vendorId
14631 
   - itemId
14632 
   - quantity
14633 
   - estimate
4369 rajveer 14634 
   - isReminder
4303 rajveer 14635 
  """
14636 
 
14637 
  thrift_spec = (
14638 
    None, # 0
14639 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14640 
    (2, TType.I64, 'itemId', None, None, ), # 2
14641 
    (3, TType.I64, 'quantity', None, None, ), # 3
14642 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14643 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14644 
  )
14645 
 
4369 rajveer 14646 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14647 
    self.vendorId = vendorId
14648 
    self.itemId = itemId
14649 
    self.quantity = quantity
14650 
    self.estimate = estimate
4369 rajveer 14651 
    self.isReminder = isReminder
4303 rajveer 14652 
 
14653 
  def read(self, iprot):
14654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14656 
      return
14657 
    iprot.readStructBegin()
14658 
    while True:
14659 
      (fname, ftype, fid) = iprot.readFieldBegin()
14660 
      if ftype == TType.STOP:
14661 
        break
14662 
      if fid == 1:
14663 
        if ftype == TType.I64:
14664 
          self.vendorId = iprot.readI64();
14665 
        else:
14666 
          iprot.skip(ftype)
14667 
      elif fid == 2:
14668 
        if ftype == TType.I64:
14669 
          self.itemId = iprot.readI64();
14670 
        else:
14671 
          iprot.skip(ftype)
14672 
      elif fid == 3:
14673 
        if ftype == TType.I64:
14674 
          self.quantity = iprot.readI64();
14675 
        else:
14676 
          iprot.skip(ftype)
14677 
      elif fid == 4:
14678 
        if ftype == TType.I64:
14679 
          self.estimate = iprot.readI64();
14680 
        else:
14681 
          iprot.skip(ftype)
4369 rajveer 14682 
      elif fid == 5:
14683 
        if ftype == TType.BOOL:
14684 
          self.isReminder = iprot.readBool();
14685 
        else:
14686 
          iprot.skip(ftype)
4303 rajveer 14687 
      else:
14688 
        iprot.skip(ftype)
14689 
      iprot.readFieldEnd()
14690 
    iprot.readStructEnd()
14691 
 
14692 
  def write(self, oprot):
14693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14695 
      return
14696 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
14697 
    if self.vendorId is not None:
14698 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14699 
      oprot.writeI64(self.vendorId)
14700 
      oprot.writeFieldEnd()
14701 
    if self.itemId is not None:
14702 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14703 
      oprot.writeI64(self.itemId)
14704 
      oprot.writeFieldEnd()
14705 
    if self.quantity is not None:
14706 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14707 
      oprot.writeI64(self.quantity)
14708 
      oprot.writeFieldEnd()
14709 
    if self.estimate is not None:
14710 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14711 
      oprot.writeI64(self.estimate)
14712 
      oprot.writeFieldEnd()
4369 rajveer 14713 
    if self.isReminder is not None:
14714 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14715 
      oprot.writeBool(self.isReminder)
14716 
      oprot.writeFieldEnd()
4303 rajveer 14717 
    oprot.writeFieldStop()
14718 
    oprot.writeStructEnd()
14719 
 
14720 
  def validate(self):
14721 
    return
14722 
 
14723 
 
14724 
  def __repr__(self):
14725 
    L = ['%s=%r' % (key, value)
14726 
      for key, value in self.__dict__.iteritems()]
14727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14728 
 
14729 
  def __eq__(self, other):
14730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14731 
 
14732 
  def __ne__(self, other):
14733 
    return not (self == other)
14734 
 
14735 
class markOrdersAsPORaised_result:
14736 
  """
14737 
  Attributes:
14738 
   - ex
14739 
  """
14740 
 
14741 
  thrift_spec = (
14742 
    None, # 0
14743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14744 
  )
14745 
 
14746 
  def __init__(self, ex=None,):
14747 
    self.ex = ex
14748 
 
14749 
  def read(self, iprot):
14750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14752 
      return
14753 
    iprot.readStructBegin()
14754 
    while True:
14755 
      (fname, ftype, fid) = iprot.readFieldBegin()
14756 
      if ftype == TType.STOP:
14757 
        break
14758 
      if fid == 1:
14759 
        if ftype == TType.STRUCT:
14760 
          self.ex = TransactionServiceException()
14761 
          self.ex.read(iprot)
14762 
        else:
14763 
          iprot.skip(ftype)
14764 
      else:
14765 
        iprot.skip(ftype)
14766 
      iprot.readFieldEnd()
14767 
    iprot.readStructEnd()
14768 
 
14769 
  def write(self, oprot):
14770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14772 
      return
14773 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
14774 
    if self.ex is not None:
14775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14776 
      self.ex.write(oprot)
14777 
      oprot.writeFieldEnd()
14778 
    oprot.writeFieldStop()
14779 
    oprot.writeStructEnd()
14780 
 
14781 
  def validate(self):
14782 
    return
14783 
 
14784 
 
14785 
  def __repr__(self):
14786 
    L = ['%s=%r' % (key, value)
14787 
      for key, value in self.__dict__.iteritems()]
14788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14789 
 
14790 
  def __eq__(self, other):
14791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14792 
 
14793 
  def __ne__(self, other):
14794 
    return not (self == other)
14795 
 
14796 
class markOrdersAsReversalInitiated_args:
14797 
  """
14798 
  Attributes:
14799 
   - vendorId
14800 
   - itemId
14801 
   - quantity
14802 
   - estimate
4369 rajveer 14803 
   - isReminder
4303 rajveer 14804 
  """
14805 
 
14806 
  thrift_spec = (
14807 
    None, # 0
14808 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14809 
    (2, TType.I64, 'itemId', None, None, ), # 2
14810 
    (3, TType.I64, 'quantity', None, None, ), # 3
14811 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14812 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14813 
  )
14814 
 
4369 rajveer 14815 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14816 
    self.vendorId = vendorId
14817 
    self.itemId = itemId
14818 
    self.quantity = quantity
14819 
    self.estimate = estimate
4369 rajveer 14820 
    self.isReminder = isReminder
4303 rajveer 14821 
 
14822 
  def read(self, iprot):
14823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14825 
      return
14826 
    iprot.readStructBegin()
14827 
    while True:
14828 
      (fname, ftype, fid) = iprot.readFieldBegin()
14829 
      if ftype == TType.STOP:
14830 
        break
14831 
      if fid == 1:
14832 
        if ftype == TType.I64:
14833 
          self.vendorId = iprot.readI64();
14834 
        else:
14835 
          iprot.skip(ftype)
14836 
      elif fid == 2:
14837 
        if ftype == TType.I64:
14838 
          self.itemId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      elif fid == 3:
14842 
        if ftype == TType.I64:
14843 
          self.quantity = iprot.readI64();
14844 
        else:
14845 
          iprot.skip(ftype)
14846 
      elif fid == 4:
14847 
        if ftype == TType.I64:
14848 
          self.estimate = iprot.readI64();
14849 
        else:
14850 
          iprot.skip(ftype)
4369 rajveer 14851 
      elif fid == 5:
14852 
        if ftype == TType.BOOL:
14853 
          self.isReminder = iprot.readBool();
14854 
        else:
14855 
          iprot.skip(ftype)
4303 rajveer 14856 
      else:
14857 
        iprot.skip(ftype)
14858 
      iprot.readFieldEnd()
14859 
    iprot.readStructEnd()
14860 
 
14861 
  def write(self, oprot):
14862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14864 
      return
14865 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
14866 
    if self.vendorId is not None:
14867 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
14868 
      oprot.writeI64(self.vendorId)
14869 
      oprot.writeFieldEnd()
14870 
    if self.itemId is not None:
14871 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14872 
      oprot.writeI64(self.itemId)
14873 
      oprot.writeFieldEnd()
14874 
    if self.quantity is not None:
14875 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
14876 
      oprot.writeI64(self.quantity)
14877 
      oprot.writeFieldEnd()
14878 
    if self.estimate is not None:
14879 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
14880 
      oprot.writeI64(self.estimate)
14881 
      oprot.writeFieldEnd()
4369 rajveer 14882 
    if self.isReminder is not None:
14883 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
14884 
      oprot.writeBool(self.isReminder)
14885 
      oprot.writeFieldEnd()
4303 rajveer 14886 
    oprot.writeFieldStop()
14887 
    oprot.writeStructEnd()
14888 
 
14889 
  def validate(self):
14890 
    return
14891 
 
14892 
 
14893 
  def __repr__(self):
14894 
    L = ['%s=%r' % (key, value)
14895 
      for key, value in self.__dict__.iteritems()]
14896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14897 
 
14898 
  def __eq__(self, other):
14899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14900 
 
14901 
  def __ne__(self, other):
14902 
    return not (self == other)
14903 
 
14904 
class markOrdersAsReversalInitiated_result:
14905 
  """
14906 
  Attributes:
14907 
   - ex
14908 
  """
14909 
 
14910 
  thrift_spec = (
14911 
    None, # 0
14912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14913 
  )
14914 
 
14915 
  def __init__(self, ex=None,):
14916 
    self.ex = ex
14917 
 
14918 
  def read(self, iprot):
14919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14921 
      return
14922 
    iprot.readStructBegin()
14923 
    while True:
14924 
      (fname, ftype, fid) = iprot.readFieldBegin()
14925 
      if ftype == TType.STOP:
14926 
        break
14927 
      if fid == 1:
14928 
        if ftype == TType.STRUCT:
14929 
          self.ex = TransactionServiceException()
14930 
          self.ex.read(iprot)
14931 
        else:
14932 
          iprot.skip(ftype)
14933 
      else:
14934 
        iprot.skip(ftype)
14935 
      iprot.readFieldEnd()
14936 
    iprot.readStructEnd()
14937 
 
14938 
  def write(self, oprot):
14939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14941 
      return
14942 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
14943 
    if self.ex is not None:
14944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14945 
      self.ex.write(oprot)
14946 
      oprot.writeFieldEnd()
14947 
    oprot.writeFieldStop()
14948 
    oprot.writeStructEnd()
14949 
 
14950 
  def validate(self):
14951 
    return
14952 
 
14953 
 
14954 
  def __repr__(self):
14955 
    L = ['%s=%r' % (key, value)
14956 
      for key, value in self.__dict__.iteritems()]
14957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14958 
 
14959 
  def __eq__(self, other):
14960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14961 
 
14962 
  def __ne__(self, other):
14963 
    return not (self == other)
14964 
 
14965 
class markOrdersAsNotAvailabke_args:
14966 
  """
14967 
  Attributes:
14968 
   - vendorId
14969 
   - itemId
14970 
   - quantity
14971 
   - estimate
4369 rajveer 14972 
   - isReminder
4303 rajveer 14973 
  """
14974 
 
14975 
  thrift_spec = (
14976 
    None, # 0
14977 
    (1, TType.I64, 'vendorId', None, None, ), # 1
14978 
    (2, TType.I64, 'itemId', None, None, ), # 2
14979 
    (3, TType.I64, 'quantity', None, None, ), # 3
14980 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 14981 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 14982 
  )
14983 
 
4369 rajveer 14984 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 14985 
    self.vendorId = vendorId
14986 
    self.itemId = itemId
14987 
    self.quantity = quantity
14988 
    self.estimate = estimate
4369 rajveer 14989 
    self.isReminder = isReminder
4303 rajveer 14990 
 
14991 
  def read(self, iprot):
14992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14994 
      return
14995 
    iprot.readStructBegin()
14996 
    while True:
14997 
      (fname, ftype, fid) = iprot.readFieldBegin()
14998 
      if ftype == TType.STOP:
14999 
        break
15000 
      if fid == 1:
15001 
        if ftype == TType.I64:
15002 
          self.vendorId = iprot.readI64();
15003 
        else:
15004 
          iprot.skip(ftype)
15005 
      elif fid == 2:
15006 
        if ftype == TType.I64:
15007 
          self.itemId = iprot.readI64();
15008 
        else:
15009 
          iprot.skip(ftype)
15010 
      elif fid == 3:
15011 
        if ftype == TType.I64:
15012 
          self.quantity = iprot.readI64();
15013 
        else:
15014 
          iprot.skip(ftype)
15015 
      elif fid == 4:
15016 
        if ftype == TType.I64:
15017 
          self.estimate = iprot.readI64();
15018 
        else:
15019 
          iprot.skip(ftype)
4369 rajveer 15020 
      elif fid == 5:
15021 
        if ftype == TType.BOOL:
15022 
          self.isReminder = iprot.readBool();
15023 
        else:
15024 
          iprot.skip(ftype)
4303 rajveer 15025 
      else:
15026 
        iprot.skip(ftype)
15027 
      iprot.readFieldEnd()
15028 
    iprot.readStructEnd()
15029 
 
15030 
  def write(self, oprot):
15031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15033 
      return
15034 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15035 
    if self.vendorId is not None:
15036 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15037 
      oprot.writeI64(self.vendorId)
15038 
      oprot.writeFieldEnd()
15039 
    if self.itemId is not None:
15040 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15041 
      oprot.writeI64(self.itemId)
15042 
      oprot.writeFieldEnd()
15043 
    if self.quantity is not None:
15044 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15045 
      oprot.writeI64(self.quantity)
15046 
      oprot.writeFieldEnd()
15047 
    if self.estimate is not None:
15048 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15049 
      oprot.writeI64(self.estimate)
15050 
      oprot.writeFieldEnd()
4369 rajveer 15051 
    if self.isReminder is not None:
15052 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15053 
      oprot.writeBool(self.isReminder)
15054 
      oprot.writeFieldEnd()
4303 rajveer 15055 
    oprot.writeFieldStop()
15056 
    oprot.writeStructEnd()
15057 
 
15058 
  def validate(self):
15059 
    return
15060 
 
15061 
 
15062 
  def __repr__(self):
15063 
    L = ['%s=%r' % (key, value)
15064 
      for key, value in self.__dict__.iteritems()]
15065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15066 
 
15067 
  def __eq__(self, other):
15068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15069 
 
15070 
  def __ne__(self, other):
15071 
    return not (self == other)
15072 
 
15073 
class markOrdersAsNotAvailabke_result:
15074 
  """
15075 
  Attributes:
15076 
   - ex
15077 
  """
15078 
 
15079 
  thrift_spec = (
15080 
    None, # 0
15081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15082 
  )
15083 
 
15084 
  def __init__(self, ex=None,):
15085 
    self.ex = ex
15086 
 
15087 
  def read(self, iprot):
15088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15090 
      return
15091 
    iprot.readStructBegin()
15092 
    while True:
15093 
      (fname, ftype, fid) = iprot.readFieldBegin()
15094 
      if ftype == TType.STOP:
15095 
        break
15096 
      if fid == 1:
15097 
        if ftype == TType.STRUCT:
15098 
          self.ex = TransactionServiceException()
15099 
          self.ex.read(iprot)
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      else:
15103 
        iprot.skip(ftype)
15104 
      iprot.readFieldEnd()
15105 
    iprot.readStructEnd()
15106 
 
15107 
  def write(self, oprot):
15108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15110 
      return
15111 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15112 
    if self.ex is not None:
15113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15114 
      self.ex.write(oprot)
15115 
      oprot.writeFieldEnd()
15116 
    oprot.writeFieldStop()
15117 
    oprot.writeStructEnd()
15118 
 
15119 
  def validate(self):
15120 
    return
15121 
 
15122 
 
15123 
  def __repr__(self):
15124 
    L = ['%s=%r' % (key, value)
15125 
      for key, value in self.__dict__.iteritems()]
15126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15127 
 
15128 
  def __eq__(self, other):
15129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15130 
 
15131 
  def __ne__(self, other):
15132 
    return not (self == other)
4369 rajveer 15133 
 
15134 
class markOrdersAsTimeout_args:
15135 
  """
15136 
  Attributes:
15137 
   - vendorId
15138 
  """
15139 
 
15140 
  thrift_spec = (
15141 
    None, # 0
15142 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15143 
  )
15144 
 
15145 
  def __init__(self, vendorId=None,):
15146 
    self.vendorId = vendorId
15147 
 
15148 
  def read(self, iprot):
15149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15151 
      return
15152 
    iprot.readStructBegin()
15153 
    while True:
15154 
      (fname, ftype, fid) = iprot.readFieldBegin()
15155 
      if ftype == TType.STOP:
15156 
        break
15157 
      if fid == 1:
15158 
        if ftype == TType.I64:
15159 
          self.vendorId = iprot.readI64();
15160 
        else:
15161 
          iprot.skip(ftype)
15162 
      else:
15163 
        iprot.skip(ftype)
15164 
      iprot.readFieldEnd()
15165 
    iprot.readStructEnd()
15166 
 
15167 
  def write(self, oprot):
15168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15170 
      return
15171 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
15172 
    if self.vendorId is not None:
15173 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15174 
      oprot.writeI64(self.vendorId)
15175 
      oprot.writeFieldEnd()
15176 
    oprot.writeFieldStop()
15177 
    oprot.writeStructEnd()
15178 
 
15179 
  def validate(self):
15180 
    return
15181 
 
15182 
 
15183 
  def __repr__(self):
15184 
    L = ['%s=%r' % (key, value)
15185 
      for key, value in self.__dict__.iteritems()]
15186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15187 
 
15188 
  def __eq__(self, other):
15189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15190 
 
15191 
  def __ne__(self, other):
15192 
    return not (self == other)
15193 
 
15194 
class markOrdersAsTimeout_result:
15195 
  """
15196 
  Attributes:
15197 
   - success
15198 
   - ex
15199 
  """
15200 
 
15201 
  thrift_spec = (
15202 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
15203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15204 
  )
15205 
 
15206 
  def __init__(self, success=None, ex=None,):
15207 
    self.success = success
15208 
    self.ex = ex
15209 
 
15210 
  def read(self, iprot):
15211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15213 
      return
15214 
    iprot.readStructBegin()
15215 
    while True:
15216 
      (fname, ftype, fid) = iprot.readFieldBegin()
15217 
      if ftype == TType.STOP:
15218 
        break
15219 
      if fid == 0:
15220 
        if ftype == TType.MAP:
15221 
          self.success = {}
15222 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15223 
          for _i265 in xrange(_size261):
15224 
            _key266 = iprot.readI32();
15225 
            _val267 = TimeoutSummary()
15226 
            _val267.read(iprot)
15227 
            self.success[_key266] = _val267
15228 
          iprot.readMapEnd()
15229 
        else:
15230 
          iprot.skip(ftype)
15231 
      elif fid == 1:
15232 
        if ftype == TType.STRUCT:
15233 
          self.ex = TransactionServiceException()
15234 
          self.ex.read(iprot)
15235 
        else:
15236 
          iprot.skip(ftype)
15237 
      else:
15238 
        iprot.skip(ftype)
15239 
      iprot.readFieldEnd()
15240 
    iprot.readStructEnd()
15241 
 
15242 
  def write(self, oprot):
15243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15245 
      return
15246 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
15247 
    if self.success is not None:
15248 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15249 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
15250 
      for kiter268,viter269 in self.success.items():
15251 
        oprot.writeI32(kiter268)
15252 
        viter269.write(oprot)
15253 
      oprot.writeMapEnd()
15254 
      oprot.writeFieldEnd()
15255 
    if self.ex is not None:
15256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15257 
      self.ex.write(oprot)
15258 
      oprot.writeFieldEnd()
15259 
    oprot.writeFieldStop()
15260 
    oprot.writeStructEnd()
15261 
 
15262 
  def validate(self):
15263 
    return
15264 
 
15265 
 
15266 
  def __repr__(self):
15267 
    L = ['%s=%r' % (key, value)
15268 
      for key, value in self.__dict__.iteritems()]
15269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15270 
 
15271 
  def __eq__(self, other):
15272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15273 
 
15274 
  def __ne__(self, other):
15275 
    return not (self == other)
4386 anupam.sin 15276 
 
15277 
class getOrderForAwb_args:
15278 
  """
15279 
  Attributes:
15280 
   - awb
15281 
  """
15282 
 
15283 
  thrift_spec = (
15284 
    None, # 0
15285 
    (1, TType.STRING, 'awb', None, None, ), # 1
15286 
  )
15287 
 
15288 
  def __init__(self, awb=None,):
15289 
    self.awb = awb
15290 
 
15291 
  def read(self, iprot):
15292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15294 
      return
15295 
    iprot.readStructBegin()
15296 
    while True:
15297 
      (fname, ftype, fid) = iprot.readFieldBegin()
15298 
      if ftype == TType.STOP:
15299 
        break
15300 
      if fid == 1:
15301 
        if ftype == TType.STRING:
15302 
          self.awb = iprot.readString();
15303 
        else:
15304 
          iprot.skip(ftype)
15305 
      else:
15306 
        iprot.skip(ftype)
15307 
      iprot.readFieldEnd()
15308 
    iprot.readStructEnd()
15309 
 
15310 
  def write(self, oprot):
15311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15313 
      return
15314 
    oprot.writeStructBegin('getOrderForAwb_args')
15315 
    if self.awb is not None:
15316 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
15317 
      oprot.writeString(self.awb)
15318 
      oprot.writeFieldEnd()
15319 
    oprot.writeFieldStop()
15320 
    oprot.writeStructEnd()
15321 
 
15322 
  def validate(self):
15323 
    return
15324 
 
15325 
 
15326 
  def __repr__(self):
15327 
    L = ['%s=%r' % (key, value)
15328 
      for key, value in self.__dict__.iteritems()]
15329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15330 
 
15331 
  def __eq__(self, other):
15332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15333 
 
15334 
  def __ne__(self, other):
15335 
    return not (self == other)
15336 
 
15337 
class getOrderForAwb_result:
15338 
  """
15339 
  Attributes:
15340 
   - success
15341 
   - ex
15342 
  """
15343 
 
15344 
  thrift_spec = (
15345 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15347 
  )
15348 
 
15349 
  def __init__(self, success=None, ex=None,):
15350 
    self.success = success
15351 
    self.ex = ex
15352 
 
15353 
  def read(self, iprot):
15354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15356 
      return
15357 
    iprot.readStructBegin()
15358 
    while True:
15359 
      (fname, ftype, fid) = iprot.readFieldBegin()
15360 
      if ftype == TType.STOP:
15361 
        break
15362 
      if fid == 0:
15363 
        if ftype == TType.STRUCT:
15364 
          self.success = Order()
15365 
          self.success.read(iprot)
15366 
        else:
15367 
          iprot.skip(ftype)
15368 
      elif fid == 1:
15369 
        if ftype == TType.STRUCT:
15370 
          self.ex = TransactionServiceException()
15371 
          self.ex.read(iprot)
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      else:
15375 
        iprot.skip(ftype)
15376 
      iprot.readFieldEnd()
15377 
    iprot.readStructEnd()
15378 
 
15379 
  def write(self, oprot):
15380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15382 
      return
15383 
    oprot.writeStructBegin('getOrderForAwb_result')
15384 
    if self.success is not None:
15385 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15386 
      self.success.write(oprot)
15387 
      oprot.writeFieldEnd()
15388 
    if self.ex is not None:
15389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15390 
      self.ex.write(oprot)
15391 
      oprot.writeFieldEnd()
15392 
    oprot.writeFieldStop()
15393 
    oprot.writeStructEnd()
15394 
 
15395 
  def validate(self):
15396 
    return
15397 
 
15398 
 
15399 
  def __repr__(self):
15400 
    L = ['%s=%r' % (key, value)
15401 
      for key, value in self.__dict__.iteritems()]
15402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15403 
 
15404 
  def __eq__(self, other):
15405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15406 
 
15407 
  def __ne__(self, other):
15408 
    return not (self == other)