Subversion Repositories SmartDukaan

Rev

Rev 4484 | Rev 4495 | 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 
 
4488 rajveer 452 
  def markOrderReturnRequestReceived(self, orderId):
453 
    """
454 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
455 
 
456 
    Parameters:
457 
     - orderId
458 
    """
459 
    pass
460 
 
461 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
462 
    """
463 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
464 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
465 
 
466 
    Parameters:
467 
     - orderId
468 
     - isAuthorized
469 
    """
470 
    pass
471 
 
2536 chandransh 472 
  def requestPickupNumber(self, orderId):
473 
    """
474 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 475 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
476 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 477 
    For any other status, it returns false.
478 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 479 
 
2536 chandransh 480 
    Parameters:
481 
     - orderId
482 
    """
483 
    pass
484 
 
485 
  def authorizePickup(self, orderId, pickupNumber):
486 
    """
4452 rajveer 487 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 488 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
489 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
490 
    	3. Returns true
2591 chandransh 491 
    If the order is in any other status, it returns false.
2536 chandransh 492 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 493 
 
2536 chandransh 494 
    Parameters:
495 
     - orderId
496 
     - pickupNumber
497 
    """
498 
    pass
499 
 
2764 chandransh 500 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
501 
    """
502 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
503 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 504 
 
2764 chandransh 505 
    Parameters:
506 
     - providerId
507 
     - pickupDetails
508 
    """
509 
    pass
510 
 
4479 rajveer 511 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 512 
    """
4452 rajveer 513 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 514 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 515 
    If the order is in any other state, it returns false.
516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 517 
 
2591 chandransh 518 
    Parameters:
519 
     - orderId
4479 rajveer 520 
     - receiveCondition
2591 chandransh 521 
    """
522 
    pass
2536 chandransh 523 
 
2591 chandransh 524 
  def validateDoa(self, orderId, isValid):
525 
    """
4452 rajveer 526 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 527 
    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 528 
    If the order is in any other state, it returns false.
529 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 530 
 
2591 chandransh 531 
    Parameters:
532 
     - orderId
533 
     - isValid
534 
    """
535 
    pass
536 
 
2616 chandransh 537 
  def reshipOrder(self, orderId):
538 
    """
4484 rajveer 539 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 540 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 541 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 542 
 
543 
    If the order is in DOA_CERT_VALID state, it does the following:
544 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
545 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 546 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 547 
 
2616 chandransh 548 
    Returns the id of the newly created order.
3431 rajveer 549 
 
2616 chandransh 550 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 551 
 
2616 chandransh 552 
    Parameters:
553 
     - orderId
554 
    """
555 
    pass
2591 chandransh 556 
 
3226 chandransh 557 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 558 
    """
4484 rajveer 559 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 560 
    	1. Creates a refund request for batch processing.
561 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 562 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 563 
 
2616 chandransh 564 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
565 
    	1. Creates a refund request for batch processing.
3226 chandransh 566 
    	2. Cancels the reservation of the item in the warehouse.
567 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 568 
 
3226 chandransh 569 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
570 
    	1. Cancels the reservation of the item in the warehouse.
571 
    	2. Marks the current order as CANCELED.
572 
 
573 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
574 
 
2616 chandransh 575 
    Returns True if it is successful, False otherwise.
3431 rajveer 576 
 
2616 chandransh 577 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 578 
 
2616 chandransh 579 
    Parameters:
580 
     - orderId
3226 chandransh 581 
     - refundedBy
582 
     - reason
2616 chandransh 583 
    """
584 
    pass
585 
 
2690 chandransh 586 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
587 
    """
588 
    Get all return orders created between the from and to dates for the given warehouse.
589 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 590 
 
2690 chandransh 591 
    Parameters:
592 
     - warehouseId
593 
     - fromDate
594 
     - toDate
595 
    """
596 
    pass
2616 chandransh 597 
 
2700 chandransh 598 
  def getReturnOrder(self, id):
599 
    """
600 
    Returns the ReturnOrder corresponding to the given id.
601 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 602 
 
2700 chandransh 603 
    Parameters:
604 
     - id
605 
    """
606 
    pass
607 
 
2690 chandransh 608 
  def processReturn(self, returnOrderId):
609 
    """
610 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 611 
 
2690 chandransh 612 
    Parameters:
613 
     - returnOrderId
614 
    """
615 
    pass
616 
 
2819 chandransh 617 
  def createPurchaseOrder(self, warehouseId):
618 
    """
619 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 620 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 621 
 
2819 chandransh 622 
    Parameters:
623 
     - warehouseId
624 
    """
625 
    pass
2690 chandransh 626 
 
3451 chandransh 627 
  def updateWeight(self, orderId, weight):
628 
    """
629 
    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 630 
 
3451 chandransh 631 
    Parameters:
632 
     - orderId
633 
     - weight
634 
    """
635 
    pass
636 
 
3469 chandransh 637 
  def changeItem(self, orderId, itemId):
638 
    """
639 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
640 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 641 
 
3469 chandransh 642 
    Parameters:
643 
     - orderId
644 
     - itemId
645 
    """
646 
    pass
647 
 
648 
  def shiftToWarehouse(self, orderId, warehouseId):
649 
    """
650 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
651 
 
652 
    Parameters:
653 
     - orderId
654 
     - warehouseId
655 
    """
656 
    pass
657 
 
3986 chandransh 658 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 659 
    """
660 
    Adds the given delay reason to the given order.
3986 chandransh 661 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 662 
    Raises an exception if no order with the given id can be found.
3469 chandransh 663 
 
3553 chandransh 664 
    Parameters:
665 
     - orderId
666 
     - delayReason
3986 chandransh 667 
     - furtherDelay
3553 chandransh 668 
    """
669 
    pass
670 
 
3956 chandransh 671 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
672 
    """
673 
    Marks the COD orders with given AWB nos. as having been processed.
674 
    Updates the captured amount for the corresponding payment.
3553 chandransh 675 
 
3956 chandransh 676 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
677 
    1. There is no order corresponding to an AWB number.
678 
    2. The captured amount for a payment exceeds the total payment.
679 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
680 
 
681 
    Parameters:
682 
     - collectedAmountMap
683 
     - xferBy
684 
     - xferTxnId
685 
     - xferDate
686 
    """
687 
    pass
688 
 
4008 mandeep.dh 689 
  def getTransactionsRequiringExtraProcessing(self, category):
690 
    """
4065 mandeep.dh 691 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 692 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 693 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 694 
 
4008 mandeep.dh 695 
    Parameters:
696 
     - category
697 
    """
698 
    pass
699 
 
700 
  def markTransactionAsProcessed(self, transactionId, category):
701 
    """
702 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 703 
    It essentially deletes the transaction id record for a particular
704 
    processing type category (if present) from DB.
705 
    This is currently used by CRM application.
4008 mandeep.dh 706 
 
707 
    Parameters:
708 
     - transactionId
709 
     - category
710 
    """
711 
    pass
712 
 
4018 chandransh 713 
  def getItemWiseRiskyOrdersCount(self, ):
714 
    """
715 
    Returns a map containing the number of risky orders keyed by item id. A risky order
716 
    is defined as one whose shipping date is about to expire.
717 
    """
718 
    pass
4008 mandeep.dh 719 
 
4295 varun.gupt 720 
  def getOrdersForItemIds(self, itemIds):
721 
    """
722 
    Returns a list of all orders which have items with given id
723 
 
724 
    Parameters:
725 
     - itemIds
726 
    """
727 
    pass
728 
 
4247 rajveer 729 
  def markOrderCancellationRequestReceived(self, orderId):
730 
    """
731 
    Mark order as cancellation request received. If customer sends request of cancellation of
732 
    a particular order, this method will be called. It will just change status of the order
733 
    depending on its current status. It also records the previous status, so that we can move
734 
    back to that status if cancellation request is denied.
4018 chandransh 735 
 
4247 rajveer 736 
    Parameters:
737 
     - orderId
738 
    """
739 
    pass
740 
 
741 
  def markOrderCancellationRequestConfirmed(self, orderId):
742 
    """
743 
    If we decide to to cancel order, CRM will call this method to move the status of order to
744 
    cancellation request confirmed. After this OM will be able to cancel the order.
745 
 
746 
    Parameters:
747 
     - orderId
748 
    """
749 
    pass
750 
 
751 
  def markOrderCancellationRequestDenied(self, orderId):
752 
    """
753 
    If we decide to not to cancel order, we will move the order ro previous status.
754 
 
755 
    Parameters:
756 
     - orderId
757 
    """
758 
    pass
759 
 
4258 rajveer 760 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 761 
    """
4258 rajveer 762 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
763 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 764 
 
765 
    Parameters:
4258 rajveer 766 
     - transactionId
4247 rajveer 767 
    """
768 
    pass
769 
 
4259 anupam.sin 770 
  def refundTransaction(self, transactionId, refundedBy, reason):
771 
    """
772 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
773 
    need to be cancelled
4247 rajveer 774 
 
4259 anupam.sin 775 
    Parameters:
776 
     - transactionId
777 
     - refundedBy
778 
     - reason
779 
    """
780 
    pass
781 
 
4324 mandeep.dh 782 
  def updateShipmentAddress(self, orderId, addressId):
783 
    """
784 
    Updates shipment address of an order. Delivery and shipping date estimates
785 
    etc. are also updated here.
786 
 
787 
    Throws TransactionServiceException in case address change is not
788 
    possible due to certain reasons such as new pincode in address is
789 
    not serviceable etc.
790 
 
791 
    Parameters:
792 
     - orderId
793 
     - addressId
794 
    """
795 
    pass
796 
 
4285 rajveer 797 
  def acceptOrdersForItemId(self, itemId, inventory):
798 
    """
799 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
800 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 801 
 
4285 rajveer 802 
    Parameters:
803 
     - itemId
804 
     - inventory
805 
    """
806 
    pass
807 
 
4369 rajveer 808 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 809 
    """
810 
    Parameters:
811 
     - vendorId
812 
     - itemId
813 
     - quantity
814 
     - estimate
4369 rajveer 815 
     - isReminder
4303 rajveer 816 
    """
817 
    pass
4285 rajveer 818 
 
4369 rajveer 819 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 820 
    """
821 
    Parameters:
822 
     - vendorId
823 
     - itemId
824 
     - quantity
825 
     - estimate
4369 rajveer 826 
     - isReminder
4303 rajveer 827 
    """
828 
    pass
829 
 
4369 rajveer 830 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 831 
    """
832 
    Parameters:
833 
     - vendorId
834 
     - itemId
835 
     - quantity
836 
     - estimate
4369 rajveer 837 
     - isReminder
4303 rajveer 838 
    """
839 
    pass
840 
 
4369 rajveer 841 
  def markOrdersAsTimeout(self, vendorId):
842 
    """
843 
    Parameters:
844 
     - vendorId
845 
    """
846 
    pass
4303 rajveer 847 
 
4386 anupam.sin 848 
  def getOrderForAwb(self, awb):
849 
    """
850 
    Returns the order corresponding to an AWB number
4369 rajveer 851 
 
4386 anupam.sin 852 
    Parameters:
853 
     - awb
854 
    """
855 
    pass
856 
 
857 
 
3376 rajveer 858 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 859 
  def __init__(self, iprot, oprot=None):
3376 rajveer 860 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 861 
 
862 
  def createTransaction(self, transaction):
863 
    """
864 
    Parameters:
865 
     - transaction
866 
    """
867 
    self.send_createTransaction(transaction)
132 ashish 868 
    return self.recv_createTransaction()
94 ashish 869 
 
870 
  def send_createTransaction(self, transaction):
871 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
872 
    args = createTransaction_args()
873 
    args.transaction = transaction
874 
    args.write(self._oprot)
875 
    self._oprot.writeMessageEnd()
876 
    self._oprot.trans.flush()
877 
 
878 
  def recv_createTransaction(self, ):
879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
880 
    if mtype == TMessageType.EXCEPTION:
881 
      x = TApplicationException()
882 
      x.read(self._iprot)
883 
      self._iprot.readMessageEnd()
884 
      raise x
885 
    result = createTransaction_result()
886 
    result.read(self._iprot)
887 
    self._iprot.readMessageEnd()
3431 rajveer 888 
    if result.success is not None:
132 ashish 889 
      return result.success
3431 rajveer 890 
    if result.ex is not None:
94 ashish 891 
      raise result.ex
132 ashish 892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 893 
 
894 
  def getTransaction(self, id):
895 
    """
896 
    Parameters:
897 
     - id
898 
    """
899 
    self.send_getTransaction(id)
900 
    return self.recv_getTransaction()
901 
 
902 
  def send_getTransaction(self, id):
903 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
904 
    args = getTransaction_args()
905 
    args.id = id
906 
    args.write(self._oprot)
907 
    self._oprot.writeMessageEnd()
908 
    self._oprot.trans.flush()
909 
 
910 
  def recv_getTransaction(self, ):
911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
912 
    if mtype == TMessageType.EXCEPTION:
913 
      x = TApplicationException()
914 
      x.read(self._iprot)
915 
      self._iprot.readMessageEnd()
916 
      raise x
917 
    result = getTransaction_result()
918 
    result.read(self._iprot)
919 
    self._iprot.readMessageEnd()
3431 rajveer 920 
    if result.success is not None:
94 ashish 921 
      return result.success
3431 rajveer 922 
    if result.ex is not None:
94 ashish 923 
      raise result.ex
924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
925 
 
926 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
927 
    """
928 
    Parameters:
929 
     - customerId
930 
     - from_date
931 
     - to_date
932 
     - status
933 
    """
934 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
935 
    return self.recv_getTransactionsForCustomer()
936 
 
937 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
938 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
939 
    args = getTransactionsForCustomer_args()
940 
    args.customerId = customerId
941 
    args.from_date = from_date
942 
    args.to_date = to_date
943 
    args.status = status
944 
    args.write(self._oprot)
945 
    self._oprot.writeMessageEnd()
946 
    self._oprot.trans.flush()
947 
 
948 
  def recv_getTransactionsForCustomer(self, ):
949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
950 
    if mtype == TMessageType.EXCEPTION:
951 
      x = TApplicationException()
952 
      x.read(self._iprot)
953 
      self._iprot.readMessageEnd()
954 
      raise x
955 
    result = getTransactionsForCustomer_result()
956 
    result.read(self._iprot)
957 
    self._iprot.readMessageEnd()
3431 rajveer 958 
    if result.success is not None:
94 ashish 959 
      return result.success
3431 rajveer 960 
    if result.ex is not None:
94 ashish 961 
      raise result.ex
962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
963 
 
132 ashish 964 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
965 
    """
966 
    Parameters:
967 
     - shoppingCartId
968 
    """
969 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
970 
    return self.recv_getTransactionsForShoppingCartId()
971 
 
972 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
973 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
974 
    args = getTransactionsForShoppingCartId_args()
975 
    args.shoppingCartId = shoppingCartId
976 
    args.write(self._oprot)
977 
    self._oprot.writeMessageEnd()
978 
    self._oprot.trans.flush()
979 
 
980 
  def recv_getTransactionsForShoppingCartId(self, ):
981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
982 
    if mtype == TMessageType.EXCEPTION:
983 
      x = TApplicationException()
984 
      x.read(self._iprot)
985 
      self._iprot.readMessageEnd()
986 
      raise x
987 
    result = getTransactionsForShoppingCartId_result()
988 
    result.read(self._iprot)
989 
    self._iprot.readMessageEnd()
3431 rajveer 990 
    if result.success is not None:
132 ashish 991 
      return result.success
3431 rajveer 992 
    if result.ex is not None:
132 ashish 993 
      raise result.ex
994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
995 
 
94 ashish 996 
  def getTransactionStatus(self, transactionId):
997 
    """
998 
    Parameters:
999 
     - transactionId
1000 
    """
1001 
    self.send_getTransactionStatus(transactionId)
1002 
    return self.recv_getTransactionStatus()
1003 
 
1004 
  def send_getTransactionStatus(self, transactionId):
1005 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1006 
    args = getTransactionStatus_args()
1007 
    args.transactionId = transactionId
1008 
    args.write(self._oprot)
1009 
    self._oprot.writeMessageEnd()
1010 
    self._oprot.trans.flush()
1011 
 
1012 
  def recv_getTransactionStatus(self, ):
1013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1014 
    if mtype == TMessageType.EXCEPTION:
1015 
      x = TApplicationException()
1016 
      x.read(self._iprot)
1017 
      self._iprot.readMessageEnd()
1018 
      raise x
1019 
    result = getTransactionStatus_result()
1020 
    result.read(self._iprot)
1021 
    self._iprot.readMessageEnd()
3431 rajveer 1022 
    if result.success is not None:
94 ashish 1023 
      return result.success
3431 rajveer 1024 
    if result.ex is not None:
94 ashish 1025 
      raise result.ex
1026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1027 
 
1028 
  def changeTransactionStatus(self, transactionId, status, description):
1029 
    """
1030 
    Parameters:
1031 
     - transactionId
1032 
     - status
1033 
     - description
1034 
    """
1035 
    self.send_changeTransactionStatus(transactionId, status, description)
1036 
    return self.recv_changeTransactionStatus()
1037 
 
1038 
  def send_changeTransactionStatus(self, transactionId, status, description):
1039 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1040 
    args = changeTransactionStatus_args()
1041 
    args.transactionId = transactionId
1042 
    args.status = status
1043 
    args.description = description
1044 
    args.write(self._oprot)
1045 
    self._oprot.writeMessageEnd()
1046 
    self._oprot.trans.flush()
1047 
 
1048 
  def recv_changeTransactionStatus(self, ):
1049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1050 
    if mtype == TMessageType.EXCEPTION:
1051 
      x = TApplicationException()
1052 
      x.read(self._iprot)
1053 
      self._iprot.readMessageEnd()
1054 
      raise x
1055 
    result = changeTransactionStatus_result()
1056 
    result.read(self._iprot)
1057 
    self._iprot.readMessageEnd()
3431 rajveer 1058 
    if result.success is not None:
94 ashish 1059 
      return result.success
3431 rajveer 1060 
    if result.ex is not None:
94 ashish 1061 
      raise result.ex
1062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1063 
 
1398 varun.gupt 1064 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - transactionId
1068 
    """
1398 varun.gupt 1069 
    self.send_enqueueTransactionInfoEmail(transactionId)
1070 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1071 
 
1398 varun.gupt 1072 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1073 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1074 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1075 
    args.transactionId = transactionId
1076 
    args.write(self._oprot)
1077 
    self._oprot.writeMessageEnd()
1078 
    self._oprot.trans.flush()
1079 
 
1398 varun.gupt 1080 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1082 
    if mtype == TMessageType.EXCEPTION:
1083 
      x = TApplicationException()
1084 
      x.read(self._iprot)
1085 
      self._iprot.readMessageEnd()
1086 
      raise x
1398 varun.gupt 1087 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1088 
    result.read(self._iprot)
1089 
    self._iprot.readMessageEnd()
3431 rajveer 1090 
    if result.success is not None:
1382 varun.gupt 1091 
      return result.success
3431 rajveer 1092 
    if result.ex is not None:
1382 varun.gupt 1093 
      raise result.ex
1398 varun.gupt 1094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1095 
 
483 rajveer 1096 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 1097 
    """
1098 
    Parameters:
483 rajveer 1099 
     - status
1100 
     - from_date
1101 
     - to_date
1102 
     - warehouse_id
94 ashish 1103 
    """
483 rajveer 1104 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
1105 
    return self.recv_getAllOrders()
94 ashish 1106 
 
483 rajveer 1107 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
1108 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1109 
    args = getAllOrders_args()
1110 
    args.status = status
1111 
    args.from_date = from_date
1112 
    args.to_date = to_date
1113 
    args.warehouse_id = warehouse_id
94 ashish 1114 
    args.write(self._oprot)
1115 
    self._oprot.writeMessageEnd()
1116 
    self._oprot.trans.flush()
1117 
 
483 rajveer 1118 
  def recv_getAllOrders(self, ):
94 ashish 1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1120 
    if mtype == TMessageType.EXCEPTION:
1121 
      x = TApplicationException()
1122 
      x.read(self._iprot)
1123 
      self._iprot.readMessageEnd()
1124 
      raise x
483 rajveer 1125 
    result = getAllOrders_result()
94 ashish 1126 
    result.read(self._iprot)
1127 
    self._iprot.readMessageEnd()
3431 rajveer 1128 
    if result.success is not None:
94 ashish 1129 
      return result.success
3431 rajveer 1130 
    if result.ex is not None:
94 ashish 1131 
      raise result.ex
483 rajveer 1132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1133 
 
4133 chandransh 1134 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1135 
    """
1136 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1137 
    Pass the status as null and the limit as 0 to ignore them.
1138 
 
1139 
    Parameters:
1140 
     - statuses
1141 
     - offset
1142 
     - limit
1143 
     - warehouse_id
1144 
    """
1145 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1146 
    return self.recv_getOrdersInBatch()
1147 
 
1148 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1149 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1150 
    args = getOrdersInBatch_args()
1151 
    args.statuses = statuses
1152 
    args.offset = offset
1153 
    args.limit = limit
1154 
    args.warehouse_id = warehouse_id
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_getOrdersInBatch(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = getOrdersInBatch_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.success is not None:
1170 
      return result.success
1171 
    if result.ex is not None:
1172 
      raise result.ex
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1174 
 
1175 
  def getOrderCount(self, statuses, warehouseId):
1176 
    """
1177 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1178 
 
1179 
    Parameters:
1180 
     - statuses
1181 
     - warehouseId
1182 
    """
1183 
    self.send_getOrderCount(statuses, warehouseId)
1184 
    return self.recv_getOrderCount()
1185 
 
1186 
  def send_getOrderCount(self, statuses, warehouseId):
1187 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1188 
    args = getOrderCount_args()
1189 
    args.statuses = statuses
1190 
    args.warehouseId = warehouseId
1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_getOrderCount(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = getOrderCount_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
1205 
    if result.success is not None:
1206 
      return result.success
1207 
    if result.ex is not None:
1208 
      raise result.ex
1209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1210 
 
999 varun.gupt 1211 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1212 
    """
1132 chandransh 1213 
    Returns orders within a range of their billing dates
3431 rajveer 1214 
 
999 varun.gupt 1215 
    Parameters:
1216 
     - status
1217 
     - start_billing_date
1218 
     - end_billing_date
1219 
     - warehouse_id
1220 
    """
1221 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1222 
    return self.recv_getOrdersByBillingDate()
1223 
 
1224 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1225 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1226 
    args = getOrdersByBillingDate_args()
1227 
    args.status = status
1228 
    args.start_billing_date = start_billing_date
1229 
    args.end_billing_date = end_billing_date
1230 
    args.warehouse_id = warehouse_id
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_getOrdersByBillingDate(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = getOrdersByBillingDate_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
3431 rajveer 1245 
    if result.success is not None:
999 varun.gupt 1246 
      return result.success
3431 rajveer 1247 
    if result.ex is not None:
999 varun.gupt 1248 
      raise result.ex
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1250 
 
3451 chandransh 1251 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1252 
    """
1253 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1254 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1255 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1256 
 
3427 chandransh 1257 
    Parameters:
1258 
     - fromShippingDate
1259 
     - toShippingDate
1260 
     - providerId
1261 
     - warehouseId
3451 chandransh 1262 
     - cod
3427 chandransh 1263 
    """
3451 chandransh 1264 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1265 
    return self.recv_getOrdersByShippingDate()
1266 
 
3451 chandransh 1267 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1268 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1269 
    args = getOrdersByShippingDate_args()
1270 
    args.fromShippingDate = fromShippingDate
1271 
    args.toShippingDate = toShippingDate
1272 
    args.providerId = providerId
1273 
    args.warehouseId = warehouseId
3451 chandransh 1274 
    args.cod = cod
3427 chandransh 1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_getOrdersByShippingDate(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = getOrdersByShippingDate_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
3431 rajveer 1289 
    if result.success is not None:
3427 chandransh 1290 
      return result.success
3431 rajveer 1291 
    if result.ex is not None:
3427 chandransh 1292 
      raise result.ex
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1294 
 
1382 varun.gupt 1295 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1296 
    """
1297 
    Returns order ids for orders which can be returned
3431 rajveer 1298 
 
1382 varun.gupt 1299 
    Parameters:
1300 
     - customer_id
1301 
     - limit
1302 
    """
1303 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1304 
    return self.recv_getReturnableOrdersForCustomer()
1305 
 
1306 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1307 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1308 
    args = getReturnableOrdersForCustomer_args()
1309 
    args.customer_id = customer_id
1310 
    args.limit = limit
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_getReturnableOrdersForCustomer(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = getReturnableOrdersForCustomer_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
3431 rajveer 1325 
    if result.success is not None:
1382 varun.gupt 1326 
      return result.success
3431 rajveer 1327 
    if result.ex is not None:
1382 varun.gupt 1328 
      raise result.ex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1330 
 
1331 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1332 
    """
1333 
    Returns order ids for orders which can be cancelled
3431 rajveer 1334 
 
1382 varun.gupt 1335 
    Parameters:
1336 
     - customer_id
1337 
     - limit
1338 
    """
1339 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1340 
    return self.recv_getCancellableOrdersForCustomer()
1341 
 
1342 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1343 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1344 
    args = getCancellableOrdersForCustomer_args()
1345 
    args.customer_id = customer_id
1346 
    args.limit = limit
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_getCancellableOrdersForCustomer(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = getCancellableOrdersForCustomer_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
3431 rajveer 1361 
    if result.success is not None:
1382 varun.gupt 1362 
      return result.success
3431 rajveer 1363 
    if result.ex is not None:
1382 varun.gupt 1364 
      raise result.ex
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1366 
 
483 rajveer 1367 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1368 
    """
1369 
    Parameters:
483 rajveer 1370 
     - orderId
1371 
     - status
1372 
     - description
94 ashish 1373 
    """
483 rajveer 1374 
    self.send_changeOrderStatus(orderId, status, description)
1375 
    return self.recv_changeOrderStatus()
94 ashish 1376 
 
483 rajveer 1377 
  def send_changeOrderStatus(self, orderId, status, description):
1378 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1379 
    args = changeOrderStatus_args()
1380 
    args.orderId = orderId
1381 
    args.status = status
1382 
    args.description = description
94 ashish 1383 
    args.write(self._oprot)
1384 
    self._oprot.writeMessageEnd()
1385 
    self._oprot.trans.flush()
1386 
 
483 rajveer 1387 
  def recv_changeOrderStatus(self, ):
94 ashish 1388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1389 
    if mtype == TMessageType.EXCEPTION:
1390 
      x = TApplicationException()
1391 
      x.read(self._iprot)
1392 
      self._iprot.readMessageEnd()
1393 
      raise x
483 rajveer 1394 
    result = changeOrderStatus_result()
94 ashish 1395 
    result.read(self._iprot)
1396 
    self._iprot.readMessageEnd()
3431 rajveer 1397 
    if result.success is not None:
94 ashish 1398 
      return result.success
3431 rajveer 1399 
    if result.ex is not None:
94 ashish 1400 
      raise result.ex
483 rajveer 1401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1402 
 
1528 ankur.sing 1403 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1404 
    """
1528 ankur.sing 1405 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1406 
    only user who owns the transaction can view its order details.
3431 rajveer 1407 
 
94 ashish 1408 
    Parameters:
1409 
     - transactionId
1528 ankur.sing 1410 
     - customerId
94 ashish 1411 
    """
1528 ankur.sing 1412 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1413 
    return self.recv_getOrdersForTransaction()
94 ashish 1414 
 
1528 ankur.sing 1415 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1416 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1417 
    args = getOrdersForTransaction_args()
94 ashish 1418 
    args.transactionId = transactionId
1528 ankur.sing 1419 
    args.customerId = customerId
94 ashish 1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
483 rajveer 1424 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
483 rajveer 1431 
    result = getOrdersForTransaction_result()
94 ashish 1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
3431 rajveer 1434 
    if result.success is not None:
94 ashish 1435 
      return result.success
3431 rajveer 1436 
    if result.ex is not None:
94 ashish 1437 
      raise result.ex
483 rajveer 1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1439 
 
3014 chandransh 1440 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1441 
    """
3014 chandransh 1442 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1443 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1444 
 
94 ashish 1445 
    Parameters:
483 rajveer 1446 
     - customerId
1447 
     - from_date
1448 
     - to_date
3014 chandransh 1449 
     - statuses
94 ashish 1450 
    """
3014 chandransh 1451 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1452 
    return self.recv_getOrdersForCustomer()
94 ashish 1453 
 
3014 chandransh 1454 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1455 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1456 
    args = getOrdersForCustomer_args()
1457 
    args.customerId = customerId
1458 
    args.from_date = from_date
1459 
    args.to_date = to_date
3014 chandransh 1460 
    args.statuses = statuses
94 ashish 1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
483 rajveer 1465 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
483 rajveer 1472 
    result = getOrdersForCustomer_result()
94 ashish 1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
3431 rajveer 1475 
    if result.success is not None:
94 ashish 1476 
      return result.success
3431 rajveer 1477 
    if result.ex is not None:
94 ashish 1478 
      raise result.ex
483 rajveer 1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1480 
 
483 rajveer 1481 
  def createOrder(self, order):
94 ashish 1482 
    """
1483 
    Parameters:
483 rajveer 1484 
     - order
94 ashish 1485 
    """
483 rajveer 1486 
    self.send_createOrder(order)
1487 
    return self.recv_createOrder()
94 ashish 1488 
 
483 rajveer 1489 
  def send_createOrder(self, order):
1490 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1491 
    args = createOrder_args()
1492 
    args.order = order
94 ashish 1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
483 rajveer 1497 
  def recv_createOrder(self, ):
94 ashish 1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
483 rajveer 1504 
    result = createOrder_result()
94 ashish 1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
94 ashish 1508 
      return result.success
3431 rajveer 1509 
    if result.ex is not None:
94 ashish 1510 
      raise result.ex
483 rajveer 1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1512 
 
483 rajveer 1513 
  def getOrder(self, id):
94 ashish 1514 
    """
1515 
    Parameters:
483 rajveer 1516 
     - id
94 ashish 1517 
    """
483 rajveer 1518 
    self.send_getOrder(id)
1519 
    return self.recv_getOrder()
94 ashish 1520 
 
483 rajveer 1521 
  def send_getOrder(self, id):
1522 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1523 
    args = getOrder_args()
1524 
    args.id = id
94 ashish 1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
483 rajveer 1529 
  def recv_getOrder(self, ):
94 ashish 1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
483 rajveer 1536 
    result = getOrder_result()
94 ashish 1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
3431 rajveer 1539 
    if result.success is not None:
94 ashish 1540 
      return result.success
3431 rajveer 1541 
    if result.ex is not None:
94 ashish 1542 
      raise result.ex
483 rajveer 1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1544 
 
483 rajveer 1545 
  def getLineItemsForOrder(self, orderId):
94 ashish 1546 
    """
1547 
    Parameters:
483 rajveer 1548 
     - orderId
94 ashish 1549 
    """
483 rajveer 1550 
    self.send_getLineItemsForOrder(orderId)
1551 
    return self.recv_getLineItemsForOrder()
94 ashish 1552 
 
483 rajveer 1553 
  def send_getLineItemsForOrder(self, orderId):
1554 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1555 
    args = getLineItemsForOrder_args()
1556 
    args.orderId = orderId
94 ashish 1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
483 rajveer 1561 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
483 rajveer 1568 
    result = getLineItemsForOrder_result()
94 ashish 1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
3431 rajveer 1571 
    if result.success is not None:
94 ashish 1572 
      return result.success
3431 rajveer 1573 
    if result.ex is not None:
94 ashish 1574 
      raise result.ex
483 rajveer 1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1576 
 
1528 ankur.sing 1577 
  def getOrderForCustomer(self, orderId, customerId):
1578 
    """
1579 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1580 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1581 
 
1528 ankur.sing 1582 
    Parameters:
1583 
     - orderId
1584 
     - customerId
1585 
    """
1586 
    self.send_getOrderForCustomer(orderId, customerId)
1587 
    return self.recv_getOrderForCustomer()
1588 
 
1589 
  def send_getOrderForCustomer(self, orderId, customerId):
1590 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1591 
    args = getOrderForCustomer_args()
1592 
    args.orderId = orderId
1593 
    args.customerId = customerId
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getOrderForCustomer(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getOrderForCustomer_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
3431 rajveer 1608 
    if result.success is not None:
1528 ankur.sing 1609 
      return result.success
3431 rajveer 1610 
    if result.ex is not None:
1528 ankur.sing 1611 
      raise result.ex
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1613 
 
4444 rajveer 1614 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1615 
    """
1616 
    Parameters:
4394 rajveer 1617 
     - type
4444 rajveer 1618 
     - warehouseId
4394 rajveer 1619 
     - status
1620 
     - timestamp
3064 chandransh 1621 
    """
4444 rajveer 1622 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1623 
    return self.recv_getAlerts()
1624 
 
4444 rajveer 1625 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1626 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1627 
    args = getAlerts_args()
4394 rajveer 1628 
    args.type = type
4444 rajveer 1629 
    args.warehouseId = warehouseId
4394 rajveer 1630 
    args.status = status
1631 
    args.timestamp = timestamp
3064 chandransh 1632 
    args.write(self._oprot)
1633 
    self._oprot.writeMessageEnd()
1634 
    self._oprot.trans.flush()
1635 
 
1636 
  def recv_getAlerts(self, ):
1637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1638 
    if mtype == TMessageType.EXCEPTION:
1639 
      x = TApplicationException()
1640 
      x.read(self._iprot)
1641 
      self._iprot.readMessageEnd()
1642 
      raise x
1643 
    result = getAlerts_result()
1644 
    result.read(self._iprot)
1645 
    self._iprot.readMessageEnd()
3431 rajveer 1646 
    if result.success is not None:
3064 chandransh 1647 
      return result.success
1648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1649 
 
4444 rajveer 1650 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1651 
    """
1652 
    Parameters:
1653 
     - type
4444 rajveer 1654 
     - warehouseId
4394 rajveer 1655 
     - description
3064 chandransh 1656 
    """
4444 rajveer 1657 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1658 
    self.recv_addAlert()
3064 chandransh 1659 
 
4444 rajveer 1660 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1661 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1662 
    args = addAlert_args()
3064 chandransh 1663 
    args.type = type
4444 rajveer 1664 
    args.warehouseId = warehouseId
4394 rajveer 1665 
    args.description = description
3064 chandransh 1666 
    args.write(self._oprot)
1667 
    self._oprot.writeMessageEnd()
1668 
    self._oprot.trans.flush()
1669 
 
4394 rajveer 1670 
  def recv_addAlert(self, ):
3064 chandransh 1671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1672 
    if mtype == TMessageType.EXCEPTION:
1673 
      x = TApplicationException()
1674 
      x.read(self._iprot)
1675 
      self._iprot.readMessageEnd()
1676 
      raise x
4394 rajveer 1677 
    result = addAlert_result()
3064 chandransh 1678 
    result.read(self._iprot)
1679 
    self._iprot.readMessageEnd()
1680 
    return
1681 
 
4444 rajveer 1682 
  def markAlertsAsSeen(self, warehouseId):
1683 
    """
1684 
    Parameters:
1685 
     - warehouseId
1686 
    """
1687 
    self.send_markAlertsAsSeen(warehouseId)
1688 
    self.recv_markAlertsAsSeen()
1689 
 
1690 
  def send_markAlertsAsSeen(self, warehouseId):
1691 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1692 
    args = markAlertsAsSeen_args()
1693 
    args.warehouseId = warehouseId
1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1698 
  def recv_markAlertsAsSeen(self, ):
1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1705 
    result = markAlertsAsSeen_result()
1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
1708 
    return
1709 
 
3064 chandransh 1710 
  def getValidOrderCount(self, ):
1711 
    """
1712 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1713 
    """
1714 
    self.send_getValidOrderCount()
1715 
    return self.recv_getValidOrderCount()
1716 
 
1717 
  def send_getValidOrderCount(self, ):
1718 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1719 
    args = getValidOrderCount_args()
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_getValidOrderCount(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = getValidOrderCount_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
3431 rajveer 1734 
    if result.success is not None:
3064 chandransh 1735 
      return result.success
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1737 
 
1738 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1739 
    """
1740 
    Returns the number of distinct customers who have done successful transactions
1741 
    """
1742 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1743 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1744 
 
1745 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1746 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1747 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1748 
    args.write(self._oprot)
1749 
    self._oprot.writeMessageEnd()
1750 
    self._oprot.trans.flush()
1751 
 
1752 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1754 
    if mtype == TMessageType.EXCEPTION:
1755 
      x = TApplicationException()
1756 
      x.read(self._iprot)
1757 
      self._iprot.readMessageEnd()
1758 
      raise x
1759 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1760 
    result.read(self._iprot)
1761 
    self._iprot.readMessageEnd()
3431 rajveer 1762 
    if result.success is not None:
3064 chandransh 1763 
      return result.success
1764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1765 
 
1766 
  def getValidOrdersAmountRange(self, ):
1767 
    """
1768 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1769 
    List contains two values, first minimum amount and second maximum amount.
1770 
    """
1771 
    self.send_getValidOrdersAmountRange()
1772 
    return self.recv_getValidOrdersAmountRange()
1773 
 
1774 
  def send_getValidOrdersAmountRange(self, ):
1775 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1776 
    args = getValidOrdersAmountRange_args()
1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getValidOrdersAmountRange(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getValidOrdersAmountRange_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
3064 chandransh 1792 
      return result.success
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1794 
 
1795 
  def getValidOrders(self, limit):
1796 
    """
1797 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1798 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 1799 
 
3064 chandransh 1800 
    Parameters:
1801 
     - limit
1802 
    """
1803 
    self.send_getValidOrders(limit)
1804 
    return self.recv_getValidOrders()
1805 
 
1806 
  def send_getValidOrders(self, limit):
1807 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1808 
    args = getValidOrders_args()
1809 
    args.limit = limit
1810 
    args.write(self._oprot)
1811 
    self._oprot.writeMessageEnd()
1812 
    self._oprot.trans.flush()
1813 
 
1814 
  def recv_getValidOrders(self, ):
1815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1816 
    if mtype == TMessageType.EXCEPTION:
1817 
      x = TApplicationException()
1818 
      x.read(self._iprot)
1819 
      self._iprot.readMessageEnd()
1820 
      raise x
1821 
    result = getValidOrders_result()
1822 
    result.read(self._iprot)
1823 
    self._iprot.readMessageEnd()
3431 rajveer 1824 
    if result.success is not None:
3064 chandransh 1825 
      return result.success
1826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1827 
 
1220 chandransh 1828 
  def batchOrders(self, warehouseId):
1829 
    """
1830 
    Create a batch of all the pending orders for the given warehouse.
1831 
    The returned list is orderd by created_timestamp.
1832 
    If there are no pending orders, an empty list is returned.
3431 rajveer 1833 
 
1220 chandransh 1834 
    Parameters:
1835 
     - warehouseId
1836 
    """
1837 
    self.send_batchOrders(warehouseId)
1838 
    return self.recv_batchOrders()
1839 
 
1840 
  def send_batchOrders(self, warehouseId):
1841 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1842 
    args = batchOrders_args()
1843 
    args.warehouseId = warehouseId
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_batchOrders(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = batchOrders_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
3431 rajveer 1858 
    if result.success is not None:
1220 chandransh 1859 
      return result.success
3431 rajveer 1860 
    if result.ex is not None:
1220 chandransh 1861 
      raise result.ex
1862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1863 
 
1208 chandransh 1864 
  def markOrderAsOutOfStock(self, orderId):
1865 
    """
1866 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 1867 
 
1208 chandransh 1868 
    Parameters:
1869 
     - orderId
1870 
    """
1871 
    self.send_markOrderAsOutOfStock(orderId)
1872 
    return self.recv_markOrderAsOutOfStock()
1873 
 
1874 
  def send_markOrderAsOutOfStock(self, orderId):
1875 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1876 
    args = markOrderAsOutOfStock_args()
1877 
    args.orderId = orderId
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_markOrderAsOutOfStock(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = markOrderAsOutOfStock_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
3431 rajveer 1892 
    if result.success is not None:
1208 chandransh 1893 
      return result.success
3431 rajveer 1894 
    if result.ex is not None:
1208 chandransh 1895 
      raise result.ex
1896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1897 
 
3064 chandransh 1898 
  def verifyOrder(self, orderId):
759 chandransh 1899 
    """
3064 chandransh 1900 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
1901 
    timestamp. It is intended to be used for COD orders but can be harmlessly
1902 
    used for all other orders as well.
1903 
    Throws an exception if no such order exists.
3431 rajveer 1904 
 
759 chandransh 1905 
    Parameters:
3064 chandransh 1906 
     - orderId
759 chandransh 1907 
    """
3064 chandransh 1908 
    self.send_verifyOrder(orderId)
1909 
    return self.recv_verifyOrder()
759 chandransh 1910 
 
3064 chandransh 1911 
  def send_verifyOrder(self, orderId):
1912 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
1913 
    args = verifyOrder_args()
1914 
    args.orderId = orderId
759 chandransh 1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
3064 chandransh 1919 
  def recv_verifyOrder(self, ):
759 chandransh 1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
3064 chandransh 1926 
    result = verifyOrder_result()
759 chandransh 1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
759 chandransh 1930 
      return result.success
3431 rajveer 1931 
    if result.ex is not None:
759 chandransh 1932 
      raise result.ex
3064 chandransh 1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 1934 
 
3064 chandransh 1935 
  def acceptOrder(self, orderId):
1113 chandransh 1936 
    """
3064 chandransh 1937 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
1938 
    given order is not a COD order, it also captures the payment if the same has
1939 
    not been captured.
1940 
    Throws an exception if no such order exists.
3431 rajveer 1941 
 
1113 chandransh 1942 
    Parameters:
3064 chandransh 1943 
     - orderId
1113 chandransh 1944 
    """
3064 chandransh 1945 
    self.send_acceptOrder(orderId)
1946 
    return self.recv_acceptOrder()
1113 chandransh 1947 
 
3064 chandransh 1948 
  def send_acceptOrder(self, orderId):
1949 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1950 
    args = acceptOrder_args()
1951 
    args.orderId = orderId
1113 chandransh 1952 
    args.write(self._oprot)
1953 
    self._oprot.writeMessageEnd()
1954 
    self._oprot.trans.flush()
1955 
 
3064 chandransh 1956 
  def recv_acceptOrder(self, ):
1113 chandransh 1957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1958 
    if mtype == TMessageType.EXCEPTION:
1959 
      x = TApplicationException()
1960 
      x.read(self._iprot)
1961 
      self._iprot.readMessageEnd()
1962 
      raise x
3064 chandransh 1963 
    result = acceptOrder_result()
1113 chandransh 1964 
    result.read(self._iprot)
1965 
    self._iprot.readMessageEnd()
3431 rajveer 1966 
    if result.success is not None:
1113 chandransh 1967 
      return result.success
3431 rajveer 1968 
    if result.ex is not None:
1113 chandransh 1969 
      raise result.ex
3064 chandransh 1970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 1971 
 
4283 anupam.sin 1972 
  def addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
1132 chandransh 1973 
    """
3064 chandransh 1974 
    Add billing details such as the bill number and the biller to the Order.
4283 anupam.sin 1975 
    Adds jacket number, item number and IMEI no. to the order. Doesn't update
1976 
    the IMEI no. if a -1 is supplied.
1977 
    Also, it generates an invoice number for the order, marks the order as
1978 
    BILLED and sets the billing timestamp.
1979 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 1980 
 
1135 chandransh 1981 
    Parameters:
3064 chandransh 1982 
     - orderId
1983 
     - invoice_number
4283 anupam.sin 1984 
     - imeiNumber
1985 
     - itemNumber
3064 chandransh 1986 
     - billed_by
4264 rajveer 1987 
     - jacketNumber
4283 anupam.sin 1988 
     - billingType
1989 
     - vendorId
1135 chandransh 1990 
    """
4283 anupam.sin 1991 
    self.send_addBillingDetails(orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId)
3064 chandransh 1992 
    return self.recv_addBillingDetails()
1135 chandransh 1993 
 
4283 anupam.sin 1994 
  def send_addBillingDetails(self, orderId, invoice_number, imeiNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId):
3064 chandransh 1995 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
1996 
    args = addBillingDetails_args()
1997 
    args.orderId = orderId
1998 
    args.invoice_number = invoice_number
4283 anupam.sin 1999 
    args.imeiNumber = imeiNumber
2000 
    args.itemNumber = itemNumber
3064 chandransh 2001 
    args.billed_by = billed_by
4264 rajveer 2002 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2003 
    args.billingType = billingType
2004 
    args.vendorId = vendorId
1135 chandransh 2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
3064 chandransh 2009 
  def recv_addBillingDetails(self, ):
1135 chandransh 2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
3064 chandransh 2016 
    result = addBillingDetails_result()
1135 chandransh 2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
3064 chandransh 2020 
      return result.success
3431 rajveer 2021 
    if result.ex is not None:
1135 chandransh 2022 
      raise result.ex
3064 chandransh 2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2024 
 
3064 chandransh 2025 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
1408 ankur.sing 2026 
    """
3064 chandransh 2027 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4410 rajveer 2028 
    given warehouse and were picked up by the given provider as MANIFESTED.
3431 rajveer 2029 
 
1408 ankur.sing 2030 
    Parameters:
3064 chandransh 2031 
     - warehouseId
1408 ankur.sing 2032 
     - providerId
3064 chandransh 2033 
     - cod
1408 ankur.sing 2034 
    """
3064 chandransh 2035 
    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
2036 
    return self.recv_markOrdersAsManifested()
1408 ankur.sing 2037 
 
3064 chandransh 2038 
  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
2039 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
2040 
    args = markOrdersAsManifested_args()
2041 
    args.warehouseId = warehouseId
1408 ankur.sing 2042 
    args.providerId = providerId
3064 chandransh 2043 
    args.cod = cod
1408 ankur.sing 2044 
    args.write(self._oprot)
2045 
    self._oprot.writeMessageEnd()
2046 
    self._oprot.trans.flush()
2047 
 
3064 chandransh 2048 
  def recv_markOrdersAsManifested(self, ):
1408 ankur.sing 2049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2050 
    if mtype == TMessageType.EXCEPTION:
2051 
      x = TApplicationException()
2052 
      x.read(self._iprot)
2053 
      self._iprot.readMessageEnd()
2054 
      raise x
3064 chandransh 2055 
    result = markOrdersAsManifested_result()
1408 ankur.sing 2056 
    result.read(self._iprot)
2057 
    self._iprot.readMessageEnd()
3431 rajveer 2058 
    if result.success is not None:
1408 ankur.sing 2059 
      return result.success
3431 rajveer 2060 
    if result.ex is not None:
3064 chandransh 2061 
      raise result.ex
2062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1408 ankur.sing 2063 
 
4410 rajveer 2064 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2065 
    """
2066 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
2067 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
2068 
 
2069 
    Parameters:
2070 
     - warehouseId
2071 
     - providerId
2072 
     - cod
2073 
    """
2074 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod)
2075 
    return self.recv_markOrdersAsShippedFromWarehouse()
2076 
 
2077 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod):
2078 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2079 
    args = markOrdersAsShippedFromWarehouse_args()
2080 
    args.warehouseId = warehouseId
2081 
    args.providerId = providerId
2082 
    args.cod = cod
2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
2087 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
2094 
    result = markOrdersAsShippedFromWarehouse_result()
2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
2097 
    if result.success is not None:
2098 
      return result.success
2099 
    if result.ex is not None:
2100 
      raise result.ex
2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
2102 
 
3064 chandransh 2103 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
94 ashish 2104 
    """
3064 chandransh 2105 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2106 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
2107 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2108 
 
94 ashish 2109 
    Parameters:
3064 chandransh 2110 
     - providerId
2111 
     - pickupDetails
304 ashish 2112 
    """
3064 chandransh 2113 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2114 
    return self.recv_markOrdersAsPickedUp()
94 ashish 2115 
 
3064 chandransh 2116 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2117 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2118 
    args = markOrdersAsPickedUp_args()
2119 
    args.providerId = providerId
2120 
    args.pickupDetails = pickupDetails
304 ashish 2121 
    args.write(self._oprot)
2122 
    self._oprot.writeMessageEnd()
2123 
    self._oprot.trans.flush()
2124 
 
3064 chandransh 2125 
  def recv_markOrdersAsPickedUp(self, ):
304 ashish 2126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2127 
    if mtype == TMessageType.EXCEPTION:
2128 
      x = TApplicationException()
2129 
      x.read(self._iprot)
2130 
      self._iprot.readMessageEnd()
2131 
      raise x
3064 chandransh 2132 
    result = markOrdersAsPickedUp_result()
304 ashish 2133 
    result.read(self._iprot)
2134 
    self._iprot.readMessageEnd()
3431 rajveer 2135 
    if result.success is not None:
304 ashish 2136 
      return result.success
3431 rajveer 2137 
    if result.ex is not None:
3064 chandransh 2138 
      raise result.ex
2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
304 ashish 2140 
 
3064 chandransh 2141 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2142 
    """
3064 chandransh 2143 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2144 
    the name of the receiver.
2145 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2146 
 
304 ashish 2147 
    Parameters:
3064 chandransh 2148 
     - providerId
2149 
     - deliveredOrders
304 ashish 2150 
    """
3064 chandransh 2151 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2152 
    self.recv_markOrdersAsDelivered()
304 ashish 2153 
 
3064 chandransh 2154 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2155 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2156 
    args = markOrdersAsDelivered_args()
2157 
    args.providerId = providerId
2158 
    args.deliveredOrders = deliveredOrders
304 ashish 2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
3064 chandransh 2163 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
3064 chandransh 2170 
    result = markOrdersAsDelivered_result()
304 ashish 2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
3431 rajveer 2173 
    if result.ex is not None:
3064 chandransh 2174 
      raise result.ex
304 ashish 2175 
    return
2176 
 
3064 chandransh 2177 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1596 ankur.sing 2178 
    """
3064 chandransh 2179 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
2180 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2181 
 
3064 chandransh 2182 
    Parameters:
2183 
     - providerId
2184 
     - returnedOrders
1596 ankur.sing 2185 
    """
3064 chandransh 2186 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
2187 
    self.recv_markOrdersAsFailed()
304 ashish 2188 
 
3064 chandransh 2189 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
2190 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
2191 
    args = markOrdersAsFailed_args()
2192 
    args.providerId = providerId
2193 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2194 
    args.write(self._oprot)
2195 
    self._oprot.writeMessageEnd()
2196 
    self._oprot.trans.flush()
2197 
 
3064 chandransh 2198 
  def recv_markOrdersAsFailed(self, ):
1596 ankur.sing 2199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2200 
    if mtype == TMessageType.EXCEPTION:
2201 
      x = TApplicationException()
2202 
      x.read(self._iprot)
2203 
      self._iprot.readMessageEnd()
2204 
      raise x
3064 chandransh 2205 
    result = markOrdersAsFailed_result()
1596 ankur.sing 2206 
    result.read(self._iprot)
2207 
    self._iprot.readMessageEnd()
3431 rajveer 2208 
    if result.ex is not None:
3064 chandransh 2209 
      raise result.ex
2210 
    return
1596 ankur.sing 2211 
 
3064 chandransh 2212 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2213 
    """
3064 chandransh 2214 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2215 
 
3064 chandransh 2216 
    Parameters:
2217 
     - providerId
2218 
     - undeliveredOrders
1627 ankur.sing 2219 
    """
3064 chandransh 2220 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
2221 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2222 
 
3064 chandransh 2223 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2224 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2225 
    args = updateNonDeliveryReason_args()
2226 
    args.providerId = providerId
2227 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2228 
    args.write(self._oprot)
2229 
    self._oprot.writeMessageEnd()
2230 
    self._oprot.trans.flush()
2231 
 
3064 chandransh 2232 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2234 
    if mtype == TMessageType.EXCEPTION:
2235 
      x = TApplicationException()
2236 
      x.read(self._iprot)
2237 
      self._iprot.readMessageEnd()
2238 
      raise x
3064 chandransh 2239 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2240 
    result.read(self._iprot)
2241 
    self._iprot.readMessageEnd()
3431 rajveer 2242 
    if result.ex is not None:
3064 chandransh 2243 
      raise result.ex
2244 
    return
1627 ankur.sing 2245 
 
3064 chandransh 2246 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2247 
    """
3064 chandransh 2248 
    Returns the list of orders whose delivery time has passed but have not been
2249 
    delivered yet for the given provider and warehouse. To get a complete list of
2250 
    undelivered orders, pass them as -1.
2251 
    Returns an empty list if no such orders exist.
3431 rajveer 2252 
 
1886 ankur.sing 2253 
    Parameters:
3064 chandransh 2254 
     - providerId
2255 
     - warehouseId
1886 ankur.sing 2256 
    """
3064 chandransh 2257 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2258 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2259 
 
3064 chandransh 2260 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2261 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2262 
    args = getUndeliveredOrders_args()
2263 
    args.providerId = providerId
2264 
    args.warehouseId = warehouseId
1886 ankur.sing 2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
3064 chandransh 2269 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
3064 chandransh 2276 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
3431 rajveer 2279 
    if result.success is not None:
1886 ankur.sing 2280 
      return result.success
3064 chandransh 2281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2282 
 
2536 chandransh 2283 
  def toggleDOAFlag(self, orderId):
2284 
    """
2285 
    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.
2286 
    Returns the final flag status.
2287 
    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 2288 
 
2536 chandransh 2289 
    Parameters:
2290 
     - orderId
2291 
    """
2292 
    self.send_toggleDOAFlag(orderId)
2293 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2294 
 
2536 chandransh 2295 
  def send_toggleDOAFlag(self, orderId):
2296 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2297 
    args = toggleDOAFlag_args()
2298 
    args.orderId = orderId
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
2303 
  def recv_toggleDOAFlag(self, ):
2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
2310 
    result = toggleDOAFlag_result()
2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
3431 rajveer 2313 
    if result.success is not None:
2536 chandransh 2314 
      return result.success
3431 rajveer 2315 
    if result.ex is not None:
2536 chandransh 2316 
      raise result.ex
2317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2318 
 
4454 rajveer 2319 
  def markOrderDoaRequestReceived(self, orderId):
2320 
    """
2321 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2322 
 
2323 
    Parameters:
2324 
     - orderId
2325 
    """
2326 
    self.send_markOrderDoaRequestReceived(orderId)
2327 
    return self.recv_markOrderDoaRequestReceived()
2328 
 
2329 
  def send_markOrderDoaRequestReceived(self, orderId):
2330 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2331 
    args = markOrderDoaRequestReceived_args()
2332 
    args.orderId = orderId
2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_markOrderDoaRequestReceived(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = markOrderDoaRequestReceived_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
2347 
    if result.success is not None:
2348 
      return result.success
2349 
    if result.ex is not None:
2350 
      raise result.ex
2351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2352 
 
2353 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2354 
    """
2355 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2356 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2357 
 
2358 
    Parameters:
2359 
     - orderId
2360 
     - isAuthorized
2361 
    """
2362 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2363 
    return self.recv_markOrderDoaRequestAuthorized()
2364 
 
2365 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2366 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2367 
    args = markOrderDoaRequestAuthorized_args()
2368 
    args.orderId = orderId
2369 
    args.isAuthorized = isAuthorized
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_markOrderDoaRequestAuthorized(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = markOrderDoaRequestAuthorized_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
2384 
    if result.success is not None:
2385 
      return result.success
2386 
    if result.ex is not None:
2387 
      raise result.ex
2388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2389 
 
4488 rajveer 2390 
  def markOrderReturnRequestReceived(self, orderId):
2391 
    """
2392 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2393 
 
2394 
    Parameters:
2395 
     - orderId
2396 
    """
2397 
    self.send_markOrderReturnRequestReceived(orderId)
2398 
    return self.recv_markOrderReturnRequestReceived()
2399 
 
2400 
  def send_markOrderReturnRequestReceived(self, orderId):
2401 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2402 
    args = markOrderReturnRequestReceived_args()
2403 
    args.orderId = orderId
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_markOrderReturnRequestReceived(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = markOrderReturnRequestReceived_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
2418 
    if result.success is not None:
2419 
      return result.success
2420 
    if result.ex is not None:
2421 
      raise result.ex
2422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
2423 
 
2424 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2425 
    """
2426 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
2427 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2428 
 
2429 
    Parameters:
2430 
     - orderId
2431 
     - isAuthorized
2432 
    """
2433 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
2434 
    return self.recv_markOrderReturnRequestAuthorized()
2435 
 
2436 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
2437 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
2438 
    args = markOrderReturnRequestAuthorized_args()
2439 
    args.orderId = orderId
2440 
    args.isAuthorized = isAuthorized
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_markOrderReturnRequestAuthorized(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = markOrderReturnRequestAuthorized_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
2455 
    if result.success is not None:
2456 
      return result.success
2457 
    if result.ex is not None:
2458 
      raise result.ex
2459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
2460 
 
2536 chandransh 2461 
  def requestPickupNumber(self, orderId):
2462 
    """
2463 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 2464 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
2465 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 2466 
    For any other status, it returns false.
2467 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2468 
 
2536 chandransh 2469 
    Parameters:
2470 
     - orderId
2471 
    """
2472 
    self.send_requestPickupNumber(orderId)
2473 
    return self.recv_requestPickupNumber()
2474 
 
2475 
  def send_requestPickupNumber(self, orderId):
2476 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
2477 
    args = requestPickupNumber_args()
2478 
    args.orderId = orderId
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_requestPickupNumber(self, ):
2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
2490 
    result = requestPickupNumber_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
3431 rajveer 2493 
    if result.success is not None:
2536 chandransh 2494 
      return result.success
3431 rajveer 2495 
    if result.ex is not None:
2536 chandransh 2496 
      raise result.ex
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
2498 
 
2499 
  def authorizePickup(self, orderId, pickupNumber):
2500 
    """
4452 rajveer 2501 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 2502 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
2503 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
2504 
    	3. Returns true
2591 chandransh 2505 
    If the order is in any other status, it returns false.
2536 chandransh 2506 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2507 
 
2536 chandransh 2508 
    Parameters:
2509 
     - orderId
2510 
     - pickupNumber
2511 
    """
2512 
    self.send_authorizePickup(orderId, pickupNumber)
2513 
    return self.recv_authorizePickup()
2514 
 
2515 
  def send_authorizePickup(self, orderId, pickupNumber):
2516 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
2517 
    args = authorizePickup_args()
2518 
    args.orderId = orderId
2519 
    args.pickupNumber = pickupNumber
2520 
    args.write(self._oprot)
2521 
    self._oprot.writeMessageEnd()
2522 
    self._oprot.trans.flush()
2523 
 
2524 
  def recv_authorizePickup(self, ):
2525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2526 
    if mtype == TMessageType.EXCEPTION:
2527 
      x = TApplicationException()
2528 
      x.read(self._iprot)
2529 
      self._iprot.readMessageEnd()
2530 
      raise x
2531 
    result = authorizePickup_result()
2532 
    result.read(self._iprot)
2533 
    self._iprot.readMessageEnd()
3431 rajveer 2534 
    if result.success is not None:
2536 chandransh 2535 
      return result.success
3431 rajveer 2536 
    if result.ex is not None:
2536 chandransh 2537 
      raise result.ex
2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
2539 
 
2764 chandransh 2540 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
2541 
    """
2542 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
2543 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3431 rajveer 2544 
 
2764 chandransh 2545 
    Parameters:
2546 
     - providerId
2547 
     - pickupDetails
2548 
    """
2549 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
2550 
    return self.recv_markDoasAsPickedUp()
2551 
 
2552 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
2553 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
2554 
    args = markDoasAsPickedUp_args()
2555 
    args.providerId = providerId
2556 
    args.pickupDetails = pickupDetails
2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
2561 
  def recv_markDoasAsPickedUp(self, ):
2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
2568 
    result = markDoasAsPickedUp_result()
2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
3431 rajveer 2571 
    if result.success is not None:
2764 chandransh 2572 
      return result.success
2573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
2574 
 
4479 rajveer 2575 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 2576 
    """
4452 rajveer 2577 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 2578 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 2579 
    If the order is in any other state, it returns false.
2580 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2581 
 
2591 chandransh 2582 
    Parameters:
2583 
     - orderId
4479 rajveer 2584 
     - receiveCondition
2591 chandransh 2585 
    """
4479 rajveer 2586 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 2587 
    return self.recv_receiveReturn()
2536 chandransh 2588 
 
4479 rajveer 2589 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 2590 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
2591 
    args = receiveReturn_args()
2591 chandransh 2592 
    args.orderId = orderId
4479 rajveer 2593 
    args.receiveCondition = receiveCondition
2591 chandransh 2594 
    args.write(self._oprot)
2595 
    self._oprot.writeMessageEnd()
2596 
    self._oprot.trans.flush()
2597 
 
2616 chandransh 2598 
  def recv_receiveReturn(self, ):
2591 chandransh 2599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2600 
    if mtype == TMessageType.EXCEPTION:
2601 
      x = TApplicationException()
2602 
      x.read(self._iprot)
2603 
      self._iprot.readMessageEnd()
2604 
      raise x
2616 chandransh 2605 
    result = receiveReturn_result()
2591 chandransh 2606 
    result.read(self._iprot)
2607 
    self._iprot.readMessageEnd()
3431 rajveer 2608 
    if result.success is not None:
2591 chandransh 2609 
      return result.success
3431 rajveer 2610 
    if result.ex is not None:
2591 chandransh 2611 
      raise result.ex
2616 chandransh 2612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 2613 
 
2614 
  def validateDoa(self, orderId, isValid):
2615 
    """
4452 rajveer 2616 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 2617 
    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 2618 
    If the order is in any other state, it returns false.
2619 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2620 
 
2591 chandransh 2621 
    Parameters:
2622 
     - orderId
2623 
     - isValid
2624 
    """
2625 
    self.send_validateDoa(orderId, isValid)
2626 
    return self.recv_validateDoa()
2627 
 
2628 
  def send_validateDoa(self, orderId, isValid):
2629 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2630 
    args = validateDoa_args()
2631 
    args.orderId = orderId
2632 
    args.isValid = isValid
2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
2637 
  def recv_validateDoa(self, ):
2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
2644 
    result = validateDoa_result()
2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
3431 rajveer 2647 
    if result.success is not None:
2591 chandransh 2648 
      return result.success
3431 rajveer 2649 
    if result.ex is not None:
2591 chandransh 2650 
      raise result.ex
2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2652 
 
2616 chandransh 2653 
  def reshipOrder(self, orderId):
2654 
    """
4484 rajveer 2655 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2656 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 2657 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 2658 
 
2659 
    If the order is in DOA_CERT_VALID state, it does the following:
2660 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2661 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 2662 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 2663 
 
2616 chandransh 2664 
    Returns the id of the newly created order.
3431 rajveer 2665 
 
2616 chandransh 2666 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2667 
 
2616 chandransh 2668 
    Parameters:
2669 
     - orderId
2670 
    """
2671 
    self.send_reshipOrder(orderId)
2672 
    return self.recv_reshipOrder()
2591 chandransh 2673 
 
2616 chandransh 2674 
  def send_reshipOrder(self, orderId):
2675 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2676 
    args = reshipOrder_args()
2677 
    args.orderId = orderId
2678 
    args.write(self._oprot)
2679 
    self._oprot.writeMessageEnd()
2680 
    self._oprot.trans.flush()
2681 
 
2682 
  def recv_reshipOrder(self, ):
2683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2684 
    if mtype == TMessageType.EXCEPTION:
2685 
      x = TApplicationException()
2686 
      x.read(self._iprot)
2687 
      self._iprot.readMessageEnd()
2688 
      raise x
2689 
    result = reshipOrder_result()
2690 
    result.read(self._iprot)
2691 
    self._iprot.readMessageEnd()
3431 rajveer 2692 
    if result.success is not None:
2616 chandransh 2693 
      return result.success
3431 rajveer 2694 
    if result.ex is not None:
2616 chandransh 2695 
      raise result.ex
2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2697 
 
3226 chandransh 2698 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2699 
    """
4484 rajveer 2700 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 2701 
    	1. Creates a refund request for batch processing.
2702 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 2703 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 2704 
 
2616 chandransh 2705 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2706 
    	1. Creates a refund request for batch processing.
3226 chandransh 2707 
    	2. Cancels the reservation of the item in the warehouse.
2708 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 2709 
 
3226 chandransh 2710 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2711 
    	1. Cancels the reservation of the item in the warehouse.
2712 
    	2. Marks the current order as CANCELED.
2713 
 
2714 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
2715 
 
2616 chandransh 2716 
    Returns True if it is successful, False otherwise.
3431 rajveer 2717 
 
2616 chandransh 2718 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 2719 
 
2616 chandransh 2720 
    Parameters:
2721 
     - orderId
3226 chandransh 2722 
     - refundedBy
2723 
     - reason
2616 chandransh 2724 
    """
3226 chandransh 2725 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 2726 
    return self.recv_refundOrder()
2727 
 
3226 chandransh 2728 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 2729 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2730 
    args = refundOrder_args()
2731 
    args.orderId = orderId
3226 chandransh 2732 
    args.refundedBy = refundedBy
2733 
    args.reason = reason
2616 chandransh 2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2738 
  def recv_refundOrder(self, ):
2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2745 
    result = refundOrder_result()
2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
3431 rajveer 2748 
    if result.success is not None:
2616 chandransh 2749 
      return result.success
3431 rajveer 2750 
    if result.ex is not None:
2616 chandransh 2751 
      raise result.ex
2752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2753 
 
2690 chandransh 2754 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2755 
    """
2756 
    Get all return orders created between the from and to dates for the given warehouse.
2757 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 2758 
 
2690 chandransh 2759 
    Parameters:
2760 
     - warehouseId
2761 
     - fromDate
2762 
     - toDate
2763 
    """
2764 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2765 
    return self.recv_getReturnOrders()
2616 chandransh 2766 
 
2690 chandransh 2767 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2768 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2769 
    args = getReturnOrders_args()
2770 
    args.warehouseId = warehouseId
2771 
    args.fromDate = fromDate
2772 
    args.toDate = toDate
2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2777 
  def recv_getReturnOrders(self, ):
2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2784 
    result = getReturnOrders_result()
2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
3431 rajveer 2787 
    if result.success is not None:
2690 chandransh 2788 
      return result.success
2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2790 
 
2700 chandransh 2791 
  def getReturnOrder(self, id):
2792 
    """
2793 
    Returns the ReturnOrder corresponding to the given id.
2794 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 2795 
 
2700 chandransh 2796 
    Parameters:
2797 
     - id
2798 
    """
2799 
    self.send_getReturnOrder(id)
2800 
    return self.recv_getReturnOrder()
2801 
 
2802 
  def send_getReturnOrder(self, id):
2803 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2804 
    args = getReturnOrder_args()
2805 
    args.id = id
2806 
    args.write(self._oprot)
2807 
    self._oprot.writeMessageEnd()
2808 
    self._oprot.trans.flush()
2809 
 
2810 
  def recv_getReturnOrder(self, ):
2811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2812 
    if mtype == TMessageType.EXCEPTION:
2813 
      x = TApplicationException()
2814 
      x.read(self._iprot)
2815 
      self._iprot.readMessageEnd()
2816 
      raise x
2817 
    result = getReturnOrder_result()
2818 
    result.read(self._iprot)
2819 
    self._iprot.readMessageEnd()
3431 rajveer 2820 
    if result.success is not None:
2700 chandransh 2821 
      return result.success
3431 rajveer 2822 
    if result.ex is not None:
2700 chandransh 2823 
      raise result.ex
2824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2825 
 
2690 chandransh 2826 
  def processReturn(self, returnOrderId):
2827 
    """
2828 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 2829 
 
2690 chandransh 2830 
    Parameters:
2831 
     - returnOrderId
2832 
    """
2833 
    self.send_processReturn(returnOrderId)
2834 
    self.recv_processReturn()
2835 
 
2836 
  def send_processReturn(self, returnOrderId):
2837 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2838 
    args = processReturn_args()
2839 
    args.returnOrderId = returnOrderId
2840 
    args.write(self._oprot)
2841 
    self._oprot.writeMessageEnd()
2842 
    self._oprot.trans.flush()
2843 
 
2844 
  def recv_processReturn(self, ):
2845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2846 
    if mtype == TMessageType.EXCEPTION:
2847 
      x = TApplicationException()
2848 
      x.read(self._iprot)
2849 
      self._iprot.readMessageEnd()
2850 
      raise x
2851 
    result = processReturn_result()
2852 
    result.read(self._iprot)
2853 
    self._iprot.readMessageEnd()
3431 rajveer 2854 
    if result.ex is not None:
2690 chandransh 2855 
      raise result.ex
2856 
    return
2857 
 
2819 chandransh 2858 
  def createPurchaseOrder(self, warehouseId):
2859 
    """
2860 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2861 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
3431 rajveer 2862 
 
2819 chandransh 2863 
    Parameters:
2864 
     - warehouseId
2865 
    """
2866 
    self.send_createPurchaseOrder(warehouseId)
2867 
    return self.recv_createPurchaseOrder()
2690 chandransh 2868 
 
2819 chandransh 2869 
  def send_createPurchaseOrder(self, warehouseId):
2870 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2871 
    args = createPurchaseOrder_args()
2872 
    args.warehouseId = warehouseId
2873 
    args.write(self._oprot)
2874 
    self._oprot.writeMessageEnd()
2875 
    self._oprot.trans.flush()
2876 
 
2877 
  def recv_createPurchaseOrder(self, ):
2878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2879 
    if mtype == TMessageType.EXCEPTION:
2880 
      x = TApplicationException()
2881 
      x.read(self._iprot)
2882 
      self._iprot.readMessageEnd()
2883 
      raise x
2884 
    result = createPurchaseOrder_result()
2885 
    result.read(self._iprot)
2886 
    self._iprot.readMessageEnd()
3431 rajveer 2887 
    if result.success is not None:
2819 chandransh 2888 
      return result.success
3431 rajveer 2889 
    if result.ex is not None:
2819 chandransh 2890 
      raise result.ex
2891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2892 
 
3451 chandransh 2893 
  def updateWeight(self, orderId, weight):
2894 
    """
2895 
    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 2896 
 
3451 chandransh 2897 
    Parameters:
2898 
     - orderId
2899 
     - weight
2900 
    """
2901 
    self.send_updateWeight(orderId, weight)
2902 
    return self.recv_updateWeight()
2903 
 
2904 
  def send_updateWeight(self, orderId, weight):
2905 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
2906 
    args = updateWeight_args()
2907 
    args.orderId = orderId
2908 
    args.weight = weight
2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_updateWeight(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = updateWeight_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
2923 
    if result.success is not None:
2924 
      return result.success
2925 
    if result.ex is not None:
2926 
      raise result.ex
2927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
2928 
 
3469 chandransh 2929 
  def changeItem(self, orderId, itemId):
2930 
    """
2931 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
2932 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 2933 
 
3469 chandransh 2934 
    Parameters:
2935 
     - orderId
2936 
     - itemId
2937 
    """
2938 
    self.send_changeItem(orderId, itemId)
2939 
    return self.recv_changeItem()
2940 
 
2941 
  def send_changeItem(self, orderId, itemId):
2942 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
2943 
    args = changeItem_args()
2944 
    args.orderId = orderId
2945 
    args.itemId = itemId
2946 
    args.write(self._oprot)
2947 
    self._oprot.writeMessageEnd()
2948 
    self._oprot.trans.flush()
2949 
 
2950 
  def recv_changeItem(self, ):
2951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2952 
    if mtype == TMessageType.EXCEPTION:
2953 
      x = TApplicationException()
2954 
      x.read(self._iprot)
2955 
      self._iprot.readMessageEnd()
2956 
      raise x
2957 
    result = changeItem_result()
2958 
    result.read(self._iprot)
2959 
    self._iprot.readMessageEnd()
2960 
    if result.success is not None:
2961 
      return result.success
2962 
    if result.ex is not None:
2963 
      raise result.ex
2964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
2965 
 
2966 
  def shiftToWarehouse(self, orderId, warehouseId):
2967 
    """
2968 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
2969 
 
2970 
    Parameters:
2971 
     - orderId
2972 
     - warehouseId
2973 
    """
2974 
    self.send_shiftToWarehouse(orderId, warehouseId)
2975 
    return self.recv_shiftToWarehouse()
2976 
 
2977 
  def send_shiftToWarehouse(self, orderId, warehouseId):
2978 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
2979 
    args = shiftToWarehouse_args()
2980 
    args.orderId = orderId
2981 
    args.warehouseId = warehouseId
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_shiftToWarehouse(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = shiftToWarehouse_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    if result.success is not None:
2997 
      return result.success
2998 
    if result.ex is not None:
2999 
      raise result.ex
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3001 
 
3986 chandransh 3002 
  def addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3003 
    """
3004 
    Adds the given delay reason to the given order.
3986 chandransh 3005 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3006 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3007 
 
3553 chandransh 3008 
    Parameters:
3009 
     - orderId
3010 
     - delayReason
3986 chandransh 3011 
     - furtherDelay
3553 chandransh 3012 
    """
3986 chandransh 3013 
    self.send_addDelayReason(orderId, delayReason, furtherDelay)
3553 chandransh 3014 
    return self.recv_addDelayReason()
3015 
 
3986 chandransh 3016 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay):
3553 chandransh 3017 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3018 
    args = addDelayReason_args()
3019 
    args.orderId = orderId
3020 
    args.delayReason = delayReason
3986 chandransh 3021 
    args.furtherDelay = furtherDelay
3553 chandransh 3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_addDelayReason(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = addDelayReason_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3036 
    if result.success is not None:
3037 
      return result.success
3038 
    if result.ex is not None:
3039 
      raise result.ex
3040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3041 
 
3956 chandransh 3042 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3043 
    """
3044 
    Marks the COD orders with given AWB nos. as having been processed.
3045 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3046 
 
3956 chandransh 3047 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3048 
    1. There is no order corresponding to an AWB number.
3049 
    2. The captured amount for a payment exceeds the total payment.
3050 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3051 
 
3052 
    Parameters:
3053 
     - collectedAmountMap
3054 
     - xferBy
3055 
     - xferTxnId
3056 
     - xferDate
3057 
    """
3058 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3059 
    return self.recv_reconcileCodCollection()
3060 
 
3061 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3062 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3063 
    args = reconcileCodCollection_args()
3064 
    args.collectedAmountMap = collectedAmountMap
3065 
    args.xferBy = xferBy
3066 
    args.xferTxnId = xferTxnId
3067 
    args.xferDate = xferDate
3068 
    args.write(self._oprot)
3069 
    self._oprot.writeMessageEnd()
3070 
    self._oprot.trans.flush()
3071 
 
3072 
  def recv_reconcileCodCollection(self, ):
3073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3074 
    if mtype == TMessageType.EXCEPTION:
3075 
      x = TApplicationException()
3076 
      x.read(self._iprot)
3077 
      self._iprot.readMessageEnd()
3078 
      raise x
3079 
    result = reconcileCodCollection_result()
3080 
    result.read(self._iprot)
3081 
    self._iprot.readMessageEnd()
3082 
    if result.success is not None:
3083 
      return result.success
3084 
    if result.ex is not None:
3085 
      raise result.ex
3086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3087 
 
4008 mandeep.dh 3088 
  def getTransactionsRequiringExtraProcessing(self, category):
3089 
    """
4065 mandeep.dh 3090 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3091 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3092 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3093 
 
4008 mandeep.dh 3094 
    Parameters:
3095 
     - category
3096 
    """
3097 
    self.send_getTransactionsRequiringExtraProcessing(category)
3098 
    return self.recv_getTransactionsRequiringExtraProcessing()
3099 
 
3100 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3101 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3102 
    args = getTransactionsRequiringExtraProcessing_args()
3103 
    args.category = category
3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = getTransactionsRequiringExtraProcessing_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3118 
    if result.success is not None:
3119 
      return result.success
3120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3121 
 
3122 
  def markTransactionAsProcessed(self, transactionId, category):
3123 
    """
3124 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3125 
    It essentially deletes the transaction id record for a particular
3126 
    processing type category (if present) from DB.
3127 
    This is currently used by CRM application.
4008 mandeep.dh 3128 
 
3129 
    Parameters:
3130 
     - transactionId
3131 
     - category
3132 
    """
3133 
    self.send_markTransactionAsProcessed(transactionId, category)
3134 
    self.recv_markTransactionAsProcessed()
3135 
 
3136 
  def send_markTransactionAsProcessed(self, transactionId, category):
3137 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3138 
    args = markTransactionAsProcessed_args()
3139 
    args.transactionId = transactionId
3140 
    args.category = category
3141 
    args.write(self._oprot)
3142 
    self._oprot.writeMessageEnd()
3143 
    self._oprot.trans.flush()
3144 
 
3145 
  def recv_markTransactionAsProcessed(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 = markTransactionAsProcessed_result()
3153 
    result.read(self._iprot)
3154 
    self._iprot.readMessageEnd()
3155 
    return
3156 
 
4018 chandransh 3157 
  def getItemWiseRiskyOrdersCount(self, ):
3158 
    """
3159 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3160 
    is defined as one whose shipping date is about to expire.
3161 
    """
3162 
    self.send_getItemWiseRiskyOrdersCount()
3163 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3164 
 
4018 chandransh 3165 
  def send_getItemWiseRiskyOrdersCount(self, ):
3166 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3167 
    args = getItemWiseRiskyOrdersCount_args()
3168 
    args.write(self._oprot)
3169 
    self._oprot.writeMessageEnd()
3170 
    self._oprot.trans.flush()
3171 
 
3172 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3174 
    if mtype == TMessageType.EXCEPTION:
3175 
      x = TApplicationException()
3176 
      x.read(self._iprot)
3177 
      self._iprot.readMessageEnd()
3178 
      raise x
3179 
    result = getItemWiseRiskyOrdersCount_result()
3180 
    result.read(self._iprot)
3181 
    self._iprot.readMessageEnd()
3182 
    if result.success is not None:
3183 
      return result.success
3184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3185 
 
4295 varun.gupt 3186 
  def getOrdersForItemIds(self, itemIds):
3187 
    """
3188 
    Returns a list of all orders which have items with given id
3189 
 
3190 
    Parameters:
3191 
     - itemIds
3192 
    """
3193 
    self.send_getOrdersForItemIds(itemIds)
3194 
    return self.recv_getOrdersForItemIds()
3195 
 
3196 
  def send_getOrdersForItemIds(self, itemIds):
3197 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3198 
    args = getOrdersForItemIds_args()
3199 
    args.itemIds = itemIds
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
3204 
  def recv_getOrdersForItemIds(self, ):
3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
3211 
    result = getOrdersForItemIds_result()
3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3214 
    if result.success is not None:
3215 
      return result.success
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3217 
 
4247 rajveer 3218 
  def markOrderCancellationRequestReceived(self, orderId):
3219 
    """
3220 
    Mark order as cancellation request received. If customer sends request of cancellation of
3221 
    a particular order, this method will be called. It will just change status of the order
3222 
    depending on its current status. It also records the previous status, so that we can move
3223 
    back to that status if cancellation request is denied.
4018 chandransh 3224 
 
4247 rajveer 3225 
    Parameters:
3226 
     - orderId
3227 
    """
3228 
    self.send_markOrderCancellationRequestReceived(orderId)
3229 
    self.recv_markOrderCancellationRequestReceived()
3230 
 
3231 
  def send_markOrderCancellationRequestReceived(self, orderId):
3232 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3233 
    args = markOrderCancellationRequestReceived_args()
3234 
    args.orderId = orderId
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_markOrderCancellationRequestReceived(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = markOrderCancellationRequestReceived_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.ex is not None:
3250 
      raise result.ex
3251 
    return
3252 
 
3253 
  def markOrderCancellationRequestConfirmed(self, orderId):
3254 
    """
3255 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3256 
    cancellation request confirmed. After this OM will be able to cancel the order.
3257 
 
3258 
    Parameters:
3259 
     - orderId
3260 
    """
3261 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3262 
    self.recv_markOrderCancellationRequestConfirmed()
3263 
 
3264 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3265 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3266 
    args = markOrderCancellationRequestConfirmed_args()
3267 
    args.orderId = orderId
3268 
    args.write(self._oprot)
3269 
    self._oprot.writeMessageEnd()
3270 
    self._oprot.trans.flush()
3271 
 
3272 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3274 
    if mtype == TMessageType.EXCEPTION:
3275 
      x = TApplicationException()
3276 
      x.read(self._iprot)
3277 
      self._iprot.readMessageEnd()
3278 
      raise x
3279 
    result = markOrderCancellationRequestConfirmed_result()
3280 
    result.read(self._iprot)
3281 
    self._iprot.readMessageEnd()
3282 
    if result.ex is not None:
3283 
      raise result.ex
3284 
    return
3285 
 
3286 
  def markOrderCancellationRequestDenied(self, orderId):
3287 
    """
3288 
    If we decide to not to cancel order, we will move the order ro previous status.
3289 
 
3290 
    Parameters:
3291 
     - orderId
3292 
    """
3293 
    self.send_markOrderCancellationRequestDenied(orderId)
3294 
    self.recv_markOrderCancellationRequestDenied()
3295 
 
3296 
  def send_markOrderCancellationRequestDenied(self, orderId):
3297 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3298 
    args = markOrderCancellationRequestDenied_args()
3299 
    args.orderId = orderId
3300 
    args.write(self._oprot)
3301 
    self._oprot.writeMessageEnd()
3302 
    self._oprot.trans.flush()
3303 
 
3304 
  def recv_markOrderCancellationRequestDenied(self, ):
3305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3306 
    if mtype == TMessageType.EXCEPTION:
3307 
      x = TApplicationException()
3308 
      x.read(self._iprot)
3309 
      self._iprot.readMessageEnd()
3310 
      raise x
3311 
    result = markOrderCancellationRequestDenied_result()
3312 
    result.read(self._iprot)
3313 
    self._iprot.readMessageEnd()
3314 
    if result.ex is not None:
3315 
      raise result.ex
3316 
    return
3317 
 
4258 rajveer 3318 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 3319 
    """
4258 rajveer 3320 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
3321 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 3322 
 
3323 
    Parameters:
4258 rajveer 3324 
     - transactionId
4247 rajveer 3325 
    """
4258 rajveer 3326 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
3327 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 3328 
 
4258 rajveer 3329 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
3330 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
3331 
    args = markTransactionAsPaymentFlagRemoved_args()
3332 
    args.transactionId = transactionId
4247 rajveer 3333 
    args.write(self._oprot)
3334 
    self._oprot.writeMessageEnd()
3335 
    self._oprot.trans.flush()
3336 
 
4258 rajveer 3337 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 3338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3339 
    if mtype == TMessageType.EXCEPTION:
3340 
      x = TApplicationException()
3341 
      x.read(self._iprot)
3342 
      self._iprot.readMessageEnd()
3343 
      raise x
4258 rajveer 3344 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 3345 
    result.read(self._iprot)
3346 
    self._iprot.readMessageEnd()
3347 
    if result.ex is not None:
3348 
      raise result.ex
3349 
    return
3350 
 
4259 anupam.sin 3351 
  def refundTransaction(self, transactionId, refundedBy, reason):
3352 
    """
3353 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
3354 
    need to be cancelled
4247 rajveer 3355 
 
4259 anupam.sin 3356 
    Parameters:
3357 
     - transactionId
3358 
     - refundedBy
3359 
     - reason
3360 
    """
3361 
    self.send_refundTransaction(transactionId, refundedBy, reason)
3362 
    self.recv_refundTransaction()
3363 
 
3364 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
3365 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
3366 
    args = refundTransaction_args()
3367 
    args.transactionId = transactionId
3368 
    args.refundedBy = refundedBy
3369 
    args.reason = reason
3370 
    args.write(self._oprot)
3371 
    self._oprot.writeMessageEnd()
3372 
    self._oprot.trans.flush()
3373 
 
3374 
  def recv_refundTransaction(self, ):
3375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3376 
    if mtype == TMessageType.EXCEPTION:
3377 
      x = TApplicationException()
3378 
      x.read(self._iprot)
3379 
      self._iprot.readMessageEnd()
3380 
      raise x
3381 
    result = refundTransaction_result()
3382 
    result.read(self._iprot)
3383 
    self._iprot.readMessageEnd()
3384 
    if result.ex is not None:
3385 
      raise result.ex
3386 
    return
3387 
 
4324 mandeep.dh 3388 
  def updateShipmentAddress(self, orderId, addressId):
3389 
    """
3390 
    Updates shipment address of an order. Delivery and shipping date estimates
3391 
    etc. are also updated here.
3392 
 
3393 
    Throws TransactionServiceException in case address change is not
3394 
    possible due to certain reasons such as new pincode in address is
3395 
    not serviceable etc.
3396 
 
3397 
    Parameters:
3398 
     - orderId
3399 
     - addressId
3400 
    """
3401 
    self.send_updateShipmentAddress(orderId, addressId)
3402 
    self.recv_updateShipmentAddress()
3403 
 
3404 
  def send_updateShipmentAddress(self, orderId, addressId):
3405 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
3406 
    args = updateShipmentAddress_args()
3407 
    args.orderId = orderId
3408 
    args.addressId = addressId
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_updateShipmentAddress(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = updateShipmentAddress_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    if result.ex is not None:
3424 
      raise result.ex
3425 
    return
3426 
 
4285 rajveer 3427 
  def acceptOrdersForItemId(self, itemId, inventory):
3428 
    """
3429 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
3430 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 3431 
 
4285 rajveer 3432 
    Parameters:
3433 
     - itemId
3434 
     - inventory
3435 
    """
3436 
    self.send_acceptOrdersForItemId(itemId, inventory)
3437 
    return self.recv_acceptOrdersForItemId()
3438 
 
3439 
  def send_acceptOrdersForItemId(self, itemId, inventory):
3440 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
3441 
    args = acceptOrdersForItemId_args()
3442 
    args.itemId = itemId
3443 
    args.inventory = inventory
3444 
    args.write(self._oprot)
3445 
    self._oprot.writeMessageEnd()
3446 
    self._oprot.trans.flush()
3447 
 
3448 
  def recv_acceptOrdersForItemId(self, ):
3449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3450 
    if mtype == TMessageType.EXCEPTION:
3451 
      x = TApplicationException()
3452 
      x.read(self._iprot)
3453 
      self._iprot.readMessageEnd()
3454 
      raise x
3455 
    result = acceptOrdersForItemId_result()
3456 
    result.read(self._iprot)
3457 
    self._iprot.readMessageEnd()
3458 
    if result.success is not None:
3459 
      return result.success
3460 
    if result.ex is not None:
3461 
      raise result.ex
3462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
3463 
 
4369 rajveer 3464 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3465 
    """
3466 
    Parameters:
3467 
     - vendorId
3468 
     - itemId
3469 
     - quantity
3470 
     - estimate
4369 rajveer 3471 
     - isReminder
4303 rajveer 3472 
    """
4369 rajveer 3473 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3474 
    self.recv_markOrdersAsPORaised()
4285 rajveer 3475 
 
4369 rajveer 3476 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3477 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
3478 
    args = markOrdersAsPORaised_args()
3479 
    args.vendorId = vendorId
3480 
    args.itemId = itemId
3481 
    args.quantity = quantity
3482 
    args.estimate = estimate
4369 rajveer 3483 
    args.isReminder = isReminder
4303 rajveer 3484 
    args.write(self._oprot)
3485 
    self._oprot.writeMessageEnd()
3486 
    self._oprot.trans.flush()
3487 
 
3488 
  def recv_markOrdersAsPORaised(self, ):
3489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3490 
    if mtype == TMessageType.EXCEPTION:
3491 
      x = TApplicationException()
3492 
      x.read(self._iprot)
3493 
      self._iprot.readMessageEnd()
3494 
      raise x
3495 
    result = markOrdersAsPORaised_result()
3496 
    result.read(self._iprot)
3497 
    self._iprot.readMessageEnd()
3498 
    if result.ex is not None:
3499 
      raise result.ex
3500 
    return
3501 
 
4369 rajveer 3502 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3503 
    """
3504 
    Parameters:
3505 
     - vendorId
3506 
     - itemId
3507 
     - quantity
3508 
     - estimate
4369 rajveer 3509 
     - isReminder
4303 rajveer 3510 
    """
4369 rajveer 3511 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3512 
    self.recv_markOrdersAsReversalInitiated()
3513 
 
4369 rajveer 3514 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3515 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
3516 
    args = markOrdersAsReversalInitiated_args()
3517 
    args.vendorId = vendorId
3518 
    args.itemId = itemId
3519 
    args.quantity = quantity
3520 
    args.estimate = estimate
4369 rajveer 3521 
    args.isReminder = isReminder
4303 rajveer 3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_markOrdersAsReversalInitiated(self, ):
3527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3528 
    if mtype == TMessageType.EXCEPTION:
3529 
      x = TApplicationException()
3530 
      x.read(self._iprot)
3531 
      self._iprot.readMessageEnd()
3532 
      raise x
3533 
    result = markOrdersAsReversalInitiated_result()
3534 
    result.read(self._iprot)
3535 
    self._iprot.readMessageEnd()
3536 
    if result.ex is not None:
3537 
      raise result.ex
3538 
    return
3539 
 
4369 rajveer 3540 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3541 
    """
3542 
    Parameters:
3543 
     - vendorId
3544 
     - itemId
3545 
     - quantity
3546 
     - estimate
4369 rajveer 3547 
     - isReminder
4303 rajveer 3548 
    """
4369 rajveer 3549 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 3550 
    self.recv_markOrdersAsNotAvailabke()
3551 
 
4369 rajveer 3552 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 3553 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
3554 
    args = markOrdersAsNotAvailabke_args()
3555 
    args.vendorId = vendorId
3556 
    args.itemId = itemId
3557 
    args.quantity = quantity
3558 
    args.estimate = estimate
4369 rajveer 3559 
    args.isReminder = isReminder
4303 rajveer 3560 
    args.write(self._oprot)
3561 
    self._oprot.writeMessageEnd()
3562 
    self._oprot.trans.flush()
3563 
 
3564 
  def recv_markOrdersAsNotAvailabke(self, ):
3565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3566 
    if mtype == TMessageType.EXCEPTION:
3567 
      x = TApplicationException()
3568 
      x.read(self._iprot)
3569 
      self._iprot.readMessageEnd()
3570 
      raise x
3571 
    result = markOrdersAsNotAvailabke_result()
3572 
    result.read(self._iprot)
3573 
    self._iprot.readMessageEnd()
3574 
    if result.ex is not None:
3575 
      raise result.ex
3576 
    return
3577 
 
4369 rajveer 3578 
  def markOrdersAsTimeout(self, vendorId):
3579 
    """
3580 
    Parameters:
3581 
     - vendorId
3582 
    """
3583 
    self.send_markOrdersAsTimeout(vendorId)
3584 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 3585 
 
4369 rajveer 3586 
  def send_markOrdersAsTimeout(self, vendorId):
3587 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
3588 
    args = markOrdersAsTimeout_args()
3589 
    args.vendorId = vendorId
3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
3594 
  def recv_markOrdersAsTimeout(self, ):
3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
3601 
    result = markOrdersAsTimeout_result()
3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
3604 
    if result.success is not None:
3605 
      return result.success
3606 
    if result.ex is not None:
3607 
      raise result.ex
3608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
3609 
 
4386 anupam.sin 3610 
  def getOrderForAwb(self, awb):
3611 
    """
3612 
    Returns the order corresponding to an AWB number
4369 rajveer 3613 
 
4386 anupam.sin 3614 
    Parameters:
3615 
     - awb
3616 
    """
3617 
    self.send_getOrderForAwb(awb)
3618 
    return self.recv_getOrderForAwb()
3619 
 
3620 
  def send_getOrderForAwb(self, awb):
3621 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
3622 
    args = getOrderForAwb_args()
3623 
    args.awb = awb
3624 
    args.write(self._oprot)
3625 
    self._oprot.writeMessageEnd()
3626 
    self._oprot.trans.flush()
3627 
 
3628 
  def recv_getOrderForAwb(self, ):
3629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3630 
    if mtype == TMessageType.EXCEPTION:
3631 
      x = TApplicationException()
3632 
      x.read(self._iprot)
3633 
      self._iprot.readMessageEnd()
3634 
      raise x
3635 
    result = getOrderForAwb_result()
3636 
    result.read(self._iprot)
3637 
    self._iprot.readMessageEnd()
3638 
    if result.success is not None:
3639 
      return result.success
3640 
    if result.ex is not None:
3641 
      raise result.ex
3642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
3643 
 
3644 
 
3376 rajveer 3645 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3646 
  def __init__(self, handler):
3376 rajveer 3647 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 3648 
    self._processMap["createTransaction"] = Processor.process_createTransaction
3649 
    self._processMap["getTransaction"] = Processor.process_getTransaction
3650 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 3651 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 3652 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
3653 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 3654 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 3655 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 3656 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
3657 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 3658 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 3659 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 3660 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
3661 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 3662 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
3663 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
3664 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
3665 
    self._processMap["createOrder"] = Processor.process_createOrder
3666 
    self._processMap["getOrder"] = Processor.process_getOrder
3667 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 3668 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 3669 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 3670 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 3671 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 3672 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
3673 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
3674 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
3675 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 3676 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 3677 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 3678 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
3679 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
3680 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
759 chandransh 3681 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
4410 rajveer 3682 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 3683 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 3684 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 3685 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 3686 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 3687 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
2536 chandransh 3688 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4454 rajveer 3689 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
3690 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 3691 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
3692 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 3693 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
3694 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 3695 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 3696 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 3697 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 3698 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
3699 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 3700 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 3701 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 3702 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 3703 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
3451 chandransh 3704 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 3705 
    self._processMap["changeItem"] = Processor.process_changeItem
3706 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 3707 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 3708 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 3709 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
3710 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 3711 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 3712 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 3713 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
3714 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
3715 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 3716 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 3717 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 3718 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 3719 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 3720 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
3721 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
3722 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 3723 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4386 anupam.sin 3724 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
94 ashish 3725 
 
3726 
  def process(self, iprot, oprot):
3727 
    (name, type, seqid) = iprot.readMessageBegin()
3728 
    if name not in self._processMap:
3729 
      iprot.skip(TType.STRUCT)
3730 
      iprot.readMessageEnd()
3731 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3732 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3733 
      x.write(oprot)
3734 
      oprot.writeMessageEnd()
3735 
      oprot.trans.flush()
3736 
      return
3737 
    else:
3738 
      self._processMap[name](self, seqid, iprot, oprot)
3739 
    return True
3740 
 
3741 
  def process_createTransaction(self, seqid, iprot, oprot):
3742 
    args = createTransaction_args()
3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
3745 
    result = createTransaction_result()
3746 
    try:
132 ashish 3747 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 3748 
    except TransactionServiceException, ex:
3749 
      result.ex = ex
3750 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
3751 
    result.write(oprot)
3752 
    oprot.writeMessageEnd()
3753 
    oprot.trans.flush()
3754 
 
3755 
  def process_getTransaction(self, seqid, iprot, oprot):
3756 
    args = getTransaction_args()
3757 
    args.read(iprot)
3758 
    iprot.readMessageEnd()
3759 
    result = getTransaction_result()
3760 
    try:
3761 
      result.success = self._handler.getTransaction(args.id)
3762 
    except TransactionServiceException, ex:
3763 
      result.ex = ex
3764 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
3765 
    result.write(oprot)
3766 
    oprot.writeMessageEnd()
3767 
    oprot.trans.flush()
3768 
 
3769 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
3770 
    args = getTransactionsForCustomer_args()
3771 
    args.read(iprot)
3772 
    iprot.readMessageEnd()
3773 
    result = getTransactionsForCustomer_result()
3774 
    try:
3775 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
3776 
    except TransactionServiceException, ex:
3777 
      result.ex = ex
3778 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
3779 
    result.write(oprot)
3780 
    oprot.writeMessageEnd()
3781 
    oprot.trans.flush()
3782 
 
132 ashish 3783 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
3784 
    args = getTransactionsForShoppingCartId_args()
3785 
    args.read(iprot)
3786 
    iprot.readMessageEnd()
3787 
    result = getTransactionsForShoppingCartId_result()
3788 
    try:
3789 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
3790 
    except TransactionServiceException, ex:
3791 
      result.ex = ex
3792 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
3793 
    result.write(oprot)
3794 
    oprot.writeMessageEnd()
3795 
    oprot.trans.flush()
3796 
 
94 ashish 3797 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
3798 
    args = getTransactionStatus_args()
3799 
    args.read(iprot)
3800 
    iprot.readMessageEnd()
3801 
    result = getTransactionStatus_result()
3802 
    try:
3803 
      result.success = self._handler.getTransactionStatus(args.transactionId)
3804 
    except TransactionServiceException, ex:
3805 
      result.ex = ex
3806 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
3807 
    result.write(oprot)
3808 
    oprot.writeMessageEnd()
3809 
    oprot.trans.flush()
3810 
 
3811 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
3812 
    args = changeTransactionStatus_args()
3813 
    args.read(iprot)
3814 
    iprot.readMessageEnd()
3815 
    result = changeTransactionStatus_result()
3816 
    try:
3817 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
3818 
    except TransactionServiceException, ex:
3819 
      result.ex = ex
3820 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
3821 
    result.write(oprot)
3822 
    oprot.writeMessageEnd()
3823 
    oprot.trans.flush()
3824 
 
1398 varun.gupt 3825 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
3826 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 3827 
    args.read(iprot)
3828 
    iprot.readMessageEnd()
1398 varun.gupt 3829 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 3830 
    try:
1398 varun.gupt 3831 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 3832 
    except TransactionServiceException, ex:
3833 
      result.ex = ex
1398 varun.gupt 3834 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 3835 
    result.write(oprot)
3836 
    oprot.writeMessageEnd()
3837 
    oprot.trans.flush()
3838 
 
483 rajveer 3839 
  def process_getAllOrders(self, seqid, iprot, oprot):
3840 
    args = getAllOrders_args()
94 ashish 3841 
    args.read(iprot)
3842 
    iprot.readMessageEnd()
483 rajveer 3843 
    result = getAllOrders_result()
94 ashish 3844 
    try:
483 rajveer 3845 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 3846 
    except TransactionServiceException, ex:
3847 
      result.ex = ex
483 rajveer 3848 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 3849 
    result.write(oprot)
3850 
    oprot.writeMessageEnd()
3851 
    oprot.trans.flush()
3852 
 
4133 chandransh 3853 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
3854 
    args = getOrdersInBatch_args()
3855 
    args.read(iprot)
3856 
    iprot.readMessageEnd()
3857 
    result = getOrdersInBatch_result()
3858 
    try:
3859 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
3860 
    except TransactionServiceException, ex:
3861 
      result.ex = ex
3862 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
3863 
    result.write(oprot)
3864 
    oprot.writeMessageEnd()
3865 
    oprot.trans.flush()
3866 
 
3867 
  def process_getOrderCount(self, seqid, iprot, oprot):
3868 
    args = getOrderCount_args()
3869 
    args.read(iprot)
3870 
    iprot.readMessageEnd()
3871 
    result = getOrderCount_result()
3872 
    try:
3873 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
3874 
    except TransactionServiceException, ex:
3875 
      result.ex = ex
3876 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
3877 
    result.write(oprot)
3878 
    oprot.writeMessageEnd()
3879 
    oprot.trans.flush()
3880 
 
999 varun.gupt 3881 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
3882 
    args = getOrdersByBillingDate_args()
3883 
    args.read(iprot)
3884 
    iprot.readMessageEnd()
3885 
    result = getOrdersByBillingDate_result()
3886 
    try:
3887 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
3888 
    except TransactionServiceException, ex:
3889 
      result.ex = ex
3890 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
3891 
    result.write(oprot)
3892 
    oprot.writeMessageEnd()
3893 
    oprot.trans.flush()
3894 
 
3427 chandransh 3895 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
3896 
    args = getOrdersByShippingDate_args()
3897 
    args.read(iprot)
3898 
    iprot.readMessageEnd()
3899 
    result = getOrdersByShippingDate_result()
3900 
    try:
3451 chandransh 3901 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 3902 
    except TransactionServiceException, ex:
3903 
      result.ex = ex
3904 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
3905 
    result.write(oprot)
3906 
    oprot.writeMessageEnd()
3907 
    oprot.trans.flush()
3908 
 
1382 varun.gupt 3909 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
3910 
    args = getReturnableOrdersForCustomer_args()
3911 
    args.read(iprot)
3912 
    iprot.readMessageEnd()
3913 
    result = getReturnableOrdersForCustomer_result()
3914 
    try:
3915 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
3916 
    except TransactionServiceException, ex:
3917 
      result.ex = ex
3918 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
3919 
    result.write(oprot)
3920 
    oprot.writeMessageEnd()
3921 
    oprot.trans.flush()
3922 
 
3923 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
3924 
    args = getCancellableOrdersForCustomer_args()
3925 
    args.read(iprot)
3926 
    iprot.readMessageEnd()
3927 
    result = getCancellableOrdersForCustomer_result()
3928 
    try:
3929 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
3930 
    except TransactionServiceException, ex:
3931 
      result.ex = ex
3932 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
3933 
    result.write(oprot)
3934 
    oprot.writeMessageEnd()
3935 
    oprot.trans.flush()
3936 
 
483 rajveer 3937 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
3938 
    args = changeOrderStatus_args()
94 ashish 3939 
    args.read(iprot)
3940 
    iprot.readMessageEnd()
483 rajveer 3941 
    result = changeOrderStatus_result()
94 ashish 3942 
    try:
483 rajveer 3943 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 3944 
    except TransactionServiceException, ex:
3945 
      result.ex = ex
483 rajveer 3946 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 3947 
    result.write(oprot)
3948 
    oprot.writeMessageEnd()
3949 
    oprot.trans.flush()
3950 
 
483 rajveer 3951 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
3952 
    args = getOrdersForTransaction_args()
94 ashish 3953 
    args.read(iprot)
3954 
    iprot.readMessageEnd()
483 rajveer 3955 
    result = getOrdersForTransaction_result()
94 ashish 3956 
    try:
1528 ankur.sing 3957 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 3958 
    except TransactionServiceException, ex:
3959 
      result.ex = ex
483 rajveer 3960 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 3961 
    result.write(oprot)
3962 
    oprot.writeMessageEnd()
3963 
    oprot.trans.flush()
3964 
 
483 rajveer 3965 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
3966 
    args = getOrdersForCustomer_args()
94 ashish 3967 
    args.read(iprot)
3968 
    iprot.readMessageEnd()
483 rajveer 3969 
    result = getOrdersForCustomer_result()
94 ashish 3970 
    try:
3014 chandransh 3971 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 3972 
    except TransactionServiceException, ex:
3973 
      result.ex = ex
483 rajveer 3974 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 3975 
    result.write(oprot)
3976 
    oprot.writeMessageEnd()
3977 
    oprot.trans.flush()
3978 
 
483 rajveer 3979 
  def process_createOrder(self, seqid, iprot, oprot):
3980 
    args = createOrder_args()
94 ashish 3981 
    args.read(iprot)
3982 
    iprot.readMessageEnd()
483 rajveer 3983 
    result = createOrder_result()
94 ashish 3984 
    try:
483 rajveer 3985 
      result.success = self._handler.createOrder(args.order)
94 ashish 3986 
    except TransactionServiceException, ex:
3987 
      result.ex = ex
483 rajveer 3988 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 3989 
    result.write(oprot)
3990 
    oprot.writeMessageEnd()
3991 
    oprot.trans.flush()
3992 
 
483 rajveer 3993 
  def process_getOrder(self, seqid, iprot, oprot):
3994 
    args = getOrder_args()
94 ashish 3995 
    args.read(iprot)
3996 
    iprot.readMessageEnd()
483 rajveer 3997 
    result = getOrder_result()
94 ashish 3998 
    try:
483 rajveer 3999 
      result.success = self._handler.getOrder(args.id)
94 ashish 4000 
    except TransactionServiceException, ex:
4001 
      result.ex = ex
483 rajveer 4002 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 4003 
    result.write(oprot)
4004 
    oprot.writeMessageEnd()
4005 
    oprot.trans.flush()
4006 
 
483 rajveer 4007 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
4008 
    args = getLineItemsForOrder_args()
94 ashish 4009 
    args.read(iprot)
4010 
    iprot.readMessageEnd()
483 rajveer 4011 
    result = getLineItemsForOrder_result()
94 ashish 4012 
    try:
483 rajveer 4013 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 4014 
    except TransactionServiceException, ex:
4015 
      result.ex = ex
483 rajveer 4016 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 4017 
    result.write(oprot)
4018 
    oprot.writeMessageEnd()
4019 
    oprot.trans.flush()
4020 
 
1528 ankur.sing 4021 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
4022 
    args = getOrderForCustomer_args()
4023 
    args.read(iprot)
4024 
    iprot.readMessageEnd()
4025 
    result = getOrderForCustomer_result()
4026 
    try:
4027 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
4028 
    except TransactionServiceException, ex:
4029 
      result.ex = ex
4030 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
4031 
    result.write(oprot)
4032 
    oprot.writeMessageEnd()
4033 
    oprot.trans.flush()
4034 
 
3064 chandransh 4035 
  def process_getAlerts(self, seqid, iprot, oprot):
4036 
    args = getAlerts_args()
4037 
    args.read(iprot)
4038 
    iprot.readMessageEnd()
4039 
    result = getAlerts_result()
4444 rajveer 4040 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 4041 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
4042 
    result.write(oprot)
4043 
    oprot.writeMessageEnd()
4044 
    oprot.trans.flush()
4045 
 
4394 rajveer 4046 
  def process_addAlert(self, seqid, iprot, oprot):
4047 
    args = addAlert_args()
3064 chandransh 4048 
    args.read(iprot)
4049 
    iprot.readMessageEnd()
4394 rajveer 4050 
    result = addAlert_result()
4444 rajveer 4051 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 4052 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 4053 
    result.write(oprot)
4054 
    oprot.writeMessageEnd()
4055 
    oprot.trans.flush()
4056 
 
4444 rajveer 4057 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
4058 
    args = markAlertsAsSeen_args()
4059 
    args.read(iprot)
4060 
    iprot.readMessageEnd()
4061 
    result = markAlertsAsSeen_result()
4062 
    self._handler.markAlertsAsSeen(args.warehouseId)
4063 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
4064 
    result.write(oprot)
4065 
    oprot.writeMessageEnd()
4066 
    oprot.trans.flush()
4067 
 
3064 chandransh 4068 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
4069 
    args = getValidOrderCount_args()
4070 
    args.read(iprot)
4071 
    iprot.readMessageEnd()
4072 
    result = getValidOrderCount_result()
4073 
    result.success = self._handler.getValidOrderCount()
4074 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
4075 
    result.write(oprot)
4076 
    oprot.writeMessageEnd()
4077 
    oprot.trans.flush()
4078 
 
4079 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
4080 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
4081 
    args.read(iprot)
4082 
    iprot.readMessageEnd()
4083 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
4084 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
4085 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
4086 
    result.write(oprot)
4087 
    oprot.writeMessageEnd()
4088 
    oprot.trans.flush()
4089 
 
4090 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
4091 
    args = getValidOrdersAmountRange_args()
4092 
    args.read(iprot)
4093 
    iprot.readMessageEnd()
4094 
    result = getValidOrdersAmountRange_result()
4095 
    result.success = self._handler.getValidOrdersAmountRange()
4096 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
4097 
    result.write(oprot)
4098 
    oprot.writeMessageEnd()
4099 
    oprot.trans.flush()
4100 
 
4101 
  def process_getValidOrders(self, seqid, iprot, oprot):
4102 
    args = getValidOrders_args()
4103 
    args.read(iprot)
4104 
    iprot.readMessageEnd()
4105 
    result = getValidOrders_result()
4106 
    result.success = self._handler.getValidOrders(args.limit)
4107 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
4108 
    result.write(oprot)
4109 
    oprot.writeMessageEnd()
4110 
    oprot.trans.flush()
4111 
 
1220 chandransh 4112 
  def process_batchOrders(self, seqid, iprot, oprot):
4113 
    args = batchOrders_args()
4114 
    args.read(iprot)
4115 
    iprot.readMessageEnd()
4116 
    result = batchOrders_result()
4117 
    try:
4118 
      result.success = self._handler.batchOrders(args.warehouseId)
4119 
    except TransactionServiceException, ex:
4120 
      result.ex = ex
4121 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
4122 
    result.write(oprot)
4123 
    oprot.writeMessageEnd()
4124 
    oprot.trans.flush()
4125 
 
1208 chandransh 4126 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
4127 
    args = markOrderAsOutOfStock_args()
4128 
    args.read(iprot)
4129 
    iprot.readMessageEnd()
4130 
    result = markOrderAsOutOfStock_result()
4131 
    try:
4132 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
4133 
    except TransactionServiceException, ex:
4134 
      result.ex = ex
4135 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
4136 
    result.write(oprot)
4137 
    oprot.writeMessageEnd()
4138 
    oprot.trans.flush()
4139 
 
3064 chandransh 4140 
  def process_verifyOrder(self, seqid, iprot, oprot):
4141 
    args = verifyOrder_args()
759 chandransh 4142 
    args.read(iprot)
4143 
    iprot.readMessageEnd()
3064 chandransh 4144 
    result = verifyOrder_result()
759 chandransh 4145 
    try:
3064 chandransh 4146 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 4147 
    except TransactionServiceException, ex:
4148 
      result.ex = ex
3064 chandransh 4149 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 4150 
    result.write(oprot)
4151 
    oprot.writeMessageEnd()
4152 
    oprot.trans.flush()
4153 
 
3064 chandransh 4154 
  def process_acceptOrder(self, seqid, iprot, oprot):
4155 
    args = acceptOrder_args()
1113 chandransh 4156 
    args.read(iprot)
4157 
    iprot.readMessageEnd()
3064 chandransh 4158 
    result = acceptOrder_result()
1113 chandransh 4159 
    try:
3064 chandransh 4160 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 4161 
    except TransactionServiceException, ex:
4162 
      result.ex = ex
3064 chandransh 4163 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 4164 
    result.write(oprot)
4165 
    oprot.writeMessageEnd()
4166 
    oprot.trans.flush()
4167 
 
3064 chandransh 4168 
  def process_addBillingDetails(self, seqid, iprot, oprot):
4169 
    args = addBillingDetails_args()
1135 chandransh 4170 
    args.read(iprot)
4171 
    iprot.readMessageEnd()
3064 chandransh 4172 
    result = addBillingDetails_result()
1135 chandransh 4173 
    try:
4283 anupam.sin 4174 
      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 4175 
    except TransactionServiceException, ex:
4176 
      result.ex = ex
3064 chandransh 4177 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 4178 
    result.write(oprot)
4179 
    oprot.writeMessageEnd()
4180 
    oprot.trans.flush()
4181 
 
3064 chandransh 4182 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
4183 
    args = markOrdersAsManifested_args()
1408 ankur.sing 4184 
    args.read(iprot)
4185 
    iprot.readMessageEnd()
3064 chandransh 4186 
    result = markOrdersAsManifested_result()
4187 
    try:
4188 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
4189 
    except TransactionServiceException, ex:
4190 
      result.ex = ex
4191 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
1408 ankur.sing 4192 
    result.write(oprot)
4193 
    oprot.writeMessageEnd()
4194 
    oprot.trans.flush()
4195 
 
4410 rajveer 4196 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
4197 
    args = markOrdersAsShippedFromWarehouse_args()
4198 
    args.read(iprot)
4199 
    iprot.readMessageEnd()
4200 
    result = markOrdersAsShippedFromWarehouse_result()
4201 
    try:
4202 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod)
4203 
    except TransactionServiceException, ex:
4204 
      result.ex = ex
4205 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
4206 
    result.write(oprot)
4207 
    oprot.writeMessageEnd()
4208 
    oprot.trans.flush()
4209 
 
3064 chandransh 4210 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
4211 
    args = markOrdersAsPickedUp_args()
304 ashish 4212 
    args.read(iprot)
4213 
    iprot.readMessageEnd()
3064 chandransh 4214 
    result = markOrdersAsPickedUp_result()
4215 
    try:
4216 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
4217 
    except TransactionServiceException, ex:
4218 
      result.ex = ex
4219 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 4220 
    result.write(oprot)
4221 
    oprot.writeMessageEnd()
4222 
    oprot.trans.flush()
94 ashish 4223 
 
3064 chandransh 4224 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
4225 
    args = markOrdersAsDelivered_args()
304 ashish 4226 
    args.read(iprot)
4227 
    iprot.readMessageEnd()
3064 chandransh 4228 
    result = markOrdersAsDelivered_result()
4229 
    try:
4230 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
4231 
    except TransactionServiceException, ex:
4232 
      result.ex = ex
4233 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 4234 
    result.write(oprot)
4235 
    oprot.writeMessageEnd()
4236 
    oprot.trans.flush()
4237 
 
3064 chandransh 4238 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
4239 
    args = markOrdersAsFailed_args()
1596 ankur.sing 4240 
    args.read(iprot)
4241 
    iprot.readMessageEnd()
3064 chandransh 4242 
    result = markOrdersAsFailed_result()
4243 
    try:
4244 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
4245 
    except TransactionServiceException, ex:
4246 
      result.ex = ex
4247 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
1596 ankur.sing 4248 
    result.write(oprot)
4249 
    oprot.writeMessageEnd()
4250 
    oprot.trans.flush()
304 ashish 4251 
 
3064 chandransh 4252 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
4253 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 4254 
    args.read(iprot)
4255 
    iprot.readMessageEnd()
3064 chandransh 4256 
    result = updateNonDeliveryReason_result()
4257 
    try:
4258 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
4259 
    except TransactionServiceException, ex:
4260 
      result.ex = ex
4261 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 4262 
    result.write(oprot)
4263 
    oprot.writeMessageEnd()
4264 
    oprot.trans.flush()
1596 ankur.sing 4265 
 
3064 chandransh 4266 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
4267 
    args = getUndeliveredOrders_args()
1627 ankur.sing 4268 
    args.read(iprot)
4269 
    iprot.readMessageEnd()
3064 chandransh 4270 
    result = getUndeliveredOrders_result()
4271 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
4272 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 4273 
    result.write(oprot)
4274 
    oprot.writeMessageEnd()
4275 
    oprot.trans.flush()
4276 
 
2536 chandransh 4277 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
4278 
    args = toggleDOAFlag_args()
4279 
    args.read(iprot)
4280 
    iprot.readMessageEnd()
4281 
    result = toggleDOAFlag_result()
4282 
    try:
4283 
      result.success = self._handler.toggleDOAFlag(args.orderId)
4284 
    except TransactionServiceException, ex:
4285 
      result.ex = ex
4286 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
4287 
    result.write(oprot)
4288 
    oprot.writeMessageEnd()
4289 
    oprot.trans.flush()
1886 ankur.sing 4290 
 
4454 rajveer 4291 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
4292 
    args = markOrderDoaRequestReceived_args()
4293 
    args.read(iprot)
4294 
    iprot.readMessageEnd()
4295 
    result = markOrderDoaRequestReceived_result()
4296 
    try:
4297 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
4298 
    except TransactionServiceException, ex:
4299 
      result.ex = ex
4300 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
4301 
    result.write(oprot)
4302 
    oprot.writeMessageEnd()
4303 
    oprot.trans.flush()
4304 
 
4305 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
4306 
    args = markOrderDoaRequestAuthorized_args()
4307 
    args.read(iprot)
4308 
    iprot.readMessageEnd()
4309 
    result = markOrderDoaRequestAuthorized_result()
4310 
    try:
4311 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
4312 
    except TransactionServiceException, ex:
4313 
      result.ex = ex
4314 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
4315 
    result.write(oprot)
4316 
    oprot.writeMessageEnd()
4317 
    oprot.trans.flush()
4318 
 
4488 rajveer 4319 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
4320 
    args = markOrderReturnRequestReceived_args()
4321 
    args.read(iprot)
4322 
    iprot.readMessageEnd()
4323 
    result = markOrderReturnRequestReceived_result()
4324 
    try:
4325 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
4326 
    except TransactionServiceException, ex:
4327 
      result.ex = ex
4328 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
4329 
    result.write(oprot)
4330 
    oprot.writeMessageEnd()
4331 
    oprot.trans.flush()
4332 
 
4333 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
4334 
    args = markOrderReturnRequestAuthorized_args()
4335 
    args.read(iprot)
4336 
    iprot.readMessageEnd()
4337 
    result = markOrderReturnRequestAuthorized_result()
4338 
    try:
4339 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
4340 
    except TransactionServiceException, ex:
4341 
      result.ex = ex
4342 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
4343 
    result.write(oprot)
4344 
    oprot.writeMessageEnd()
4345 
    oprot.trans.flush()
4346 
 
2536 chandransh 4347 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
4348 
    args = requestPickupNumber_args()
4349 
    args.read(iprot)
4350 
    iprot.readMessageEnd()
4351 
    result = requestPickupNumber_result()
4352 
    try:
4353 
      result.success = self._handler.requestPickupNumber(args.orderId)
4354 
    except TransactionServiceException, ex:
4355 
      result.ex = ex
4356 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
4357 
    result.write(oprot)
4358 
    oprot.writeMessageEnd()
4359 
    oprot.trans.flush()
4360 
 
4361 
  def process_authorizePickup(self, seqid, iprot, oprot):
4362 
    args = authorizePickup_args()
4363 
    args.read(iprot)
4364 
    iprot.readMessageEnd()
4365 
    result = authorizePickup_result()
4366 
    try:
4367 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
4368 
    except TransactionServiceException, ex:
4369 
      result.ex = ex
4370 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
4371 
    result.write(oprot)
4372 
    oprot.writeMessageEnd()
4373 
    oprot.trans.flush()
4374 
 
2764 chandransh 4375 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
4376 
    args = markDoasAsPickedUp_args()
4377 
    args.read(iprot)
4378 
    iprot.readMessageEnd()
4379 
    result = markDoasAsPickedUp_result()
4380 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
4381 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
4382 
    result.write(oprot)
4383 
    oprot.writeMessageEnd()
4384 
    oprot.trans.flush()
4385 
 
2616 chandransh 4386 
  def process_receiveReturn(self, seqid, iprot, oprot):
4387 
    args = receiveReturn_args()
2591 chandransh 4388 
    args.read(iprot)
4389 
    iprot.readMessageEnd()
2616 chandransh 4390 
    result = receiveReturn_result()
2591 chandransh 4391 
    try:
4479 rajveer 4392 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 4393 
    except TransactionServiceException, ex:
4394 
      result.ex = ex
2616 chandransh 4395 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
2536 chandransh 4399 
 
2591 chandransh 4400 
  def process_validateDoa(self, seqid, iprot, oprot):
4401 
    args = validateDoa_args()
4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
4404 
    result = validateDoa_result()
4405 
    try:
4406 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
4407 
    except TransactionServiceException, ex:
4408 
      result.ex = ex
4409 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
4410 
    result.write(oprot)
4411 
    oprot.writeMessageEnd()
4412 
    oprot.trans.flush()
4413 
 
2616 chandransh 4414 
  def process_reshipOrder(self, seqid, iprot, oprot):
4415 
    args = reshipOrder_args()
4416 
    args.read(iprot)
4417 
    iprot.readMessageEnd()
4418 
    result = reshipOrder_result()
4419 
    try:
4420 
      result.success = self._handler.reshipOrder(args.orderId)
4421 
    except TransactionServiceException, ex:
4422 
      result.ex = ex
4423 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
4424 
    result.write(oprot)
4425 
    oprot.writeMessageEnd()
4426 
    oprot.trans.flush()
2591 chandransh 4427 
 
2616 chandransh 4428 
  def process_refundOrder(self, seqid, iprot, oprot):
4429 
    args = refundOrder_args()
4430 
    args.read(iprot)
4431 
    iprot.readMessageEnd()
4432 
    result = refundOrder_result()
4433 
    try:
3226 chandransh 4434 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 4435 
    except TransactionServiceException, ex:
4436 
      result.ex = ex
4437 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
4438 
    result.write(oprot)
4439 
    oprot.writeMessageEnd()
4440 
    oprot.trans.flush()
4441 
 
2690 chandransh 4442 
  def process_getReturnOrders(self, seqid, iprot, oprot):
4443 
    args = getReturnOrders_args()
4444 
    args.read(iprot)
4445 
    iprot.readMessageEnd()
4446 
    result = getReturnOrders_result()
4447 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
4448 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
4449 
    result.write(oprot)
4450 
    oprot.writeMessageEnd()
4451 
    oprot.trans.flush()
2616 chandransh 4452 
 
2700 chandransh 4453 
  def process_getReturnOrder(self, seqid, iprot, oprot):
4454 
    args = getReturnOrder_args()
4455 
    args.read(iprot)
4456 
    iprot.readMessageEnd()
4457 
    result = getReturnOrder_result()
4458 
    try:
4459 
      result.success = self._handler.getReturnOrder(args.id)
4460 
    except TransactionServiceException, ex:
4461 
      result.ex = ex
4462 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
4463 
    result.write(oprot)
4464 
    oprot.writeMessageEnd()
4465 
    oprot.trans.flush()
4466 
 
2690 chandransh 4467 
  def process_processReturn(self, seqid, iprot, oprot):
4468 
    args = processReturn_args()
4469 
    args.read(iprot)
4470 
    iprot.readMessageEnd()
4471 
    result = processReturn_result()
4472 
    try:
4473 
      self._handler.processReturn(args.returnOrderId)
4474 
    except TransactionServiceException, ex:
4475 
      result.ex = ex
4476 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
4477 
    result.write(oprot)
4478 
    oprot.writeMessageEnd()
4479 
    oprot.trans.flush()
4480 
 
2819 chandransh 4481 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
4482 
    args = createPurchaseOrder_args()
4483 
    args.read(iprot)
4484 
    iprot.readMessageEnd()
4485 
    result = createPurchaseOrder_result()
4486 
    try:
4487 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
4488 
    except TransactionServiceException, ex:
4489 
      result.ex = ex
4490 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
4491 
    result.write(oprot)
4492 
    oprot.writeMessageEnd()
4493 
    oprot.trans.flush()
2690 chandransh 4494 
 
3451 chandransh 4495 
  def process_updateWeight(self, seqid, iprot, oprot):
4496 
    args = updateWeight_args()
4497 
    args.read(iprot)
4498 
    iprot.readMessageEnd()
4499 
    result = updateWeight_result()
4500 
    try:
4501 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
4502 
    except TransactionServiceException, ex:
4503 
      result.ex = ex
4504 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
2819 chandransh 4508 
 
3469 chandransh 4509 
  def process_changeItem(self, seqid, iprot, oprot):
4510 
    args = changeItem_args()
4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
4513 
    result = changeItem_result()
4514 
    try:
4515 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
4516 
    except TransactionServiceException, ex:
4517 
      result.ex = ex
4518 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
4519 
    result.write(oprot)
4520 
    oprot.writeMessageEnd()
4521 
    oprot.trans.flush()
3451 chandransh 4522 
 
3469 chandransh 4523 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
4524 
    args = shiftToWarehouse_args()
4525 
    args.read(iprot)
4526 
    iprot.readMessageEnd()
4527 
    result = shiftToWarehouse_result()
4528 
    try:
4529 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
4530 
    except TransactionServiceException, ex:
4531 
      result.ex = ex
4532 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
4533 
    result.write(oprot)
4534 
    oprot.writeMessageEnd()
4535 
    oprot.trans.flush()
4536 
 
3553 chandransh 4537 
  def process_addDelayReason(self, seqid, iprot, oprot):
4538 
    args = addDelayReason_args()
4539 
    args.read(iprot)
4540 
    iprot.readMessageEnd()
4541 
    result = addDelayReason_result()
4542 
    try:
3986 chandransh 4543 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay)
3553 chandransh 4544 
    except TransactionServiceException, ex:
4545 
      result.ex = ex
4546 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
4547 
    result.write(oprot)
4548 
    oprot.writeMessageEnd()
4549 
    oprot.trans.flush()
3469 chandransh 4550 
 
3956 chandransh 4551 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
4552 
    args = reconcileCodCollection_args()
4553 
    args.read(iprot)
4554 
    iprot.readMessageEnd()
4555 
    result = reconcileCodCollection_result()
4556 
    try:
4557 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
4558 
    except TransactionServiceException, ex:
4559 
      result.ex = ex
4560 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
4561 
    result.write(oprot)
4562 
    oprot.writeMessageEnd()
4563 
    oprot.trans.flush()
3553 chandransh 4564 
 
4008 mandeep.dh 4565 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
4566 
    args = getTransactionsRequiringExtraProcessing_args()
4567 
    args.read(iprot)
4568 
    iprot.readMessageEnd()
4569 
    result = getTransactionsRequiringExtraProcessing_result()
4570 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
4571 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
4572 
    result.write(oprot)
4573 
    oprot.writeMessageEnd()
4574 
    oprot.trans.flush()
3956 chandransh 4575 
 
4008 mandeep.dh 4576 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
4577 
    args = markTransactionAsProcessed_args()
4578 
    args.read(iprot)
4579 
    iprot.readMessageEnd()
4580 
    result = markTransactionAsProcessed_result()
4581 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
4582 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
4018 chandransh 4587 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
4588 
    args = getItemWiseRiskyOrdersCount_args()
4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
4591 
    result = getItemWiseRiskyOrdersCount_result()
4592 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
4593 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
4594 
    result.write(oprot)
4595 
    oprot.writeMessageEnd()
4596 
    oprot.trans.flush()
4008 mandeep.dh 4597 
 
4295 varun.gupt 4598 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
4599 
    args = getOrdersForItemIds_args()
4600 
    args.read(iprot)
4601 
    iprot.readMessageEnd()
4602 
    result = getOrdersForItemIds_result()
4603 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
4604 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
4608 
 
4247 rajveer 4609 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
4610 
    args = markOrderCancellationRequestReceived_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = markOrderCancellationRequestReceived_result()
4614 
    try:
4615 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
4616 
    except TransactionServiceException, ex:
4617 
      result.ex = ex
4618 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
4018 chandransh 4622 
 
4247 rajveer 4623 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
4624 
    args = markOrderCancellationRequestConfirmed_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = markOrderCancellationRequestConfirmed_result()
4628 
    try:
4629 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
4630 
    except TransactionServiceException, ex:
4631 
      result.ex = ex
4632 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
4633 
    result.write(oprot)
4634 
    oprot.writeMessageEnd()
4635 
    oprot.trans.flush()
4636 
 
4637 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
4638 
    args = markOrderCancellationRequestDenied_args()
4639 
    args.read(iprot)
4640 
    iprot.readMessageEnd()
4641 
    result = markOrderCancellationRequestDenied_result()
4642 
    try:
4643 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
4644 
    except TransactionServiceException, ex:
4645 
      result.ex = ex
4646 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
4647 
    result.write(oprot)
4648 
    oprot.writeMessageEnd()
4649 
    oprot.trans.flush()
4650 
 
4258 rajveer 4651 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
4652 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 4653 
    args.read(iprot)
4654 
    iprot.readMessageEnd()
4258 rajveer 4655 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4656 
    try:
4258 rajveer 4657 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 4658 
    except TransactionServiceException, ex:
4659 
      result.ex = ex
4258 rajveer 4660 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
4664 
 
4259 anupam.sin 4665 
  def process_refundTransaction(self, seqid, iprot, oprot):
4666 
    args = refundTransaction_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = refundTransaction_result()
4670 
    try:
4671 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
4672 
    except TransactionServiceException, ex:
4673 
      result.ex = ex
4674 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
4675 
    result.write(oprot)
4676 
    oprot.writeMessageEnd()
4677 
    oprot.trans.flush()
4247 rajveer 4678 
 
4324 mandeep.dh 4679 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
4680 
    args = updateShipmentAddress_args()
4681 
    args.read(iprot)
4682 
    iprot.readMessageEnd()
4683 
    result = updateShipmentAddress_result()
4684 
    try:
4685 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
4686 
    except TransactionServiceException, ex:
4687 
      result.ex = ex
4688 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
4689 
    result.write(oprot)
4690 
    oprot.writeMessageEnd()
4691 
    oprot.trans.flush()
4692 
 
4285 rajveer 4693 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
4694 
    args = acceptOrdersForItemId_args()
4695 
    args.read(iprot)
4696 
    iprot.readMessageEnd()
4697 
    result = acceptOrdersForItemId_result()
4698 
    try:
4699 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
4700 
    except TransactionServiceException, ex:
4701 
      result.ex = ex
4702 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
4703 
    result.write(oprot)
4704 
    oprot.writeMessageEnd()
4705 
    oprot.trans.flush()
4259 anupam.sin 4706 
 
4303 rajveer 4707 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
4708 
    args = markOrdersAsPORaised_args()
4709 
    args.read(iprot)
4710 
    iprot.readMessageEnd()
4711 
    result = markOrdersAsPORaised_result()
4712 
    try:
4369 rajveer 4713 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4714 
    except TransactionServiceException, ex:
4715 
      result.ex = ex
4716 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
4717 
    result.write(oprot)
4718 
    oprot.writeMessageEnd()
4719 
    oprot.trans.flush()
4285 rajveer 4720 
 
4303 rajveer 4721 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
4722 
    args = markOrdersAsReversalInitiated_args()
4723 
    args.read(iprot)
4724 
    iprot.readMessageEnd()
4725 
    result = markOrdersAsReversalInitiated_result()
4726 
    try:
4369 rajveer 4727 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4728 
    except TransactionServiceException, ex:
4729 
      result.ex = ex
4730 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
4731 
    result.write(oprot)
4732 
    oprot.writeMessageEnd()
4733 
    oprot.trans.flush()
4734 
 
4735 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
4736 
    args = markOrdersAsNotAvailabke_args()
4737 
    args.read(iprot)
4738 
    iprot.readMessageEnd()
4739 
    result = markOrdersAsNotAvailabke_result()
4740 
    try:
4369 rajveer 4741 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 4742 
    except TransactionServiceException, ex:
4743 
      result.ex = ex
4744 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
4745 
    result.write(oprot)
4746 
    oprot.writeMessageEnd()
4747 
    oprot.trans.flush()
4748 
 
4369 rajveer 4749 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
4750 
    args = markOrdersAsTimeout_args()
4751 
    args.read(iprot)
4752 
    iprot.readMessageEnd()
4753 
    result = markOrdersAsTimeout_result()
4754 
    try:
4755 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
4756 
    except TransactionServiceException, ex:
4757 
      result.ex = ex
4758 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
4759 
    result.write(oprot)
4760 
    oprot.writeMessageEnd()
4761 
    oprot.trans.flush()
4303 rajveer 4762 
 
4386 anupam.sin 4763 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
4764 
    args = getOrderForAwb_args()
4765 
    args.read(iprot)
4766 
    iprot.readMessageEnd()
4767 
    result = getOrderForAwb_result()
4768 
    try:
4769 
      result.success = self._handler.getOrderForAwb(args.awb)
4770 
    except TransactionServiceException, ex:
4771 
      result.ex = ex
4772 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
4773 
    result.write(oprot)
4774 
    oprot.writeMessageEnd()
4775 
    oprot.trans.flush()
4369 rajveer 4776 
 
4386 anupam.sin 4777 
 
94 ashish 4778 
# HELPER FUNCTIONS AND STRUCTURES
4779 
 
4780 
class createTransaction_args:
4781 
  """
4782 
  Attributes:
4783 
   - transaction
4784 
  """
4785 
 
4786 
  thrift_spec = (
4787 
    None, # 0
4788 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
4789 
  )
4790 
 
4791 
  def __init__(self, transaction=None,):
4792 
    self.transaction = transaction
4793 
 
4794 
  def read(self, iprot):
4795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4797 
      return
4798 
    iprot.readStructBegin()
4799 
    while True:
4800 
      (fname, ftype, fid) = iprot.readFieldBegin()
4801 
      if ftype == TType.STOP:
4802 
        break
4803 
      if fid == 1:
4804 
        if ftype == TType.STRUCT:
4805 
          self.transaction = Transaction()
4806 
          self.transaction.read(iprot)
4807 
        else:
4808 
          iprot.skip(ftype)
4809 
      else:
4810 
        iprot.skip(ftype)
4811 
      iprot.readFieldEnd()
4812 
    iprot.readStructEnd()
4813 
 
4814 
  def write(self, oprot):
4815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4817 
      return
4818 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 4819 
    if self.transaction is not None:
94 ashish 4820 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
4821 
      self.transaction.write(oprot)
4822 
      oprot.writeFieldEnd()
4823 
    oprot.writeFieldStop()
4824 
    oprot.writeStructEnd()
4825 
 
3431 rajveer 4826 
  def validate(self):
4827 
    return
4828 
 
4829 
 
94 ashish 4830 
  def __repr__(self):
4831 
    L = ['%s=%r' % (key, value)
4832 
      for key, value in self.__dict__.iteritems()]
4833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4834 
 
4835 
  def __eq__(self, other):
4836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4837 
 
4838 
  def __ne__(self, other):
4839 
    return not (self == other)
4840 
 
4841 
class createTransaction_result:
4842 
  """
4843 
  Attributes:
132 ashish 4844 
   - success
94 ashish 4845 
   - ex
4846 
  """
4847 
 
4848 
  thrift_spec = (
132 ashish 4849 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 4850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4851 
  )
4852 
 
132 ashish 4853 
  def __init__(self, success=None, ex=None,):
4854 
    self.success = success
94 ashish 4855 
    self.ex = ex
4856 
 
4857 
  def read(self, iprot):
4858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4860 
      return
4861 
    iprot.readStructBegin()
4862 
    while True:
4863 
      (fname, ftype, fid) = iprot.readFieldBegin()
4864 
      if ftype == TType.STOP:
4865 
        break
132 ashish 4866 
      if fid == 0:
4867 
        if ftype == TType.I64:
4868 
          self.success = iprot.readI64();
4869 
        else:
4870 
          iprot.skip(ftype)
4871 
      elif fid == 1:
94 ashish 4872 
        if ftype == TType.STRUCT:
4873 
          self.ex = TransactionServiceException()
4874 
          self.ex.read(iprot)
4875 
        else:
4876 
          iprot.skip(ftype)
4877 
      else:
4878 
        iprot.skip(ftype)
4879 
      iprot.readFieldEnd()
4880 
    iprot.readStructEnd()
4881 
 
4882 
  def write(self, oprot):
4883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4885 
      return
4886 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 4887 
    if self.success is not None:
132 ashish 4888 
      oprot.writeFieldBegin('success', TType.I64, 0)
4889 
      oprot.writeI64(self.success)
4890 
      oprot.writeFieldEnd()
3431 rajveer 4891 
    if self.ex is not None:
94 ashish 4892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4893 
      self.ex.write(oprot)
4894 
      oprot.writeFieldEnd()
4895 
    oprot.writeFieldStop()
4896 
    oprot.writeStructEnd()
4897 
 
3431 rajveer 4898 
  def validate(self):
4899 
    return
4900 
 
4901 
 
94 ashish 4902 
  def __repr__(self):
4903 
    L = ['%s=%r' % (key, value)
4904 
      for key, value in self.__dict__.iteritems()]
4905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4906 
 
4907 
  def __eq__(self, other):
4908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4909 
 
4910 
  def __ne__(self, other):
4911 
    return not (self == other)
4912 
 
4913 
class getTransaction_args:
4914 
  """
4915 
  Attributes:
4916 
   - id
4917 
  """
4918 
 
4919 
  thrift_spec = (
4920 
    None, # 0
4921 
    (1, TType.I64, 'id', None, None, ), # 1
4922 
  )
4923 
 
4924 
  def __init__(self, id=None,):
4925 
    self.id = id
4926 
 
4927 
  def read(self, iprot):
4928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4930 
      return
4931 
    iprot.readStructBegin()
4932 
    while True:
4933 
      (fname, ftype, fid) = iprot.readFieldBegin()
4934 
      if ftype == TType.STOP:
4935 
        break
4936 
      if fid == 1:
4937 
        if ftype == TType.I64:
4938 
          self.id = iprot.readI64();
4939 
        else:
4940 
          iprot.skip(ftype)
4941 
      else:
4942 
        iprot.skip(ftype)
4943 
      iprot.readFieldEnd()
4944 
    iprot.readStructEnd()
4945 
 
4946 
  def write(self, oprot):
4947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4949 
      return
4950 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 4951 
    if self.id is not None:
94 ashish 4952 
      oprot.writeFieldBegin('id', TType.I64, 1)
4953 
      oprot.writeI64(self.id)
4954 
      oprot.writeFieldEnd()
4955 
    oprot.writeFieldStop()
4956 
    oprot.writeStructEnd()
4957 
 
3431 rajveer 4958 
  def validate(self):
4959 
    return
4960 
 
4961 
 
94 ashish 4962 
  def __repr__(self):
4963 
    L = ['%s=%r' % (key, value)
4964 
      for key, value in self.__dict__.iteritems()]
4965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4966 
 
4967 
  def __eq__(self, other):
4968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4969 
 
4970 
  def __ne__(self, other):
4971 
    return not (self == other)
4972 
 
4973 
class getTransaction_result:
4974 
  """
4975 
  Attributes:
4976 
   - success
4977 
   - ex
4978 
  """
4979 
 
4980 
  thrift_spec = (
4981 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
4982 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4983 
  )
4984 
 
4985 
  def __init__(self, success=None, ex=None,):
4986 
    self.success = success
4987 
    self.ex = ex
4988 
 
4989 
  def read(self, iprot):
4990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4992 
      return
4993 
    iprot.readStructBegin()
4994 
    while True:
4995 
      (fname, ftype, fid) = iprot.readFieldBegin()
4996 
      if ftype == TType.STOP:
4997 
        break
4998 
      if fid == 0:
4999 
        if ftype == TType.STRUCT:
5000 
          self.success = Transaction()
5001 
          self.success.read(iprot)
5002 
        else:
5003 
          iprot.skip(ftype)
5004 
      elif fid == 1:
5005 
        if ftype == TType.STRUCT:
5006 
          self.ex = TransactionServiceException()
5007 
          self.ex.read(iprot)
5008 
        else:
5009 
          iprot.skip(ftype)
5010 
      else:
5011 
        iprot.skip(ftype)
5012 
      iprot.readFieldEnd()
5013 
    iprot.readStructEnd()
5014 
 
5015 
  def write(self, oprot):
5016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5018 
      return
5019 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 5020 
    if self.success is not None:
94 ashish 5021 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5022 
      self.success.write(oprot)
5023 
      oprot.writeFieldEnd()
3431 rajveer 5024 
    if self.ex is not None:
94 ashish 5025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5026 
      self.ex.write(oprot)
5027 
      oprot.writeFieldEnd()
5028 
    oprot.writeFieldStop()
5029 
    oprot.writeStructEnd()
5030 
 
3431 rajveer 5031 
  def validate(self):
5032 
    return
5033 
 
5034 
 
94 ashish 5035 
  def __repr__(self):
5036 
    L = ['%s=%r' % (key, value)
5037 
      for key, value in self.__dict__.iteritems()]
5038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5039 
 
5040 
  def __eq__(self, other):
5041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5042 
 
5043 
  def __ne__(self, other):
5044 
    return not (self == other)
5045 
 
5046 
class getTransactionsForCustomer_args:
5047 
  """
5048 
  Attributes:
5049 
   - customerId
5050 
   - from_date
5051 
   - to_date
5052 
   - status
5053 
  """
5054 
 
5055 
  thrift_spec = (
5056 
    None, # 0
5057 
    (1, TType.I64, 'customerId', None, None, ), # 1
5058 
    (2, TType.I64, 'from_date', None, None, ), # 2
5059 
    (3, TType.I64, 'to_date', None, None, ), # 3
5060 
    (4, TType.I32, 'status', None, None, ), # 4
5061 
  )
5062 
 
5063 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5064 
    self.customerId = customerId
5065 
    self.from_date = from_date
5066 
    self.to_date = to_date
5067 
    self.status = status
5068 
 
5069 
  def read(self, iprot):
5070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5072 
      return
5073 
    iprot.readStructBegin()
5074 
    while True:
5075 
      (fname, ftype, fid) = iprot.readFieldBegin()
5076 
      if ftype == TType.STOP:
5077 
        break
5078 
      if fid == 1:
5079 
        if ftype == TType.I64:
5080 
          self.customerId = iprot.readI64();
5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      elif fid == 2:
5084 
        if ftype == TType.I64:
5085 
          self.from_date = iprot.readI64();
5086 
        else:
5087 
          iprot.skip(ftype)
5088 
      elif fid == 3:
5089 
        if ftype == TType.I64:
5090 
          self.to_date = iprot.readI64();
5091 
        else:
5092 
          iprot.skip(ftype)
5093 
      elif fid == 4:
5094 
        if ftype == TType.I32:
5095 
          self.status = iprot.readI32();
5096 
        else:
5097 
          iprot.skip(ftype)
5098 
      else:
5099 
        iprot.skip(ftype)
5100 
      iprot.readFieldEnd()
5101 
    iprot.readStructEnd()
5102 
 
5103 
  def write(self, oprot):
5104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5106 
      return
5107 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 5108 
    if self.customerId is not None:
94 ashish 5109 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5110 
      oprot.writeI64(self.customerId)
5111 
      oprot.writeFieldEnd()
3431 rajveer 5112 
    if self.from_date is not None:
94 ashish 5113 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5114 
      oprot.writeI64(self.from_date)
5115 
      oprot.writeFieldEnd()
3431 rajveer 5116 
    if self.to_date is not None:
94 ashish 5117 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5118 
      oprot.writeI64(self.to_date)
5119 
      oprot.writeFieldEnd()
3431 rajveer 5120 
    if self.status is not None:
94 ashish 5121 
      oprot.writeFieldBegin('status', TType.I32, 4)
5122 
      oprot.writeI32(self.status)
5123 
      oprot.writeFieldEnd()
5124 
    oprot.writeFieldStop()
5125 
    oprot.writeStructEnd()
5126 
 
3431 rajveer 5127 
  def validate(self):
5128 
    return
5129 
 
5130 
 
94 ashish 5131 
  def __repr__(self):
5132 
    L = ['%s=%r' % (key, value)
5133 
      for key, value in self.__dict__.iteritems()]
5134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5135 
 
5136 
  def __eq__(self, other):
5137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5138 
 
5139 
  def __ne__(self, other):
5140 
    return not (self == other)
5141 
 
5142 
class getTransactionsForCustomer_result:
5143 
  """
5144 
  Attributes:
5145 
   - success
5146 
   - ex
5147 
  """
5148 
 
5149 
  thrift_spec = (
5150 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5152 
  )
5153 
 
5154 
  def __init__(self, success=None, ex=None,):
5155 
    self.success = success
5156 
    self.ex = ex
5157 
 
5158 
  def read(self, iprot):
5159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5161 
      return
5162 
    iprot.readStructBegin()
5163 
    while True:
5164 
      (fname, ftype, fid) = iprot.readFieldBegin()
5165 
      if ftype == TType.STOP:
5166 
        break
5167 
      if fid == 0:
5168 
        if ftype == TType.LIST:
5169 
          self.success = []
685 chandransh 5170 
          (_etype17, _size14) = iprot.readListBegin()
5171 
          for _i18 in xrange(_size14):
5172 
            _elem19 = Transaction()
5173 
            _elem19.read(iprot)
5174 
            self.success.append(_elem19)
94 ashish 5175 
          iprot.readListEnd()
5176 
        else:
5177 
          iprot.skip(ftype)
5178 
      elif fid == 1:
5179 
        if ftype == TType.STRUCT:
5180 
          self.ex = TransactionServiceException()
5181 
          self.ex.read(iprot)
5182 
        else:
5183 
          iprot.skip(ftype)
5184 
      else:
5185 
        iprot.skip(ftype)
5186 
      iprot.readFieldEnd()
5187 
    iprot.readStructEnd()
5188 
 
5189 
  def write(self, oprot):
5190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5192 
      return
5193 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 5194 
    if self.success is not None:
94 ashish 5195 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5196 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5197 
      for iter20 in self.success:
5198 
        iter20.write(oprot)
94 ashish 5199 
      oprot.writeListEnd()
5200 
      oprot.writeFieldEnd()
3431 rajveer 5201 
    if self.ex is not None:
94 ashish 5202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5203 
      self.ex.write(oprot)
5204 
      oprot.writeFieldEnd()
5205 
    oprot.writeFieldStop()
5206 
    oprot.writeStructEnd()
5207 
 
3431 rajveer 5208 
  def validate(self):
5209 
    return
5210 
 
5211 
 
94 ashish 5212 
  def __repr__(self):
5213 
    L = ['%s=%r' % (key, value)
5214 
      for key, value in self.__dict__.iteritems()]
5215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5216 
 
5217 
  def __eq__(self, other):
5218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5219 
 
5220 
  def __ne__(self, other):
5221 
    return not (self == other)
5222 
 
132 ashish 5223 
class getTransactionsForShoppingCartId_args:
5224 
  """
5225 
  Attributes:
5226 
   - shoppingCartId
5227 
  """
5228 
 
5229 
  thrift_spec = (
5230 
    None, # 0
5231 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
5232 
  )
5233 
 
5234 
  def __init__(self, shoppingCartId=None,):
5235 
    self.shoppingCartId = shoppingCartId
5236 
 
5237 
  def read(self, iprot):
5238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5240 
      return
5241 
    iprot.readStructBegin()
5242 
    while True:
5243 
      (fname, ftype, fid) = iprot.readFieldBegin()
5244 
      if ftype == TType.STOP:
5245 
        break
5246 
      if fid == 1:
5247 
        if ftype == TType.I64:
5248 
          self.shoppingCartId = iprot.readI64();
5249 
        else:
5250 
          iprot.skip(ftype)
5251 
      else:
5252 
        iprot.skip(ftype)
5253 
      iprot.readFieldEnd()
5254 
    iprot.readStructEnd()
5255 
 
5256 
  def write(self, oprot):
5257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5259 
      return
5260 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 5261 
    if self.shoppingCartId is not None:
132 ashish 5262 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
5263 
      oprot.writeI64(self.shoppingCartId)
5264 
      oprot.writeFieldEnd()
5265 
    oprot.writeFieldStop()
5266 
    oprot.writeStructEnd()
5267 
 
3431 rajveer 5268 
  def validate(self):
5269 
    return
5270 
 
5271 
 
132 ashish 5272 
  def __repr__(self):
5273 
    L = ['%s=%r' % (key, value)
5274 
      for key, value in self.__dict__.iteritems()]
5275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5276 
 
5277 
  def __eq__(self, other):
5278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5279 
 
5280 
  def __ne__(self, other):
5281 
    return not (self == other)
5282 
 
5283 
class getTransactionsForShoppingCartId_result:
5284 
  """
5285 
  Attributes:
5286 
   - success
5287 
   - ex
5288 
  """
5289 
 
5290 
  thrift_spec = (
5291 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
5292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5293 
  )
5294 
 
5295 
  def __init__(self, success=None, ex=None,):
5296 
    self.success = success
5297 
    self.ex = ex
5298 
 
5299 
  def read(self, iprot):
5300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5302 
      return
5303 
    iprot.readStructBegin()
5304 
    while True:
5305 
      (fname, ftype, fid) = iprot.readFieldBegin()
5306 
      if ftype == TType.STOP:
5307 
        break
5308 
      if fid == 0:
5309 
        if ftype == TType.LIST:
5310 
          self.success = []
685 chandransh 5311 
          (_etype24, _size21) = iprot.readListBegin()
5312 
          for _i25 in xrange(_size21):
5313 
            _elem26 = Transaction()
5314 
            _elem26.read(iprot)
5315 
            self.success.append(_elem26)
132 ashish 5316 
          iprot.readListEnd()
5317 
        else:
5318 
          iprot.skip(ftype)
5319 
      elif fid == 1:
5320 
        if ftype == TType.STRUCT:
5321 
          self.ex = TransactionServiceException()
5322 
          self.ex.read(iprot)
5323 
        else:
5324 
          iprot.skip(ftype)
5325 
      else:
5326 
        iprot.skip(ftype)
5327 
      iprot.readFieldEnd()
5328 
    iprot.readStructEnd()
5329 
 
5330 
  def write(self, oprot):
5331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5333 
      return
5334 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 5335 
    if self.success is not None:
132 ashish 5336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5337 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5338 
      for iter27 in self.success:
5339 
        iter27.write(oprot)
132 ashish 5340 
      oprot.writeListEnd()
5341 
      oprot.writeFieldEnd()
3431 rajveer 5342 
    if self.ex is not None:
132 ashish 5343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5344 
      self.ex.write(oprot)
5345 
      oprot.writeFieldEnd()
5346 
    oprot.writeFieldStop()
5347 
    oprot.writeStructEnd()
5348 
 
3431 rajveer 5349 
  def validate(self):
5350 
    return
5351 
 
5352 
 
132 ashish 5353 
  def __repr__(self):
5354 
    L = ['%s=%r' % (key, value)
5355 
      for key, value in self.__dict__.iteritems()]
5356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5357 
 
5358 
  def __eq__(self, other):
5359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5360 
 
5361 
  def __ne__(self, other):
5362 
    return not (self == other)
5363 
 
94 ashish 5364 
class getTransactionStatus_args:
5365 
  """
5366 
  Attributes:
5367 
   - transactionId
5368 
  """
5369 
 
5370 
  thrift_spec = (
5371 
    None, # 0
5372 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5373 
  )
5374 
 
5375 
  def __init__(self, transactionId=None,):
5376 
    self.transactionId = transactionId
5377 
 
5378 
  def read(self, iprot):
5379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5381 
      return
5382 
    iprot.readStructBegin()
5383 
    while True:
5384 
      (fname, ftype, fid) = iprot.readFieldBegin()
5385 
      if ftype == TType.STOP:
5386 
        break
5387 
      if fid == 1:
5388 
        if ftype == TType.I64:
5389 
          self.transactionId = iprot.readI64();
5390 
        else:
5391 
          iprot.skip(ftype)
5392 
      else:
5393 
        iprot.skip(ftype)
5394 
      iprot.readFieldEnd()
5395 
    iprot.readStructEnd()
5396 
 
5397 
  def write(self, oprot):
5398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5400 
      return
5401 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 5402 
    if self.transactionId is not None:
94 ashish 5403 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5404 
      oprot.writeI64(self.transactionId)
5405 
      oprot.writeFieldEnd()
5406 
    oprot.writeFieldStop()
5407 
    oprot.writeStructEnd()
5408 
 
3431 rajveer 5409 
  def validate(self):
5410 
    return
5411 
 
5412 
 
94 ashish 5413 
  def __repr__(self):
5414 
    L = ['%s=%r' % (key, value)
5415 
      for key, value in self.__dict__.iteritems()]
5416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5417 
 
5418 
  def __eq__(self, other):
5419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5420 
 
5421 
  def __ne__(self, other):
5422 
    return not (self == other)
5423 
 
5424 
class getTransactionStatus_result:
5425 
  """
5426 
  Attributes:
5427 
   - success
5428 
   - ex
5429 
  """
5430 
 
5431 
  thrift_spec = (
5432 
    (0, TType.I32, 'success', None, None, ), # 0
5433 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5434 
  )
5435 
 
5436 
  def __init__(self, success=None, ex=None,):
5437 
    self.success = success
5438 
    self.ex = ex
5439 
 
5440 
  def read(self, iprot):
5441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5443 
      return
5444 
    iprot.readStructBegin()
5445 
    while True:
5446 
      (fname, ftype, fid) = iprot.readFieldBegin()
5447 
      if ftype == TType.STOP:
5448 
        break
5449 
      if fid == 0:
5450 
        if ftype == TType.I32:
5451 
          self.success = iprot.readI32();
5452 
        else:
5453 
          iprot.skip(ftype)
5454 
      elif fid == 1:
5455 
        if ftype == TType.STRUCT:
5456 
          self.ex = TransactionServiceException()
5457 
          self.ex.read(iprot)
5458 
        else:
5459 
          iprot.skip(ftype)
5460 
      else:
5461 
        iprot.skip(ftype)
5462 
      iprot.readFieldEnd()
5463 
    iprot.readStructEnd()
5464 
 
5465 
  def write(self, oprot):
5466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5468 
      return
5469 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 5470 
    if self.success is not None:
94 ashish 5471 
      oprot.writeFieldBegin('success', TType.I32, 0)
5472 
      oprot.writeI32(self.success)
5473 
      oprot.writeFieldEnd()
3431 rajveer 5474 
    if self.ex is not None:
94 ashish 5475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5476 
      self.ex.write(oprot)
5477 
      oprot.writeFieldEnd()
5478 
    oprot.writeFieldStop()
5479 
    oprot.writeStructEnd()
5480 
 
3431 rajveer 5481 
  def validate(self):
5482 
    return
5483 
 
5484 
 
94 ashish 5485 
  def __repr__(self):
5486 
    L = ['%s=%r' % (key, value)
5487 
      for key, value in self.__dict__.iteritems()]
5488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5489 
 
5490 
  def __eq__(self, other):
5491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5492 
 
5493 
  def __ne__(self, other):
5494 
    return not (self == other)
5495 
 
5496 
class changeTransactionStatus_args:
5497 
  """
5498 
  Attributes:
5499 
   - transactionId
5500 
   - status
5501 
   - description
5502 
  """
5503 
 
5504 
  thrift_spec = (
5505 
    None, # 0
5506 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5507 
    (2, TType.I32, 'status', None, None, ), # 2
5508 
    (3, TType.STRING, 'description', None, None, ), # 3
5509 
  )
5510 
 
5511 
  def __init__(self, transactionId=None, status=None, description=None,):
5512 
    self.transactionId = transactionId
5513 
    self.status = status
5514 
    self.description = description
5515 
 
5516 
  def read(self, iprot):
5517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5519 
      return
5520 
    iprot.readStructBegin()
5521 
    while True:
5522 
      (fname, ftype, fid) = iprot.readFieldBegin()
5523 
      if ftype == TType.STOP:
5524 
        break
5525 
      if fid == 1:
5526 
        if ftype == TType.I64:
5527 
          self.transactionId = iprot.readI64();
5528 
        else:
5529 
          iprot.skip(ftype)
5530 
      elif fid == 2:
5531 
        if ftype == TType.I32:
5532 
          self.status = iprot.readI32();
5533 
        else:
5534 
          iprot.skip(ftype)
5535 
      elif fid == 3:
5536 
        if ftype == TType.STRING:
5537 
          self.description = iprot.readString();
5538 
        else:
5539 
          iprot.skip(ftype)
5540 
      else:
5541 
        iprot.skip(ftype)
5542 
      iprot.readFieldEnd()
5543 
    iprot.readStructEnd()
5544 
 
5545 
  def write(self, oprot):
5546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5548 
      return
5549 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 5550 
    if self.transactionId is not None:
94 ashish 5551 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5552 
      oprot.writeI64(self.transactionId)
5553 
      oprot.writeFieldEnd()
3431 rajveer 5554 
    if self.status is not None:
94 ashish 5555 
      oprot.writeFieldBegin('status', TType.I32, 2)
5556 
      oprot.writeI32(self.status)
5557 
      oprot.writeFieldEnd()
3431 rajveer 5558 
    if self.description is not None:
94 ashish 5559 
      oprot.writeFieldBegin('description', TType.STRING, 3)
5560 
      oprot.writeString(self.description)
5561 
      oprot.writeFieldEnd()
5562 
    oprot.writeFieldStop()
5563 
    oprot.writeStructEnd()
5564 
 
3431 rajveer 5565 
  def validate(self):
5566 
    return
5567 
 
5568 
 
94 ashish 5569 
  def __repr__(self):
5570 
    L = ['%s=%r' % (key, value)
5571 
      for key, value in self.__dict__.iteritems()]
5572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5573 
 
5574 
  def __eq__(self, other):
5575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5576 
 
5577 
  def __ne__(self, other):
5578 
    return not (self == other)
5579 
 
5580 
class changeTransactionStatus_result:
5581 
  """
5582 
  Attributes:
5583 
   - success
5584 
   - ex
5585 
  """
5586 
 
5587 
  thrift_spec = (
5588 
    (0, TType.BOOL, 'success', None, None, ), # 0
5589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5590 
  )
5591 
 
5592 
  def __init__(self, success=None, ex=None,):
5593 
    self.success = success
5594 
    self.ex = ex
5595 
 
5596 
  def read(self, iprot):
5597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5599 
      return
5600 
    iprot.readStructBegin()
5601 
    while True:
5602 
      (fname, ftype, fid) = iprot.readFieldBegin()
5603 
      if ftype == TType.STOP:
5604 
        break
5605 
      if fid == 0:
5606 
        if ftype == TType.BOOL:
5607 
          self.success = iprot.readBool();
5608 
        else:
5609 
          iprot.skip(ftype)
5610 
      elif fid == 1:
5611 
        if ftype == TType.STRUCT:
5612 
          self.ex = TransactionServiceException()
5613 
          self.ex.read(iprot)
5614 
        else:
5615 
          iprot.skip(ftype)
5616 
      else:
5617 
        iprot.skip(ftype)
5618 
      iprot.readFieldEnd()
5619 
    iprot.readStructEnd()
5620 
 
5621 
  def write(self, oprot):
5622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5624 
      return
5625 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 5626 
    if self.success is not None:
94 ashish 5627 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5628 
      oprot.writeBool(self.success)
5629 
      oprot.writeFieldEnd()
3431 rajveer 5630 
    if self.ex is not None:
94 ashish 5631 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5632 
      self.ex.write(oprot)
5633 
      oprot.writeFieldEnd()
5634 
    oprot.writeFieldStop()
5635 
    oprot.writeStructEnd()
5636 
 
3431 rajveer 5637 
  def validate(self):
5638 
    return
5639 
 
5640 
 
94 ashish 5641 
  def __repr__(self):
5642 
    L = ['%s=%r' % (key, value)
5643 
      for key, value in self.__dict__.iteritems()]
5644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5645 
 
5646 
  def __eq__(self, other):
5647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5648 
 
5649 
  def __ne__(self, other):
5650 
    return not (self == other)
5651 
 
1398 varun.gupt 5652 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 5653 
  """
5654 
  Attributes:
5655 
   - transactionId
5656 
  """
5657 
 
5658 
  thrift_spec = (
5659 
    None, # 0
5660 
    (1, TType.I64, 'transactionId', None, None, ), # 1
5661 
  )
5662 
 
5663 
  def __init__(self, transactionId=None,):
5664 
    self.transactionId = transactionId
5665 
 
5666 
  def read(self, iprot):
5667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5669 
      return
5670 
    iprot.readStructBegin()
5671 
    while True:
5672 
      (fname, ftype, fid) = iprot.readFieldBegin()
5673 
      if ftype == TType.STOP:
5674 
        break
5675 
      if fid == 1:
5676 
        if ftype == TType.I64:
5677 
          self.transactionId = iprot.readI64();
5678 
        else:
5679 
          iprot.skip(ftype)
5680 
      else:
5681 
        iprot.skip(ftype)
5682 
      iprot.readFieldEnd()
5683 
    iprot.readStructEnd()
5684 
 
5685 
  def write(self, oprot):
5686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5688 
      return
1398 varun.gupt 5689 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 5690 
    if self.transactionId is not None:
1382 varun.gupt 5691 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5692 
      oprot.writeI64(self.transactionId)
5693 
      oprot.writeFieldEnd()
5694 
    oprot.writeFieldStop()
5695 
    oprot.writeStructEnd()
5696 
 
3431 rajveer 5697 
  def validate(self):
5698 
    return
5699 
 
5700 
 
1382 varun.gupt 5701 
  def __repr__(self):
5702 
    L = ['%s=%r' % (key, value)
5703 
      for key, value in self.__dict__.iteritems()]
5704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5705 
 
5706 
  def __eq__(self, other):
5707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5708 
 
5709 
  def __ne__(self, other):
5710 
    return not (self == other)
5711 
 
1398 varun.gupt 5712 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 5713 
  """
5714 
  Attributes:
5715 
   - success
5716 
   - ex
5717 
  """
5718 
 
5719 
  thrift_spec = (
5720 
    (0, TType.BOOL, 'success', None, None, ), # 0
5721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5722 
  )
5723 
 
5724 
  def __init__(self, success=None, ex=None,):
5725 
    self.success = success
5726 
    self.ex = ex
5727 
 
5728 
  def read(self, iprot):
5729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5731 
      return
5732 
    iprot.readStructBegin()
5733 
    while True:
5734 
      (fname, ftype, fid) = iprot.readFieldBegin()
5735 
      if ftype == TType.STOP:
5736 
        break
5737 
      if fid == 0:
5738 
        if ftype == TType.BOOL:
5739 
          self.success = iprot.readBool();
5740 
        else:
5741 
          iprot.skip(ftype)
5742 
      elif fid == 1:
5743 
        if ftype == TType.STRUCT:
5744 
          self.ex = TransactionServiceException()
5745 
          self.ex.read(iprot)
5746 
        else:
5747 
          iprot.skip(ftype)
5748 
      else:
5749 
        iprot.skip(ftype)
5750 
      iprot.readFieldEnd()
5751 
    iprot.readStructEnd()
5752 
 
5753 
  def write(self, oprot):
5754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5756 
      return
1398 varun.gupt 5757 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 5758 
    if self.success is not None:
1382 varun.gupt 5759 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5760 
      oprot.writeBool(self.success)
5761 
      oprot.writeFieldEnd()
3431 rajveer 5762 
    if self.ex is not None:
1382 varun.gupt 5763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5764 
      self.ex.write(oprot)
5765 
      oprot.writeFieldEnd()
5766 
    oprot.writeFieldStop()
5767 
    oprot.writeStructEnd()
5768 
 
3431 rajveer 5769 
  def validate(self):
5770 
    return
5771 
 
5772 
 
1382 varun.gupt 5773 
  def __repr__(self):
5774 
    L = ['%s=%r' % (key, value)
5775 
      for key, value in self.__dict__.iteritems()]
5776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5777 
 
5778 
  def __eq__(self, other):
5779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5780 
 
5781 
  def __ne__(self, other):
5782 
    return not (self == other)
5783 
 
483 rajveer 5784 
class getAllOrders_args:
94 ashish 5785 
  """
5786 
  Attributes:
483 rajveer 5787 
   - status
5788 
   - from_date
5789 
   - to_date
5790 
   - warehouse_id
94 ashish 5791 
  """
5792 
 
5793 
  thrift_spec = (
5794 
    None, # 0
483 rajveer 5795 
    (1, TType.I32, 'status', None, None, ), # 1
5796 
    (2, TType.I64, 'from_date', None, None, ), # 2
5797 
    (3, TType.I64, 'to_date', None, None, ), # 3
5798 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 5799 
  )
5800 
 
483 rajveer 5801 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
5802 
    self.status = status
5803 
    self.from_date = from_date
5804 
    self.to_date = to_date
5805 
    self.warehouse_id = warehouse_id
94 ashish 5806 
 
5807 
  def read(self, iprot):
5808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5810 
      return
5811 
    iprot.readStructBegin()
5812 
    while True:
5813 
      (fname, ftype, fid) = iprot.readFieldBegin()
5814 
      if ftype == TType.STOP:
5815 
        break
5816 
      if fid == 1:
483 rajveer 5817 
        if ftype == TType.I32:
5818 
          self.status = iprot.readI32();
94 ashish 5819 
        else:
5820 
          iprot.skip(ftype)
483 rajveer 5821 
      elif fid == 2:
5822 
        if ftype == TType.I64:
5823 
          self.from_date = iprot.readI64();
94 ashish 5824 
        else:
5825 
          iprot.skip(ftype)
483 rajveer 5826 
      elif fid == 3:
5827 
        if ftype == TType.I64:
5828 
          self.to_date = iprot.readI64();
94 ashish 5829 
        else:
5830 
          iprot.skip(ftype)
483 rajveer 5831 
      elif fid == 4:
94 ashish 5832 
        if ftype == TType.I64:
483 rajveer 5833 
          self.warehouse_id = iprot.readI64();
94 ashish 5834 
        else:
5835 
          iprot.skip(ftype)
5836 
      else:
5837 
        iprot.skip(ftype)
5838 
      iprot.readFieldEnd()
5839 
    iprot.readStructEnd()
5840 
 
5841 
  def write(self, oprot):
5842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5844 
      return
483 rajveer 5845 
    oprot.writeStructBegin('getAllOrders_args')
3431 rajveer 5846 
    if self.status is not None:
483 rajveer 5847 
      oprot.writeFieldBegin('status', TType.I32, 1)
5848 
      oprot.writeI32(self.status)
94 ashish 5849 
      oprot.writeFieldEnd()
3431 rajveer 5850 
    if self.from_date is not None:
483 rajveer 5851 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5852 
      oprot.writeI64(self.from_date)
94 ashish 5853 
      oprot.writeFieldEnd()
3431 rajveer 5854 
    if self.to_date is not None:
483 rajveer 5855 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5856 
      oprot.writeI64(self.to_date)
94 ashish 5857 
      oprot.writeFieldEnd()
3431 rajveer 5858 
    if self.warehouse_id is not None:
483 rajveer 5859 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
5860 
      oprot.writeI64(self.warehouse_id)
94 ashish 5861 
      oprot.writeFieldEnd()
5862 
    oprot.writeFieldStop()
5863 
    oprot.writeStructEnd()
5864 
 
3431 rajveer 5865 
  def validate(self):
5866 
    return
5867 
 
5868 
 
94 ashish 5869 
  def __repr__(self):
5870 
    L = ['%s=%r' % (key, value)
5871 
      for key, value in self.__dict__.iteritems()]
5872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5873 
 
5874 
  def __eq__(self, other):
5875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5876 
 
5877 
  def __ne__(self, other):
5878 
    return not (self == other)
5879 
 
483 rajveer 5880 
class getAllOrders_result:
94 ashish 5881 
  """
5882 
  Attributes:
5883 
   - success
5884 
   - ex
5885 
  """
5886 
 
5887 
  thrift_spec = (
483 rajveer 5888 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5890 
  )
5891 
 
5892 
  def __init__(self, success=None, ex=None,):
5893 
    self.success = success
5894 
    self.ex = ex
5895 
 
5896 
  def read(self, iprot):
5897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5899 
      return
5900 
    iprot.readStructBegin()
5901 
    while True:
5902 
      (fname, ftype, fid) = iprot.readFieldBegin()
5903 
      if ftype == TType.STOP:
5904 
        break
5905 
      if fid == 0:
483 rajveer 5906 
        if ftype == TType.LIST:
5907 
          self.success = []
685 chandransh 5908 
          (_etype31, _size28) = iprot.readListBegin()
5909 
          for _i32 in xrange(_size28):
5910 
            _elem33 = Order()
5911 
            _elem33.read(iprot)
5912 
            self.success.append(_elem33)
483 rajveer 5913 
          iprot.readListEnd()
94 ashish 5914 
        else:
5915 
          iprot.skip(ftype)
5916 
      elif fid == 1:
5917 
        if ftype == TType.STRUCT:
5918 
          self.ex = TransactionServiceException()
5919 
          self.ex.read(iprot)
5920 
        else:
5921 
          iprot.skip(ftype)
5922 
      else:
5923 
        iprot.skip(ftype)
5924 
      iprot.readFieldEnd()
5925 
    iprot.readStructEnd()
5926 
 
5927 
  def write(self, oprot):
5928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5930 
      return
483 rajveer 5931 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 5932 
    if self.success is not None:
483 rajveer 5933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5934 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 5935 
      for iter34 in self.success:
5936 
        iter34.write(oprot)
483 rajveer 5937 
      oprot.writeListEnd()
94 ashish 5938 
      oprot.writeFieldEnd()
3431 rajveer 5939 
    if self.ex is not None:
94 ashish 5940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5941 
      self.ex.write(oprot)
5942 
      oprot.writeFieldEnd()
5943 
    oprot.writeFieldStop()
5944 
    oprot.writeStructEnd()
5945 
 
3431 rajveer 5946 
  def validate(self):
5947 
    return
5948 
 
5949 
 
94 ashish 5950 
  def __repr__(self):
5951 
    L = ['%s=%r' % (key, value)
5952 
      for key, value in self.__dict__.iteritems()]
5953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5954 
 
5955 
  def __eq__(self, other):
5956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5957 
 
5958 
  def __ne__(self, other):
5959 
    return not (self == other)
5960 
 
4133 chandransh 5961 
class getOrdersInBatch_args:
5962 
  """
5963 
  Attributes:
5964 
   - statuses
5965 
   - offset
5966 
   - limit
5967 
   - warehouse_id
5968 
  """
5969 
 
5970 
  thrift_spec = (
5971 
    None, # 0
5972 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
5973 
    (2, TType.I64, 'offset', None, None, ), # 2
5974 
    (3, TType.I64, 'limit', None, None, ), # 3
5975 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
5976 
  )
5977 
 
5978 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
5979 
    self.statuses = statuses
5980 
    self.offset = offset
5981 
    self.limit = limit
5982 
    self.warehouse_id = warehouse_id
5983 
 
5984 
  def read(self, iprot):
5985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5987 
      return
5988 
    iprot.readStructBegin()
5989 
    while True:
5990 
      (fname, ftype, fid) = iprot.readFieldBegin()
5991 
      if ftype == TType.STOP:
5992 
        break
5993 
      if fid == 1:
5994 
        if ftype == TType.LIST:
5995 
          self.statuses = []
5996 
          (_etype38, _size35) = iprot.readListBegin()
5997 
          for _i39 in xrange(_size35):
5998 
            _elem40 = iprot.readI32();
5999 
            self.statuses.append(_elem40)
6000 
          iprot.readListEnd()
6001 
        else:
6002 
          iprot.skip(ftype)
6003 
      elif fid == 2:
6004 
        if ftype == TType.I64:
6005 
          self.offset = iprot.readI64();
6006 
        else:
6007 
          iprot.skip(ftype)
6008 
      elif fid == 3:
6009 
        if ftype == TType.I64:
6010 
          self.limit = iprot.readI64();
6011 
        else:
6012 
          iprot.skip(ftype)
6013 
      elif fid == 4:
6014 
        if ftype == TType.I64:
6015 
          self.warehouse_id = iprot.readI64();
6016 
        else:
6017 
          iprot.skip(ftype)
6018 
      else:
6019 
        iprot.skip(ftype)
6020 
      iprot.readFieldEnd()
6021 
    iprot.readStructEnd()
6022 
 
6023 
  def write(self, oprot):
6024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6026 
      return
6027 
    oprot.writeStructBegin('getOrdersInBatch_args')
6028 
    if self.statuses is not None:
6029 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6030 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 
      for iter41 in self.statuses:
6032 
        oprot.writeI32(iter41)
6033 
      oprot.writeListEnd()
6034 
      oprot.writeFieldEnd()
6035 
    if self.offset is not None:
6036 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6037 
      oprot.writeI64(self.offset)
6038 
      oprot.writeFieldEnd()
6039 
    if self.limit is not None:
6040 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6041 
      oprot.writeI64(self.limit)
6042 
      oprot.writeFieldEnd()
6043 
    if self.warehouse_id is not None:
6044 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6045 
      oprot.writeI64(self.warehouse_id)
6046 
      oprot.writeFieldEnd()
6047 
    oprot.writeFieldStop()
6048 
    oprot.writeStructEnd()
6049 
 
6050 
  def validate(self):
6051 
    return
6052 
 
6053 
 
6054 
  def __repr__(self):
6055 
    L = ['%s=%r' % (key, value)
6056 
      for key, value in self.__dict__.iteritems()]
6057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6058 
 
6059 
  def __eq__(self, other):
6060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6061 
 
6062 
  def __ne__(self, other):
6063 
    return not (self == other)
6064 
 
6065 
class getOrdersInBatch_result:
6066 
  """
6067 
  Attributes:
6068 
   - success
6069 
   - ex
6070 
  """
6071 
 
6072 
  thrift_spec = (
6073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6075 
  )
6076 
 
6077 
  def __init__(self, success=None, ex=None,):
6078 
    self.success = success
6079 
    self.ex = ex
6080 
 
6081 
  def read(self, iprot):
6082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6084 
      return
6085 
    iprot.readStructBegin()
6086 
    while True:
6087 
      (fname, ftype, fid) = iprot.readFieldBegin()
6088 
      if ftype == TType.STOP:
6089 
        break
6090 
      if fid == 0:
6091 
        if ftype == TType.LIST:
6092 
          self.success = []
6093 
          (_etype45, _size42) = iprot.readListBegin()
6094 
          for _i46 in xrange(_size42):
6095 
            _elem47 = Order()
6096 
            _elem47.read(iprot)
6097 
            self.success.append(_elem47)
6098 
          iprot.readListEnd()
6099 
        else:
6100 
          iprot.skip(ftype)
6101 
      elif fid == 1:
6102 
        if ftype == TType.STRUCT:
6103 
          self.ex = TransactionServiceException()
6104 
          self.ex.read(iprot)
6105 
        else:
6106 
          iprot.skip(ftype)
6107 
      else:
6108 
        iprot.skip(ftype)
6109 
      iprot.readFieldEnd()
6110 
    iprot.readStructEnd()
6111 
 
6112 
  def write(self, oprot):
6113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6115 
      return
6116 
    oprot.writeStructBegin('getOrdersInBatch_result')
6117 
    if self.success is not None:
6118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6120 
      for iter48 in self.success:
6121 
        iter48.write(oprot)
6122 
      oprot.writeListEnd()
6123 
      oprot.writeFieldEnd()
6124 
    if self.ex is not None:
6125 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6126 
      self.ex.write(oprot)
6127 
      oprot.writeFieldEnd()
6128 
    oprot.writeFieldStop()
6129 
    oprot.writeStructEnd()
6130 
 
6131 
  def validate(self):
6132 
    return
6133 
 
6134 
 
6135 
  def __repr__(self):
6136 
    L = ['%s=%r' % (key, value)
6137 
      for key, value in self.__dict__.iteritems()]
6138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6139 
 
6140 
  def __eq__(self, other):
6141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6142 
 
6143 
  def __ne__(self, other):
6144 
    return not (self == other)
6145 
 
6146 
class getOrderCount_args:
6147 
  """
6148 
  Attributes:
6149 
   - statuses
6150 
   - warehouseId
6151 
  """
6152 
 
6153 
  thrift_spec = (
6154 
    None, # 0
6155 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
6156 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6157 
  )
6158 
 
6159 
  def __init__(self, statuses=None, warehouseId=None,):
6160 
    self.statuses = statuses
6161 
    self.warehouseId = warehouseId
6162 
 
6163 
  def read(self, iprot):
6164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6166 
      return
6167 
    iprot.readStructBegin()
6168 
    while True:
6169 
      (fname, ftype, fid) = iprot.readFieldBegin()
6170 
      if ftype == TType.STOP:
6171 
        break
6172 
      if fid == 1:
6173 
        if ftype == TType.LIST:
6174 
          self.statuses = []
6175 
          (_etype52, _size49) = iprot.readListBegin()
6176 
          for _i53 in xrange(_size49):
6177 
            _elem54 = iprot.readI32();
6178 
            self.statuses.append(_elem54)
6179 
          iprot.readListEnd()
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      elif fid == 2:
6183 
        if ftype == TType.I64:
6184 
          self.warehouseId = iprot.readI64();
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      else:
6188 
        iprot.skip(ftype)
6189 
      iprot.readFieldEnd()
6190 
    iprot.readStructEnd()
6191 
 
6192 
  def write(self, oprot):
6193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6195 
      return
6196 
    oprot.writeStructBegin('getOrderCount_args')
6197 
    if self.statuses is not None:
6198 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
6199 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6200 
      for iter55 in self.statuses:
6201 
        oprot.writeI32(iter55)
6202 
      oprot.writeListEnd()
6203 
      oprot.writeFieldEnd()
6204 
    if self.warehouseId is not None:
6205 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6206 
      oprot.writeI64(self.warehouseId)
6207 
      oprot.writeFieldEnd()
6208 
    oprot.writeFieldStop()
6209 
    oprot.writeStructEnd()
6210 
 
6211 
  def validate(self):
6212 
    return
6213 
 
6214 
 
6215 
  def __repr__(self):
6216 
    L = ['%s=%r' % (key, value)
6217 
      for key, value in self.__dict__.iteritems()]
6218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6219 
 
6220 
  def __eq__(self, other):
6221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6222 
 
6223 
  def __ne__(self, other):
6224 
    return not (self == other)
6225 
 
6226 
class getOrderCount_result:
6227 
  """
6228 
  Attributes:
6229 
   - success
6230 
   - ex
6231 
  """
6232 
 
6233 
  thrift_spec = (
6234 
    (0, TType.I32, 'success', None, None, ), # 0
6235 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6236 
  )
6237 
 
6238 
  def __init__(self, success=None, ex=None,):
6239 
    self.success = success
6240 
    self.ex = ex
6241 
 
6242 
  def read(self, iprot):
6243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6245 
      return
6246 
    iprot.readStructBegin()
6247 
    while True:
6248 
      (fname, ftype, fid) = iprot.readFieldBegin()
6249 
      if ftype == TType.STOP:
6250 
        break
6251 
      if fid == 0:
6252 
        if ftype == TType.I32:
6253 
          self.success = iprot.readI32();
6254 
        else:
6255 
          iprot.skip(ftype)
6256 
      elif fid == 1:
6257 
        if ftype == TType.STRUCT:
6258 
          self.ex = TransactionServiceException()
6259 
          self.ex.read(iprot)
6260 
        else:
6261 
          iprot.skip(ftype)
6262 
      else:
6263 
        iprot.skip(ftype)
6264 
      iprot.readFieldEnd()
6265 
    iprot.readStructEnd()
6266 
 
6267 
  def write(self, oprot):
6268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6270 
      return
6271 
    oprot.writeStructBegin('getOrderCount_result')
6272 
    if self.success is not None:
6273 
      oprot.writeFieldBegin('success', TType.I32, 0)
6274 
      oprot.writeI32(self.success)
6275 
      oprot.writeFieldEnd()
6276 
    if self.ex is not None:
6277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6278 
      self.ex.write(oprot)
6279 
      oprot.writeFieldEnd()
6280 
    oprot.writeFieldStop()
6281 
    oprot.writeStructEnd()
6282 
 
6283 
  def validate(self):
6284 
    return
6285 
 
6286 
 
6287 
  def __repr__(self):
6288 
    L = ['%s=%r' % (key, value)
6289 
      for key, value in self.__dict__.iteritems()]
6290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6291 
 
6292 
  def __eq__(self, other):
6293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6294 
 
6295 
  def __ne__(self, other):
6296 
    return not (self == other)
6297 
 
999 varun.gupt 6298 
class getOrdersByBillingDate_args:
6299 
  """
6300 
  Attributes:
6301 
   - status
6302 
   - start_billing_date
6303 
   - end_billing_date
6304 
   - warehouse_id
6305 
  """
6306 
 
6307 
  thrift_spec = (
6308 
    None, # 0
6309 
    (1, TType.I32, 'status', None, None, ), # 1
6310 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
6311 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
6312 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
6313 
  )
6314 
 
6315 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
6316 
    self.status = status
6317 
    self.start_billing_date = start_billing_date
6318 
    self.end_billing_date = end_billing_date
6319 
    self.warehouse_id = warehouse_id
6320 
 
6321 
  def read(self, iprot):
6322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6324 
      return
6325 
    iprot.readStructBegin()
6326 
    while True:
6327 
      (fname, ftype, fid) = iprot.readFieldBegin()
6328 
      if ftype == TType.STOP:
6329 
        break
6330 
      if fid == 1:
6331 
        if ftype == TType.I32:
6332 
          self.status = iprot.readI32();
6333 
        else:
6334 
          iprot.skip(ftype)
6335 
      elif fid == 2:
6336 
        if ftype == TType.I64:
6337 
          self.start_billing_date = iprot.readI64();
6338 
        else:
6339 
          iprot.skip(ftype)
6340 
      elif fid == 3:
6341 
        if ftype == TType.I64:
6342 
          self.end_billing_date = iprot.readI64();
6343 
        else:
6344 
          iprot.skip(ftype)
6345 
      elif fid == 4:
6346 
        if ftype == TType.I64:
6347 
          self.warehouse_id = iprot.readI64();
6348 
        else:
6349 
          iprot.skip(ftype)
6350 
      else:
6351 
        iprot.skip(ftype)
6352 
      iprot.readFieldEnd()
6353 
    iprot.readStructEnd()
6354 
 
6355 
  def write(self, oprot):
6356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6358 
      return
6359 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 6360 
    if self.status is not None:
999 varun.gupt 6361 
      oprot.writeFieldBegin('status', TType.I32, 1)
6362 
      oprot.writeI32(self.status)
6363 
      oprot.writeFieldEnd()
3431 rajveer 6364 
    if self.start_billing_date is not None:
999 varun.gupt 6365 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
6366 
      oprot.writeI64(self.start_billing_date)
6367 
      oprot.writeFieldEnd()
3431 rajveer 6368 
    if self.end_billing_date is not None:
999 varun.gupt 6369 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
6370 
      oprot.writeI64(self.end_billing_date)
6371 
      oprot.writeFieldEnd()
3431 rajveer 6372 
    if self.warehouse_id is not None:
999 varun.gupt 6373 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
6374 
      oprot.writeI64(self.warehouse_id)
6375 
      oprot.writeFieldEnd()
6376 
    oprot.writeFieldStop()
6377 
    oprot.writeStructEnd()
6378 
 
3431 rajveer 6379 
  def validate(self):
6380 
    return
6381 
 
6382 
 
999 varun.gupt 6383 
  def __repr__(self):
6384 
    L = ['%s=%r' % (key, value)
6385 
      for key, value in self.__dict__.iteritems()]
6386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6387 
 
6388 
  def __eq__(self, other):
6389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6390 
 
6391 
  def __ne__(self, other):
6392 
    return not (self == other)
6393 
 
6394 
class getOrdersByBillingDate_result:
6395 
  """
6396 
  Attributes:
6397 
   - success
6398 
   - ex
6399 
  """
6400 
 
6401 
  thrift_spec = (
6402 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6403 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6404 
  )
6405 
 
6406 
  def __init__(self, success=None, ex=None,):
6407 
    self.success = success
6408 
    self.ex = ex
6409 
 
6410 
  def read(self, iprot):
6411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6413 
      return
6414 
    iprot.readStructBegin()
6415 
    while True:
6416 
      (fname, ftype, fid) = iprot.readFieldBegin()
6417 
      if ftype == TType.STOP:
6418 
        break
6419 
      if fid == 0:
6420 
        if ftype == TType.LIST:
6421 
          self.success = []
4133 chandransh 6422 
          (_etype59, _size56) = iprot.readListBegin()
6423 
          for _i60 in xrange(_size56):
6424 
            _elem61 = Order()
6425 
            _elem61.read(iprot)
6426 
            self.success.append(_elem61)
999 varun.gupt 6427 
          iprot.readListEnd()
6428 
        else:
6429 
          iprot.skip(ftype)
6430 
      elif fid == 1:
6431 
        if ftype == TType.STRUCT:
6432 
          self.ex = TransactionServiceException()
6433 
          self.ex.read(iprot)
6434 
        else:
6435 
          iprot.skip(ftype)
6436 
      else:
6437 
        iprot.skip(ftype)
6438 
      iprot.readFieldEnd()
6439 
    iprot.readStructEnd()
6440 
 
6441 
  def write(self, oprot):
6442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6444 
      return
6445 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 6446 
    if self.success is not None:
999 varun.gupt 6447 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6448 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6449 
      for iter62 in self.success:
6450 
        iter62.write(oprot)
999 varun.gupt 6451 
      oprot.writeListEnd()
6452 
      oprot.writeFieldEnd()
3431 rajveer 6453 
    if self.ex is not None:
999 varun.gupt 6454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6455 
      self.ex.write(oprot)
6456 
      oprot.writeFieldEnd()
6457 
    oprot.writeFieldStop()
6458 
    oprot.writeStructEnd()
6459 
 
3431 rajveer 6460 
  def validate(self):
6461 
    return
6462 
 
6463 
 
999 varun.gupt 6464 
  def __repr__(self):
6465 
    L = ['%s=%r' % (key, value)
6466 
      for key, value in self.__dict__.iteritems()]
6467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6468 
 
6469 
  def __eq__(self, other):
6470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6471 
 
6472 
  def __ne__(self, other):
6473 
    return not (self == other)
6474 
 
3427 chandransh 6475 
class getOrdersByShippingDate_args:
6476 
  """
6477 
  Attributes:
6478 
   - fromShippingDate
6479 
   - toShippingDate
6480 
   - providerId
6481 
   - warehouseId
3451 chandransh 6482 
   - cod
3427 chandransh 6483 
  """
6484 
 
6485 
  thrift_spec = (
6486 
    None, # 0
6487 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
6488 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
6489 
    (3, TType.I64, 'providerId', None, None, ), # 3
6490 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 6491 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 6492 
  )
6493 
 
3451 chandransh 6494 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 6495 
    self.fromShippingDate = fromShippingDate
6496 
    self.toShippingDate = toShippingDate
6497 
    self.providerId = providerId
6498 
    self.warehouseId = warehouseId
3451 chandransh 6499 
    self.cod = cod
3427 chandransh 6500 
 
6501 
  def read(self, iprot):
6502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6504 
      return
6505 
    iprot.readStructBegin()
6506 
    while True:
6507 
      (fname, ftype, fid) = iprot.readFieldBegin()
6508 
      if ftype == TType.STOP:
6509 
        break
6510 
      if fid == 1:
6511 
        if ftype == TType.I64:
6512 
          self.fromShippingDate = iprot.readI64();
6513 
        else:
6514 
          iprot.skip(ftype)
6515 
      elif fid == 2:
6516 
        if ftype == TType.I64:
6517 
          self.toShippingDate = iprot.readI64();
6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      elif fid == 3:
6521 
        if ftype == TType.I64:
6522 
          self.providerId = iprot.readI64();
6523 
        else:
6524 
          iprot.skip(ftype)
6525 
      elif fid == 4:
6526 
        if ftype == TType.I64:
6527 
          self.warehouseId = iprot.readI64();
6528 
        else:
6529 
          iprot.skip(ftype)
3451 chandransh 6530 
      elif fid == 5:
6531 
        if ftype == TType.BOOL:
6532 
          self.cod = iprot.readBool();
6533 
        else:
6534 
          iprot.skip(ftype)
3427 chandransh 6535 
      else:
6536 
        iprot.skip(ftype)
6537 
      iprot.readFieldEnd()
6538 
    iprot.readStructEnd()
6539 
 
6540 
  def write(self, oprot):
6541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6543 
      return
6544 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 6545 
    if self.fromShippingDate is not None:
3427 chandransh 6546 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
6547 
      oprot.writeI64(self.fromShippingDate)
6548 
      oprot.writeFieldEnd()
3431 rajveer 6549 
    if self.toShippingDate is not None:
3427 chandransh 6550 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
6551 
      oprot.writeI64(self.toShippingDate)
6552 
      oprot.writeFieldEnd()
3431 rajveer 6553 
    if self.providerId is not None:
3427 chandransh 6554 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
6555 
      oprot.writeI64(self.providerId)
6556 
      oprot.writeFieldEnd()
3431 rajveer 6557 
    if self.warehouseId is not None:
3427 chandransh 6558 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6559 
      oprot.writeI64(self.warehouseId)
6560 
      oprot.writeFieldEnd()
3451 chandransh 6561 
    if self.cod is not None:
6562 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
6563 
      oprot.writeBool(self.cod)
6564 
      oprot.writeFieldEnd()
3427 chandransh 6565 
    oprot.writeFieldStop()
6566 
    oprot.writeStructEnd()
6567 
 
3431 rajveer 6568 
  def validate(self):
6569 
    return
6570 
 
6571 
 
3427 chandransh 6572 
  def __repr__(self):
6573 
    L = ['%s=%r' % (key, value)
6574 
      for key, value in self.__dict__.iteritems()]
6575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6576 
 
6577 
  def __eq__(self, other):
6578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6579 
 
6580 
  def __ne__(self, other):
6581 
    return not (self == other)
6582 
 
6583 
class getOrdersByShippingDate_result:
6584 
  """
6585 
  Attributes:
6586 
   - success
6587 
   - ex
6588 
  """
6589 
 
6590 
  thrift_spec = (
6591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6593 
  )
6594 
 
6595 
  def __init__(self, success=None, ex=None,):
6596 
    self.success = success
6597 
    self.ex = ex
6598 
 
6599 
  def read(self, iprot):
6600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6602 
      return
6603 
    iprot.readStructBegin()
6604 
    while True:
6605 
      (fname, ftype, fid) = iprot.readFieldBegin()
6606 
      if ftype == TType.STOP:
6607 
        break
6608 
      if fid == 0:
6609 
        if ftype == TType.LIST:
6610 
          self.success = []
4133 chandransh 6611 
          (_etype66, _size63) = iprot.readListBegin()
6612 
          for _i67 in xrange(_size63):
6613 
            _elem68 = Order()
6614 
            _elem68.read(iprot)
6615 
            self.success.append(_elem68)
3427 chandransh 6616 
          iprot.readListEnd()
6617 
        else:
6618 
          iprot.skip(ftype)
6619 
      elif fid == 1:
6620 
        if ftype == TType.STRUCT:
6621 
          self.ex = TransactionServiceException()
6622 
          self.ex.read(iprot)
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      else:
6626 
        iprot.skip(ftype)
6627 
      iprot.readFieldEnd()
6628 
    iprot.readStructEnd()
6629 
 
6630 
  def write(self, oprot):
6631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6633 
      return
6634 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 6635 
    if self.success is not None:
3427 chandransh 6636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 6638 
      for iter69 in self.success:
6639 
        iter69.write(oprot)
3427 chandransh 6640 
      oprot.writeListEnd()
6641 
      oprot.writeFieldEnd()
3431 rajveer 6642 
    if self.ex is not None:
3427 chandransh 6643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6644 
      self.ex.write(oprot)
6645 
      oprot.writeFieldEnd()
6646 
    oprot.writeFieldStop()
6647 
    oprot.writeStructEnd()
6648 
 
3431 rajveer 6649 
  def validate(self):
6650 
    return
6651 
 
6652 
 
3427 chandransh 6653 
  def __repr__(self):
6654 
    L = ['%s=%r' % (key, value)
6655 
      for key, value in self.__dict__.iteritems()]
6656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6657 
 
6658 
  def __eq__(self, other):
6659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6660 
 
6661 
  def __ne__(self, other):
6662 
    return not (self == other)
6663 
 
1382 varun.gupt 6664 
class getReturnableOrdersForCustomer_args:
6665 
  """
6666 
  Attributes:
6667 
   - customer_id
6668 
   - limit
6669 
  """
6670 
 
6671 
  thrift_spec = (
6672 
    None, # 0
6673 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6674 
    (2, TType.I64, 'limit', None, None, ), # 2
6675 
  )
6676 
 
6677 
  def __init__(self, customer_id=None, limit=None,):
6678 
    self.customer_id = customer_id
6679 
    self.limit = limit
6680 
 
6681 
  def read(self, iprot):
6682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6684 
      return
6685 
    iprot.readStructBegin()
6686 
    while True:
6687 
      (fname, ftype, fid) = iprot.readFieldBegin()
6688 
      if ftype == TType.STOP:
6689 
        break
6690 
      if fid == 1:
6691 
        if ftype == TType.I64:
6692 
          self.customer_id = iprot.readI64();
6693 
        else:
6694 
          iprot.skip(ftype)
6695 
      elif fid == 2:
6696 
        if ftype == TType.I64:
6697 
          self.limit = iprot.readI64();
6698 
        else:
6699 
          iprot.skip(ftype)
6700 
      else:
6701 
        iprot.skip(ftype)
6702 
      iprot.readFieldEnd()
6703 
    iprot.readStructEnd()
6704 
 
6705 
  def write(self, oprot):
6706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6708 
      return
6709 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 6710 
    if self.customer_id is not None:
1382 varun.gupt 6711 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6712 
      oprot.writeI64(self.customer_id)
6713 
      oprot.writeFieldEnd()
3431 rajveer 6714 
    if self.limit is not None:
1382 varun.gupt 6715 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6716 
      oprot.writeI64(self.limit)
6717 
      oprot.writeFieldEnd()
6718 
    oprot.writeFieldStop()
6719 
    oprot.writeStructEnd()
6720 
 
3431 rajveer 6721 
  def validate(self):
6722 
    return
6723 
 
6724 
 
1382 varun.gupt 6725 
  def __repr__(self):
6726 
    L = ['%s=%r' % (key, value)
6727 
      for key, value in self.__dict__.iteritems()]
6728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6729 
 
6730 
  def __eq__(self, other):
6731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6732 
 
6733 
  def __ne__(self, other):
6734 
    return not (self == other)
6735 
 
6736 
class getReturnableOrdersForCustomer_result:
6737 
  """
6738 
  Attributes:
6739 
   - success
6740 
   - ex
6741 
  """
6742 
 
6743 
  thrift_spec = (
6744 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6745 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6746 
  )
6747 
 
6748 
  def __init__(self, success=None, ex=None,):
6749 
    self.success = success
6750 
    self.ex = ex
6751 
 
6752 
  def read(self, iprot):
6753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6755 
      return
6756 
    iprot.readStructBegin()
6757 
    while True:
6758 
      (fname, ftype, fid) = iprot.readFieldBegin()
6759 
      if ftype == TType.STOP:
6760 
        break
6761 
      if fid == 0:
6762 
        if ftype == TType.LIST:
6763 
          self.success = []
4133 chandransh 6764 
          (_etype73, _size70) = iprot.readListBegin()
6765 
          for _i74 in xrange(_size70):
6766 
            _elem75 = iprot.readI64();
6767 
            self.success.append(_elem75)
1382 varun.gupt 6768 
          iprot.readListEnd()
6769 
        else:
6770 
          iprot.skip(ftype)
6771 
      elif fid == 1:
6772 
        if ftype == TType.STRUCT:
6773 
          self.ex = TransactionServiceException()
6774 
          self.ex.read(iprot)
6775 
        else:
6776 
          iprot.skip(ftype)
6777 
      else:
6778 
        iprot.skip(ftype)
6779 
      iprot.readFieldEnd()
6780 
    iprot.readStructEnd()
6781 
 
6782 
  def write(self, oprot):
6783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6785 
      return
6786 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 6787 
    if self.success is not None:
1382 varun.gupt 6788 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6789 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6790 
      for iter76 in self.success:
6791 
        oprot.writeI64(iter76)
1382 varun.gupt 6792 
      oprot.writeListEnd()
6793 
      oprot.writeFieldEnd()
3431 rajveer 6794 
    if self.ex is not None:
1382 varun.gupt 6795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6796 
      self.ex.write(oprot)
6797 
      oprot.writeFieldEnd()
6798 
    oprot.writeFieldStop()
6799 
    oprot.writeStructEnd()
6800 
 
3431 rajveer 6801 
  def validate(self):
6802 
    return
6803 
 
6804 
 
1382 varun.gupt 6805 
  def __repr__(self):
6806 
    L = ['%s=%r' % (key, value)
6807 
      for key, value in self.__dict__.iteritems()]
6808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6809 
 
6810 
  def __eq__(self, other):
6811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6812 
 
6813 
  def __ne__(self, other):
6814 
    return not (self == other)
6815 
 
6816 
class getCancellableOrdersForCustomer_args:
6817 
  """
6818 
  Attributes:
6819 
   - customer_id
6820 
   - limit
6821 
  """
6822 
 
6823 
  thrift_spec = (
6824 
    None, # 0
6825 
    (1, TType.I64, 'customer_id', None, None, ), # 1
6826 
    (2, TType.I64, 'limit', None, None, ), # 2
6827 
  )
6828 
 
6829 
  def __init__(self, customer_id=None, limit=None,):
6830 
    self.customer_id = customer_id
6831 
    self.limit = limit
6832 
 
6833 
  def read(self, iprot):
6834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6836 
      return
6837 
    iprot.readStructBegin()
6838 
    while True:
6839 
      (fname, ftype, fid) = iprot.readFieldBegin()
6840 
      if ftype == TType.STOP:
6841 
        break
6842 
      if fid == 1:
6843 
        if ftype == TType.I64:
6844 
          self.customer_id = iprot.readI64();
6845 
        else:
6846 
          iprot.skip(ftype)
6847 
      elif fid == 2:
6848 
        if ftype == TType.I64:
6849 
          self.limit = iprot.readI64();
6850 
        else:
6851 
          iprot.skip(ftype)
6852 
      else:
6853 
        iprot.skip(ftype)
6854 
      iprot.readFieldEnd()
6855 
    iprot.readStructEnd()
6856 
 
6857 
  def write(self, oprot):
6858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6860 
      return
6861 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 6862 
    if self.customer_id is not None:
1382 varun.gupt 6863 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
6864 
      oprot.writeI64(self.customer_id)
6865 
      oprot.writeFieldEnd()
3431 rajveer 6866 
    if self.limit is not None:
1382 varun.gupt 6867 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6868 
      oprot.writeI64(self.limit)
6869 
      oprot.writeFieldEnd()
6870 
    oprot.writeFieldStop()
6871 
    oprot.writeStructEnd()
6872 
 
3431 rajveer 6873 
  def validate(self):
6874 
    return
6875 
 
6876 
 
1382 varun.gupt 6877 
  def __repr__(self):
6878 
    L = ['%s=%r' % (key, value)
6879 
      for key, value in self.__dict__.iteritems()]
6880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6881 
 
6882 
  def __eq__(self, other):
6883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6884 
 
6885 
  def __ne__(self, other):
6886 
    return not (self == other)
6887 
 
6888 
class getCancellableOrdersForCustomer_result:
6889 
  """
6890 
  Attributes:
6891 
   - success
6892 
   - ex
6893 
  """
6894 
 
6895 
  thrift_spec = (
6896 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6898 
  )
6899 
 
6900 
  def __init__(self, success=None, ex=None,):
6901 
    self.success = success
6902 
    self.ex = ex
6903 
 
6904 
  def read(self, iprot):
6905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6907 
      return
6908 
    iprot.readStructBegin()
6909 
    while True:
6910 
      (fname, ftype, fid) = iprot.readFieldBegin()
6911 
      if ftype == TType.STOP:
6912 
        break
6913 
      if fid == 0:
6914 
        if ftype == TType.LIST:
6915 
          self.success = []
4133 chandransh 6916 
          (_etype80, _size77) = iprot.readListBegin()
6917 
          for _i81 in xrange(_size77):
6918 
            _elem82 = iprot.readI64();
6919 
            self.success.append(_elem82)
1382 varun.gupt 6920 
          iprot.readListEnd()
6921 
        else:
6922 
          iprot.skip(ftype)
6923 
      elif fid == 1:
6924 
        if ftype == TType.STRUCT:
6925 
          self.ex = TransactionServiceException()
6926 
          self.ex.read(iprot)
6927 
        else:
6928 
          iprot.skip(ftype)
6929 
      else:
6930 
        iprot.skip(ftype)
6931 
      iprot.readFieldEnd()
6932 
    iprot.readStructEnd()
6933 
 
6934 
  def write(self, oprot):
6935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6937 
      return
6938 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 6939 
    if self.success is not None:
1382 varun.gupt 6940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6941 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 6942 
      for iter83 in self.success:
6943 
        oprot.writeI64(iter83)
1382 varun.gupt 6944 
      oprot.writeListEnd()
6945 
      oprot.writeFieldEnd()
3431 rajveer 6946 
    if self.ex is not None:
1382 varun.gupt 6947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6948 
      self.ex.write(oprot)
6949 
      oprot.writeFieldEnd()
6950 
    oprot.writeFieldStop()
6951 
    oprot.writeStructEnd()
6952 
 
3431 rajveer 6953 
  def validate(self):
6954 
    return
6955 
 
6956 
 
1382 varun.gupt 6957 
  def __repr__(self):
6958 
    L = ['%s=%r' % (key, value)
6959 
      for key, value in self.__dict__.iteritems()]
6960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6961 
 
6962 
  def __eq__(self, other):
6963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6964 
 
6965 
  def __ne__(self, other):
6966 
    return not (self == other)
6967 
 
483 rajveer 6968 
class changeOrderStatus_args:
94 ashish 6969 
  """
6970 
  Attributes:
483 rajveer 6971 
   - orderId
6972 
   - status
6973 
   - description
94 ashish 6974 
  """
6975 
 
6976 
  thrift_spec = (
6977 
    None, # 0
483 rajveer 6978 
    (1, TType.I64, 'orderId', None, None, ), # 1
6979 
    (2, TType.I32, 'status', None, None, ), # 2
6980 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 6981 
  )
6982 
 
483 rajveer 6983 
  def __init__(self, orderId=None, status=None, description=None,):
6984 
    self.orderId = orderId
6985 
    self.status = status
6986 
    self.description = description
94 ashish 6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 1:
6998 
        if ftype == TType.I64:
483 rajveer 6999 
          self.orderId = iprot.readI64();
94 ashish 7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      elif fid == 2:
483 rajveer 7003 
        if ftype == TType.I32:
7004 
          self.status = iprot.readI32();
94 ashish 7005 
        else:
7006 
          iprot.skip(ftype)
483 rajveer 7007 
      elif fid == 3:
7008 
        if ftype == TType.STRING:
7009 
          self.description = iprot.readString();
7010 
        else:
7011 
          iprot.skip(ftype)
94 ashish 7012 
      else:
7013 
        iprot.skip(ftype)
7014 
      iprot.readFieldEnd()
7015 
    iprot.readStructEnd()
7016 
 
7017 
  def write(self, oprot):
7018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7020 
      return
483 rajveer 7021 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 7022 
    if self.orderId is not None:
483 rajveer 7023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7024 
      oprot.writeI64(self.orderId)
94 ashish 7025 
      oprot.writeFieldEnd()
3431 rajveer 7026 
    if self.status is not None:
483 rajveer 7027 
      oprot.writeFieldBegin('status', TType.I32, 2)
7028 
      oprot.writeI32(self.status)
94 ashish 7029 
      oprot.writeFieldEnd()
3431 rajveer 7030 
    if self.description is not None:
483 rajveer 7031 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7032 
      oprot.writeString(self.description)
7033 
      oprot.writeFieldEnd()
94 ashish 7034 
    oprot.writeFieldStop()
7035 
    oprot.writeStructEnd()
7036 
 
3431 rajveer 7037 
  def validate(self):
7038 
    return
7039 
 
7040 
 
94 ashish 7041 
  def __repr__(self):
7042 
    L = ['%s=%r' % (key, value)
7043 
      for key, value in self.__dict__.iteritems()]
7044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7045 
 
7046 
  def __eq__(self, other):
7047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7048 
 
7049 
  def __ne__(self, other):
7050 
    return not (self == other)
7051 
 
483 rajveer 7052 
class changeOrderStatus_result:
94 ashish 7053 
  """
7054 
  Attributes:
7055 
   - success
7056 
   - ex
7057 
  """
7058 
 
7059 
  thrift_spec = (
7060 
    (0, TType.BOOL, 'success', None, None, ), # 0
7061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7062 
  )
7063 
 
7064 
  def __init__(self, success=None, ex=None,):
7065 
    self.success = success
7066 
    self.ex = ex
7067 
 
7068 
  def read(self, iprot):
7069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7071 
      return
7072 
    iprot.readStructBegin()
7073 
    while True:
7074 
      (fname, ftype, fid) = iprot.readFieldBegin()
7075 
      if ftype == TType.STOP:
7076 
        break
7077 
      if fid == 0:
7078 
        if ftype == TType.BOOL:
7079 
          self.success = iprot.readBool();
7080 
        else:
7081 
          iprot.skip(ftype)
7082 
      elif fid == 1:
7083 
        if ftype == TType.STRUCT:
7084 
          self.ex = TransactionServiceException()
7085 
          self.ex.read(iprot)
7086 
        else:
7087 
          iprot.skip(ftype)
7088 
      else:
7089 
        iprot.skip(ftype)
7090 
      iprot.readFieldEnd()
7091 
    iprot.readStructEnd()
7092 
 
7093 
  def write(self, oprot):
7094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7096 
      return
483 rajveer 7097 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 7098 
    if self.success is not None:
94 ashish 7099 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7100 
      oprot.writeBool(self.success)
7101 
      oprot.writeFieldEnd()
3431 rajveer 7102 
    if self.ex is not None:
94 ashish 7103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7104 
      self.ex.write(oprot)
7105 
      oprot.writeFieldEnd()
7106 
    oprot.writeFieldStop()
7107 
    oprot.writeStructEnd()
7108 
 
3431 rajveer 7109 
  def validate(self):
7110 
    return
7111 
 
7112 
 
94 ashish 7113 
  def __repr__(self):
7114 
    L = ['%s=%r' % (key, value)
7115 
      for key, value in self.__dict__.iteritems()]
7116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7117 
 
7118 
  def __eq__(self, other):
7119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7120 
 
7121 
  def __ne__(self, other):
7122 
    return not (self == other)
7123 
 
3064 chandransh 7124 
class getOrdersForTransaction_args:
494 rajveer 7125 
  """
7126 
  Attributes:
3064 chandransh 7127 
   - transactionId
7128 
   - customerId
494 rajveer 7129 
  """
7130 
 
7131 
  thrift_spec = (
7132 
    None, # 0
3064 chandransh 7133 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7134 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 7135 
  )
7136 
 
3064 chandransh 7137 
  def __init__(self, transactionId=None, customerId=None,):
7138 
    self.transactionId = transactionId
7139 
    self.customerId = customerId
494 rajveer 7140 
 
7141 
  def read(self, iprot):
7142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7144 
      return
7145 
    iprot.readStructBegin()
7146 
    while True:
7147 
      (fname, ftype, fid) = iprot.readFieldBegin()
7148 
      if ftype == TType.STOP:
7149 
        break
7150 
      if fid == 1:
7151 
        if ftype == TType.I64:
3064 chandransh 7152 
          self.transactionId = iprot.readI64();
494 rajveer 7153 
        else:
7154 
          iprot.skip(ftype)
7155 
      elif fid == 2:
3064 chandransh 7156 
        if ftype == TType.I64:
7157 
          self.customerId = iprot.readI64();
494 rajveer 7158 
        else:
7159 
          iprot.skip(ftype)
7160 
      else:
7161 
        iprot.skip(ftype)
7162 
      iprot.readFieldEnd()
7163 
    iprot.readStructEnd()
7164 
 
7165 
  def write(self, oprot):
7166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7168 
      return
3064 chandransh 7169 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 7170 
    if self.transactionId is not None:
3064 chandransh 7171 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7172 
      oprot.writeI64(self.transactionId)
494 rajveer 7173 
      oprot.writeFieldEnd()
3431 rajveer 7174 
    if self.customerId is not None:
3064 chandransh 7175 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
7176 
      oprot.writeI64(self.customerId)
494 rajveer 7177 
      oprot.writeFieldEnd()
7178 
    oprot.writeFieldStop()
7179 
    oprot.writeStructEnd()
7180 
 
3431 rajveer 7181 
  def validate(self):
7182 
    return
7183 
 
7184 
 
494 rajveer 7185 
  def __repr__(self):
7186 
    L = ['%s=%r' % (key, value)
7187 
      for key, value in self.__dict__.iteritems()]
7188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7189 
 
7190 
  def __eq__(self, other):
7191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7192 
 
7193 
  def __ne__(self, other):
7194 
    return not (self == other)
7195 
 
3064 chandransh 7196 
class getOrdersForTransaction_result:
494 rajveer 7197 
  """
7198 
  Attributes:
7199 
   - success
7200 
   - ex
7201 
  """
7202 
 
7203 
  thrift_spec = (
3064 chandransh 7204 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 7205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7206 
  )
7207 
 
7208 
  def __init__(self, success=None, ex=None,):
7209 
    self.success = success
7210 
    self.ex = ex
7211 
 
7212 
  def read(self, iprot):
7213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7215 
      return
7216 
    iprot.readStructBegin()
7217 
    while True:
7218 
      (fname, ftype, fid) = iprot.readFieldBegin()
7219 
      if ftype == TType.STOP:
7220 
        break
7221 
      if fid == 0:
3064 chandransh 7222 
        if ftype == TType.LIST:
7223 
          self.success = []
4133 chandransh 7224 
          (_etype87, _size84) = iprot.readListBegin()
7225 
          for _i88 in xrange(_size84):
7226 
            _elem89 = Order()
7227 
            _elem89.read(iprot)
7228 
            self.success.append(_elem89)
3064 chandransh 7229 
          iprot.readListEnd()
494 rajveer 7230 
        else:
7231 
          iprot.skip(ftype)
7232 
      elif fid == 1:
7233 
        if ftype == TType.STRUCT:
7234 
          self.ex = TransactionServiceException()
7235 
          self.ex.read(iprot)
7236 
        else:
7237 
          iprot.skip(ftype)
7238 
      else:
7239 
        iprot.skip(ftype)
7240 
      iprot.readFieldEnd()
7241 
    iprot.readStructEnd()
7242 
 
7243 
  def write(self, oprot):
7244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7246 
      return
3064 chandransh 7247 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 7248 
    if self.success is not None:
3064 chandransh 7249 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7250 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7251 
      for iter90 in self.success:
7252 
        iter90.write(oprot)
3064 chandransh 7253 
      oprot.writeListEnd()
494 rajveer 7254 
      oprot.writeFieldEnd()
3431 rajveer 7255 
    if self.ex is not None:
494 rajveer 7256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7257 
      self.ex.write(oprot)
7258 
      oprot.writeFieldEnd()
7259 
    oprot.writeFieldStop()
7260 
    oprot.writeStructEnd()
7261 
 
3431 rajveer 7262 
  def validate(self):
7263 
    return
7264 
 
7265 
 
494 rajveer 7266 
  def __repr__(self):
7267 
    L = ['%s=%r' % (key, value)
7268 
      for key, value in self.__dict__.iteritems()]
7269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7270 
 
7271 
  def __eq__(self, other):
7272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7273 
 
7274 
  def __ne__(self, other):
7275 
    return not (self == other)
7276 
 
3064 chandransh 7277 
class getOrdersForCustomer_args:
1149 chandransh 7278 
  """
7279 
  Attributes:
3064 chandransh 7280 
   - customerId
7281 
   - from_date
7282 
   - to_date
7283 
   - statuses
1149 chandransh 7284 
  """
7285 
 
7286 
  thrift_spec = (
7287 
    None, # 0
3064 chandransh 7288 
    (1, TType.I64, 'customerId', None, None, ), # 1
7289 
    (2, TType.I64, 'from_date', None, None, ), # 2
7290 
    (3, TType.I64, 'to_date', None, None, ), # 3
7291 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 7292 
  )
7293 
 
3064 chandransh 7294 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
7295 
    self.customerId = customerId
7296 
    self.from_date = from_date
7297 
    self.to_date = to_date
7298 
    self.statuses = statuses
1149 chandransh 7299 
 
7300 
  def read(self, iprot):
7301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7303 
      return
7304 
    iprot.readStructBegin()
7305 
    while True:
7306 
      (fname, ftype, fid) = iprot.readFieldBegin()
7307 
      if ftype == TType.STOP:
7308 
        break
7309 
      if fid == 1:
7310 
        if ftype == TType.I64:
3064 chandransh 7311 
          self.customerId = iprot.readI64();
1149 chandransh 7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      elif fid == 2:
7315 
        if ftype == TType.I64:
3064 chandransh 7316 
          self.from_date = iprot.readI64();
1149 chandransh 7317 
        else:
7318 
          iprot.skip(ftype)
2783 chandransh 7319 
      elif fid == 3:
7320 
        if ftype == TType.I64:
3064 chandransh 7321 
          self.to_date = iprot.readI64();
2783 chandransh 7322 
        else:
7323 
          iprot.skip(ftype)
7324 
      elif fid == 4:
3064 chandransh 7325 
        if ftype == TType.LIST:
7326 
          self.statuses = []
4133 chandransh 7327 
          (_etype94, _size91) = iprot.readListBegin()
7328 
          for _i95 in xrange(_size91):
7329 
            _elem96 = iprot.readI32();
7330 
            self.statuses.append(_elem96)
3064 chandransh 7331 
          iprot.readListEnd()
2783 chandransh 7332 
        else:
7333 
          iprot.skip(ftype)
1149 chandransh 7334 
      else:
7335 
        iprot.skip(ftype)
7336 
      iprot.readFieldEnd()
7337 
    iprot.readStructEnd()
7338 
 
7339 
  def write(self, oprot):
7340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7342 
      return
3064 chandransh 7343 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 7344 
    if self.customerId is not None:
3064 chandransh 7345 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7346 
      oprot.writeI64(self.customerId)
1149 chandransh 7347 
      oprot.writeFieldEnd()
3431 rajveer 7348 
    if self.from_date is not None:
3064 chandransh 7349 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7350 
      oprot.writeI64(self.from_date)
1149 chandransh 7351 
      oprot.writeFieldEnd()
3431 rajveer 7352 
    if self.to_date is not None:
3064 chandransh 7353 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7354 
      oprot.writeI64(self.to_date)
2783 chandransh 7355 
      oprot.writeFieldEnd()
3431 rajveer 7356 
    if self.statuses is not None:
3064 chandransh 7357 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
7358 
      oprot.writeListBegin(TType.I32, len(self.statuses))
4133 chandransh 7359 
      for iter97 in self.statuses:
7360 
        oprot.writeI32(iter97)
3064 chandransh 7361 
      oprot.writeListEnd()
2783 chandransh 7362 
      oprot.writeFieldEnd()
1149 chandransh 7363 
    oprot.writeFieldStop()
7364 
    oprot.writeStructEnd()
7365 
 
3431 rajveer 7366 
  def validate(self):
7367 
    return
7368 
 
7369 
 
1149 chandransh 7370 
  def __repr__(self):
7371 
    L = ['%s=%r' % (key, value)
7372 
      for key, value in self.__dict__.iteritems()]
7373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7374 
 
7375 
  def __eq__(self, other):
7376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7377 
 
7378 
  def __ne__(self, other):
7379 
    return not (self == other)
7380 
 
3064 chandransh 7381 
class getOrdersForCustomer_result:
1149 chandransh 7382 
  """
7383 
  Attributes:
7384 
   - success
7385 
   - ex
7386 
  """
7387 
 
7388 
  thrift_spec = (
3064 chandransh 7389 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 7390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7391 
  )
7392 
 
7393 
  def __init__(self, success=None, ex=None,):
7394 
    self.success = success
7395 
    self.ex = ex
7396 
 
7397 
  def read(self, iprot):
7398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7400 
      return
7401 
    iprot.readStructBegin()
7402 
    while True:
7403 
      (fname, ftype, fid) = iprot.readFieldBegin()
7404 
      if ftype == TType.STOP:
7405 
        break
7406 
      if fid == 0:
3064 chandransh 7407 
        if ftype == TType.LIST:
7408 
          self.success = []
4133 chandransh 7409 
          (_etype101, _size98) = iprot.readListBegin()
7410 
          for _i102 in xrange(_size98):
7411 
            _elem103 = Order()
7412 
            _elem103.read(iprot)
7413 
            self.success.append(_elem103)
3064 chandransh 7414 
          iprot.readListEnd()
1149 chandransh 7415 
        else:
7416 
          iprot.skip(ftype)
7417 
      elif fid == 1:
7418 
        if ftype == TType.STRUCT:
7419 
          self.ex = TransactionServiceException()
7420 
          self.ex.read(iprot)
7421 
        else:
7422 
          iprot.skip(ftype)
7423 
      else:
7424 
        iprot.skip(ftype)
7425 
      iprot.readFieldEnd()
7426 
    iprot.readStructEnd()
7427 
 
7428 
  def write(self, oprot):
7429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7431 
      return
3064 chandransh 7432 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 7433 
    if self.success is not None:
3064 chandransh 7434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7436 
      for iter104 in self.success:
7437 
        iter104.write(oprot)
3064 chandransh 7438 
      oprot.writeListEnd()
1149 chandransh 7439 
      oprot.writeFieldEnd()
3431 rajveer 7440 
    if self.ex is not None:
1149 chandransh 7441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7442 
      self.ex.write(oprot)
7443 
      oprot.writeFieldEnd()
7444 
    oprot.writeFieldStop()
7445 
    oprot.writeStructEnd()
7446 
 
3431 rajveer 7447 
  def validate(self):
7448 
    return
7449 
 
7450 
 
1149 chandransh 7451 
  def __repr__(self):
7452 
    L = ['%s=%r' % (key, value)
7453 
      for key, value in self.__dict__.iteritems()]
7454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7455 
 
7456 
  def __eq__(self, other):
7457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7458 
 
7459 
  def __ne__(self, other):
7460 
    return not (self == other)
7461 
 
3064 chandransh 7462 
class createOrder_args:
921 rajveer 7463 
  """
7464 
  Attributes:
3064 chandransh 7465 
   - order
921 rajveer 7466 
  """
7467 
 
7468 
  thrift_spec = (
7469 
    None, # 0
3064 chandransh 7470 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 7471 
  )
7472 
 
3064 chandransh 7473 
  def __init__(self, order=None,):
7474 
    self.order = order
921 rajveer 7475 
 
7476 
  def read(self, iprot):
7477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7479 
      return
7480 
    iprot.readStructBegin()
7481 
    while True:
7482 
      (fname, ftype, fid) = iprot.readFieldBegin()
7483 
      if ftype == TType.STOP:
7484 
        break
7485 
      if fid == 1:
3064 chandransh 7486 
        if ftype == TType.STRUCT:
7487 
          self.order = Order()
7488 
          self.order.read(iprot)
921 rajveer 7489 
        else:
7490 
          iprot.skip(ftype)
7491 
      else:
7492 
        iprot.skip(ftype)
7493 
      iprot.readFieldEnd()
7494 
    iprot.readStructEnd()
7495 
 
7496 
  def write(self, oprot):
7497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7499 
      return
3064 chandransh 7500 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 7501 
    if self.order is not None:
3064 chandransh 7502 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
7503 
      self.order.write(oprot)
921 rajveer 7504 
      oprot.writeFieldEnd()
7505 
    oprot.writeFieldStop()
7506 
    oprot.writeStructEnd()
7507 
 
3431 rajveer 7508 
  def validate(self):
7509 
    return
7510 
 
7511 
 
921 rajveer 7512 
  def __repr__(self):
7513 
    L = ['%s=%r' % (key, value)
7514 
      for key, value in self.__dict__.iteritems()]
7515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7516 
 
7517 
  def __eq__(self, other):
7518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7519 
 
7520 
  def __ne__(self, other):
7521 
    return not (self == other)
7522 
 
3064 chandransh 7523 
class createOrder_result:
921 rajveer 7524 
  """
7525 
  Attributes:
7526 
   - success
7527 
   - ex
7528 
  """
7529 
 
7530 
  thrift_spec = (
3064 chandransh 7531 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 7532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7533 
  )
7534 
 
7535 
  def __init__(self, success=None, ex=None,):
7536 
    self.success = success
7537 
    self.ex = ex
7538 
 
7539 
  def read(self, iprot):
7540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7542 
      return
7543 
    iprot.readStructBegin()
7544 
    while True:
7545 
      (fname, ftype, fid) = iprot.readFieldBegin()
7546 
      if ftype == TType.STOP:
7547 
        break
7548 
      if fid == 0:
3064 chandransh 7549 
        if ftype == TType.I64:
7550 
          self.success = iprot.readI64();
921 rajveer 7551 
        else:
7552 
          iprot.skip(ftype)
7553 
      elif fid == 1:
7554 
        if ftype == TType.STRUCT:
7555 
          self.ex = TransactionServiceException()
7556 
          self.ex.read(iprot)
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      else:
7560 
        iprot.skip(ftype)
7561 
      iprot.readFieldEnd()
7562 
    iprot.readStructEnd()
7563 
 
7564 
  def write(self, oprot):
7565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7567 
      return
3064 chandransh 7568 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 7569 
    if self.success is not None:
3064 chandransh 7570 
      oprot.writeFieldBegin('success', TType.I64, 0)
7571 
      oprot.writeI64(self.success)
921 rajveer 7572 
      oprot.writeFieldEnd()
3431 rajveer 7573 
    if self.ex is not None:
921 rajveer 7574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7575 
      self.ex.write(oprot)
7576 
      oprot.writeFieldEnd()
7577 
    oprot.writeFieldStop()
7578 
    oprot.writeStructEnd()
7579 
 
3431 rajveer 7580 
  def validate(self):
7581 
    return
7582 
 
7583 
 
921 rajveer 7584 
  def __repr__(self):
7585 
    L = ['%s=%r' % (key, value)
7586 
      for key, value in self.__dict__.iteritems()]
7587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7588 
 
7589 
  def __eq__(self, other):
7590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7591 
 
7592 
  def __ne__(self, other):
7593 
    return not (self == other)
7594 
 
3064 chandransh 7595 
class getOrder_args:
921 rajveer 7596 
  """
7597 
  Attributes:
3064 chandransh 7598 
   - id
921 rajveer 7599 
  """
7600 
 
7601 
  thrift_spec = (
7602 
    None, # 0
3064 chandransh 7603 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 7604 
  )
7605 
 
3064 chandransh 7606 
  def __init__(self, id=None,):
7607 
    self.id = id
921 rajveer 7608 
 
7609 
  def read(self, iprot):
7610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7612 
      return
7613 
    iprot.readStructBegin()
7614 
    while True:
7615 
      (fname, ftype, fid) = iprot.readFieldBegin()
7616 
      if ftype == TType.STOP:
7617 
        break
7618 
      if fid == 1:
7619 
        if ftype == TType.I64:
3064 chandransh 7620 
          self.id = iprot.readI64();
921 rajveer 7621 
        else:
7622 
          iprot.skip(ftype)
7623 
      else:
7624 
        iprot.skip(ftype)
7625 
      iprot.readFieldEnd()
7626 
    iprot.readStructEnd()
7627 
 
7628 
  def write(self, oprot):
7629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7631 
      return
3064 chandransh 7632 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 7633 
    if self.id is not None:
3064 chandransh 7634 
      oprot.writeFieldBegin('id', TType.I64, 1)
7635 
      oprot.writeI64(self.id)
921 rajveer 7636 
      oprot.writeFieldEnd()
7637 
    oprot.writeFieldStop()
7638 
    oprot.writeStructEnd()
7639 
 
3431 rajveer 7640 
  def validate(self):
7641 
    return
7642 
 
7643 
 
921 rajveer 7644 
  def __repr__(self):
7645 
    L = ['%s=%r' % (key, value)
7646 
      for key, value in self.__dict__.iteritems()]
7647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7648 
 
7649 
  def __eq__(self, other):
7650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7651 
 
7652 
  def __ne__(self, other):
7653 
    return not (self == other)
7654 
 
3064 chandransh 7655 
class getOrder_result:
921 rajveer 7656 
  """
7657 
  Attributes:
7658 
   - success
7659 
   - ex
7660 
  """
7661 
 
7662 
  thrift_spec = (
3064 chandransh 7663 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 7664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7665 
  )
7666 
 
7667 
  def __init__(self, success=None, ex=None,):
7668 
    self.success = success
7669 
    self.ex = ex
7670 
 
7671 
  def read(self, iprot):
7672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7674 
      return
7675 
    iprot.readStructBegin()
7676 
    while True:
7677 
      (fname, ftype, fid) = iprot.readFieldBegin()
7678 
      if ftype == TType.STOP:
7679 
        break
7680 
      if fid == 0:
3064 chandransh 7681 
        if ftype == TType.STRUCT:
7682 
          self.success = Order()
7683 
          self.success.read(iprot)
921 rajveer 7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      elif fid == 1:
7687 
        if ftype == TType.STRUCT:
7688 
          self.ex = TransactionServiceException()
7689 
          self.ex.read(iprot)
7690 
        else:
7691 
          iprot.skip(ftype)
7692 
      else:
7693 
        iprot.skip(ftype)
7694 
      iprot.readFieldEnd()
7695 
    iprot.readStructEnd()
7696 
 
7697 
  def write(self, oprot):
7698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7700 
      return
3064 chandransh 7701 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 7702 
    if self.success is not None:
3064 chandransh 7703 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7704 
      self.success.write(oprot)
921 rajveer 7705 
      oprot.writeFieldEnd()
3431 rajveer 7706 
    if self.ex is not None:
921 rajveer 7707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7708 
      self.ex.write(oprot)
7709 
      oprot.writeFieldEnd()
7710 
    oprot.writeFieldStop()
7711 
    oprot.writeStructEnd()
7712 
 
3431 rajveer 7713 
  def validate(self):
7714 
    return
7715 
 
7716 
 
921 rajveer 7717 
  def __repr__(self):
7718 
    L = ['%s=%r' % (key, value)
7719 
      for key, value in self.__dict__.iteritems()]
7720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7721 
 
7722 
  def __eq__(self, other):
7723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7724 
 
7725 
  def __ne__(self, other):
7726 
    return not (self == other)
7727 
 
3064 chandransh 7728 
class getLineItemsForOrder_args:
94 ashish 7729 
  """
7730 
  Attributes:
3064 chandransh 7731 
   - orderId
94 ashish 7732 
  """
7733 
 
7734 
  thrift_spec = (
7735 
    None, # 0
3064 chandransh 7736 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 7737 
  )
7738 
 
3064 chandransh 7739 
  def __init__(self, orderId=None,):
7740 
    self.orderId = orderId
94 ashish 7741 
 
7742 
  def read(self, iprot):
7743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7745 
      return
7746 
    iprot.readStructBegin()
7747 
    while True:
7748 
      (fname, ftype, fid) = iprot.readFieldBegin()
7749 
      if ftype == TType.STOP:
7750 
        break
7751 
      if fid == 1:
7752 
        if ftype == TType.I64:
3064 chandransh 7753 
          self.orderId = iprot.readI64();
94 ashish 7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      else:
7757 
        iprot.skip(ftype)
7758 
      iprot.readFieldEnd()
7759 
    iprot.readStructEnd()
7760 
 
7761 
  def write(self, oprot):
7762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7764 
      return
3064 chandransh 7765 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 7766 
    if self.orderId is not None:
3064 chandransh 7767 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7768 
      oprot.writeI64(self.orderId)
94 ashish 7769 
      oprot.writeFieldEnd()
7770 
    oprot.writeFieldStop()
7771 
    oprot.writeStructEnd()
7772 
 
3431 rajveer 7773 
  def validate(self):
7774 
    return
7775 
 
7776 
 
94 ashish 7777 
  def __repr__(self):
7778 
    L = ['%s=%r' % (key, value)
7779 
      for key, value in self.__dict__.iteritems()]
7780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7781 
 
7782 
  def __eq__(self, other):
7783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7784 
 
7785 
  def __ne__(self, other):
7786 
    return not (self == other)
7787 
 
3064 chandransh 7788 
class getLineItemsForOrder_result:
94 ashish 7789 
  """
7790 
  Attributes:
7791 
   - success
7792 
   - ex
7793 
  """
7794 
 
7795 
  thrift_spec = (
3064 chandransh 7796 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 7797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7798 
  )
7799 
 
7800 
  def __init__(self, success=None, ex=None,):
7801 
    self.success = success
7802 
    self.ex = ex
7803 
 
7804 
  def read(self, iprot):
7805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7807 
      return
7808 
    iprot.readStructBegin()
7809 
    while True:
7810 
      (fname, ftype, fid) = iprot.readFieldBegin()
7811 
      if ftype == TType.STOP:
7812 
        break
7813 
      if fid == 0:
483 rajveer 7814 
        if ftype == TType.LIST:
7815 
          self.success = []
4133 chandransh 7816 
          (_etype108, _size105) = iprot.readListBegin()
7817 
          for _i109 in xrange(_size105):
7818 
            _elem110 = LineItem()
7819 
            _elem110.read(iprot)
7820 
            self.success.append(_elem110)
483 rajveer 7821 
          iprot.readListEnd()
94 ashish 7822 
        else:
7823 
          iprot.skip(ftype)
7824 
      elif fid == 1:
7825 
        if ftype == TType.STRUCT:
7826 
          self.ex = TransactionServiceException()
7827 
          self.ex.read(iprot)
7828 
        else:
7829 
          iprot.skip(ftype)
7830 
      else:
7831 
        iprot.skip(ftype)
7832 
      iprot.readFieldEnd()
7833 
    iprot.readStructEnd()
7834 
 
7835 
  def write(self, oprot):
7836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7838 
      return
3064 chandransh 7839 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 7840 
    if self.success is not None:
483 rajveer 7841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 7843 
      for iter111 in self.success:
7844 
        iter111.write(oprot)
483 rajveer 7845 
      oprot.writeListEnd()
94 ashish 7846 
      oprot.writeFieldEnd()
3431 rajveer 7847 
    if self.ex is not None:
94 ashish 7848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7849 
      self.ex.write(oprot)
7850 
      oprot.writeFieldEnd()
7851 
    oprot.writeFieldStop()
7852 
    oprot.writeStructEnd()
7853 
 
3431 rajveer 7854 
  def validate(self):
7855 
    return
7856 
 
7857 
 
94 ashish 7858 
  def __repr__(self):
7859 
    L = ['%s=%r' % (key, value)
7860 
      for key, value in self.__dict__.iteritems()]
7861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7862 
 
7863 
  def __eq__(self, other):
7864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7865 
 
7866 
  def __ne__(self, other):
7867 
    return not (self == other)
7868 
 
3064 chandransh 7869 
class getOrderForCustomer_args:
94 ashish 7870 
  """
7871 
  Attributes:
3064 chandransh 7872 
   - orderId
483 rajveer 7873 
   - customerId
94 ashish 7874 
  """
7875 
 
7876 
  thrift_spec = (
7877 
    None, # 0
3064 chandransh 7878 
    (1, TType.I64, 'orderId', None, None, ), # 1
7879 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 7880 
  )
7881 
 
3064 chandransh 7882 
  def __init__(self, orderId=None, customerId=None,):
7883 
    self.orderId = orderId
483 rajveer 7884 
    self.customerId = customerId
94 ashish 7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      if fid == 1:
7896 
        if ftype == TType.I64:
3064 chandransh 7897 
          self.orderId = iprot.readI64();
94 ashish 7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      elif fid == 2:
7901 
        if ftype == TType.I64:
3064 chandransh 7902 
          self.customerId = iprot.readI64();
94 ashish 7903 
        else:
7904 
          iprot.skip(ftype)
7905 
      else:
7906 
        iprot.skip(ftype)
7907 
      iprot.readFieldEnd()
7908 
    iprot.readStructEnd()
7909 
 
7910 
  def write(self, oprot):
7911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7913 
      return
3064 chandransh 7914 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 7915 
    if self.orderId is not None:
3064 chandransh 7916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7917 
      oprot.writeI64(self.orderId)
7918 
      oprot.writeFieldEnd()
3431 rajveer 7919 
    if self.customerId is not None:
3064 chandransh 7920 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 7921 
      oprot.writeI64(self.customerId)
94 ashish 7922 
      oprot.writeFieldEnd()
7923 
    oprot.writeFieldStop()
7924 
    oprot.writeStructEnd()
7925 
 
3431 rajveer 7926 
  def validate(self):
7927 
    return
7928 
 
7929 
 
94 ashish 7930 
  def __repr__(self):
7931 
    L = ['%s=%r' % (key, value)
7932 
      for key, value in self.__dict__.iteritems()]
7933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7934 
 
7935 
  def __eq__(self, other):
7936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7937 
 
7938 
  def __ne__(self, other):
7939 
    return not (self == other)
7940 
 
3064 chandransh 7941 
class getOrderForCustomer_result:
94 ashish 7942 
  """
7943 
  Attributes:
7944 
   - success
7945 
   - ex
7946 
  """
7947 
 
7948 
  thrift_spec = (
3064 chandransh 7949 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 7950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7951 
  )
7952 
 
7953 
  def __init__(self, success=None, ex=None,):
7954 
    self.success = success
7955 
    self.ex = ex
7956 
 
7957 
  def read(self, iprot):
7958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7960 
      return
7961 
    iprot.readStructBegin()
7962 
    while True:
7963 
      (fname, ftype, fid) = iprot.readFieldBegin()
7964 
      if ftype == TType.STOP:
7965 
        break
7966 
      if fid == 0:
3064 chandransh 7967 
        if ftype == TType.STRUCT:
7968 
          self.success = Order()
7969 
          self.success.read(iprot)
94 ashish 7970 
        else:
7971 
          iprot.skip(ftype)
7972 
      elif fid == 1:
7973 
        if ftype == TType.STRUCT:
7974 
          self.ex = TransactionServiceException()
7975 
          self.ex.read(iprot)
7976 
        else:
7977 
          iprot.skip(ftype)
7978 
      else:
7979 
        iprot.skip(ftype)
7980 
      iprot.readFieldEnd()
7981 
    iprot.readStructEnd()
7982 
 
7983 
  def write(self, oprot):
7984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7986 
      return
3064 chandransh 7987 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 7988 
    if self.success is not None:
3064 chandransh 7989 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7990 
      self.success.write(oprot)
94 ashish 7991 
      oprot.writeFieldEnd()
3431 rajveer 7992 
    if self.ex is not None:
94 ashish 7993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7994 
      self.ex.write(oprot)
7995 
      oprot.writeFieldEnd()
7996 
    oprot.writeFieldStop()
7997 
    oprot.writeStructEnd()
7998 
 
3431 rajveer 7999 
  def validate(self):
8000 
    return
8001 
 
8002 
 
94 ashish 8003 
  def __repr__(self):
8004 
    L = ['%s=%r' % (key, value)
8005 
      for key, value in self.__dict__.iteritems()]
8006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8007 
 
8008 
  def __eq__(self, other):
8009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8010 
 
8011 
  def __ne__(self, other):
8012 
    return not (self == other)
8013 
 
3064 chandransh 8014 
class getAlerts_args:
94 ashish 8015 
  """
8016 
  Attributes:
4394 rajveer 8017 
   - type
4444 rajveer 8018 
   - warehouseId
4394 rajveer 8019 
   - status
8020 
   - timestamp
94 ashish 8021 
  """
8022 
 
8023 
  thrift_spec = (
8024 
    None, # 0
4394 rajveer 8025 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8026 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8027 
    (3, TType.I64, 'status', None, None, ), # 3
8028 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 8029 
  )
8030 
 
4444 rajveer 8031 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 8032 
    self.type = type
4444 rajveer 8033 
    self.warehouseId = warehouseId
4394 rajveer 8034 
    self.status = status
8035 
    self.timestamp = timestamp
94 ashish 8036 
 
8037 
  def read(self, iprot):
8038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8040 
      return
8041 
    iprot.readStructBegin()
8042 
    while True:
8043 
      (fname, ftype, fid) = iprot.readFieldBegin()
8044 
      if ftype == TType.STOP:
8045 
        break
8046 
      if fid == 1:
3064 chandransh 8047 
        if ftype == TType.I64:
4394 rajveer 8048 
          self.type = iprot.readI64();
94 ashish 8049 
        else:
8050 
          iprot.skip(ftype)
3064 chandransh 8051 
      elif fid == 2:
4394 rajveer 8052 
        if ftype == TType.I64:
4444 rajveer 8053 
          self.warehouseId = iprot.readI64();
3064 chandransh 8054 
        else:
8055 
          iprot.skip(ftype)
4394 rajveer 8056 
      elif fid == 3:
8057 
        if ftype == TType.I64:
4444 rajveer 8058 
          self.status = iprot.readI64();
8059 
        else:
8060 
          iprot.skip(ftype)
8061 
      elif fid == 4:
8062 
        if ftype == TType.I64:
4394 rajveer 8063 
          self.timestamp = iprot.readI64();
8064 
        else:
8065 
          iprot.skip(ftype)
94 ashish 8066 
      else:
8067 
        iprot.skip(ftype)
8068 
      iprot.readFieldEnd()
8069 
    iprot.readStructEnd()
8070 
 
8071 
  def write(self, oprot):
8072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8074 
      return
3064 chandransh 8075 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 8076 
    if self.type is not None:
8077 
      oprot.writeFieldBegin('type', TType.I64, 1)
8078 
      oprot.writeI64(self.type)
94 ashish 8079 
      oprot.writeFieldEnd()
4444 rajveer 8080 
    if self.warehouseId is not None:
8081 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8082 
      oprot.writeI64(self.warehouseId)
8083 
      oprot.writeFieldEnd()
4394 rajveer 8084 
    if self.status is not None:
4444 rajveer 8085 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 8086 
      oprot.writeI64(self.status)
3064 chandransh 8087 
      oprot.writeFieldEnd()
4394 rajveer 8088 
    if self.timestamp is not None:
4444 rajveer 8089 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 8090 
      oprot.writeI64(self.timestamp)
8091 
      oprot.writeFieldEnd()
94 ashish 8092 
    oprot.writeFieldStop()
8093 
    oprot.writeStructEnd()
8094 
 
3431 rajveer 8095 
  def validate(self):
8096 
    return
8097 
 
8098 
 
94 ashish 8099 
  def __repr__(self):
8100 
    L = ['%s=%r' % (key, value)
8101 
      for key, value in self.__dict__.iteritems()]
8102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8103 
 
8104 
  def __eq__(self, other):
8105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8106 
 
8107 
  def __ne__(self, other):
8108 
    return not (self == other)
8109 
 
3064 chandransh 8110 
class getAlerts_result:
94 ashish 8111 
  """
8112 
  Attributes:
8113 
   - success
8114 
  """
8115 
 
8116 
  thrift_spec = (
3064 chandransh 8117 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 8118 
  )
8119 
 
3064 chandransh 8120 
  def __init__(self, success=None,):
94 ashish 8121 
    self.success = success
8122 
 
8123 
  def read(self, iprot):
8124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8126 
      return
8127 
    iprot.readStructBegin()
8128 
    while True:
8129 
      (fname, ftype, fid) = iprot.readFieldBegin()
8130 
      if ftype == TType.STOP:
8131 
        break
8132 
      if fid == 0:
3064 chandransh 8133 
        if ftype == TType.LIST:
8134 
          self.success = []
4133 chandransh 8135 
          (_etype115, _size112) = iprot.readListBegin()
8136 
          for _i116 in xrange(_size112):
8137 
            _elem117 = Alert()
8138 
            _elem117.read(iprot)
8139 
            self.success.append(_elem117)
3064 chandransh 8140 
          iprot.readListEnd()
94 ashish 8141 
        else:
8142 
          iprot.skip(ftype)
8143 
      else:
8144 
        iprot.skip(ftype)
8145 
      iprot.readFieldEnd()
8146 
    iprot.readStructEnd()
8147 
 
8148 
  def write(self, oprot):
8149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8151 
      return
3064 chandransh 8152 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 8153 
    if self.success is not None:
3064 chandransh 8154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8156 
      for iter118 in self.success:
8157 
        iter118.write(oprot)
3064 chandransh 8158 
      oprot.writeListEnd()
94 ashish 8159 
      oprot.writeFieldEnd()
8160 
    oprot.writeFieldStop()
8161 
    oprot.writeStructEnd()
8162 
 
3431 rajveer 8163 
  def validate(self):
8164 
    return
8165 
 
8166 
 
94 ashish 8167 
  def __repr__(self):
8168 
    L = ['%s=%r' % (key, value)
8169 
      for key, value in self.__dict__.iteritems()]
8170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8171 
 
8172 
  def __eq__(self, other):
8173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8174 
 
8175 
  def __ne__(self, other):
8176 
    return not (self == other)
8177 
 
4394 rajveer 8178 
class addAlert_args:
94 ashish 8179 
  """
8180 
  Attributes:
3064 chandransh 8181 
   - type
4444 rajveer 8182 
   - warehouseId
4394 rajveer 8183 
   - description
94 ashish 8184 
  """
8185 
 
8186 
  thrift_spec = (
8187 
    None, # 0
4394 rajveer 8188 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 8189 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8190 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8191 
  )
8192 
 
4444 rajveer 8193 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 8194 
    self.type = type
4444 rajveer 8195 
    self.warehouseId = warehouseId
4394 rajveer 8196 
    self.description = description
94 ashish 8197 
 
8198 
  def read(self, iprot):
8199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8201 
      return
8202 
    iprot.readStructBegin()
8203 
    while True:
8204 
      (fname, ftype, fid) = iprot.readFieldBegin()
8205 
      if ftype == TType.STOP:
8206 
        break
8207 
      if fid == 1:
8208 
        if ftype == TType.I64:
4394 rajveer 8209 
          self.type = iprot.readI64();
94 ashish 8210 
        else:
8211 
          iprot.skip(ftype)
3064 chandransh 8212 
      elif fid == 2:
4444 rajveer 8213 
        if ftype == TType.I64:
8214 
          self.warehouseId = iprot.readI64();
8215 
        else:
8216 
          iprot.skip(ftype)
8217 
      elif fid == 3:
3064 chandransh 8218 
        if ftype == TType.STRING:
4394 rajveer 8219 
          self.description = iprot.readString();
3064 chandransh 8220 
        else:
8221 
          iprot.skip(ftype)
94 ashish 8222 
      else:
8223 
        iprot.skip(ftype)
8224 
      iprot.readFieldEnd()
8225 
    iprot.readStructEnd()
8226 
 
8227 
  def write(self, oprot):
8228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8230 
      return
4394 rajveer 8231 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 8232 
    if self.type is not None:
4394 rajveer 8233 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 8234 
      oprot.writeI64(self.type)
8235 
      oprot.writeFieldEnd()
4444 rajveer 8236 
    if self.warehouseId is not None:
8237 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8238 
      oprot.writeI64(self.warehouseId)
8239 
      oprot.writeFieldEnd()
4394 rajveer 8240 
    if self.description is not None:
4444 rajveer 8241 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 8242 
      oprot.writeString(self.description)
3064 chandransh 8243 
      oprot.writeFieldEnd()
94 ashish 8244 
    oprot.writeFieldStop()
8245 
    oprot.writeStructEnd()
8246 
 
3431 rajveer 8247 
  def validate(self):
8248 
    return
8249 
 
8250 
 
94 ashish 8251 
  def __repr__(self):
8252 
    L = ['%s=%r' % (key, value)
8253 
      for key, value in self.__dict__.iteritems()]
8254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8255 
 
8256 
  def __eq__(self, other):
8257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8258 
 
8259 
  def __ne__(self, other):
8260 
    return not (self == other)
8261 
 
4394 rajveer 8262 
class addAlert_result:
3064 chandransh 8263 
 
8264 
  thrift_spec = (
8265 
  )
8266 
 
8267 
  def read(self, iprot):
8268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8270 
      return
8271 
    iprot.readStructBegin()
8272 
    while True:
8273 
      (fname, ftype, fid) = iprot.readFieldBegin()
8274 
      if ftype == TType.STOP:
8275 
        break
8276 
      else:
8277 
        iprot.skip(ftype)
8278 
      iprot.readFieldEnd()
8279 
    iprot.readStructEnd()
8280 
 
8281 
  def write(self, oprot):
8282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8284 
      return
4394 rajveer 8285 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 8286 
    oprot.writeFieldStop()
8287 
    oprot.writeStructEnd()
8288 
 
3431 rajveer 8289 
  def validate(self):
8290 
    return
8291 
 
8292 
 
3064 chandransh 8293 
  def __repr__(self):
8294 
    L = ['%s=%r' % (key, value)
8295 
      for key, value in self.__dict__.iteritems()]
8296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8297 
 
8298 
  def __eq__(self, other):
8299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8300 
 
8301 
  def __ne__(self, other):
8302 
    return not (self == other)
8303 
 
4444 rajveer 8304 
class markAlertsAsSeen_args:
8305 
  """
8306 
  Attributes:
8307 
   - warehouseId
8308 
  """
8309 
 
8310 
  thrift_spec = (
8311 
    None, # 0
8312 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8313 
  )
8314 
 
8315 
  def __init__(self, warehouseId=None,):
8316 
    self.warehouseId = warehouseId
8317 
 
8318 
  def read(self, iprot):
8319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8321 
      return
8322 
    iprot.readStructBegin()
8323 
    while True:
8324 
      (fname, ftype, fid) = iprot.readFieldBegin()
8325 
      if ftype == TType.STOP:
8326 
        break
8327 
      if fid == 1:
8328 
        if ftype == TType.I64:
8329 
          self.warehouseId = iprot.readI64();
8330 
        else:
8331 
          iprot.skip(ftype)
8332 
      else:
8333 
        iprot.skip(ftype)
8334 
      iprot.readFieldEnd()
8335 
    iprot.readStructEnd()
8336 
 
8337 
  def write(self, oprot):
8338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8340 
      return
8341 
    oprot.writeStructBegin('markAlertsAsSeen_args')
8342 
    if self.warehouseId is not None:
8343 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8344 
      oprot.writeI64(self.warehouseId)
8345 
      oprot.writeFieldEnd()
8346 
    oprot.writeFieldStop()
8347 
    oprot.writeStructEnd()
8348 
 
8349 
  def validate(self):
8350 
    return
8351 
 
8352 
 
8353 
  def __repr__(self):
8354 
    L = ['%s=%r' % (key, value)
8355 
      for key, value in self.__dict__.iteritems()]
8356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8357 
 
8358 
  def __eq__(self, other):
8359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8360 
 
8361 
  def __ne__(self, other):
8362 
    return not (self == other)
8363 
 
8364 
class markAlertsAsSeen_result:
8365 
 
8366 
  thrift_spec = (
8367 
  )
8368 
 
8369 
  def read(self, iprot):
8370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8372 
      return
8373 
    iprot.readStructBegin()
8374 
    while True:
8375 
      (fname, ftype, fid) = iprot.readFieldBegin()
8376 
      if ftype == TType.STOP:
8377 
        break
8378 
      else:
8379 
        iprot.skip(ftype)
8380 
      iprot.readFieldEnd()
8381 
    iprot.readStructEnd()
8382 
 
8383 
  def write(self, oprot):
8384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8386 
      return
8387 
    oprot.writeStructBegin('markAlertsAsSeen_result')
8388 
    oprot.writeFieldStop()
8389 
    oprot.writeStructEnd()
8390 
 
8391 
  def validate(self):
8392 
    return
8393 
 
8394 
 
8395 
  def __repr__(self):
8396 
    L = ['%s=%r' % (key, value)
8397 
      for key, value in self.__dict__.iteritems()]
8398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8399 
 
8400 
  def __eq__(self, other):
8401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8402 
 
8403 
  def __ne__(self, other):
8404 
    return not (self == other)
8405 
 
3064 chandransh 8406 
class getValidOrderCount_args:
8407 
 
8408 
  thrift_spec = (
8409 
  )
8410 
 
8411 
  def read(self, iprot):
8412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8414 
      return
8415 
    iprot.readStructBegin()
8416 
    while True:
8417 
      (fname, ftype, fid) = iprot.readFieldBegin()
8418 
      if ftype == TType.STOP:
8419 
        break
8420 
      else:
8421 
        iprot.skip(ftype)
8422 
      iprot.readFieldEnd()
8423 
    iprot.readStructEnd()
8424 
 
8425 
  def write(self, oprot):
8426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8428 
      return
8429 
    oprot.writeStructBegin('getValidOrderCount_args')
8430 
    oprot.writeFieldStop()
8431 
    oprot.writeStructEnd()
8432 
 
3431 rajveer 8433 
  def validate(self):
8434 
    return
8435 
 
8436 
 
3064 chandransh 8437 
  def __repr__(self):
8438 
    L = ['%s=%r' % (key, value)
8439 
      for key, value in self.__dict__.iteritems()]
8440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8441 
 
8442 
  def __eq__(self, other):
8443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8444 
 
8445 
  def __ne__(self, other):
8446 
    return not (self == other)
8447 
 
8448 
class getValidOrderCount_result:
94 ashish 8449 
  """
8450 
  Attributes:
8451 
   - success
8452 
  """
8453 
 
8454 
  thrift_spec = (
3064 chandransh 8455 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8456 
  )
8457 
 
3064 chandransh 8458 
  def __init__(self, success=None,):
94 ashish 8459 
    self.success = success
8460 
 
8461 
  def read(self, iprot):
8462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8464 
      return
8465 
    iprot.readStructBegin()
8466 
    while True:
8467 
      (fname, ftype, fid) = iprot.readFieldBegin()
8468 
      if ftype == TType.STOP:
8469 
        break
8470 
      if fid == 0:
3064 chandransh 8471 
        if ftype == TType.I64:
8472 
          self.success = iprot.readI64();
94 ashish 8473 
        else:
8474 
          iprot.skip(ftype)
8475 
      else:
8476 
        iprot.skip(ftype)
8477 
      iprot.readFieldEnd()
8478 
    iprot.readStructEnd()
8479 
 
8480 
  def write(self, oprot):
8481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8483 
      return
3064 chandransh 8484 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 8485 
    if self.success is not None:
3064 chandransh 8486 
      oprot.writeFieldBegin('success', TType.I64, 0)
8487 
      oprot.writeI64(self.success)
94 ashish 8488 
      oprot.writeFieldEnd()
8489 
    oprot.writeFieldStop()
8490 
    oprot.writeStructEnd()
8491 
 
3431 rajveer 8492 
  def validate(self):
8493 
    return
8494 
 
8495 
 
94 ashish 8496 
  def __repr__(self):
8497 
    L = ['%s=%r' % (key, value)
8498 
      for key, value in self.__dict__.iteritems()]
8499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8500 
 
8501 
  def __eq__(self, other):
8502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8503 
 
8504 
  def __ne__(self, other):
8505 
    return not (self == other)
8506 
 
3064 chandransh 8507 
class getNoOfCustomersWithSuccessfulTransaction_args:
8508 
 
8509 
  thrift_spec = (
8510 
  )
8511 
 
8512 
  def read(self, iprot):
8513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8515 
      return
8516 
    iprot.readStructBegin()
8517 
    while True:
8518 
      (fname, ftype, fid) = iprot.readFieldBegin()
8519 
      if ftype == TType.STOP:
8520 
        break
8521 
      else:
8522 
        iprot.skip(ftype)
8523 
      iprot.readFieldEnd()
8524 
    iprot.readStructEnd()
8525 
 
8526 
  def write(self, oprot):
8527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8529 
      return
8530 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
8531 
    oprot.writeFieldStop()
8532 
    oprot.writeStructEnd()
8533 
 
3431 rajveer 8534 
  def validate(self):
8535 
    return
8536 
 
8537 
 
3064 chandransh 8538 
  def __repr__(self):
8539 
    L = ['%s=%r' % (key, value)
8540 
      for key, value in self.__dict__.iteritems()]
8541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8542 
 
8543 
  def __eq__(self, other):
8544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8545 
 
8546 
  def __ne__(self, other):
8547 
    return not (self == other)
8548 
 
8549 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 8550 
  """
8551 
  Attributes:
3064 chandransh 8552 
   - success
94 ashish 8553 
  """
8554 
 
8555 
  thrift_spec = (
3064 chandransh 8556 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8557 
  )
8558 
 
3064 chandransh 8559 
  def __init__(self, success=None,):
8560 
    self.success = success
94 ashish 8561 
 
8562 
  def read(self, iprot):
8563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8565 
      return
8566 
    iprot.readStructBegin()
8567 
    while True:
8568 
      (fname, ftype, fid) = iprot.readFieldBegin()
8569 
      if ftype == TType.STOP:
8570 
        break
3064 chandransh 8571 
      if fid == 0:
94 ashish 8572 
        if ftype == TType.I64:
3064 chandransh 8573 
          self.success = iprot.readI64();
94 ashish 8574 
        else:
8575 
          iprot.skip(ftype)
8576 
      else:
8577 
        iprot.skip(ftype)
8578 
      iprot.readFieldEnd()
8579 
    iprot.readStructEnd()
8580 
 
8581 
  def write(self, oprot):
8582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8584 
      return
3064 chandransh 8585 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 8586 
    if self.success is not None:
3064 chandransh 8587 
      oprot.writeFieldBegin('success', TType.I64, 0)
8588 
      oprot.writeI64(self.success)
94 ashish 8589 
      oprot.writeFieldEnd()
8590 
    oprot.writeFieldStop()
8591 
    oprot.writeStructEnd()
8592 
 
3431 rajveer 8593 
  def validate(self):
8594 
    return
8595 
 
8596 
 
94 ashish 8597 
  def __repr__(self):
8598 
    L = ['%s=%r' % (key, value)
8599 
      for key, value in self.__dict__.iteritems()]
8600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8601 
 
8602 
  def __eq__(self, other):
8603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8604 
 
8605 
  def __ne__(self, other):
8606 
    return not (self == other)
8607 
 
3064 chandransh 8608 
class getValidOrdersAmountRange_args:
8609 
 
8610 
  thrift_spec = (
8611 
  )
8612 
 
8613 
  def read(self, iprot):
8614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8616 
      return
8617 
    iprot.readStructBegin()
8618 
    while True:
8619 
      (fname, ftype, fid) = iprot.readFieldBegin()
8620 
      if ftype == TType.STOP:
8621 
        break
8622 
      else:
8623 
        iprot.skip(ftype)
8624 
      iprot.readFieldEnd()
8625 
    iprot.readStructEnd()
8626 
 
8627 
  def write(self, oprot):
8628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8630 
      return
8631 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
8632 
    oprot.writeFieldStop()
8633 
    oprot.writeStructEnd()
8634 
 
3431 rajveer 8635 
  def validate(self):
8636 
    return
8637 
 
8638 
 
3064 chandransh 8639 
  def __repr__(self):
8640 
    L = ['%s=%r' % (key, value)
8641 
      for key, value in self.__dict__.iteritems()]
8642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8643 
 
8644 
  def __eq__(self, other):
8645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8646 
 
8647 
  def __ne__(self, other):
8648 
    return not (self == other)
8649 
 
8650 
class getValidOrdersAmountRange_result:
94 ashish 8651 
  """
8652 
  Attributes:
8653 
   - success
8654 
  """
8655 
 
8656 
  thrift_spec = (
3064 chandransh 8657 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 8658 
  )
8659 
 
3064 chandransh 8660 
  def __init__(self, success=None,):
94 ashish 8661 
    self.success = success
8662 
 
8663 
  def read(self, iprot):
8664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8666 
      return
8667 
    iprot.readStructBegin()
8668 
    while True:
8669 
      (fname, ftype, fid) = iprot.readFieldBegin()
8670 
      if ftype == TType.STOP:
8671 
        break
8672 
      if fid == 0:
483 rajveer 8673 
        if ftype == TType.LIST:
8674 
          self.success = []
4133 chandransh 8675 
          (_etype122, _size119) = iprot.readListBegin()
8676 
          for _i123 in xrange(_size119):
8677 
            _elem124 = iprot.readDouble();
8678 
            self.success.append(_elem124)
483 rajveer 8679 
          iprot.readListEnd()
94 ashish 8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      else:
8683 
        iprot.skip(ftype)
8684 
      iprot.readFieldEnd()
8685 
    iprot.readStructEnd()
8686 
 
8687 
  def write(self, oprot):
8688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8690 
      return
3064 chandransh 8691 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 8692 
    if self.success is not None:
483 rajveer 8693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 8694 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
4133 chandransh 8695 
      for iter125 in self.success:
8696 
        oprot.writeDouble(iter125)
483 rajveer 8697 
      oprot.writeListEnd()
94 ashish 8698 
      oprot.writeFieldEnd()
8699 
    oprot.writeFieldStop()
8700 
    oprot.writeStructEnd()
8701 
 
3431 rajveer 8702 
  def validate(self):
8703 
    return
8704 
 
8705 
 
94 ashish 8706 
  def __repr__(self):
8707 
    L = ['%s=%r' % (key, value)
8708 
      for key, value in self.__dict__.iteritems()]
8709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8710 
 
8711 
  def __eq__(self, other):
8712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8713 
 
8714 
  def __ne__(self, other):
8715 
    return not (self == other)
8716 
 
3064 chandransh 8717 
class getValidOrders_args:
1528 ankur.sing 8718 
  """
8719 
  Attributes:
3064 chandransh 8720 
   - limit
1528 ankur.sing 8721 
  """
8722 
 
8723 
  thrift_spec = (
8724 
    None, # 0
3064 chandransh 8725 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 8726 
  )
8727 
 
3064 chandransh 8728 
  def __init__(self, limit=None,):
8729 
    self.limit = limit
1528 ankur.sing 8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      if fid == 1:
8741 
        if ftype == TType.I64:
3064 chandransh 8742 
          self.limit = iprot.readI64();
1528 ankur.sing 8743 
        else:
8744 
          iprot.skip(ftype)
8745 
      else:
8746 
        iprot.skip(ftype)
8747 
      iprot.readFieldEnd()
8748 
    iprot.readStructEnd()
8749 
 
8750 
  def write(self, oprot):
8751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8753 
      return
3064 chandransh 8754 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 8755 
    if self.limit is not None:
3064 chandransh 8756 
      oprot.writeFieldBegin('limit', TType.I64, 1)
8757 
      oprot.writeI64(self.limit)
1528 ankur.sing 8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
3431 rajveer 8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
1528 ankur.sing 8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
3064 chandransh 8777 
class getValidOrders_result:
1528 ankur.sing 8778 
  """
8779 
  Attributes:
8780 
   - success
8781 
  """
8782 
 
8783 
  thrift_spec = (
3064 chandransh 8784 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 8785 
  )
8786 
 
3064 chandransh 8787 
  def __init__(self, success=None,):
1528 ankur.sing 8788 
    self.success = success
8789 
 
8790 
  def read(self, iprot):
8791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8793 
      return
8794 
    iprot.readStructBegin()
8795 
    while True:
8796 
      (fname, ftype, fid) = iprot.readFieldBegin()
8797 
      if ftype == TType.STOP:
8798 
        break
8799 
      if fid == 0:
3064 chandransh 8800 
        if ftype == TType.LIST:
8801 
          self.success = []
4133 chandransh 8802 
          (_etype129, _size126) = iprot.readListBegin()
8803 
          for _i130 in xrange(_size126):
8804 
            _elem131 = Order()
8805 
            _elem131.read(iprot)
8806 
            self.success.append(_elem131)
3064 chandransh 8807 
          iprot.readListEnd()
1528 ankur.sing 8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      else:
8811 
        iprot.skip(ftype)
8812 
      iprot.readFieldEnd()
8813 
    iprot.readStructEnd()
8814 
 
8815 
  def write(self, oprot):
8816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8818 
      return
3064 chandransh 8819 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 8820 
    if self.success is not None:
3064 chandransh 8821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8823 
      for iter132 in self.success:
8824 
        iter132.write(oprot)
3064 chandransh 8825 
      oprot.writeListEnd()
1528 ankur.sing 8826 
      oprot.writeFieldEnd()
8827 
    oprot.writeFieldStop()
8828 
    oprot.writeStructEnd()
8829 
 
3431 rajveer 8830 
  def validate(self):
8831 
    return
8832 
 
8833 
 
1528 ankur.sing 8834 
  def __repr__(self):
8835 
    L = ['%s=%r' % (key, value)
8836 
      for key, value in self.__dict__.iteritems()]
8837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8838 
 
8839 
  def __eq__(self, other):
8840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8841 
 
8842 
  def __ne__(self, other):
8843 
    return not (self == other)
8844 
 
1220 chandransh 8845 
class batchOrders_args:
8846 
  """
8847 
  Attributes:
8848 
   - warehouseId
8849 
  """
8850 
 
8851 
  thrift_spec = (
8852 
    None, # 0
8853 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8854 
  )
8855 
 
8856 
  def __init__(self, warehouseId=None,):
8857 
    self.warehouseId = warehouseId
8858 
 
8859 
  def read(self, iprot):
8860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8862 
      return
8863 
    iprot.readStructBegin()
8864 
    while True:
8865 
      (fname, ftype, fid) = iprot.readFieldBegin()
8866 
      if ftype == TType.STOP:
8867 
        break
8868 
      if fid == 1:
8869 
        if ftype == TType.I64:
8870 
          self.warehouseId = iprot.readI64();
8871 
        else:
8872 
          iprot.skip(ftype)
8873 
      else:
8874 
        iprot.skip(ftype)
8875 
      iprot.readFieldEnd()
8876 
    iprot.readStructEnd()
8877 
 
8878 
  def write(self, oprot):
8879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8881 
      return
8882 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 8883 
    if self.warehouseId is not None:
1220 chandransh 8884 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8885 
      oprot.writeI64(self.warehouseId)
8886 
      oprot.writeFieldEnd()
8887 
    oprot.writeFieldStop()
8888 
    oprot.writeStructEnd()
8889 
 
3431 rajveer 8890 
  def validate(self):
8891 
    return
8892 
 
8893 
 
1220 chandransh 8894 
  def __repr__(self):
8895 
    L = ['%s=%r' % (key, value)
8896 
      for key, value in self.__dict__.iteritems()]
8897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8898 
 
8899 
  def __eq__(self, other):
8900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8901 
 
8902 
  def __ne__(self, other):
8903 
    return not (self == other)
8904 
 
8905 
class batchOrders_result:
8906 
  """
8907 
  Attributes:
8908 
   - success
8909 
   - ex
8910 
  """
8911 
 
8912 
  thrift_spec = (
8913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8915 
  )
8916 
 
8917 
  def __init__(self, success=None, ex=None,):
8918 
    self.success = success
8919 
    self.ex = ex
8920 
 
8921 
  def read(self, iprot):
8922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8924 
      return
8925 
    iprot.readStructBegin()
8926 
    while True:
8927 
      (fname, ftype, fid) = iprot.readFieldBegin()
8928 
      if ftype == TType.STOP:
8929 
        break
8930 
      if fid == 0:
8931 
        if ftype == TType.LIST:
8932 
          self.success = []
4133 chandransh 8933 
          (_etype136, _size133) = iprot.readListBegin()
8934 
          for _i137 in xrange(_size133):
8935 
            _elem138 = Order()
8936 
            _elem138.read(iprot)
8937 
            self.success.append(_elem138)
1220 chandransh 8938 
          iprot.readListEnd()
8939 
        else:
8940 
          iprot.skip(ftype)
8941 
      elif fid == 1:
8942 
        if ftype == TType.STRUCT:
8943 
          self.ex = TransactionServiceException()
8944 
          self.ex.read(iprot)
8945 
        else:
8946 
          iprot.skip(ftype)
8947 
      else:
8948 
        iprot.skip(ftype)
8949 
      iprot.readFieldEnd()
8950 
    iprot.readStructEnd()
8951 
 
8952 
  def write(self, oprot):
8953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8955 
      return
8956 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 8957 
    if self.success is not None:
1220 chandransh 8958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 8960 
      for iter139 in self.success:
8961 
        iter139.write(oprot)
1220 chandransh 8962 
      oprot.writeListEnd()
8963 
      oprot.writeFieldEnd()
3431 rajveer 8964 
    if self.ex is not None:
1220 chandransh 8965 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8966 
      self.ex.write(oprot)
8967 
      oprot.writeFieldEnd()
8968 
    oprot.writeFieldStop()
8969 
    oprot.writeStructEnd()
8970 
 
3431 rajveer 8971 
  def validate(self):
8972 
    return
8973 
 
8974 
 
1220 chandransh 8975 
  def __repr__(self):
8976 
    L = ['%s=%r' % (key, value)
8977 
      for key, value in self.__dict__.iteritems()]
8978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8979 
 
8980 
  def __eq__(self, other):
8981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8982 
 
8983 
  def __ne__(self, other):
8984 
    return not (self == other)
8985 
 
1208 chandransh 8986 
class markOrderAsOutOfStock_args:
8987 
  """
8988 
  Attributes:
8989 
   - orderId
8990 
  """
8991 
 
8992 
  thrift_spec = (
8993 
    None, # 0
8994 
    (1, TType.I64, 'orderId', None, None, ), # 1
8995 
  )
8996 
 
8997 
  def __init__(self, orderId=None,):
8998 
    self.orderId = orderId
8999 
 
9000 
  def read(self, iprot):
9001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9003 
      return
9004 
    iprot.readStructBegin()
9005 
    while True:
9006 
      (fname, ftype, fid) = iprot.readFieldBegin()
9007 
      if ftype == TType.STOP:
9008 
        break
9009 
      if fid == 1:
9010 
        if ftype == TType.I64:
9011 
          self.orderId = iprot.readI64();
9012 
        else:
9013 
          iprot.skip(ftype)
9014 
      else:
9015 
        iprot.skip(ftype)
9016 
      iprot.readFieldEnd()
9017 
    iprot.readStructEnd()
9018 
 
9019 
  def write(self, oprot):
9020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9022 
      return
9023 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 9024 
    if self.orderId is not None:
1208 chandransh 9025 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9026 
      oprot.writeI64(self.orderId)
9027 
      oprot.writeFieldEnd()
9028 
    oprot.writeFieldStop()
9029 
    oprot.writeStructEnd()
9030 
 
3431 rajveer 9031 
  def validate(self):
9032 
    return
9033 
 
9034 
 
1208 chandransh 9035 
  def __repr__(self):
9036 
    L = ['%s=%r' % (key, value)
9037 
      for key, value in self.__dict__.iteritems()]
9038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9039 
 
9040 
  def __eq__(self, other):
9041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9042 
 
9043 
  def __ne__(self, other):
9044 
    return not (self == other)
9045 
 
9046 
class markOrderAsOutOfStock_result:
9047 
  """
9048 
  Attributes:
9049 
   - success
9050 
   - ex
9051 
  """
9052 
 
9053 
  thrift_spec = (
9054 
    (0, TType.BOOL, 'success', None, None, ), # 0
9055 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9056 
  )
9057 
 
9058 
  def __init__(self, success=None, ex=None,):
9059 
    self.success = success
9060 
    self.ex = ex
9061 
 
9062 
  def read(self, iprot):
9063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9065 
      return
9066 
    iprot.readStructBegin()
9067 
    while True:
9068 
      (fname, ftype, fid) = iprot.readFieldBegin()
9069 
      if ftype == TType.STOP:
9070 
        break
9071 
      if fid == 0:
9072 
        if ftype == TType.BOOL:
9073 
          self.success = iprot.readBool();
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      elif fid == 1:
9077 
        if ftype == TType.STRUCT:
9078 
          self.ex = TransactionServiceException()
9079 
          self.ex.read(iprot)
9080 
        else:
9081 
          iprot.skip(ftype)
9082 
      else:
9083 
        iprot.skip(ftype)
9084 
      iprot.readFieldEnd()
9085 
    iprot.readStructEnd()
9086 
 
9087 
  def write(self, oprot):
9088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9090 
      return
9091 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 9092 
    if self.success is not None:
1208 chandransh 9093 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9094 
      oprot.writeBool(self.success)
9095 
      oprot.writeFieldEnd()
3431 rajveer 9096 
    if self.ex is not None:
1208 chandransh 9097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9098 
      self.ex.write(oprot)
9099 
      oprot.writeFieldEnd()
9100 
    oprot.writeFieldStop()
9101 
    oprot.writeStructEnd()
9102 
 
3431 rajveer 9103 
  def validate(self):
9104 
    return
9105 
 
9106 
 
1208 chandransh 9107 
  def __repr__(self):
9108 
    L = ['%s=%r' % (key, value)
9109 
      for key, value in self.__dict__.iteritems()]
9110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9111 
 
9112 
  def __eq__(self, other):
9113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9114 
 
9115 
  def __ne__(self, other):
9116 
    return not (self == other)
9117 
 
3064 chandransh 9118 
class verifyOrder_args:
759 chandransh 9119 
  """
9120 
  Attributes:
3064 chandransh 9121 
   - orderId
759 chandransh 9122 
  """
9123 
 
9124 
  thrift_spec = (
9125 
    None, # 0
3064 chandransh 9126 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 9127 
  )
9128 
 
3064 chandransh 9129 
  def __init__(self, orderId=None,):
9130 
    self.orderId = orderId
759 chandransh 9131 
 
9132 
  def read(self, iprot):
9133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9135 
      return
9136 
    iprot.readStructBegin()
9137 
    while True:
9138 
      (fname, ftype, fid) = iprot.readFieldBegin()
9139 
      if ftype == TType.STOP:
9140 
        break
9141 
      if fid == 1:
9142 
        if ftype == TType.I64:
3064 chandransh 9143 
          self.orderId = iprot.readI64();
759 chandransh 9144 
        else:
9145 
          iprot.skip(ftype)
9146 
      else:
9147 
        iprot.skip(ftype)
9148 
      iprot.readFieldEnd()
9149 
    iprot.readStructEnd()
9150 
 
9151 
  def write(self, oprot):
9152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9154 
      return
3064 chandransh 9155 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 9156 
    if self.orderId is not None:
3064 chandransh 9157 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9158 
      oprot.writeI64(self.orderId)
759 chandransh 9159 
      oprot.writeFieldEnd()
9160 
    oprot.writeFieldStop()
9161 
    oprot.writeStructEnd()
9162 
 
3431 rajveer 9163 
  def validate(self):
9164 
    return
9165 
 
9166 
 
759 chandransh 9167 
  def __repr__(self):
9168 
    L = ['%s=%r' % (key, value)
9169 
      for key, value in self.__dict__.iteritems()]
9170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9171 
 
9172 
  def __eq__(self, other):
9173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9174 
 
9175 
  def __ne__(self, other):
9176 
    return not (self == other)
9177 
 
3064 chandransh 9178 
class verifyOrder_result:
759 chandransh 9179 
  """
9180 
  Attributes:
9181 
   - success
9182 
   - ex
9183 
  """
9184 
 
9185 
  thrift_spec = (
9186 
    (0, TType.BOOL, 'success', None, None, ), # 0
9187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9188 
  )
9189 
 
9190 
  def __init__(self, success=None, ex=None,):
9191 
    self.success = success
9192 
    self.ex = ex
9193 
 
9194 
  def read(self, iprot):
9195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9197 
      return
9198 
    iprot.readStructBegin()
9199 
    while True:
9200 
      (fname, ftype, fid) = iprot.readFieldBegin()
9201 
      if ftype == TType.STOP:
9202 
        break
9203 
      if fid == 0:
9204 
        if ftype == TType.BOOL:
9205 
          self.success = iprot.readBool();
9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      elif fid == 1:
9209 
        if ftype == TType.STRUCT:
9210 
          self.ex = TransactionServiceException()
9211 
          self.ex.read(iprot)
9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
3064 chandransh 9223 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 9224 
    if self.success is not None:
759 chandransh 9225 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9226 
      oprot.writeBool(self.success)
9227 
      oprot.writeFieldEnd()
3431 rajveer 9228 
    if self.ex is not None:
759 chandransh 9229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9230 
      self.ex.write(oprot)
9231 
      oprot.writeFieldEnd()
9232 
    oprot.writeFieldStop()
9233 
    oprot.writeStructEnd()
9234 
 
3431 rajveer 9235 
  def validate(self):
9236 
    return
9237 
 
9238 
 
759 chandransh 9239 
  def __repr__(self):
9240 
    L = ['%s=%r' % (key, value)
9241 
      for key, value in self.__dict__.iteritems()]
9242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9243 
 
9244 
  def __eq__(self, other):
9245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9246 
 
9247 
  def __ne__(self, other):
9248 
    return not (self == other)
9249 
 
3064 chandransh 9250 
class acceptOrder_args:
1113 chandransh 9251 
  """
9252 
  Attributes:
3064 chandransh 9253 
   - orderId
1113 chandransh 9254 
  """
9255 
 
9256 
  thrift_spec = (
9257 
    None, # 0
3064 chandransh 9258 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 9259 
  )
9260 
 
3064 chandransh 9261 
  def __init__(self, orderId=None,):
9262 
    self.orderId = orderId
1113 chandransh 9263 
 
9264 
  def read(self, iprot):
9265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9267 
      return
9268 
    iprot.readStructBegin()
9269 
    while True:
9270 
      (fname, ftype, fid) = iprot.readFieldBegin()
9271 
      if ftype == TType.STOP:
9272 
        break
9273 
      if fid == 1:
9274 
        if ftype == TType.I64:
3064 chandransh 9275 
          self.orderId = iprot.readI64();
1113 chandransh 9276 
        else:
9277 
          iprot.skip(ftype)
9278 
      else:
9279 
        iprot.skip(ftype)
9280 
      iprot.readFieldEnd()
9281 
    iprot.readStructEnd()
9282 
 
9283 
  def write(self, oprot):
9284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9286 
      return
3064 chandransh 9287 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 9288 
    if self.orderId is not None:
3064 chandransh 9289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9290 
      oprot.writeI64(self.orderId)
1113 chandransh 9291 
      oprot.writeFieldEnd()
9292 
    oprot.writeFieldStop()
9293 
    oprot.writeStructEnd()
9294 
 
3431 rajveer 9295 
  def validate(self):
9296 
    return
9297 
 
9298 
 
1113 chandransh 9299 
  def __repr__(self):
9300 
    L = ['%s=%r' % (key, value)
9301 
      for key, value in self.__dict__.iteritems()]
9302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9303 
 
9304 
  def __eq__(self, other):
9305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9306 
 
9307 
  def __ne__(self, other):
9308 
    return not (self == other)
9309 
 
3064 chandransh 9310 
class acceptOrder_result:
1113 chandransh 9311 
  """
9312 
  Attributes:
9313 
   - success
9314 
   - ex
9315 
  """
9316 
 
9317 
  thrift_spec = (
3064 chandransh 9318 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 9319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9320 
  )
9321 
 
9322 
  def __init__(self, success=None, ex=None,):
9323 
    self.success = success
9324 
    self.ex = ex
9325 
 
9326 
  def read(self, iprot):
9327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9329 
      return
9330 
    iprot.readStructBegin()
9331 
    while True:
9332 
      (fname, ftype, fid) = iprot.readFieldBegin()
9333 
      if ftype == TType.STOP:
9334 
        break
9335 
      if fid == 0:
3064 chandransh 9336 
        if ftype == TType.BOOL:
9337 
          self.success = iprot.readBool();
1113 chandransh 9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      elif fid == 1:
9341 
        if ftype == TType.STRUCT:
9342 
          self.ex = TransactionServiceException()
9343 
          self.ex.read(iprot)
9344 
        else:
9345 
          iprot.skip(ftype)
9346 
      else:
9347 
        iprot.skip(ftype)
9348 
      iprot.readFieldEnd()
9349 
    iprot.readStructEnd()
9350 
 
9351 
  def write(self, oprot):
9352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9354 
      return
3064 chandransh 9355 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 9356 
    if self.success is not None:
3064 chandransh 9357 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9358 
      oprot.writeBool(self.success)
1113 chandransh 9359 
      oprot.writeFieldEnd()
3431 rajveer 9360 
    if self.ex is not None:
1113 chandransh 9361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9362 
      self.ex.write(oprot)
9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
3431 rajveer 9367 
  def validate(self):
9368 
    return
9369 
 
9370 
 
1113 chandransh 9371 
  def __repr__(self):
9372 
    L = ['%s=%r' % (key, value)
9373 
      for key, value in self.__dict__.iteritems()]
9374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9375 
 
9376 
  def __eq__(self, other):
9377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9378 
 
9379 
  def __ne__(self, other):
9380 
    return not (self == other)
9381 
 
3064 chandransh 9382 
class addBillingDetails_args:
1135 chandransh 9383 
  """
9384 
  Attributes:
3064 chandransh 9385 
   - orderId
9386 
   - invoice_number
4283 anupam.sin 9387 
   - imeiNumber
9388 
   - itemNumber
3064 chandransh 9389 
   - billed_by
4264 rajveer 9390 
   - jacketNumber
4283 anupam.sin 9391 
   - billingType
9392 
   - vendorId
1135 chandransh 9393 
  """
9394 
 
9395 
  thrift_spec = (
9396 
    None, # 0
3064 chandransh 9397 
    (1, TType.I64, 'orderId', None, None, ), # 1
9398 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4283 anupam.sin 9399 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
9400 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
9401 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
9402 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
9403 
    (7, TType.I64, 'billingType', None, None, ), # 7
9404 
    (8, TType.I64, 'vendorId', None, None, ), # 8
1135 chandransh 9405 
  )
9406 
 
4283 anupam.sin 9407 
  def __init__(self, orderId=None, invoice_number=None, imeiNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, vendorId=None,):
3064 chandransh 9408 
    self.orderId = orderId
9409 
    self.invoice_number = invoice_number
4283 anupam.sin 9410 
    self.imeiNumber = imeiNumber
9411 
    self.itemNumber = itemNumber
3064 chandransh 9412 
    self.billed_by = billed_by
4264 rajveer 9413 
    self.jacketNumber = jacketNumber
4283 anupam.sin 9414 
    self.billingType = billingType
9415 
    self.vendorId = vendorId
1135 chandransh 9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
3064 chandransh 9428 
          self.orderId = iprot.readI64();
1135 chandransh 9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      elif fid == 2:
3064 chandransh 9432 
        if ftype == TType.STRING:
9433 
          self.invoice_number = iprot.readString();
1135 chandransh 9434 
        else:
9435 
          iprot.skip(ftype)
3064 chandransh 9436 
      elif fid == 3:
4264 rajveer 9437 
        if ftype == TType.I64:
3064 chandransh 9438 
          self.imeiNumber = iprot.readI64();
9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      elif fid == 4:
9442 
        if ftype == TType.STRING:
9443 
          self.itemNumber = iprot.readString();
9444 
        else:
9445 
          iprot.skip(ftype)
9446 
      elif fid == 5:
9447 
        if ftype == TType.STRING:
4283 anupam.sin 9448 
          self.billed_by = iprot.readString();
3064 chandransh 9449 
        else:
9450 
          iprot.skip(ftype)
9451 
      elif fid == 6:
9452 
        if ftype == TType.I64:
4283 anupam.sin 9453 
          self.jacketNumber = iprot.readI64();
9454 
        else:
9455 
          iprot.skip(ftype)
9456 
      elif fid == 7:
9457 
        if ftype == TType.I64:
3064 chandransh 9458 
          self.billingType = iprot.readI64();
9459 
        else:
9460 
          iprot.skip(ftype)
4283 anupam.sin 9461 
      elif fid == 8:
9462 
        if ftype == TType.I64:
9463 
          self.vendorId = iprot.readI64();
9464 
        else:
9465 
          iprot.skip(ftype)
1246 chandransh 9466 
      else:
9467 
        iprot.skip(ftype)
9468 
      iprot.readFieldEnd()
9469 
    iprot.readStructEnd()
9470 
 
9471 
  def write(self, oprot):
9472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9474 
      return
4283 anupam.sin 9475 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 9476 
    if self.orderId is not None:
3064 chandransh 9477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9478 
      oprot.writeI64(self.orderId)
1246 chandransh 9479 
      oprot.writeFieldEnd()
4283 anupam.sin 9480 
    if self.invoice_number is not None:
9481 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
9482 
      oprot.writeString(self.invoice_number)
1246 chandransh 9483 
      oprot.writeFieldEnd()
3431 rajveer 9484 
    if self.imeiNumber is not None:
3064 chandransh 9485 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
9486 
      oprot.writeI64(self.imeiNumber)
9487 
      oprot.writeFieldEnd()
3431 rajveer 9488 
    if self.itemNumber is not None:
3064 chandransh 9489 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
9490 
      oprot.writeString(self.itemNumber)
9491 
      oprot.writeFieldEnd()
4283 anupam.sin 9492 
    if self.billed_by is not None:
9493 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
9494 
      oprot.writeString(self.billed_by)
3064 chandransh 9495 
      oprot.writeFieldEnd()
4283 anupam.sin 9496 
    if self.jacketNumber is not None:
9497 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
9498 
      oprot.writeI64(self.jacketNumber)
9499 
      oprot.writeFieldEnd()
3431 rajveer 9500 
    if self.billingType is not None:
4283 anupam.sin 9501 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 9502 
      oprot.writeI64(self.billingType)
9503 
      oprot.writeFieldEnd()
4283 anupam.sin 9504 
    if self.vendorId is not None:
9505 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
9506 
      oprot.writeI64(self.vendorId)
9507 
      oprot.writeFieldEnd()
1246 chandransh 9508 
    oprot.writeFieldStop()
9509 
    oprot.writeStructEnd()
9510 
 
3431 rajveer 9511 
  def validate(self):
9512 
    return
9513 
 
9514 
 
1246 chandransh 9515 
  def __repr__(self):
9516 
    L = ['%s=%r' % (key, value)
9517 
      for key, value in self.__dict__.iteritems()]
9518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9519 
 
9520 
  def __eq__(self, other):
9521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9522 
 
9523 
  def __ne__(self, other):
9524 
    return not (self == other)
9525 
 
4283 anupam.sin 9526 
class addBillingDetails_result:
1246 chandransh 9527 
  """
9528 
  Attributes:
3064 chandransh 9529 
   - success
1246 chandransh 9530 
   - ex
9531 
  """
9532 
 
9533 
  thrift_spec = (
3064 chandransh 9534 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 9535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9536 
  )
9537 
 
3064 chandransh 9538 
  def __init__(self, success=None, ex=None,):
9539 
    self.success = success
1246 chandransh 9540 
    self.ex = ex
9541 
 
9542 
  def read(self, iprot):
9543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9545 
      return
9546 
    iprot.readStructBegin()
9547 
    while True:
9548 
      (fname, ftype, fid) = iprot.readFieldBegin()
9549 
      if ftype == TType.STOP:
9550 
        break
3064 chandransh 9551 
      if fid == 0:
9552 
        if ftype == TType.BOOL:
9553 
          self.success = iprot.readBool();
9554 
        else:
9555 
          iprot.skip(ftype)
9556 
      elif fid == 1:
1246 chandransh 9557 
        if ftype == TType.STRUCT:
9558 
          self.ex = TransactionServiceException()
9559 
          self.ex.read(iprot)
9560 
        else:
9561 
          iprot.skip(ftype)
9562 
      else:
9563 
        iprot.skip(ftype)
9564 
      iprot.readFieldEnd()
9565 
    iprot.readStructEnd()
9566 
 
9567 
  def write(self, oprot):
9568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9570 
      return
4283 anupam.sin 9571 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 9572 
    if self.success is not None:
3064 chandransh 9573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9574 
      oprot.writeBool(self.success)
9575 
      oprot.writeFieldEnd()
3431 rajveer 9576 
    if self.ex is not None:
1246 chandransh 9577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9578 
      self.ex.write(oprot)
9579 
      oprot.writeFieldEnd()
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
3431 rajveer 9583 
  def validate(self):
9584 
    return
9585 
 
9586 
 
1246 chandransh 9587 
  def __repr__(self):
9588 
    L = ['%s=%r' % (key, value)
9589 
      for key, value in self.__dict__.iteritems()]
9590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9591 
 
9592 
  def __eq__(self, other):
9593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9594 
 
9595 
  def __ne__(self, other):
9596 
    return not (self == other)
9597 
 
3064 chandransh 9598 
class markOrdersAsManifested_args:
1408 ankur.sing 9599 
  """
9600 
  Attributes:
3064 chandransh 9601 
   - warehouseId
1408 ankur.sing 9602 
   - providerId
3064 chandransh 9603 
   - cod
1408 ankur.sing 9604 
  """
9605 
 
9606 
  thrift_spec = (
9607 
    None, # 0
3064 chandransh 9608 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9609 
    (2, TType.I64, 'providerId', None, None, ), # 2
9610 
    (3, TType.BOOL, 'cod', None, None, ), # 3
1408 ankur.sing 9611 
  )
9612 
 
3064 chandransh 9613 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9614 
    self.warehouseId = warehouseId
1408 ankur.sing 9615 
    self.providerId = providerId
3064 chandransh 9616 
    self.cod = cod
1408 ankur.sing 9617 
 
9618 
  def read(self, iprot):
9619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9621 
      return
9622 
    iprot.readStructBegin()
9623 
    while True:
9624 
      (fname, ftype, fid) = iprot.readFieldBegin()
9625 
      if ftype == TType.STOP:
9626 
        break
9627 
      if fid == 1:
9628 
        if ftype == TType.I64:
3064 chandransh 9629 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 9630 
        else:
9631 
          iprot.skip(ftype)
9632 
      elif fid == 2:
9633 
        if ftype == TType.I64:
3064 chandransh 9634 
          self.providerId = iprot.readI64();
1408 ankur.sing 9635 
        else:
9636 
          iprot.skip(ftype)
3064 chandransh 9637 
      elif fid == 3:
9638 
        if ftype == TType.BOOL:
9639 
          self.cod = iprot.readBool();
9640 
        else:
9641 
          iprot.skip(ftype)
1408 ankur.sing 9642 
      else:
9643 
        iprot.skip(ftype)
9644 
      iprot.readFieldEnd()
9645 
    iprot.readStructEnd()
9646 
 
9647 
  def write(self, oprot):
9648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9650 
      return
3064 chandransh 9651 
    oprot.writeStructBegin('markOrdersAsManifested_args')
3431 rajveer 9652 
    if self.warehouseId is not None:
3064 chandransh 9653 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9654 
      oprot.writeI64(self.warehouseId)
9655 
      oprot.writeFieldEnd()
3431 rajveer 9656 
    if self.providerId is not None:
3064 chandransh 9657 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 9658 
      oprot.writeI64(self.providerId)
9659 
      oprot.writeFieldEnd()
3431 rajveer 9660 
    if self.cod is not None:
3064 chandransh 9661 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9662 
      oprot.writeBool(self.cod)
1408 ankur.sing 9663 
      oprot.writeFieldEnd()
9664 
    oprot.writeFieldStop()
9665 
    oprot.writeStructEnd()
9666 
 
3431 rajveer 9667 
  def validate(self):
9668 
    return
9669 
 
9670 
 
1408 ankur.sing 9671 
  def __repr__(self):
9672 
    L = ['%s=%r' % (key, value)
9673 
      for key, value in self.__dict__.iteritems()]
9674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9675 
 
9676 
  def __eq__(self, other):
9677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9678 
 
9679 
  def __ne__(self, other):
9680 
    return not (self == other)
9681 
 
3064 chandransh 9682 
class markOrdersAsManifested_result:
1408 ankur.sing 9683 
  """
9684 
  Attributes:
9685 
   - success
3064 chandransh 9686 
   - ex
1408 ankur.sing 9687 
  """
9688 
 
9689 
  thrift_spec = (
3064 chandransh 9690 
    (0, TType.BOOL, 'success', None, None, ), # 0
9691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 9692 
  )
9693 
 
3064 chandransh 9694 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 9695 
    self.success = success
3064 chandransh 9696 
    self.ex = ex
1408 ankur.sing 9697 
 
9698 
  def read(self, iprot):
9699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9701 
      return
9702 
    iprot.readStructBegin()
9703 
    while True:
9704 
      (fname, ftype, fid) = iprot.readFieldBegin()
9705 
      if ftype == TType.STOP:
9706 
        break
9707 
      if fid == 0:
3064 chandransh 9708 
        if ftype == TType.BOOL:
9709 
          self.success = iprot.readBool();
1408 ankur.sing 9710 
        else:
9711 
          iprot.skip(ftype)
3064 chandransh 9712 
      elif fid == 1:
9713 
        if ftype == TType.STRUCT:
9714 
          self.ex = TransactionServiceException()
9715 
          self.ex.read(iprot)
9716 
        else:
9717 
          iprot.skip(ftype)
1408 ankur.sing 9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
3064 chandransh 9727 
    oprot.writeStructBegin('markOrdersAsManifested_result')
3431 rajveer 9728 
    if self.success is not None:
3064 chandransh 9729 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9730 
      oprot.writeBool(self.success)
1408 ankur.sing 9731 
      oprot.writeFieldEnd()
3431 rajveer 9732 
    if self.ex is not None:
3064 chandransh 9733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9734 
      self.ex.write(oprot)
9735 
      oprot.writeFieldEnd()
1408 ankur.sing 9736 
    oprot.writeFieldStop()
9737 
    oprot.writeStructEnd()
9738 
 
3431 rajveer 9739 
  def validate(self):
9740 
    return
9741 
 
9742 
 
1408 ankur.sing 9743 
  def __repr__(self):
9744 
    L = ['%s=%r' % (key, value)
9745 
      for key, value in self.__dict__.iteritems()]
9746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9747 
 
9748 
  def __eq__(self, other):
9749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9750 
 
9751 
  def __ne__(self, other):
9752 
    return not (self == other)
9753 
 
4410 rajveer 9754 
class markOrdersAsShippedFromWarehouse_args:
9755 
  """
9756 
  Attributes:
9757 
   - warehouseId
9758 
   - providerId
9759 
   - cod
9760 
  """
9761 
 
9762 
  thrift_spec = (
9763 
    None, # 0
9764 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9765 
    (2, TType.I64, 'providerId', None, None, ), # 2
9766 
    (3, TType.BOOL, 'cod', None, None, ), # 3
9767 
  )
9768 
 
9769 
  def __init__(self, warehouseId=None, providerId=None, cod=None,):
9770 
    self.warehouseId = warehouseId
9771 
    self.providerId = providerId
9772 
    self.cod = cod
9773 
 
9774 
  def read(self, iprot):
9775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9777 
      return
9778 
    iprot.readStructBegin()
9779 
    while True:
9780 
      (fname, ftype, fid) = iprot.readFieldBegin()
9781 
      if ftype == TType.STOP:
9782 
        break
9783 
      if fid == 1:
9784 
        if ftype == TType.I64:
9785 
          self.warehouseId = iprot.readI64();
9786 
        else:
9787 
          iprot.skip(ftype)
9788 
      elif fid == 2:
9789 
        if ftype == TType.I64:
9790 
          self.providerId = iprot.readI64();
9791 
        else:
9792 
          iprot.skip(ftype)
9793 
      elif fid == 3:
9794 
        if ftype == TType.BOOL:
9795 
          self.cod = iprot.readBool();
9796 
        else:
9797 
          iprot.skip(ftype)
9798 
      else:
9799 
        iprot.skip(ftype)
9800 
      iprot.readFieldEnd()
9801 
    iprot.readStructEnd()
9802 
 
9803 
  def write(self, oprot):
9804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9806 
      return
9807 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
9808 
    if self.warehouseId is not None:
9809 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9810 
      oprot.writeI64(self.warehouseId)
9811 
      oprot.writeFieldEnd()
9812 
    if self.providerId is not None:
9813 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
9814 
      oprot.writeI64(self.providerId)
9815 
      oprot.writeFieldEnd()
9816 
    if self.cod is not None:
9817 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
9818 
      oprot.writeBool(self.cod)
9819 
      oprot.writeFieldEnd()
9820 
    oprot.writeFieldStop()
9821 
    oprot.writeStructEnd()
9822 
 
9823 
  def validate(self):
9824 
    return
9825 
 
9826 
 
9827 
  def __repr__(self):
9828 
    L = ['%s=%r' % (key, value)
9829 
      for key, value in self.__dict__.iteritems()]
9830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9831 
 
9832 
  def __eq__(self, other):
9833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9834 
 
9835 
  def __ne__(self, other):
9836 
    return not (self == other)
9837 
 
9838 
class markOrdersAsShippedFromWarehouse_result:
9839 
  """
9840 
  Attributes:
9841 
   - success
9842 
   - ex
9843 
  """
9844 
 
9845 
  thrift_spec = (
9846 
    (0, TType.BOOL, 'success', None, None, ), # 0
9847 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9848 
  )
9849 
 
9850 
  def __init__(self, success=None, ex=None,):
9851 
    self.success = success
9852 
    self.ex = ex
9853 
 
9854 
  def read(self, iprot):
9855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9857 
      return
9858 
    iprot.readStructBegin()
9859 
    while True:
9860 
      (fname, ftype, fid) = iprot.readFieldBegin()
9861 
      if ftype == TType.STOP:
9862 
        break
9863 
      if fid == 0:
9864 
        if ftype == TType.BOOL:
9865 
          self.success = iprot.readBool();
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      elif fid == 1:
9869 
        if ftype == TType.STRUCT:
9870 
          self.ex = TransactionServiceException()
9871 
          self.ex.read(iprot)
9872 
        else:
9873 
          iprot.skip(ftype)
9874 
      else:
9875 
        iprot.skip(ftype)
9876 
      iprot.readFieldEnd()
9877 
    iprot.readStructEnd()
9878 
 
9879 
  def write(self, oprot):
9880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9882 
      return
9883 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
9884 
    if self.success is not None:
9885 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9886 
      oprot.writeBool(self.success)
9887 
      oprot.writeFieldEnd()
9888 
    if self.ex is not None:
9889 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9890 
      self.ex.write(oprot)
9891 
      oprot.writeFieldEnd()
9892 
    oprot.writeFieldStop()
9893 
    oprot.writeStructEnd()
9894 
 
9895 
  def validate(self):
9896 
    return
9897 
 
9898 
 
9899 
  def __repr__(self):
9900 
    L = ['%s=%r' % (key, value)
9901 
      for key, value in self.__dict__.iteritems()]
9902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9903 
 
9904 
  def __eq__(self, other):
9905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9906 
 
9907 
  def __ne__(self, other):
9908 
    return not (self == other)
9909 
 
3064 chandransh 9910 
class markOrdersAsPickedUp_args:
304 ashish 9911 
  """
9912 
  Attributes:
3064 chandransh 9913 
   - providerId
9914 
   - pickupDetails
304 ashish 9915 
  """
94 ashish 9916 
 
304 ashish 9917 
  thrift_spec = (
9918 
    None, # 0
3064 chandransh 9919 
    (1, TType.I64, 'providerId', None, None, ), # 1
9920 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 9921 
  )
9922 
 
3064 chandransh 9923 
  def __init__(self, providerId=None, pickupDetails=None,):
9924 
    self.providerId = providerId
9925 
    self.pickupDetails = pickupDetails
304 ashish 9926 
 
9927 
  def read(self, iprot):
9928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9930 
      return
9931 
    iprot.readStructBegin()
9932 
    while True:
9933 
      (fname, ftype, fid) = iprot.readFieldBegin()
9934 
      if ftype == TType.STOP:
9935 
        break
9936 
      if fid == 1:
9937 
        if ftype == TType.I64:
3064 chandransh 9938 
          self.providerId = iprot.readI64();
304 ashish 9939 
        else:
9940 
          iprot.skip(ftype)
9941 
      elif fid == 2:
3064 chandransh 9942 
        if ftype == TType.MAP:
9943 
          self.pickupDetails = {}
4133 chandransh 9944 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9945 
          for _i144 in xrange(_size140):
9946 
            _key145 = iprot.readString();
9947 
            _val146 = iprot.readString();
9948 
            self.pickupDetails[_key145] = _val146
3064 chandransh 9949 
          iprot.readMapEnd()
304 ashish 9950 
        else:
9951 
          iprot.skip(ftype)
9952 
      else:
9953 
        iprot.skip(ftype)
9954 
      iprot.readFieldEnd()
9955 
    iprot.readStructEnd()
9956 
 
9957 
  def write(self, oprot):
9958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9960 
      return
3064 chandransh 9961 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
3431 rajveer 9962 
    if self.providerId is not None:
3064 chandransh 9963 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
9964 
      oprot.writeI64(self.providerId)
304 ashish 9965 
      oprot.writeFieldEnd()
3431 rajveer 9966 
    if self.pickupDetails is not None:
3064 chandransh 9967 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
9968 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 9969 
      for kiter147,viter148 in self.pickupDetails.items():
9970 
        oprot.writeString(kiter147)
9971 
        oprot.writeString(viter148)
3064 chandransh 9972 
      oprot.writeMapEnd()
304 ashish 9973 
      oprot.writeFieldEnd()
9974 
    oprot.writeFieldStop()
9975 
    oprot.writeStructEnd()
9976 
 
3431 rajveer 9977 
  def validate(self):
9978 
    return
9979 
 
9980 
 
304 ashish 9981 
  def __repr__(self):
9982 
    L = ['%s=%r' % (key, value)
9983 
      for key, value in self.__dict__.iteritems()]
9984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9985 
 
9986 
  def __eq__(self, other):
9987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9988 
 
9989 
  def __ne__(self, other):
9990 
    return not (self == other)
9991 
 
3064 chandransh 9992 
class markOrdersAsPickedUp_result:
304 ashish 9993 
  """
9994 
  Attributes:
9995 
   - success
3064 chandransh 9996 
   - ex
304 ashish 9997 
  """
9998 
 
9999 
  thrift_spec = (
3064 chandransh 10000 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10002 
  )
10003 
 
3064 chandransh 10004 
  def __init__(self, success=None, ex=None,):
304 ashish 10005 
    self.success = success
3064 chandransh 10006 
    self.ex = ex
304 ashish 10007 
 
10008 
  def read(self, iprot):
10009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10011 
      return
10012 
    iprot.readStructBegin()
10013 
    while True:
10014 
      (fname, ftype, fid) = iprot.readFieldBegin()
10015 
      if ftype == TType.STOP:
10016 
        break
10017 
      if fid == 0:
10018 
        if ftype == TType.LIST:
10019 
          self.success = []
4133 chandransh 10020 
          (_etype152, _size149) = iprot.readListBegin()
10021 
          for _i153 in xrange(_size149):
10022 
            _elem154 = Order()
10023 
            _elem154.read(iprot)
10024 
            self.success.append(_elem154)
304 ashish 10025 
          iprot.readListEnd()
10026 
        else:
10027 
          iprot.skip(ftype)
3064 chandransh 10028 
      elif fid == 1:
10029 
        if ftype == TType.STRUCT:
10030 
          self.ex = TransactionServiceException()
10031 
          self.ex.read(iprot)
10032 
        else:
10033 
          iprot.skip(ftype)
304 ashish 10034 
      else:
10035 
        iprot.skip(ftype)
10036 
      iprot.readFieldEnd()
10037 
    iprot.readStructEnd()
10038 
 
10039 
  def write(self, oprot):
10040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10042 
      return
3064 chandransh 10043 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
3431 rajveer 10044 
    if self.success is not None:
304 ashish 10045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10047 
      for iter155 in self.success:
10048 
        iter155.write(oprot)
304 ashish 10049 
      oprot.writeListEnd()
10050 
      oprot.writeFieldEnd()
3431 rajveer 10051 
    if self.ex is not None:
3064 chandransh 10052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10053 
      self.ex.write(oprot)
10054 
      oprot.writeFieldEnd()
304 ashish 10055 
    oprot.writeFieldStop()
10056 
    oprot.writeStructEnd()
10057 
 
3431 rajveer 10058 
  def validate(self):
10059 
    return
10060 
 
10061 
 
304 ashish 10062 
  def __repr__(self):
10063 
    L = ['%s=%r' % (key, value)
10064 
      for key, value in self.__dict__.iteritems()]
10065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10066 
 
10067 
  def __eq__(self, other):
10068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10069 
 
10070 
  def __ne__(self, other):
10071 
    return not (self == other)
10072 
 
3064 chandransh 10073 
class markOrdersAsDelivered_args:
304 ashish 10074 
  """
10075 
  Attributes:
3064 chandransh 10076 
   - providerId
10077 
   - deliveredOrders
304 ashish 10078 
  """
10079 
 
10080 
  thrift_spec = (
10081 
    None, # 0
3064 chandransh 10082 
    (1, TType.I64, 'providerId', None, None, ), # 1
10083 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 10084 
  )
10085 
 
3064 chandransh 10086 
  def __init__(self, providerId=None, deliveredOrders=None,):
10087 
    self.providerId = providerId
10088 
    self.deliveredOrders = deliveredOrders
304 ashish 10089 
 
10090 
  def read(self, iprot):
10091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10093 
      return
10094 
    iprot.readStructBegin()
10095 
    while True:
10096 
      (fname, ftype, fid) = iprot.readFieldBegin()
10097 
      if ftype == TType.STOP:
10098 
        break
10099 
      if fid == 1:
10100 
        if ftype == TType.I64:
3064 chandransh 10101 
          self.providerId = iprot.readI64();
304 ashish 10102 
        else:
10103 
          iprot.skip(ftype)
10104 
      elif fid == 2:
3064 chandransh 10105 
        if ftype == TType.MAP:
10106 
          self.deliveredOrders = {}
4133 chandransh 10107 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
10108 
          for _i160 in xrange(_size156):
10109 
            _key161 = iprot.readString();
10110 
            _val162 = iprot.readString();
10111 
            self.deliveredOrders[_key161] = _val162
3064 chandransh 10112 
          iprot.readMapEnd()
304 ashish 10113 
        else:
10114 
          iprot.skip(ftype)
10115 
      else:
10116 
        iprot.skip(ftype)
10117 
      iprot.readFieldEnd()
10118 
    iprot.readStructEnd()
10119 
 
10120 
  def write(self, oprot):
10121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10123 
      return
3064 chandransh 10124 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 10125 
    if self.providerId is not None:
3064 chandransh 10126 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10127 
      oprot.writeI64(self.providerId)
304 ashish 10128 
      oprot.writeFieldEnd()
3431 rajveer 10129 
    if self.deliveredOrders is not None:
3064 chandransh 10130 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
10131 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
4133 chandransh 10132 
      for kiter163,viter164 in self.deliveredOrders.items():
10133 
        oprot.writeString(kiter163)
10134 
        oprot.writeString(viter164)
3064 chandransh 10135 
      oprot.writeMapEnd()
304 ashish 10136 
      oprot.writeFieldEnd()
10137 
    oprot.writeFieldStop()
10138 
    oprot.writeStructEnd()
10139 
 
3431 rajveer 10140 
  def validate(self):
10141 
    return
10142 
 
10143 
 
304 ashish 10144 
  def __repr__(self):
10145 
    L = ['%s=%r' % (key, value)
10146 
      for key, value in self.__dict__.iteritems()]
10147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10148 
 
10149 
  def __eq__(self, other):
10150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10151 
 
10152 
  def __ne__(self, other):
10153 
    return not (self == other)
10154 
 
3064 chandransh 10155 
class markOrdersAsDelivered_result:
10156 
  """
10157 
  Attributes:
10158 
   - ex
10159 
  """
304 ashish 10160 
 
10161 
  thrift_spec = (
3064 chandransh 10162 
    None, # 0
10163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 10164 
  )
10165 
 
3064 chandransh 10166 
  def __init__(self, ex=None,):
10167 
    self.ex = ex
304 ashish 10168 
 
1596 ankur.sing 10169 
  def read(self, iprot):
10170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10172 
      return
10173 
    iprot.readStructBegin()
10174 
    while True:
10175 
      (fname, ftype, fid) = iprot.readFieldBegin()
10176 
      if ftype == TType.STOP:
10177 
        break
3064 chandransh 10178 
      if fid == 1:
10179 
        if ftype == TType.STRUCT:
10180 
          self.ex = TransactionServiceException()
10181 
          self.ex.read(iprot)
10182 
        else:
10183 
          iprot.skip(ftype)
1596 ankur.sing 10184 
      else:
10185 
        iprot.skip(ftype)
10186 
      iprot.readFieldEnd()
10187 
    iprot.readStructEnd()
10188 
 
10189 
  def write(self, oprot):
10190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10192 
      return
3064 chandransh 10193 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 10194 
    if self.ex is not None:
3064 chandransh 10195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10196 
      self.ex.write(oprot)
10197 
      oprot.writeFieldEnd()
1596 ankur.sing 10198 
    oprot.writeFieldStop()
10199 
    oprot.writeStructEnd()
10200 
 
3431 rajveer 10201 
  def validate(self):
10202 
    return
10203 
 
10204 
 
1596 ankur.sing 10205 
  def __repr__(self):
10206 
    L = ['%s=%r' % (key, value)
10207 
      for key, value in self.__dict__.iteritems()]
10208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10209 
 
10210 
  def __eq__(self, other):
10211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10212 
 
10213 
  def __ne__(self, other):
10214 
    return not (self == other)
10215 
 
3064 chandransh 10216 
class markOrdersAsFailed_args:
1596 ankur.sing 10217 
  """
10218 
  Attributes:
3064 chandransh 10219 
   - providerId
10220 
   - returnedOrders
1596 ankur.sing 10221 
  """
10222 
 
10223 
  thrift_spec = (
3064 chandransh 10224 
    None, # 0
10225 
    (1, TType.I64, 'providerId', None, None, ), # 1
10226 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 10227 
  )
10228 
 
3064 chandransh 10229 
  def __init__(self, providerId=None, returnedOrders=None,):
10230 
    self.providerId = providerId
10231 
    self.returnedOrders = returnedOrders
1596 ankur.sing 10232 
 
10233 
  def read(self, iprot):
10234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10236 
      return
10237 
    iprot.readStructBegin()
10238 
    while True:
10239 
      (fname, ftype, fid) = iprot.readFieldBegin()
10240 
      if ftype == TType.STOP:
10241 
        break
3064 chandransh 10242 
      if fid == 1:
1596 ankur.sing 10243 
        if ftype == TType.I64:
3064 chandransh 10244 
          self.providerId = iprot.readI64();
1596 ankur.sing 10245 
        else:
10246 
          iprot.skip(ftype)
3064 chandransh 10247 
      elif fid == 2:
10248 
        if ftype == TType.MAP:
10249 
          self.returnedOrders = {}
4133 chandransh 10250 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10251 
          for _i169 in xrange(_size165):
10252 
            _key170 = iprot.readString();
10253 
            _val171 = iprot.readString();
10254 
            self.returnedOrders[_key170] = _val171
3064 chandransh 10255 
          iprot.readMapEnd()
10256 
        else:
10257 
          iprot.skip(ftype)
1596 ankur.sing 10258 
      else:
10259 
        iprot.skip(ftype)
10260 
      iprot.readFieldEnd()
10261 
    iprot.readStructEnd()
10262 
 
10263 
  def write(self, oprot):
10264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10266 
      return
3064 chandransh 10267 
    oprot.writeStructBegin('markOrdersAsFailed_args')
3431 rajveer 10268 
    if self.providerId is not None:
3064 chandransh 10269 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10270 
      oprot.writeI64(self.providerId)
1596 ankur.sing 10271 
      oprot.writeFieldEnd()
3431 rajveer 10272 
    if self.returnedOrders is not None:
3064 chandransh 10273 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
10274 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
4133 chandransh 10275 
      for kiter172,viter173 in self.returnedOrders.items():
10276 
        oprot.writeString(kiter172)
10277 
        oprot.writeString(viter173)
3064 chandransh 10278 
      oprot.writeMapEnd()
10279 
      oprot.writeFieldEnd()
1596 ankur.sing 10280 
    oprot.writeFieldStop()
10281 
    oprot.writeStructEnd()
10282 
 
3431 rajveer 10283 
  def validate(self):
10284 
    return
10285 
 
10286 
 
1596 ankur.sing 10287 
  def __repr__(self):
10288 
    L = ['%s=%r' % (key, value)
10289 
      for key, value in self.__dict__.iteritems()]
10290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10291 
 
10292 
  def __eq__(self, other):
10293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10294 
 
10295 
  def __ne__(self, other):
10296 
    return not (self == other)
10297 
 
3064 chandransh 10298 
class markOrdersAsFailed_result:
10299 
  """
10300 
  Attributes:
10301 
   - ex
10302 
  """
1596 ankur.sing 10303 
 
1627 ankur.sing 10304 
  thrift_spec = (
3064 chandransh 10305 
    None, # 0
10306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10307 
  )
10308 
 
3064 chandransh 10309 
  def __init__(self, ex=None,):
10310 
    self.ex = ex
10311 
 
1627 ankur.sing 10312 
  def read(self, iprot):
10313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10315 
      return
10316 
    iprot.readStructBegin()
10317 
    while True:
10318 
      (fname, ftype, fid) = iprot.readFieldBegin()
10319 
      if ftype == TType.STOP:
10320 
        break
3064 chandransh 10321 
      if fid == 1:
10322 
        if ftype == TType.STRUCT:
10323 
          self.ex = TransactionServiceException()
10324 
          self.ex.read(iprot)
10325 
        else:
10326 
          iprot.skip(ftype)
1627 ankur.sing 10327 
      else:
10328 
        iprot.skip(ftype)
10329 
      iprot.readFieldEnd()
10330 
    iprot.readStructEnd()
10331 
 
10332 
  def write(self, oprot):
10333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10335 
      return
3064 chandransh 10336 
    oprot.writeStructBegin('markOrdersAsFailed_result')
3431 rajveer 10337 
    if self.ex is not None:
3064 chandransh 10338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10339 
      self.ex.write(oprot)
10340 
      oprot.writeFieldEnd()
1627 ankur.sing 10341 
    oprot.writeFieldStop()
10342 
    oprot.writeStructEnd()
10343 
 
3431 rajveer 10344 
  def validate(self):
10345 
    return
10346 
 
10347 
 
1627 ankur.sing 10348 
  def __repr__(self):
10349 
    L = ['%s=%r' % (key, value)
10350 
      for key, value in self.__dict__.iteritems()]
10351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10352 
 
10353 
  def __eq__(self, other):
10354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10355 
 
10356 
  def __ne__(self, other):
10357 
    return not (self == other)
10358 
 
3064 chandransh 10359 
class updateNonDeliveryReason_args:
1627 ankur.sing 10360 
  """
10361 
  Attributes:
3064 chandransh 10362 
   - providerId
10363 
   - undeliveredOrders
1627 ankur.sing 10364 
  """
10365 
 
10366 
  thrift_spec = (
3064 chandransh 10367 
    None, # 0
10368 
    (1, TType.I64, 'providerId', None, None, ), # 1
10369 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 10370 
  )
10371 
 
3064 chandransh 10372 
  def __init__(self, providerId=None, undeliveredOrders=None,):
10373 
    self.providerId = providerId
10374 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 10375 
 
10376 
  def read(self, iprot):
10377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10379 
      return
10380 
    iprot.readStructBegin()
10381 
    while True:
10382 
      (fname, ftype, fid) = iprot.readFieldBegin()
10383 
      if ftype == TType.STOP:
10384 
        break
3064 chandransh 10385 
      if fid == 1:
1627 ankur.sing 10386 
        if ftype == TType.I64:
3064 chandransh 10387 
          self.providerId = iprot.readI64();
1627 ankur.sing 10388 
        else:
10389 
          iprot.skip(ftype)
3064 chandransh 10390 
      elif fid == 2:
10391 
        if ftype == TType.MAP:
10392 
          self.undeliveredOrders = {}
4133 chandransh 10393 
          (_ktype175, _vtype176, _size174 ) = iprot.readMapBegin()
10394 
          for _i178 in xrange(_size174):
10395 
            _key179 = iprot.readString();
10396 
            _val180 = iprot.readString();
10397 
            self.undeliveredOrders[_key179] = _val180
3064 chandransh 10398 
          iprot.readMapEnd()
10399 
        else:
10400 
          iprot.skip(ftype)
1627 ankur.sing 10401 
      else:
10402 
        iprot.skip(ftype)
10403 
      iprot.readFieldEnd()
10404 
    iprot.readStructEnd()
10405 
 
10406 
  def write(self, oprot):
10407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10409 
      return
3064 chandransh 10410 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 10411 
    if self.providerId is not None:
3064 chandransh 10412 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10413 
      oprot.writeI64(self.providerId)
1627 ankur.sing 10414 
      oprot.writeFieldEnd()
3431 rajveer 10415 
    if self.undeliveredOrders is not None:
3064 chandransh 10416 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
10417 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
4133 chandransh 10418 
      for kiter181,viter182 in self.undeliveredOrders.items():
10419 
        oprot.writeString(kiter181)
10420 
        oprot.writeString(viter182)
3064 chandransh 10421 
      oprot.writeMapEnd()
10422 
      oprot.writeFieldEnd()
1627 ankur.sing 10423 
    oprot.writeFieldStop()
10424 
    oprot.writeStructEnd()
10425 
 
3431 rajveer 10426 
  def validate(self):
10427 
    return
10428 
 
10429 
 
1627 ankur.sing 10430 
  def __repr__(self):
10431 
    L = ['%s=%r' % (key, value)
10432 
      for key, value in self.__dict__.iteritems()]
10433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10434 
 
10435 
  def __eq__(self, other):
10436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10437 
 
10438 
  def __ne__(self, other):
10439 
    return not (self == other)
10440 
 
3064 chandransh 10441 
class updateNonDeliveryReason_result:
1627 ankur.sing 10442 
  """
10443 
  Attributes:
3064 chandransh 10444 
   - ex
1627 ankur.sing 10445 
  """
10446 
 
10447 
  thrift_spec = (
3064 chandransh 10448 
    None, # 0
10449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 10450 
  )
10451 
 
3064 chandransh 10452 
  def __init__(self, ex=None,):
10453 
    self.ex = ex
1627 ankur.sing 10454 
 
10455 
  def read(self, iprot):
10456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10458 
      return
10459 
    iprot.readStructBegin()
10460 
    while True:
10461 
      (fname, ftype, fid) = iprot.readFieldBegin()
10462 
      if ftype == TType.STOP:
10463 
        break
3064 chandransh 10464 
      if fid == 1:
10465 
        if ftype == TType.STRUCT:
10466 
          self.ex = TransactionServiceException()
10467 
          self.ex.read(iprot)
1627 ankur.sing 10468 
        else:
10469 
          iprot.skip(ftype)
10470 
      else:
10471 
        iprot.skip(ftype)
10472 
      iprot.readFieldEnd()
10473 
    iprot.readStructEnd()
10474 
 
10475 
  def write(self, oprot):
10476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10478 
      return
3064 chandransh 10479 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
3431 rajveer 10480 
    if self.ex is not None:
3064 chandransh 10481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10482 
      self.ex.write(oprot)
1627 ankur.sing 10483 
      oprot.writeFieldEnd()
10484 
    oprot.writeFieldStop()
10485 
    oprot.writeStructEnd()
10486 
 
3431 rajveer 10487 
  def validate(self):
10488 
    return
10489 
 
10490 
 
1627 ankur.sing 10491 
  def __repr__(self):
10492 
    L = ['%s=%r' % (key, value)
10493 
      for key, value in self.__dict__.iteritems()]
10494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10495 
 
10496 
  def __eq__(self, other):
10497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10498 
 
10499 
  def __ne__(self, other):
10500 
    return not (self == other)
10501 
 
3064 chandransh 10502 
class getUndeliveredOrders_args:
1886 ankur.sing 10503 
  """
10504 
  Attributes:
3064 chandransh 10505 
   - providerId
10506 
   - warehouseId
1886 ankur.sing 10507 
  """
1627 ankur.sing 10508 
 
1886 ankur.sing 10509 
  thrift_spec = (
10510 
    None, # 0
3064 chandransh 10511 
    (1, TType.I64, 'providerId', None, None, ), # 1
10512 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 10513 
  )
10514 
 
3064 chandransh 10515 
  def __init__(self, providerId=None, warehouseId=None,):
10516 
    self.providerId = providerId
10517 
    self.warehouseId = warehouseId
1886 ankur.sing 10518 
 
10519 
  def read(self, iprot):
10520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10522 
      return
10523 
    iprot.readStructBegin()
10524 
    while True:
10525 
      (fname, ftype, fid) = iprot.readFieldBegin()
10526 
      if ftype == TType.STOP:
10527 
        break
10528 
      if fid == 1:
10529 
        if ftype == TType.I64:
3064 chandransh 10530 
          self.providerId = iprot.readI64();
1886 ankur.sing 10531 
        else:
10532 
          iprot.skip(ftype)
3064 chandransh 10533 
      elif fid == 2:
10534 
        if ftype == TType.I64:
10535 
          self.warehouseId = iprot.readI64();
10536 
        else:
10537 
          iprot.skip(ftype)
1886 ankur.sing 10538 
      else:
10539 
        iprot.skip(ftype)
10540 
      iprot.readFieldEnd()
10541 
    iprot.readStructEnd()
10542 
 
10543 
  def write(self, oprot):
10544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10546 
      return
3064 chandransh 10547 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 10548 
    if self.providerId is not None:
3064 chandransh 10549 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
10550 
      oprot.writeI64(self.providerId)
1886 ankur.sing 10551 
      oprot.writeFieldEnd()
3431 rajveer 10552 
    if self.warehouseId is not None:
3064 chandransh 10553 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10554 
      oprot.writeI64(self.warehouseId)
10555 
      oprot.writeFieldEnd()
1886 ankur.sing 10556 
    oprot.writeFieldStop()
10557 
    oprot.writeStructEnd()
10558 
 
3431 rajveer 10559 
  def validate(self):
10560 
    return
10561 
 
10562 
 
1886 ankur.sing 10563 
  def __repr__(self):
10564 
    L = ['%s=%r' % (key, value)
10565 
      for key, value in self.__dict__.iteritems()]
10566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10567 
 
10568 
  def __eq__(self, other):
10569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10570 
 
10571 
  def __ne__(self, other):
10572 
    return not (self == other)
10573 
 
3064 chandransh 10574 
class getUndeliveredOrders_result:
1886 ankur.sing 10575 
  """
10576 
  Attributes:
10577 
   - success
10578 
  """
10579 
 
10580 
  thrift_spec = (
10581 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10582 
  )
10583 
 
10584 
  def __init__(self, success=None,):
10585 
    self.success = success
10586 
 
10587 
  def read(self, iprot):
10588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10590 
      return
10591 
    iprot.readStructBegin()
10592 
    while True:
10593 
      (fname, ftype, fid) = iprot.readFieldBegin()
10594 
      if ftype == TType.STOP:
10595 
        break
10596 
      if fid == 0:
10597 
        if ftype == TType.LIST:
10598 
          self.success = []
4133 chandransh 10599 
          (_etype186, _size183) = iprot.readListBegin()
10600 
          for _i187 in xrange(_size183):
10601 
            _elem188 = Order()
10602 
            _elem188.read(iprot)
10603 
            self.success.append(_elem188)
1886 ankur.sing 10604 
          iprot.readListEnd()
10605 
        else:
10606 
          iprot.skip(ftype)
10607 
      else:
10608 
        iprot.skip(ftype)
10609 
      iprot.readFieldEnd()
10610 
    iprot.readStructEnd()
10611 
 
10612 
  def write(self, oprot):
10613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10615 
      return
3064 chandransh 10616 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 10617 
    if self.success is not None:
1886 ankur.sing 10618 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10619 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 10620 
      for iter189 in self.success:
10621 
        iter189.write(oprot)
1886 ankur.sing 10622 
      oprot.writeListEnd()
10623 
      oprot.writeFieldEnd()
10624 
    oprot.writeFieldStop()
10625 
    oprot.writeStructEnd()
10626 
 
3431 rajveer 10627 
  def validate(self):
10628 
    return
10629 
 
10630 
 
1886 ankur.sing 10631 
  def __repr__(self):
10632 
    L = ['%s=%r' % (key, value)
10633 
      for key, value in self.__dict__.iteritems()]
10634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10635 
 
10636 
  def __eq__(self, other):
10637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10638 
 
10639 
  def __ne__(self, other):
10640 
    return not (self == other)
10641 
 
2536 chandransh 10642 
class toggleDOAFlag_args:
10643 
  """
10644 
  Attributes:
10645 
   - orderId
10646 
  """
1886 ankur.sing 10647 
 
2536 chandransh 10648 
  thrift_spec = (
10649 
    None, # 0
10650 
    (1, TType.I64, 'orderId', None, None, ), # 1
10651 
  )
10652 
 
10653 
  def __init__(self, orderId=None,):
10654 
    self.orderId = orderId
10655 
 
10656 
  def read(self, iprot):
10657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10659 
      return
10660 
    iprot.readStructBegin()
10661 
    while True:
10662 
      (fname, ftype, fid) = iprot.readFieldBegin()
10663 
      if ftype == TType.STOP:
10664 
        break
10665 
      if fid == 1:
10666 
        if ftype == TType.I64:
10667 
          self.orderId = iprot.readI64();
10668 
        else:
10669 
          iprot.skip(ftype)
10670 
      else:
10671 
        iprot.skip(ftype)
10672 
      iprot.readFieldEnd()
10673 
    iprot.readStructEnd()
10674 
 
10675 
  def write(self, oprot):
10676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10678 
      return
10679 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 10680 
    if self.orderId is not None:
2536 chandransh 10681 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10682 
      oprot.writeI64(self.orderId)
10683 
      oprot.writeFieldEnd()
10684 
    oprot.writeFieldStop()
10685 
    oprot.writeStructEnd()
10686 
 
3431 rajveer 10687 
  def validate(self):
10688 
    return
10689 
 
10690 
 
2536 chandransh 10691 
  def __repr__(self):
10692 
    L = ['%s=%r' % (key, value)
10693 
      for key, value in self.__dict__.iteritems()]
10694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10695 
 
10696 
  def __eq__(self, other):
10697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10698 
 
10699 
  def __ne__(self, other):
10700 
    return not (self == other)
10701 
 
10702 
class toggleDOAFlag_result:
10703 
  """
10704 
  Attributes:
10705 
   - success
10706 
   - ex
10707 
  """
10708 
 
10709 
  thrift_spec = (
10710 
    (0, TType.BOOL, 'success', None, None, ), # 0
10711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10712 
  )
10713 
 
10714 
  def __init__(self, success=None, ex=None,):
10715 
    self.success = success
10716 
    self.ex = ex
10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 0:
10728 
        if ftype == TType.BOOL:
10729 
          self.success = iprot.readBool();
10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      elif fid == 1:
10733 
        if ftype == TType.STRUCT:
10734 
          self.ex = TransactionServiceException()
10735 
          self.ex.read(iprot)
10736 
        else:
10737 
          iprot.skip(ftype)
10738 
      else:
10739 
        iprot.skip(ftype)
10740 
      iprot.readFieldEnd()
10741 
    iprot.readStructEnd()
10742 
 
10743 
  def write(self, oprot):
10744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10746 
      return
10747 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 10748 
    if self.success is not None:
2536 chandransh 10749 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10750 
      oprot.writeBool(self.success)
10751 
      oprot.writeFieldEnd()
3431 rajveer 10752 
    if self.ex is not None:
2536 chandransh 10753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10754 
      self.ex.write(oprot)
10755 
      oprot.writeFieldEnd()
10756 
    oprot.writeFieldStop()
10757 
    oprot.writeStructEnd()
10758 
 
3431 rajveer 10759 
  def validate(self):
10760 
    return
10761 
 
10762 
 
2536 chandransh 10763 
  def __repr__(self):
10764 
    L = ['%s=%r' % (key, value)
10765 
      for key, value in self.__dict__.iteritems()]
10766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10767 
 
10768 
  def __eq__(self, other):
10769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10770 
 
10771 
  def __ne__(self, other):
10772 
    return not (self == other)
10773 
 
4454 rajveer 10774 
class markOrderDoaRequestReceived_args:
10775 
  """
10776 
  Attributes:
10777 
   - orderId
10778 
  """
10779 
 
10780 
  thrift_spec = (
10781 
    None, # 0
10782 
    (1, TType.I64, 'orderId', None, None, ), # 1
10783 
  )
10784 
 
10785 
  def __init__(self, orderId=None,):
10786 
    self.orderId = orderId
10787 
 
10788 
  def read(self, iprot):
10789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10791 
      return
10792 
    iprot.readStructBegin()
10793 
    while True:
10794 
      (fname, ftype, fid) = iprot.readFieldBegin()
10795 
      if ftype == TType.STOP:
10796 
        break
10797 
      if fid == 1:
10798 
        if ftype == TType.I64:
10799 
          self.orderId = iprot.readI64();
10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      else:
10803 
        iprot.skip(ftype)
10804 
      iprot.readFieldEnd()
10805 
    iprot.readStructEnd()
10806 
 
10807 
  def write(self, oprot):
10808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10810 
      return
10811 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
10812 
    if self.orderId is not None:
10813 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10814 
      oprot.writeI64(self.orderId)
10815 
      oprot.writeFieldEnd()
10816 
    oprot.writeFieldStop()
10817 
    oprot.writeStructEnd()
10818 
 
10819 
  def validate(self):
10820 
    return
10821 
 
10822 
 
10823 
  def __repr__(self):
10824 
    L = ['%s=%r' % (key, value)
10825 
      for key, value in self.__dict__.iteritems()]
10826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10827 
 
10828 
  def __eq__(self, other):
10829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10830 
 
10831 
  def __ne__(self, other):
10832 
    return not (self == other)
10833 
 
10834 
class markOrderDoaRequestReceived_result:
10835 
  """
10836 
  Attributes:
10837 
   - success
10838 
   - ex
10839 
  """
10840 
 
10841 
  thrift_spec = (
10842 
    (0, TType.BOOL, 'success', None, None, ), # 0
10843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10844 
  )
10845 
 
10846 
  def __init__(self, success=None, ex=None,):
10847 
    self.success = success
10848 
    self.ex = ex
10849 
 
10850 
  def read(self, iprot):
10851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10853 
      return
10854 
    iprot.readStructBegin()
10855 
    while True:
10856 
      (fname, ftype, fid) = iprot.readFieldBegin()
10857 
      if ftype == TType.STOP:
10858 
        break
10859 
      if fid == 0:
10860 
        if ftype == TType.BOOL:
10861 
          self.success = iprot.readBool();
10862 
        else:
10863 
          iprot.skip(ftype)
10864 
      elif fid == 1:
10865 
        if ftype == TType.STRUCT:
10866 
          self.ex = TransactionServiceException()
10867 
          self.ex.read(iprot)
10868 
        else:
10869 
          iprot.skip(ftype)
10870 
      else:
10871 
        iprot.skip(ftype)
10872 
      iprot.readFieldEnd()
10873 
    iprot.readStructEnd()
10874 
 
10875 
  def write(self, oprot):
10876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10878 
      return
10879 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
10880 
    if self.success is not None:
10881 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10882 
      oprot.writeBool(self.success)
10883 
      oprot.writeFieldEnd()
10884 
    if self.ex is not None:
10885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10886 
      self.ex.write(oprot)
10887 
      oprot.writeFieldEnd()
10888 
    oprot.writeFieldStop()
10889 
    oprot.writeStructEnd()
10890 
 
10891 
  def validate(self):
10892 
    return
10893 
 
10894 
 
10895 
  def __repr__(self):
10896 
    L = ['%s=%r' % (key, value)
10897 
      for key, value in self.__dict__.iteritems()]
10898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10899 
 
10900 
  def __eq__(self, other):
10901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10902 
 
10903 
  def __ne__(self, other):
10904 
    return not (self == other)
10905 
 
10906 
class markOrderDoaRequestAuthorized_args:
10907 
  """
10908 
  Attributes:
10909 
   - orderId
10910 
   - isAuthorized
10911 
  """
10912 
 
10913 
  thrift_spec = (
10914 
    None, # 0
10915 
    (1, TType.I64, 'orderId', None, None, ), # 1
10916 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
10917 
  )
10918 
 
10919 
  def __init__(self, orderId=None, isAuthorized=None,):
10920 
    self.orderId = orderId
10921 
    self.isAuthorized = isAuthorized
10922 
 
10923 
  def read(self, iprot):
10924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10926 
      return
10927 
    iprot.readStructBegin()
10928 
    while True:
10929 
      (fname, ftype, fid) = iprot.readFieldBegin()
10930 
      if ftype == TType.STOP:
10931 
        break
10932 
      if fid == 1:
10933 
        if ftype == TType.I64:
10934 
          self.orderId = iprot.readI64();
10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      elif fid == 2:
10938 
        if ftype == TType.BOOL:
10939 
          self.isAuthorized = iprot.readBool();
10940 
        else:
10941 
          iprot.skip(ftype)
10942 
      else:
10943 
        iprot.skip(ftype)
10944 
      iprot.readFieldEnd()
10945 
    iprot.readStructEnd()
10946 
 
10947 
  def write(self, oprot):
10948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10950 
      return
10951 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
10952 
    if self.orderId is not None:
10953 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10954 
      oprot.writeI64(self.orderId)
10955 
      oprot.writeFieldEnd()
10956 
    if self.isAuthorized is not None:
10957 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
10958 
      oprot.writeBool(self.isAuthorized)
10959 
      oprot.writeFieldEnd()
10960 
    oprot.writeFieldStop()
10961 
    oprot.writeStructEnd()
10962 
 
10963 
  def validate(self):
10964 
    return
10965 
 
10966 
 
10967 
  def __repr__(self):
10968 
    L = ['%s=%r' % (key, value)
10969 
      for key, value in self.__dict__.iteritems()]
10970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10971 
 
10972 
  def __eq__(self, other):
10973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10974 
 
10975 
  def __ne__(self, other):
10976 
    return not (self == other)
10977 
 
10978 
class markOrderDoaRequestAuthorized_result:
10979 
  """
10980 
  Attributes:
10981 
   - success
10982 
   - ex
10983 
  """
10984 
 
10985 
  thrift_spec = (
10986 
    (0, TType.BOOL, 'success', None, None, ), # 0
10987 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10988 
  )
10989 
 
10990 
  def __init__(self, success=None, ex=None,):
10991 
    self.success = success
10992 
    self.ex = ex
10993 
 
10994 
  def read(self, iprot):
10995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10997 
      return
10998 
    iprot.readStructBegin()
10999 
    while True:
11000 
      (fname, ftype, fid) = iprot.readFieldBegin()
11001 
      if ftype == TType.STOP:
11002 
        break
11003 
      if fid == 0:
11004 
        if ftype == TType.BOOL:
11005 
          self.success = iprot.readBool();
11006 
        else:
11007 
          iprot.skip(ftype)
11008 
      elif fid == 1:
11009 
        if ftype == TType.STRUCT:
11010 
          self.ex = TransactionServiceException()
11011 
          self.ex.read(iprot)
11012 
        else:
11013 
          iprot.skip(ftype)
11014 
      else:
11015 
        iprot.skip(ftype)
11016 
      iprot.readFieldEnd()
11017 
    iprot.readStructEnd()
11018 
 
11019 
  def write(self, oprot):
11020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11022 
      return
11023 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
11024 
    if self.success is not None:
11025 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11026 
      oprot.writeBool(self.success)
11027 
      oprot.writeFieldEnd()
11028 
    if self.ex is not None:
11029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11030 
      self.ex.write(oprot)
11031 
      oprot.writeFieldEnd()
11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
4488 rajveer 11050 
class markOrderReturnRequestReceived_args:
11051 
  """
11052 
  Attributes:
11053 
   - orderId
11054 
  """
11055 
 
11056 
  thrift_spec = (
11057 
    None, # 0
11058 
    (1, TType.I64, 'orderId', None, None, ), # 1
11059 
  )
11060 
 
11061 
  def __init__(self, orderId=None,):
11062 
    self.orderId = orderId
11063 
 
11064 
  def read(self, iprot):
11065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11067 
      return
11068 
    iprot.readStructBegin()
11069 
    while True:
11070 
      (fname, ftype, fid) = iprot.readFieldBegin()
11071 
      if ftype == TType.STOP:
11072 
        break
11073 
      if fid == 1:
11074 
        if ftype == TType.I64:
11075 
          self.orderId = iprot.readI64();
11076 
        else:
11077 
          iprot.skip(ftype)
11078 
      else:
11079 
        iprot.skip(ftype)
11080 
      iprot.readFieldEnd()
11081 
    iprot.readStructEnd()
11082 
 
11083 
  def write(self, oprot):
11084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11086 
      return
11087 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
11088 
    if self.orderId is not None:
11089 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11090 
      oprot.writeI64(self.orderId)
11091 
      oprot.writeFieldEnd()
11092 
    oprot.writeFieldStop()
11093 
    oprot.writeStructEnd()
11094 
 
11095 
  def validate(self):
11096 
    return
11097 
 
11098 
 
11099 
  def __repr__(self):
11100 
    L = ['%s=%r' % (key, value)
11101 
      for key, value in self.__dict__.iteritems()]
11102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11103 
 
11104 
  def __eq__(self, other):
11105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11106 
 
11107 
  def __ne__(self, other):
11108 
    return not (self == other)
11109 
 
11110 
class markOrderReturnRequestReceived_result:
11111 
  """
11112 
  Attributes:
11113 
   - success
11114 
   - ex
11115 
  """
11116 
 
11117 
  thrift_spec = (
11118 
    (0, TType.BOOL, 'success', None, None, ), # 0
11119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11120 
  )
11121 
 
11122 
  def __init__(self, success=None, ex=None,):
11123 
    self.success = success
11124 
    self.ex = ex
11125 
 
11126 
  def read(self, iprot):
11127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11129 
      return
11130 
    iprot.readStructBegin()
11131 
    while True:
11132 
      (fname, ftype, fid) = iprot.readFieldBegin()
11133 
      if ftype == TType.STOP:
11134 
        break
11135 
      if fid == 0:
11136 
        if ftype == TType.BOOL:
11137 
          self.success = iprot.readBool();
11138 
        else:
11139 
          iprot.skip(ftype)
11140 
      elif fid == 1:
11141 
        if ftype == TType.STRUCT:
11142 
          self.ex = TransactionServiceException()
11143 
          self.ex.read(iprot)
11144 
        else:
11145 
          iprot.skip(ftype)
11146 
      else:
11147 
        iprot.skip(ftype)
11148 
      iprot.readFieldEnd()
11149 
    iprot.readStructEnd()
11150 
 
11151 
  def write(self, oprot):
11152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11154 
      return
11155 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
11156 
    if self.success is not None:
11157 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11158 
      oprot.writeBool(self.success)
11159 
      oprot.writeFieldEnd()
11160 
    if self.ex is not None:
11161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11162 
      self.ex.write(oprot)
11163 
      oprot.writeFieldEnd()
11164 
    oprot.writeFieldStop()
11165 
    oprot.writeStructEnd()
11166 
 
11167 
  def validate(self):
11168 
    return
11169 
 
11170 
 
11171 
  def __repr__(self):
11172 
    L = ['%s=%r' % (key, value)
11173 
      for key, value in self.__dict__.iteritems()]
11174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11175 
 
11176 
  def __eq__(self, other):
11177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11178 
 
11179 
  def __ne__(self, other):
11180 
    return not (self == other)
11181 
 
11182 
class markOrderReturnRequestAuthorized_args:
11183 
  """
11184 
  Attributes:
11185 
   - orderId
11186 
   - isAuthorized
11187 
  """
11188 
 
11189 
  thrift_spec = (
11190 
    None, # 0
11191 
    (1, TType.I64, 'orderId', None, None, ), # 1
11192 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
11193 
  )
11194 
 
11195 
  def __init__(self, orderId=None, isAuthorized=None,):
11196 
    self.orderId = orderId
11197 
    self.isAuthorized = isAuthorized
11198 
 
11199 
  def read(self, iprot):
11200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11202 
      return
11203 
    iprot.readStructBegin()
11204 
    while True:
11205 
      (fname, ftype, fid) = iprot.readFieldBegin()
11206 
      if ftype == TType.STOP:
11207 
        break
11208 
      if fid == 1:
11209 
        if ftype == TType.I64:
11210 
          self.orderId = iprot.readI64();
11211 
        else:
11212 
          iprot.skip(ftype)
11213 
      elif fid == 2:
11214 
        if ftype == TType.BOOL:
11215 
          self.isAuthorized = iprot.readBool();
11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      else:
11219 
        iprot.skip(ftype)
11220 
      iprot.readFieldEnd()
11221 
    iprot.readStructEnd()
11222 
 
11223 
  def write(self, oprot):
11224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11226 
      return
11227 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
11228 
    if self.orderId is not None:
11229 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11230 
      oprot.writeI64(self.orderId)
11231 
      oprot.writeFieldEnd()
11232 
    if self.isAuthorized is not None:
11233 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
11234 
      oprot.writeBool(self.isAuthorized)
11235 
      oprot.writeFieldEnd()
11236 
    oprot.writeFieldStop()
11237 
    oprot.writeStructEnd()
11238 
 
11239 
  def validate(self):
11240 
    return
11241 
 
11242 
 
11243 
  def __repr__(self):
11244 
    L = ['%s=%r' % (key, value)
11245 
      for key, value in self.__dict__.iteritems()]
11246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11247 
 
11248 
  def __eq__(self, other):
11249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11250 
 
11251 
  def __ne__(self, other):
11252 
    return not (self == other)
11253 
 
11254 
class markOrderReturnRequestAuthorized_result:
11255 
  """
11256 
  Attributes:
11257 
   - success
11258 
   - ex
11259 
  """
11260 
 
11261 
  thrift_spec = (
11262 
    (0, TType.BOOL, 'success', None, None, ), # 0
11263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11264 
  )
11265 
 
11266 
  def __init__(self, success=None, ex=None,):
11267 
    self.success = success
11268 
    self.ex = ex
11269 
 
11270 
  def read(self, iprot):
11271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11273 
      return
11274 
    iprot.readStructBegin()
11275 
    while True:
11276 
      (fname, ftype, fid) = iprot.readFieldBegin()
11277 
      if ftype == TType.STOP:
11278 
        break
11279 
      if fid == 0:
11280 
        if ftype == TType.BOOL:
11281 
          self.success = iprot.readBool();
11282 
        else:
11283 
          iprot.skip(ftype)
11284 
      elif fid == 1:
11285 
        if ftype == TType.STRUCT:
11286 
          self.ex = TransactionServiceException()
11287 
          self.ex.read(iprot)
11288 
        else:
11289 
          iprot.skip(ftype)
11290 
      else:
11291 
        iprot.skip(ftype)
11292 
      iprot.readFieldEnd()
11293 
    iprot.readStructEnd()
11294 
 
11295 
  def write(self, oprot):
11296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11298 
      return
11299 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
11300 
    if self.success is not None:
11301 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11302 
      oprot.writeBool(self.success)
11303 
      oprot.writeFieldEnd()
11304 
    if self.ex is not None:
11305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11306 
      self.ex.write(oprot)
11307 
      oprot.writeFieldEnd()
11308 
    oprot.writeFieldStop()
11309 
    oprot.writeStructEnd()
11310 
 
11311 
  def validate(self):
11312 
    return
11313 
 
11314 
 
11315 
  def __repr__(self):
11316 
    L = ['%s=%r' % (key, value)
11317 
      for key, value in self.__dict__.iteritems()]
11318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11319 
 
11320 
  def __eq__(self, other):
11321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11322 
 
11323 
  def __ne__(self, other):
11324 
    return not (self == other)
11325 
 
2536 chandransh 11326 
class requestPickupNumber_args:
11327 
  """
11328 
  Attributes:
11329 
   - orderId
11330 
  """
11331 
 
11332 
  thrift_spec = (
11333 
    None, # 0
11334 
    (1, TType.I64, 'orderId', None, None, ), # 1
11335 
  )
11336 
 
11337 
  def __init__(self, orderId=None,):
11338 
    self.orderId = orderId
11339 
 
11340 
  def read(self, iprot):
11341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11343 
      return
11344 
    iprot.readStructBegin()
11345 
    while True:
11346 
      (fname, ftype, fid) = iprot.readFieldBegin()
11347 
      if ftype == TType.STOP:
11348 
        break
11349 
      if fid == 1:
11350 
        if ftype == TType.I64:
11351 
          self.orderId = iprot.readI64();
11352 
        else:
11353 
          iprot.skip(ftype)
11354 
      else:
11355 
        iprot.skip(ftype)
11356 
      iprot.readFieldEnd()
11357 
    iprot.readStructEnd()
11358 
 
11359 
  def write(self, oprot):
11360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11362 
      return
11363 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 11364 
    if self.orderId is not None:
2536 chandransh 11365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11366 
      oprot.writeI64(self.orderId)
11367 
      oprot.writeFieldEnd()
11368 
    oprot.writeFieldStop()
11369 
    oprot.writeStructEnd()
11370 
 
3431 rajveer 11371 
  def validate(self):
11372 
    return
11373 
 
11374 
 
2536 chandransh 11375 
  def __repr__(self):
11376 
    L = ['%s=%r' % (key, value)
11377 
      for key, value in self.__dict__.iteritems()]
11378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11379 
 
11380 
  def __eq__(self, other):
11381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11382 
 
11383 
  def __ne__(self, other):
11384 
    return not (self == other)
11385 
 
11386 
class requestPickupNumber_result:
11387 
  """
11388 
  Attributes:
11389 
   - success
11390 
   - ex
11391 
  """
11392 
 
11393 
  thrift_spec = (
11394 
    (0, TType.BOOL, 'success', None, None, ), # 0
11395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11396 
  )
11397 
 
11398 
  def __init__(self, success=None, ex=None,):
11399 
    self.success = success
11400 
    self.ex = ex
11401 
 
11402 
  def read(self, iprot):
11403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11405 
      return
11406 
    iprot.readStructBegin()
11407 
    while True:
11408 
      (fname, ftype, fid) = iprot.readFieldBegin()
11409 
      if ftype == TType.STOP:
11410 
        break
11411 
      if fid == 0:
11412 
        if ftype == TType.BOOL:
11413 
          self.success = iprot.readBool();
11414 
        else:
11415 
          iprot.skip(ftype)
11416 
      elif fid == 1:
11417 
        if ftype == TType.STRUCT:
11418 
          self.ex = TransactionServiceException()
11419 
          self.ex.read(iprot)
11420 
        else:
11421 
          iprot.skip(ftype)
11422 
      else:
11423 
        iprot.skip(ftype)
11424 
      iprot.readFieldEnd()
11425 
    iprot.readStructEnd()
11426 
 
11427 
  def write(self, oprot):
11428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11430 
      return
11431 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 11432 
    if self.success is not None:
2536 chandransh 11433 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11434 
      oprot.writeBool(self.success)
11435 
      oprot.writeFieldEnd()
3431 rajveer 11436 
    if self.ex is not None:
2536 chandransh 11437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11438 
      self.ex.write(oprot)
11439 
      oprot.writeFieldEnd()
11440 
    oprot.writeFieldStop()
11441 
    oprot.writeStructEnd()
11442 
 
3431 rajveer 11443 
  def validate(self):
11444 
    return
11445 
 
11446 
 
2536 chandransh 11447 
  def __repr__(self):
11448 
    L = ['%s=%r' % (key, value)
11449 
      for key, value in self.__dict__.iteritems()]
11450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11451 
 
11452 
  def __eq__(self, other):
11453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11454 
 
11455 
  def __ne__(self, other):
11456 
    return not (self == other)
11457 
 
11458 
class authorizePickup_args:
11459 
  """
11460 
  Attributes:
11461 
   - orderId
11462 
   - pickupNumber
11463 
  """
11464 
 
11465 
  thrift_spec = (
11466 
    None, # 0
11467 
    (1, TType.I64, 'orderId', None, None, ), # 1
11468 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
11469 
  )
11470 
 
11471 
  def __init__(self, orderId=None, pickupNumber=None,):
11472 
    self.orderId = orderId
11473 
    self.pickupNumber = pickupNumber
11474 
 
11475 
  def read(self, iprot):
11476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11478 
      return
11479 
    iprot.readStructBegin()
11480 
    while True:
11481 
      (fname, ftype, fid) = iprot.readFieldBegin()
11482 
      if ftype == TType.STOP:
11483 
        break
11484 
      if fid == 1:
11485 
        if ftype == TType.I64:
11486 
          self.orderId = iprot.readI64();
11487 
        else:
11488 
          iprot.skip(ftype)
11489 
      elif fid == 2:
11490 
        if ftype == TType.STRING:
11491 
          self.pickupNumber = iprot.readString();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
11503 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 11504 
    if self.orderId is not None:
2536 chandransh 11505 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11506 
      oprot.writeI64(self.orderId)
11507 
      oprot.writeFieldEnd()
3431 rajveer 11508 
    if self.pickupNumber is not None:
2536 chandransh 11509 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
11510 
      oprot.writeString(self.pickupNumber)
11511 
      oprot.writeFieldEnd()
11512 
    oprot.writeFieldStop()
11513 
    oprot.writeStructEnd()
11514 
 
3431 rajveer 11515 
  def validate(self):
11516 
    return
11517 
 
11518 
 
2536 chandransh 11519 
  def __repr__(self):
11520 
    L = ['%s=%r' % (key, value)
11521 
      for key, value in self.__dict__.iteritems()]
11522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11523 
 
11524 
  def __eq__(self, other):
11525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11526 
 
11527 
  def __ne__(self, other):
11528 
    return not (self == other)
11529 
 
11530 
class authorizePickup_result:
11531 
  """
11532 
  Attributes:
11533 
   - success
11534 
   - ex
11535 
  """
11536 
 
11537 
  thrift_spec = (
11538 
    (0, TType.BOOL, 'success', None, None, ), # 0
11539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11540 
  )
11541 
 
11542 
  def __init__(self, success=None, ex=None,):
11543 
    self.success = success
11544 
    self.ex = ex
11545 
 
11546 
  def read(self, iprot):
11547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11549 
      return
11550 
    iprot.readStructBegin()
11551 
    while True:
11552 
      (fname, ftype, fid) = iprot.readFieldBegin()
11553 
      if ftype == TType.STOP:
11554 
        break
11555 
      if fid == 0:
11556 
        if ftype == TType.BOOL:
11557 
          self.success = iprot.readBool();
11558 
        else:
11559 
          iprot.skip(ftype)
11560 
      elif fid == 1:
11561 
        if ftype == TType.STRUCT:
11562 
          self.ex = TransactionServiceException()
11563 
          self.ex.read(iprot)
11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      else:
11567 
        iprot.skip(ftype)
11568 
      iprot.readFieldEnd()
11569 
    iprot.readStructEnd()
11570 
 
11571 
  def write(self, oprot):
11572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11574 
      return
11575 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 11576 
    if self.success is not None:
2536 chandransh 11577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11578 
      oprot.writeBool(self.success)
11579 
      oprot.writeFieldEnd()
3431 rajveer 11580 
    if self.ex is not None:
2536 chandransh 11581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11582 
      self.ex.write(oprot)
11583 
      oprot.writeFieldEnd()
11584 
    oprot.writeFieldStop()
11585 
    oprot.writeStructEnd()
11586 
 
3431 rajveer 11587 
  def validate(self):
11588 
    return
11589 
 
11590 
 
2536 chandransh 11591 
  def __repr__(self):
11592 
    L = ['%s=%r' % (key, value)
11593 
      for key, value in self.__dict__.iteritems()]
11594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11595 
 
11596 
  def __eq__(self, other):
11597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11598 
 
11599 
  def __ne__(self, other):
11600 
    return not (self == other)
11601 
 
2764 chandransh 11602 
class markDoasAsPickedUp_args:
11603 
  """
11604 
  Attributes:
11605 
   - providerId
11606 
   - pickupDetails
11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    None, # 0
11611 
    (1, TType.I64, 'providerId', None, None, ), # 1
11612 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
11613 
  )
11614 
 
11615 
  def __init__(self, providerId=None, pickupDetails=None,):
11616 
    self.providerId = providerId
11617 
    self.pickupDetails = pickupDetails
11618 
 
11619 
  def read(self, iprot):
11620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11622 
      return
11623 
    iprot.readStructBegin()
11624 
    while True:
11625 
      (fname, ftype, fid) = iprot.readFieldBegin()
11626 
      if ftype == TType.STOP:
11627 
        break
11628 
      if fid == 1:
11629 
        if ftype == TType.I64:
11630 
          self.providerId = iprot.readI64();
11631 
        else:
11632 
          iprot.skip(ftype)
11633 
      elif fid == 2:
11634 
        if ftype == TType.MAP:
11635 
          self.pickupDetails = {}
4133 chandransh 11636 
          (_ktype191, _vtype192, _size190 ) = iprot.readMapBegin()
11637 
          for _i194 in xrange(_size190):
11638 
            _key195 = iprot.readString();
11639 
            _val196 = iprot.readString();
11640 
            self.pickupDetails[_key195] = _val196
2764 chandransh 11641 
          iprot.readMapEnd()
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 11654 
    if self.providerId is not None:
2764 chandransh 11655 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11656 
      oprot.writeI64(self.providerId)
11657 
      oprot.writeFieldEnd()
3431 rajveer 11658 
    if self.pickupDetails is not None:
2764 chandransh 11659 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11660 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
4133 chandransh 11661 
      for kiter197,viter198 in self.pickupDetails.items():
11662 
        oprot.writeString(kiter197)
11663 
        oprot.writeString(viter198)
2764 chandransh 11664 
      oprot.writeMapEnd()
11665 
      oprot.writeFieldEnd()
11666 
    oprot.writeFieldStop()
11667 
    oprot.writeStructEnd()
11668 
 
3431 rajveer 11669 
  def validate(self):
11670 
    return
11671 
 
11672 
 
2764 chandransh 11673 
  def __repr__(self):
11674 
    L = ['%s=%r' % (key, value)
11675 
      for key, value in self.__dict__.iteritems()]
11676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11677 
 
11678 
  def __eq__(self, other):
11679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11680 
 
11681 
  def __ne__(self, other):
11682 
    return not (self == other)
11683 
 
11684 
class markDoasAsPickedUp_result:
11685 
  """
11686 
  Attributes:
11687 
   - success
11688 
  """
11689 
 
11690 
  thrift_spec = (
11691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11692 
  )
11693 
 
11694 
  def __init__(self, success=None,):
11695 
    self.success = success
11696 
 
11697 
  def read(self, iprot):
11698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11700 
      return
11701 
    iprot.readStructBegin()
11702 
    while True:
11703 
      (fname, ftype, fid) = iprot.readFieldBegin()
11704 
      if ftype == TType.STOP:
11705 
        break
11706 
      if fid == 0:
11707 
        if ftype == TType.LIST:
11708 
          self.success = []
4133 chandransh 11709 
          (_etype202, _size199) = iprot.readListBegin()
11710 
          for _i203 in xrange(_size199):
11711 
            _elem204 = Order()
11712 
            _elem204.read(iprot)
11713 
            self.success.append(_elem204)
2764 chandransh 11714 
          iprot.readListEnd()
11715 
        else:
11716 
          iprot.skip(ftype)
11717 
      else:
11718 
        iprot.skip(ftype)
11719 
      iprot.readFieldEnd()
11720 
    iprot.readStructEnd()
11721 
 
11722 
  def write(self, oprot):
11723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11725 
      return
11726 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
3431 rajveer 11727 
    if self.success is not None:
2764 chandransh 11728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 11730 
      for iter205 in self.success:
11731 
        iter205.write(oprot)
2764 chandransh 11732 
      oprot.writeListEnd()
11733 
      oprot.writeFieldEnd()
11734 
    oprot.writeFieldStop()
11735 
    oprot.writeStructEnd()
11736 
 
3431 rajveer 11737 
  def validate(self):
11738 
    return
11739 
 
11740 
 
2764 chandransh 11741 
  def __repr__(self):
11742 
    L = ['%s=%r' % (key, value)
11743 
      for key, value in self.__dict__.iteritems()]
11744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11745 
 
11746 
  def __eq__(self, other):
11747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11748 
 
11749 
  def __ne__(self, other):
11750 
    return not (self == other)
11751 
 
2616 chandransh 11752 
class receiveReturn_args:
2591 chandransh 11753 
  """
11754 
  Attributes:
11755 
   - orderId
4479 rajveer 11756 
   - receiveCondition
2591 chandransh 11757 
  """
2536 chandransh 11758 
 
2591 chandransh 11759 
  thrift_spec = (
11760 
    None, # 0
11761 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 11762 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 11763 
  )
11764 
 
4479 rajveer 11765 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 11766 
    self.orderId = orderId
4479 rajveer 11767 
    self.receiveCondition = receiveCondition
2591 chandransh 11768 
 
11769 
  def read(self, iprot):
11770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11772 
      return
11773 
    iprot.readStructBegin()
11774 
    while True:
11775 
      (fname, ftype, fid) = iprot.readFieldBegin()
11776 
      if ftype == TType.STOP:
11777 
        break
11778 
      if fid == 1:
11779 
        if ftype == TType.I64:
11780 
          self.orderId = iprot.readI64();
11781 
        else:
11782 
          iprot.skip(ftype)
4479 rajveer 11783 
      elif fid == 2:
11784 
        if ftype == TType.I64:
11785 
          self.receiveCondition = iprot.readI64();
11786 
        else:
11787 
          iprot.skip(ftype)
2591 chandransh 11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
2616 chandransh 11797 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 11798 
    if self.orderId is not None:
2591 chandransh 11799 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11800 
      oprot.writeI64(self.orderId)
11801 
      oprot.writeFieldEnd()
4479 rajveer 11802 
    if self.receiveCondition is not None:
11803 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
11804 
      oprot.writeI64(self.receiveCondition)
11805 
      oprot.writeFieldEnd()
2591 chandransh 11806 
    oprot.writeFieldStop()
11807 
    oprot.writeStructEnd()
11808 
 
3431 rajveer 11809 
  def validate(self):
11810 
    return
11811 
 
11812 
 
2591 chandransh 11813 
  def __repr__(self):
11814 
    L = ['%s=%r' % (key, value)
11815 
      for key, value in self.__dict__.iteritems()]
11816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11817 
 
11818 
  def __eq__(self, other):
11819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11820 
 
11821 
  def __ne__(self, other):
11822 
    return not (self == other)
11823 
 
2616 chandransh 11824 
class receiveReturn_result:
2591 chandransh 11825 
  """
11826 
  Attributes:
11827 
   - success
11828 
   - ex
11829 
  """
11830 
 
11831 
  thrift_spec = (
11832 
    (0, TType.BOOL, 'success', None, None, ), # 0
11833 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11834 
  )
11835 
 
11836 
  def __init__(self, success=None, ex=None,):
11837 
    self.success = success
11838 
    self.ex = ex
11839 
 
11840 
  def read(self, iprot):
11841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11843 
      return
11844 
    iprot.readStructBegin()
11845 
    while True:
11846 
      (fname, ftype, fid) = iprot.readFieldBegin()
11847 
      if ftype == TType.STOP:
11848 
        break
11849 
      if fid == 0:
11850 
        if ftype == TType.BOOL:
11851 
          self.success = iprot.readBool();
11852 
        else:
11853 
          iprot.skip(ftype)
11854 
      elif fid == 1:
11855 
        if ftype == TType.STRUCT:
11856 
          self.ex = TransactionServiceException()
11857 
          self.ex.read(iprot)
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      else:
11861 
        iprot.skip(ftype)
11862 
      iprot.readFieldEnd()
11863 
    iprot.readStructEnd()
11864 
 
11865 
  def write(self, oprot):
11866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11868 
      return
2616 chandransh 11869 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 11870 
    if self.success is not None:
2591 chandransh 11871 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11872 
      oprot.writeBool(self.success)
11873 
      oprot.writeFieldEnd()
3431 rajveer 11874 
    if self.ex is not None:
2591 chandransh 11875 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11876 
      self.ex.write(oprot)
11877 
      oprot.writeFieldEnd()
11878 
    oprot.writeFieldStop()
11879 
    oprot.writeStructEnd()
11880 
 
3431 rajveer 11881 
  def validate(self):
11882 
    return
11883 
 
11884 
 
2591 chandransh 11885 
  def __repr__(self):
11886 
    L = ['%s=%r' % (key, value)
11887 
      for key, value in self.__dict__.iteritems()]
11888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11889 
 
11890 
  def __eq__(self, other):
11891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11892 
 
11893 
  def __ne__(self, other):
11894 
    return not (self == other)
11895 
 
11896 
class validateDoa_args:
11897 
  """
11898 
  Attributes:
11899 
   - orderId
11900 
   - isValid
11901 
  """
11902 
 
11903 
  thrift_spec = (
11904 
    None, # 0
11905 
    (1, TType.I64, 'orderId', None, None, ), # 1
11906 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
11907 
  )
11908 
 
11909 
  def __init__(self, orderId=None, isValid=None,):
11910 
    self.orderId = orderId
11911 
    self.isValid = isValid
11912 
 
11913 
  def read(self, iprot):
11914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11916 
      return
11917 
    iprot.readStructBegin()
11918 
    while True:
11919 
      (fname, ftype, fid) = iprot.readFieldBegin()
11920 
      if ftype == TType.STOP:
11921 
        break
11922 
      if fid == 1:
11923 
        if ftype == TType.I64:
11924 
          self.orderId = iprot.readI64();
11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      elif fid == 2:
11928 
        if ftype == TType.BOOL:
11929 
          self.isValid = iprot.readBool();
11930 
        else:
11931 
          iprot.skip(ftype)
11932 
      else:
11933 
        iprot.skip(ftype)
11934 
      iprot.readFieldEnd()
11935 
    iprot.readStructEnd()
11936 
 
11937 
  def write(self, oprot):
11938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11940 
      return
11941 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 11942 
    if self.orderId is not None:
2591 chandransh 11943 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11944 
      oprot.writeI64(self.orderId)
11945 
      oprot.writeFieldEnd()
3431 rajveer 11946 
    if self.isValid is not None:
2591 chandransh 11947 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
11948 
      oprot.writeBool(self.isValid)
11949 
      oprot.writeFieldEnd()
11950 
    oprot.writeFieldStop()
11951 
    oprot.writeStructEnd()
11952 
 
3431 rajveer 11953 
  def validate(self):
11954 
    return
11955 
 
11956 
 
2591 chandransh 11957 
  def __repr__(self):
11958 
    L = ['%s=%r' % (key, value)
11959 
      for key, value in self.__dict__.iteritems()]
11960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11961 
 
11962 
  def __eq__(self, other):
11963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11964 
 
11965 
  def __ne__(self, other):
11966 
    return not (self == other)
11967 
 
11968 
class validateDoa_result:
11969 
  """
11970 
  Attributes:
11971 
   - success
11972 
   - ex
11973 
  """
11974 
 
11975 
  thrift_spec = (
11976 
    (0, TType.BOOL, 'success', None, None, ), # 0
11977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11978 
  )
11979 
 
11980 
  def __init__(self, success=None, ex=None,):
11981 
    self.success = success
11982 
    self.ex = ex
11983 
 
11984 
  def read(self, iprot):
11985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11987 
      return
11988 
    iprot.readStructBegin()
11989 
    while True:
11990 
      (fname, ftype, fid) = iprot.readFieldBegin()
11991 
      if ftype == TType.STOP:
11992 
        break
11993 
      if fid == 0:
11994 
        if ftype == TType.BOOL:
11995 
          self.success = iprot.readBool();
11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      elif fid == 1:
11999 
        if ftype == TType.STRUCT:
12000 
          self.ex = TransactionServiceException()
12001 
          self.ex.read(iprot)
12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      else:
12005 
        iprot.skip(ftype)
12006 
      iprot.readFieldEnd()
12007 
    iprot.readStructEnd()
12008 
 
12009 
  def write(self, oprot):
12010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12012 
      return
12013 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 12014 
    if self.success is not None:
2591 chandransh 12015 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12016 
      oprot.writeBool(self.success)
12017 
      oprot.writeFieldEnd()
3431 rajveer 12018 
    if self.ex is not None:
2591 chandransh 12019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12020 
      self.ex.write(oprot)
12021 
      oprot.writeFieldEnd()
12022 
    oprot.writeFieldStop()
12023 
    oprot.writeStructEnd()
12024 
 
3431 rajveer 12025 
  def validate(self):
12026 
    return
12027 
 
12028 
 
2591 chandransh 12029 
  def __repr__(self):
12030 
    L = ['%s=%r' % (key, value)
12031 
      for key, value in self.__dict__.iteritems()]
12032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12033 
 
12034 
  def __eq__(self, other):
12035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12036 
 
12037 
  def __ne__(self, other):
12038 
    return not (self == other)
12039 
 
2616 chandransh 12040 
class reshipOrder_args:
12041 
  """
12042 
  Attributes:
12043 
   - orderId
12044 
  """
2591 chandransh 12045 
 
2616 chandransh 12046 
  thrift_spec = (
12047 
    None, # 0
12048 
    (1, TType.I64, 'orderId', None, None, ), # 1
12049 
  )
12050 
 
12051 
  def __init__(self, orderId=None,):
12052 
    self.orderId = orderId
12053 
 
12054 
  def read(self, iprot):
12055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12057 
      return
12058 
    iprot.readStructBegin()
12059 
    while True:
12060 
      (fname, ftype, fid) = iprot.readFieldBegin()
12061 
      if ftype == TType.STOP:
12062 
        break
12063 
      if fid == 1:
12064 
        if ftype == TType.I64:
12065 
          self.orderId = iprot.readI64();
12066 
        else:
12067 
          iprot.skip(ftype)
12068 
      else:
12069 
        iprot.skip(ftype)
12070 
      iprot.readFieldEnd()
12071 
    iprot.readStructEnd()
12072 
 
12073 
  def write(self, oprot):
12074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12076 
      return
12077 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 12078 
    if self.orderId is not None:
2616 chandransh 12079 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12080 
      oprot.writeI64(self.orderId)
12081 
      oprot.writeFieldEnd()
12082 
    oprot.writeFieldStop()
12083 
    oprot.writeStructEnd()
12084 
 
3431 rajveer 12085 
  def validate(self):
12086 
    return
12087 
 
12088 
 
2616 chandransh 12089 
  def __repr__(self):
12090 
    L = ['%s=%r' % (key, value)
12091 
      for key, value in self.__dict__.iteritems()]
12092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12093 
 
12094 
  def __eq__(self, other):
12095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12096 
 
12097 
  def __ne__(self, other):
12098 
    return not (self == other)
12099 
 
12100 
class reshipOrder_result:
12101 
  """
12102 
  Attributes:
12103 
   - success
12104 
   - ex
12105 
  """
12106 
 
12107 
  thrift_spec = (
12108 
    (0, TType.I64, 'success', None, None, ), # 0
12109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12110 
  )
12111 
 
12112 
  def __init__(self, success=None, ex=None,):
12113 
    self.success = success
12114 
    self.ex = ex
12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 0:
12126 
        if ftype == TType.I64:
12127 
          self.success = iprot.readI64();
12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      elif fid == 1:
12131 
        if ftype == TType.STRUCT:
12132 
          self.ex = TransactionServiceException()
12133 
          self.ex.read(iprot)
12134 
        else:
12135 
          iprot.skip(ftype)
12136 
      else:
12137 
        iprot.skip(ftype)
12138 
      iprot.readFieldEnd()
12139 
    iprot.readStructEnd()
12140 
 
12141 
  def write(self, oprot):
12142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12144 
      return
12145 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 12146 
    if self.success is not None:
2616 chandransh 12147 
      oprot.writeFieldBegin('success', TType.I64, 0)
12148 
      oprot.writeI64(self.success)
12149 
      oprot.writeFieldEnd()
3431 rajveer 12150 
    if self.ex is not None:
2616 chandransh 12151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12152 
      self.ex.write(oprot)
12153 
      oprot.writeFieldEnd()
12154 
    oprot.writeFieldStop()
12155 
    oprot.writeStructEnd()
12156 
 
3431 rajveer 12157 
  def validate(self):
12158 
    return
12159 
 
12160 
 
2616 chandransh 12161 
  def __repr__(self):
12162 
    L = ['%s=%r' % (key, value)
12163 
      for key, value in self.__dict__.iteritems()]
12164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12165 
 
12166 
  def __eq__(self, other):
12167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12168 
 
12169 
  def __ne__(self, other):
12170 
    return not (self == other)
12171 
 
12172 
class refundOrder_args:
12173 
  """
12174 
  Attributes:
12175 
   - orderId
3226 chandransh 12176 
   - refundedBy
12177 
   - reason
2616 chandransh 12178 
  """
12179 
 
12180 
  thrift_spec = (
12181 
    None, # 0
12182 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 12183 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
12184 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 12185 
  )
12186 
 
3226 chandransh 12187 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 12188 
    self.orderId = orderId
3226 chandransh 12189 
    self.refundedBy = refundedBy
12190 
    self.reason = reason
2616 chandransh 12191 
 
12192 
  def read(self, iprot):
12193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12195 
      return
12196 
    iprot.readStructBegin()
12197 
    while True:
12198 
      (fname, ftype, fid) = iprot.readFieldBegin()
12199 
      if ftype == TType.STOP:
12200 
        break
12201 
      if fid == 1:
12202 
        if ftype == TType.I64:
12203 
          self.orderId = iprot.readI64();
12204 
        else:
12205 
          iprot.skip(ftype)
3226 chandransh 12206 
      elif fid == 2:
12207 
        if ftype == TType.STRING:
12208 
          self.refundedBy = iprot.readString();
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      elif fid == 3:
12212 
        if ftype == TType.STRING:
12213 
          self.reason = iprot.readString();
12214 
        else:
12215 
          iprot.skip(ftype)
2616 chandransh 12216 
      else:
12217 
        iprot.skip(ftype)
12218 
      iprot.readFieldEnd()
12219 
    iprot.readStructEnd()
12220 
 
12221 
  def write(self, oprot):
12222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12224 
      return
12225 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 12226 
    if self.orderId is not None:
2616 chandransh 12227 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12228 
      oprot.writeI64(self.orderId)
12229 
      oprot.writeFieldEnd()
3431 rajveer 12230 
    if self.refundedBy is not None:
3226 chandransh 12231 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
12232 
      oprot.writeString(self.refundedBy)
12233 
      oprot.writeFieldEnd()
3431 rajveer 12234 
    if self.reason is not None:
3226 chandransh 12235 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
12236 
      oprot.writeString(self.reason)
12237 
      oprot.writeFieldEnd()
2616 chandransh 12238 
    oprot.writeFieldStop()
12239 
    oprot.writeStructEnd()
12240 
 
3431 rajveer 12241 
  def validate(self):
12242 
    return
12243 
 
12244 
 
2616 chandransh 12245 
  def __repr__(self):
12246 
    L = ['%s=%r' % (key, value)
12247 
      for key, value in self.__dict__.iteritems()]
12248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12249 
 
12250 
  def __eq__(self, other):
12251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12252 
 
12253 
  def __ne__(self, other):
12254 
    return not (self == other)
12255 
 
12256 
class refundOrder_result:
12257 
  """
12258 
  Attributes:
12259 
   - success
12260 
   - ex
12261 
  """
12262 
 
12263 
  thrift_spec = (
12264 
    (0, TType.BOOL, 'success', None, None, ), # 0
12265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12266 
  )
12267 
 
12268 
  def __init__(self, success=None, ex=None,):
12269 
    self.success = success
12270 
    self.ex = ex
12271 
 
12272 
  def read(self, iprot):
12273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12275 
      return
12276 
    iprot.readStructBegin()
12277 
    while True:
12278 
      (fname, ftype, fid) = iprot.readFieldBegin()
12279 
      if ftype == TType.STOP:
12280 
        break
12281 
      if fid == 0:
12282 
        if ftype == TType.BOOL:
12283 
          self.success = iprot.readBool();
12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      elif fid == 1:
12287 
        if ftype == TType.STRUCT:
12288 
          self.ex = TransactionServiceException()
12289 
          self.ex.read(iprot)
12290 
        else:
12291 
          iprot.skip(ftype)
12292 
      else:
12293 
        iprot.skip(ftype)
12294 
      iprot.readFieldEnd()
12295 
    iprot.readStructEnd()
12296 
 
12297 
  def write(self, oprot):
12298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12300 
      return
12301 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 12302 
    if self.success is not None:
2616 chandransh 12303 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12304 
      oprot.writeBool(self.success)
12305 
      oprot.writeFieldEnd()
3431 rajveer 12306 
    if self.ex is not None:
2616 chandransh 12307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12308 
      self.ex.write(oprot)
12309 
      oprot.writeFieldEnd()
12310 
    oprot.writeFieldStop()
12311 
    oprot.writeStructEnd()
12312 
 
3431 rajveer 12313 
  def validate(self):
12314 
    return
12315 
 
12316 
 
2616 chandransh 12317 
  def __repr__(self):
12318 
    L = ['%s=%r' % (key, value)
12319 
      for key, value in self.__dict__.iteritems()]
12320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12321 
 
12322 
  def __eq__(self, other):
12323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12324 
 
12325 
  def __ne__(self, other):
12326 
    return not (self == other)
12327 
 
2690 chandransh 12328 
class getReturnOrders_args:
12329 
  """
12330 
  Attributes:
12331 
   - warehouseId
12332 
   - fromDate
12333 
   - toDate
12334 
  """
2616 chandransh 12335 
 
2690 chandransh 12336 
  thrift_spec = (
12337 
    None, # 0
12338 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12339 
    (2, TType.I64, 'fromDate', None, None, ), # 2
12340 
    (3, TType.I64, 'toDate', None, None, ), # 3
12341 
  )
12342 
 
12343 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
12344 
    self.warehouseId = warehouseId
12345 
    self.fromDate = fromDate
12346 
    self.toDate = toDate
12347 
 
12348 
  def read(self, iprot):
12349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12351 
      return
12352 
    iprot.readStructBegin()
12353 
    while True:
12354 
      (fname, ftype, fid) = iprot.readFieldBegin()
12355 
      if ftype == TType.STOP:
12356 
        break
12357 
      if fid == 1:
12358 
        if ftype == TType.I64:
12359 
          self.warehouseId = iprot.readI64();
12360 
        else:
12361 
          iprot.skip(ftype)
12362 
      elif fid == 2:
12363 
        if ftype == TType.I64:
12364 
          self.fromDate = iprot.readI64();
12365 
        else:
12366 
          iprot.skip(ftype)
12367 
      elif fid == 3:
12368 
        if ftype == TType.I64:
12369 
          self.toDate = iprot.readI64();
12370 
        else:
12371 
          iprot.skip(ftype)
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
12381 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 12382 
    if self.warehouseId is not None:
2690 chandransh 12383 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12384 
      oprot.writeI64(self.warehouseId)
12385 
      oprot.writeFieldEnd()
3431 rajveer 12386 
    if self.fromDate is not None:
2690 chandransh 12387 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
12388 
      oprot.writeI64(self.fromDate)
12389 
      oprot.writeFieldEnd()
3431 rajveer 12390 
    if self.toDate is not None:
2690 chandransh 12391 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
12392 
      oprot.writeI64(self.toDate)
12393 
      oprot.writeFieldEnd()
12394 
    oprot.writeFieldStop()
12395 
    oprot.writeStructEnd()
12396 
 
3431 rajveer 12397 
  def validate(self):
12398 
    return
12399 
 
12400 
 
2690 chandransh 12401 
  def __repr__(self):
12402 
    L = ['%s=%r' % (key, value)
12403 
      for key, value in self.__dict__.iteritems()]
12404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12405 
 
12406 
  def __eq__(self, other):
12407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12408 
 
12409 
  def __ne__(self, other):
12410 
    return not (self == other)
12411 
 
12412 
class getReturnOrders_result:
12413 
  """
12414 
  Attributes:
12415 
   - success
12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
12420 
  )
12421 
 
12422 
  def __init__(self, success=None,):
12423 
    self.success = success
12424 
 
12425 
  def read(self, iprot):
12426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12428 
      return
12429 
    iprot.readStructBegin()
12430 
    while True:
12431 
      (fname, ftype, fid) = iprot.readFieldBegin()
12432 
      if ftype == TType.STOP:
12433 
        break
12434 
      if fid == 0:
12435 
        if ftype == TType.LIST:
12436 
          self.success = []
4133 chandransh 12437 
          (_etype209, _size206) = iprot.readListBegin()
12438 
          for _i210 in xrange(_size206):
12439 
            _elem211 = ReturnOrder()
12440 
            _elem211.read(iprot)
12441 
            self.success.append(_elem211)
2690 chandransh 12442 
          iprot.readListEnd()
12443 
        else:
12444 
          iprot.skip(ftype)
12445 
      else:
12446 
        iprot.skip(ftype)
12447 
      iprot.readFieldEnd()
12448 
    iprot.readStructEnd()
12449 
 
12450 
  def write(self, oprot):
12451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12453 
      return
12454 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 12455 
    if self.success is not None:
2690 chandransh 12456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4133 chandransh 12458 
      for iter212 in self.success:
12459 
        iter212.write(oprot)
2690 chandransh 12460 
      oprot.writeListEnd()
12461 
      oprot.writeFieldEnd()
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
3431 rajveer 12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
2690 chandransh 12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
2700 chandransh 12480 
class getReturnOrder_args:
12481 
  """
12482 
  Attributes:
12483 
   - id
12484 
  """
12485 
 
12486 
  thrift_spec = (
12487 
    None, # 0
12488 
    (1, TType.I64, 'id', None, None, ), # 1
12489 
  )
12490 
 
12491 
  def __init__(self, id=None,):
12492 
    self.id = id
12493 
 
12494 
  def read(self, iprot):
12495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12497 
      return
12498 
    iprot.readStructBegin()
12499 
    while True:
12500 
      (fname, ftype, fid) = iprot.readFieldBegin()
12501 
      if ftype == TType.STOP:
12502 
        break
12503 
      if fid == 1:
12504 
        if ftype == TType.I64:
12505 
          self.id = iprot.readI64();
12506 
        else:
12507 
          iprot.skip(ftype)
12508 
      else:
12509 
        iprot.skip(ftype)
12510 
      iprot.readFieldEnd()
12511 
    iprot.readStructEnd()
12512 
 
12513 
  def write(self, oprot):
12514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12516 
      return
12517 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 12518 
    if self.id is not None:
2700 chandransh 12519 
      oprot.writeFieldBegin('id', TType.I64, 1)
12520 
      oprot.writeI64(self.id)
12521 
      oprot.writeFieldEnd()
12522 
    oprot.writeFieldStop()
12523 
    oprot.writeStructEnd()
12524 
 
3431 rajveer 12525 
  def validate(self):
12526 
    return
12527 
 
12528 
 
2700 chandransh 12529 
  def __repr__(self):
12530 
    L = ['%s=%r' % (key, value)
12531 
      for key, value in self.__dict__.iteritems()]
12532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12533 
 
12534 
  def __eq__(self, other):
12535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12536 
 
12537 
  def __ne__(self, other):
12538 
    return not (self == other)
12539 
 
12540 
class getReturnOrder_result:
12541 
  """
12542 
  Attributes:
12543 
   - success
12544 
   - ex
12545 
  """
12546 
 
12547 
  thrift_spec = (
12548 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
12549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12550 
  )
12551 
 
12552 
  def __init__(self, success=None, ex=None,):
12553 
    self.success = success
12554 
    self.ex = ex
12555 
 
12556 
  def read(self, iprot):
12557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12559 
      return
12560 
    iprot.readStructBegin()
12561 
    while True:
12562 
      (fname, ftype, fid) = iprot.readFieldBegin()
12563 
      if ftype == TType.STOP:
12564 
        break
12565 
      if fid == 0:
12566 
        if ftype == TType.STRUCT:
12567 
          self.success = ReturnOrder()
12568 
          self.success.read(iprot)
12569 
        else:
12570 
          iprot.skip(ftype)
12571 
      elif fid == 1:
12572 
        if ftype == TType.STRUCT:
12573 
          self.ex = TransactionServiceException()
12574 
          self.ex.read(iprot)
12575 
        else:
12576 
          iprot.skip(ftype)
12577 
      else:
12578 
        iprot.skip(ftype)
12579 
      iprot.readFieldEnd()
12580 
    iprot.readStructEnd()
12581 
 
12582 
  def write(self, oprot):
12583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12585 
      return
12586 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 12587 
    if self.success is not None:
2700 chandransh 12588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12589 
      self.success.write(oprot)
12590 
      oprot.writeFieldEnd()
3431 rajveer 12591 
    if self.ex is not None:
2700 chandransh 12592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12593 
      self.ex.write(oprot)
12594 
      oprot.writeFieldEnd()
12595 
    oprot.writeFieldStop()
12596 
    oprot.writeStructEnd()
12597 
 
3431 rajveer 12598 
  def validate(self):
12599 
    return
12600 
 
12601 
 
2700 chandransh 12602 
  def __repr__(self):
12603 
    L = ['%s=%r' % (key, value)
12604 
      for key, value in self.__dict__.iteritems()]
12605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12606 
 
12607 
  def __eq__(self, other):
12608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12609 
 
12610 
  def __ne__(self, other):
12611 
    return not (self == other)
12612 
 
2690 chandransh 12613 
class processReturn_args:
12614 
  """
12615 
  Attributes:
12616 
   - returnOrderId
12617 
  """
12618 
 
12619 
  thrift_spec = (
12620 
    None, # 0
12621 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
12622 
  )
12623 
 
12624 
  def __init__(self, returnOrderId=None,):
12625 
    self.returnOrderId = returnOrderId
12626 
 
12627 
  def read(self, iprot):
12628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12630 
      return
12631 
    iprot.readStructBegin()
12632 
    while True:
12633 
      (fname, ftype, fid) = iprot.readFieldBegin()
12634 
      if ftype == TType.STOP:
12635 
        break
12636 
      if fid == 1:
12637 
        if ftype == TType.I64:
12638 
          self.returnOrderId = iprot.readI64();
12639 
        else:
12640 
          iprot.skip(ftype)
12641 
      else:
12642 
        iprot.skip(ftype)
12643 
      iprot.readFieldEnd()
12644 
    iprot.readStructEnd()
12645 
 
12646 
  def write(self, oprot):
12647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12649 
      return
12650 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 12651 
    if self.returnOrderId is not None:
2690 chandransh 12652 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
12653 
      oprot.writeI64(self.returnOrderId)
12654 
      oprot.writeFieldEnd()
12655 
    oprot.writeFieldStop()
12656 
    oprot.writeStructEnd()
12657 
 
3431 rajveer 12658 
  def validate(self):
12659 
    return
12660 
 
12661 
 
2690 chandransh 12662 
  def __repr__(self):
12663 
    L = ['%s=%r' % (key, value)
12664 
      for key, value in self.__dict__.iteritems()]
12665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12666 
 
12667 
  def __eq__(self, other):
12668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12669 
 
12670 
  def __ne__(self, other):
12671 
    return not (self == other)
12672 
 
12673 
class processReturn_result:
12674 
  """
12675 
  Attributes:
12676 
   - ex
12677 
  """
12678 
 
12679 
  thrift_spec = (
12680 
    None, # 0
12681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12682 
  )
12683 
 
12684 
  def __init__(self, ex=None,):
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 == 1:
12697 
        if ftype == TType.STRUCT:
12698 
          self.ex = TransactionServiceException()
12699 
          self.ex.read(iprot)
12700 
        else:
12701 
          iprot.skip(ftype)
12702 
      else:
12703 
        iprot.skip(ftype)
12704 
      iprot.readFieldEnd()
12705 
    iprot.readStructEnd()
12706 
 
12707 
  def write(self, oprot):
12708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12710 
      return
12711 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 12712 
    if self.ex is not None:
2690 chandransh 12713 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12714 
      self.ex.write(oprot)
12715 
      oprot.writeFieldEnd()
12716 
    oprot.writeFieldStop()
12717 
    oprot.writeStructEnd()
12718 
 
3431 rajveer 12719 
  def validate(self):
12720 
    return
12721 
 
12722 
 
2690 chandransh 12723 
  def __repr__(self):
12724 
    L = ['%s=%r' % (key, value)
12725 
      for key, value in self.__dict__.iteritems()]
12726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12727 
 
12728 
  def __eq__(self, other):
12729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12730 
 
12731 
  def __ne__(self, other):
12732 
    return not (self == other)
12733 
 
2819 chandransh 12734 
class createPurchaseOrder_args:
12735 
  """
12736 
  Attributes:
12737 
   - warehouseId
12738 
  """
2690 chandransh 12739 
 
2819 chandransh 12740 
  thrift_spec = (
12741 
    None, # 0
12742 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12743 
  )
12744 
 
12745 
  def __init__(self, warehouseId=None,):
12746 
    self.warehouseId = warehouseId
12747 
 
12748 
  def read(self, iprot):
12749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12751 
      return
12752 
    iprot.readStructBegin()
12753 
    while True:
12754 
      (fname, ftype, fid) = iprot.readFieldBegin()
12755 
      if ftype == TType.STOP:
12756 
        break
12757 
      if fid == 1:
12758 
        if ftype == TType.I64:
12759 
          self.warehouseId = iprot.readI64();
12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      else:
12763 
        iprot.skip(ftype)
12764 
      iprot.readFieldEnd()
12765 
    iprot.readStructEnd()
12766 
 
12767 
  def write(self, oprot):
12768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12770 
      return
12771 
    oprot.writeStructBegin('createPurchaseOrder_args')
3431 rajveer 12772 
    if self.warehouseId is not None:
2819 chandransh 12773 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12774 
      oprot.writeI64(self.warehouseId)
12775 
      oprot.writeFieldEnd()
12776 
    oprot.writeFieldStop()
12777 
    oprot.writeStructEnd()
12778 
 
3431 rajveer 12779 
  def validate(self):
12780 
    return
12781 
 
12782 
 
2819 chandransh 12783 
  def __repr__(self):
12784 
    L = ['%s=%r' % (key, value)
12785 
      for key, value in self.__dict__.iteritems()]
12786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12787 
 
12788 
  def __eq__(self, other):
12789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12790 
 
12791 
  def __ne__(self, other):
12792 
    return not (self == other)
12793 
 
12794 
class createPurchaseOrder_result:
12795 
  """
12796 
  Attributes:
12797 
   - success
12798 
   - ex
12799 
  """
12800 
 
12801 
  thrift_spec = (
12802 
    (0, TType.I64, 'success', None, None, ), # 0
12803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12804 
  )
12805 
 
12806 
  def __init__(self, success=None, ex=None,):
12807 
    self.success = success
12808 
    self.ex = ex
12809 
 
12810 
  def read(self, iprot):
12811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12813 
      return
12814 
    iprot.readStructBegin()
12815 
    while True:
12816 
      (fname, ftype, fid) = iprot.readFieldBegin()
12817 
      if ftype == TType.STOP:
12818 
        break
12819 
      if fid == 0:
12820 
        if ftype == TType.I64:
12821 
          self.success = iprot.readI64();
12822 
        else:
12823 
          iprot.skip(ftype)
12824 
      elif fid == 1:
12825 
        if ftype == TType.STRUCT:
12826 
          self.ex = TransactionServiceException()
12827 
          self.ex.read(iprot)
12828 
        else:
12829 
          iprot.skip(ftype)
12830 
      else:
12831 
        iprot.skip(ftype)
12832 
      iprot.readFieldEnd()
12833 
    iprot.readStructEnd()
12834 
 
12835 
  def write(self, oprot):
12836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12838 
      return
12839 
    oprot.writeStructBegin('createPurchaseOrder_result')
3431 rajveer 12840 
    if self.success is not None:
2819 chandransh 12841 
      oprot.writeFieldBegin('success', TType.I64, 0)
12842 
      oprot.writeI64(self.success)
12843 
      oprot.writeFieldEnd()
3431 rajveer 12844 
    if self.ex is not None:
2819 chandransh 12845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12846 
      self.ex.write(oprot)
12847 
      oprot.writeFieldEnd()
12848 
    oprot.writeFieldStop()
12849 
    oprot.writeStructEnd()
12850 
 
3431 rajveer 12851 
  def validate(self):
12852 
    return
12853 
 
12854 
 
2819 chandransh 12855 
  def __repr__(self):
12856 
    L = ['%s=%r' % (key, value)
12857 
      for key, value in self.__dict__.iteritems()]
12858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12859 
 
12860 
  def __eq__(self, other):
12861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12862 
 
12863 
  def __ne__(self, other):
12864 
    return not (self == other)
3451 chandransh 12865 
 
12866 
class updateWeight_args:
12867 
  """
12868 
  Attributes:
12869 
   - orderId
12870 
   - weight
12871 
  """
12872 
 
12873 
  thrift_spec = (
12874 
    None, # 0
12875 
    (1, TType.I64, 'orderId', None, None, ), # 1
12876 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
12877 
  )
12878 
 
12879 
  def __init__(self, orderId=None, weight=None,):
12880 
    self.orderId = orderId
12881 
    self.weight = weight
12882 
 
12883 
  def read(self, iprot):
12884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12886 
      return
12887 
    iprot.readStructBegin()
12888 
    while True:
12889 
      (fname, ftype, fid) = iprot.readFieldBegin()
12890 
      if ftype == TType.STOP:
12891 
        break
12892 
      if fid == 1:
12893 
        if ftype == TType.I64:
12894 
          self.orderId = iprot.readI64();
12895 
        else:
12896 
          iprot.skip(ftype)
12897 
      elif fid == 2:
12898 
        if ftype == TType.DOUBLE:
12899 
          self.weight = iprot.readDouble();
12900 
        else:
12901 
          iprot.skip(ftype)
12902 
      else:
12903 
        iprot.skip(ftype)
12904 
      iprot.readFieldEnd()
12905 
    iprot.readStructEnd()
12906 
 
12907 
  def write(self, oprot):
12908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12910 
      return
12911 
    oprot.writeStructBegin('updateWeight_args')
12912 
    if self.orderId is not None:
12913 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12914 
      oprot.writeI64(self.orderId)
12915 
      oprot.writeFieldEnd()
12916 
    if self.weight is not None:
12917 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
12918 
      oprot.writeDouble(self.weight)
12919 
      oprot.writeFieldEnd()
12920 
    oprot.writeFieldStop()
12921 
    oprot.writeStructEnd()
12922 
 
12923 
  def validate(self):
12924 
    return
12925 
 
12926 
 
12927 
  def __repr__(self):
12928 
    L = ['%s=%r' % (key, value)
12929 
      for key, value in self.__dict__.iteritems()]
12930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12931 
 
12932 
  def __eq__(self, other):
12933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12934 
 
12935 
  def __ne__(self, other):
12936 
    return not (self == other)
12937 
 
12938 
class updateWeight_result:
12939 
  """
12940 
  Attributes:
12941 
   - success
12942 
   - ex
12943 
  """
12944 
 
12945 
  thrift_spec = (
12946 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
12947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12948 
  )
12949 
 
12950 
  def __init__(self, success=None, ex=None,):
12951 
    self.success = success
12952 
    self.ex = ex
12953 
 
12954 
  def read(self, iprot):
12955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12957 
      return
12958 
    iprot.readStructBegin()
12959 
    while True:
12960 
      (fname, ftype, fid) = iprot.readFieldBegin()
12961 
      if ftype == TType.STOP:
12962 
        break
12963 
      if fid == 0:
12964 
        if ftype == TType.STRUCT:
12965 
          self.success = Order()
12966 
          self.success.read(iprot)
12967 
        else:
12968 
          iprot.skip(ftype)
12969 
      elif fid == 1:
12970 
        if ftype == TType.STRUCT:
12971 
          self.ex = TransactionServiceException()
12972 
          self.ex.read(iprot)
12973 
        else:
12974 
          iprot.skip(ftype)
12975 
      else:
12976 
        iprot.skip(ftype)
12977 
      iprot.readFieldEnd()
12978 
    iprot.readStructEnd()
12979 
 
12980 
  def write(self, oprot):
12981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12983 
      return
12984 
    oprot.writeStructBegin('updateWeight_result')
12985 
    if self.success is not None:
12986 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12987 
      self.success.write(oprot)
12988 
      oprot.writeFieldEnd()
12989 
    if self.ex is not None:
12990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12991 
      self.ex.write(oprot)
12992 
      oprot.writeFieldEnd()
12993 
    oprot.writeFieldStop()
12994 
    oprot.writeStructEnd()
12995 
 
12996 
  def validate(self):
12997 
    return
12998 
 
12999 
 
13000 
  def __repr__(self):
13001 
    L = ['%s=%r' % (key, value)
13002 
      for key, value in self.__dict__.iteritems()]
13003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13004 
 
13005 
  def __eq__(self, other):
13006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13007 
 
13008 
  def __ne__(self, other):
13009 
    return not (self == other)
3469 chandransh 13010 
 
13011 
class changeItem_args:
13012 
  """
13013 
  Attributes:
13014 
   - orderId
13015 
   - itemId
13016 
  """
13017 
 
13018 
  thrift_spec = (
13019 
    None, # 0
13020 
    (1, TType.I64, 'orderId', None, None, ), # 1
13021 
    (2, TType.I64, 'itemId', None, None, ), # 2
13022 
  )
13023 
 
13024 
  def __init__(self, orderId=None, itemId=None,):
13025 
    self.orderId = orderId
13026 
    self.itemId = itemId
13027 
 
13028 
  def read(self, iprot):
13029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13031 
      return
13032 
    iprot.readStructBegin()
13033 
    while True:
13034 
      (fname, ftype, fid) = iprot.readFieldBegin()
13035 
      if ftype == TType.STOP:
13036 
        break
13037 
      if fid == 1:
13038 
        if ftype == TType.I64:
13039 
          self.orderId = iprot.readI64();
13040 
        else:
13041 
          iprot.skip(ftype)
13042 
      elif fid == 2:
13043 
        if ftype == TType.I64:
13044 
          self.itemId = iprot.readI64();
13045 
        else:
13046 
          iprot.skip(ftype)
13047 
      else:
13048 
        iprot.skip(ftype)
13049 
      iprot.readFieldEnd()
13050 
    iprot.readStructEnd()
13051 
 
13052 
  def write(self, oprot):
13053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13055 
      return
13056 
    oprot.writeStructBegin('changeItem_args')
13057 
    if self.orderId is not None:
13058 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13059 
      oprot.writeI64(self.orderId)
13060 
      oprot.writeFieldEnd()
13061 
    if self.itemId is not None:
13062 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13063 
      oprot.writeI64(self.itemId)
13064 
      oprot.writeFieldEnd()
13065 
    oprot.writeFieldStop()
13066 
    oprot.writeStructEnd()
13067 
 
13068 
  def validate(self):
13069 
    return
13070 
 
13071 
 
13072 
  def __repr__(self):
13073 
    L = ['%s=%r' % (key, value)
13074 
      for key, value in self.__dict__.iteritems()]
13075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13076 
 
13077 
  def __eq__(self, other):
13078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13079 
 
13080 
  def __ne__(self, other):
13081 
    return not (self == other)
13082 
 
13083 
class changeItem_result:
13084 
  """
13085 
  Attributes:
13086 
   - success
13087 
   - ex
13088 
  """
13089 
 
13090 
  thrift_spec = (
13091 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13093 
  )
13094 
 
13095 
  def __init__(self, success=None, ex=None,):
13096 
    self.success = success
13097 
    self.ex = ex
13098 
 
13099 
  def read(self, iprot):
13100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13102 
      return
13103 
    iprot.readStructBegin()
13104 
    while True:
13105 
      (fname, ftype, fid) = iprot.readFieldBegin()
13106 
      if ftype == TType.STOP:
13107 
        break
13108 
      if fid == 0:
13109 
        if ftype == TType.STRUCT:
13110 
          self.success = Order()
13111 
          self.success.read(iprot)
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      elif fid == 1:
13115 
        if ftype == TType.STRUCT:
13116 
          self.ex = TransactionServiceException()
13117 
          self.ex.read(iprot)
13118 
        else:
13119 
          iprot.skip(ftype)
13120 
      else:
13121 
        iprot.skip(ftype)
13122 
      iprot.readFieldEnd()
13123 
    iprot.readStructEnd()
13124 
 
13125 
  def write(self, oprot):
13126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13128 
      return
13129 
    oprot.writeStructBegin('changeItem_result')
13130 
    if self.success is not None:
13131 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13132 
      self.success.write(oprot)
13133 
      oprot.writeFieldEnd()
13134 
    if self.ex is not None:
13135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13136 
      self.ex.write(oprot)
13137 
      oprot.writeFieldEnd()
13138 
    oprot.writeFieldStop()
13139 
    oprot.writeStructEnd()
13140 
 
13141 
  def validate(self):
13142 
    return
13143 
 
13144 
 
13145 
  def __repr__(self):
13146 
    L = ['%s=%r' % (key, value)
13147 
      for key, value in self.__dict__.iteritems()]
13148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13149 
 
13150 
  def __eq__(self, other):
13151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13152 
 
13153 
  def __ne__(self, other):
13154 
    return not (self == other)
13155 
 
13156 
class shiftToWarehouse_args:
13157 
  """
13158 
  Attributes:
13159 
   - orderId
13160 
   - warehouseId
13161 
  """
13162 
 
13163 
  thrift_spec = (
13164 
    None, # 0
13165 
    (1, TType.I64, 'orderId', None, None, ), # 1
13166 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13167 
  )
13168 
 
13169 
  def __init__(self, orderId=None, warehouseId=None,):
13170 
    self.orderId = orderId
13171 
    self.warehouseId = warehouseId
13172 
 
13173 
  def read(self, iprot):
13174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13176 
      return
13177 
    iprot.readStructBegin()
13178 
    while True:
13179 
      (fname, ftype, fid) = iprot.readFieldBegin()
13180 
      if ftype == TType.STOP:
13181 
        break
13182 
      if fid == 1:
13183 
        if ftype == TType.I64:
13184 
          self.orderId = iprot.readI64();
13185 
        else:
13186 
          iprot.skip(ftype)
13187 
      elif fid == 2:
13188 
        if ftype == TType.I64:
13189 
          self.warehouseId = iprot.readI64();
13190 
        else:
13191 
          iprot.skip(ftype)
13192 
      else:
13193 
        iprot.skip(ftype)
13194 
      iprot.readFieldEnd()
13195 
    iprot.readStructEnd()
13196 
 
13197 
  def write(self, oprot):
13198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13200 
      return
13201 
    oprot.writeStructBegin('shiftToWarehouse_args')
13202 
    if self.orderId is not None:
13203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13204 
      oprot.writeI64(self.orderId)
13205 
      oprot.writeFieldEnd()
13206 
    if self.warehouseId is not None:
13207 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13208 
      oprot.writeI64(self.warehouseId)
13209 
      oprot.writeFieldEnd()
13210 
    oprot.writeFieldStop()
13211 
    oprot.writeStructEnd()
13212 
 
13213 
  def validate(self):
13214 
    return
13215 
 
13216 
 
13217 
  def __repr__(self):
13218 
    L = ['%s=%r' % (key, value)
13219 
      for key, value in self.__dict__.iteritems()]
13220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13221 
 
13222 
  def __eq__(self, other):
13223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13224 
 
13225 
  def __ne__(self, other):
13226 
    return not (self == other)
13227 
 
13228 
class shiftToWarehouse_result:
13229 
  """
13230 
  Attributes:
13231 
   - success
13232 
   - ex
13233 
  """
13234 
 
13235 
  thrift_spec = (
13236 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
13237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13238 
  )
13239 
 
13240 
  def __init__(self, success=None, ex=None,):
13241 
    self.success = success
13242 
    self.ex = ex
13243 
 
13244 
  def read(self, iprot):
13245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13247 
      return
13248 
    iprot.readStructBegin()
13249 
    while True:
13250 
      (fname, ftype, fid) = iprot.readFieldBegin()
13251 
      if ftype == TType.STOP:
13252 
        break
13253 
      if fid == 0:
13254 
        if ftype == TType.STRUCT:
13255 
          self.success = Order()
13256 
          self.success.read(iprot)
13257 
        else:
13258 
          iprot.skip(ftype)
13259 
      elif fid == 1:
13260 
        if ftype == TType.STRUCT:
13261 
          self.ex = TransactionServiceException()
13262 
          self.ex.read(iprot)
13263 
        else:
13264 
          iprot.skip(ftype)
13265 
      else:
13266 
        iprot.skip(ftype)
13267 
      iprot.readFieldEnd()
13268 
    iprot.readStructEnd()
13269 
 
13270 
  def write(self, oprot):
13271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13273 
      return
13274 
    oprot.writeStructBegin('shiftToWarehouse_result')
13275 
    if self.success is not None:
13276 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13277 
      self.success.write(oprot)
13278 
      oprot.writeFieldEnd()
13279 
    if self.ex is not None:
13280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13281 
      self.ex.write(oprot)
13282 
      oprot.writeFieldEnd()
13283 
    oprot.writeFieldStop()
13284 
    oprot.writeStructEnd()
13285 
 
13286 
  def validate(self):
13287 
    return
13288 
 
13289 
 
13290 
  def __repr__(self):
13291 
    L = ['%s=%r' % (key, value)
13292 
      for key, value in self.__dict__.iteritems()]
13293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13294 
 
13295 
  def __eq__(self, other):
13296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13297 
 
13298 
  def __ne__(self, other):
13299 
    return not (self == other)
3553 chandransh 13300 
 
13301 
class addDelayReason_args:
13302 
  """
13303 
  Attributes:
13304 
   - orderId
13305 
   - delayReason
3986 chandransh 13306 
   - furtherDelay
3553 chandransh 13307 
  """
13308 
 
13309 
  thrift_spec = (
13310 
    None, # 0
13311 
    (1, TType.I64, 'orderId', None, None, ), # 1
13312 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 13313 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
3553 chandransh 13314 
  )
13315 
 
3986 chandransh 13316 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None,):
3553 chandransh 13317 
    self.orderId = orderId
13318 
    self.delayReason = delayReason
3986 chandransh 13319 
    self.furtherDelay = furtherDelay
3553 chandransh 13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      if fid == 1:
13331 
        if ftype == TType.I64:
13332 
          self.orderId = iprot.readI64();
13333 
        else:
13334 
          iprot.skip(ftype)
13335 
      elif fid == 2:
13336 
        if ftype == TType.I32:
13337 
          self.delayReason = iprot.readI32();
13338 
        else:
13339 
          iprot.skip(ftype)
3986 chandransh 13340 
      elif fid == 3:
13341 
        if ftype == TType.I64:
13342 
          self.furtherDelay = iprot.readI64();
13343 
        else:
13344 
          iprot.skip(ftype)
3553 chandransh 13345 
      else:
13346 
        iprot.skip(ftype)
13347 
      iprot.readFieldEnd()
13348 
    iprot.readStructEnd()
13349 
 
13350 
  def write(self, oprot):
13351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13353 
      return
13354 
    oprot.writeStructBegin('addDelayReason_args')
13355 
    if self.orderId is not None:
13356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13357 
      oprot.writeI64(self.orderId)
13358 
      oprot.writeFieldEnd()
13359 
    if self.delayReason is not None:
13360 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
13361 
      oprot.writeI32(self.delayReason)
13362 
      oprot.writeFieldEnd()
3986 chandransh 13363 
    if self.furtherDelay is not None:
13364 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
13365 
      oprot.writeI64(self.furtherDelay)
13366 
      oprot.writeFieldEnd()
3553 chandransh 13367 
    oprot.writeFieldStop()
13368 
    oprot.writeStructEnd()
13369 
 
13370 
  def validate(self):
13371 
    return
13372 
 
13373 
 
13374 
  def __repr__(self):
13375 
    L = ['%s=%r' % (key, value)
13376 
      for key, value in self.__dict__.iteritems()]
13377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13378 
 
13379 
  def __eq__(self, other):
13380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13381 
 
13382 
  def __ne__(self, other):
13383 
    return not (self == other)
13384 
 
13385 
class addDelayReason_result:
13386 
  """
13387 
  Attributes:
13388 
   - success
13389 
   - ex
13390 
  """
13391 
 
13392 
  thrift_spec = (
13393 
    (0, TType.BOOL, 'success', None, None, ), # 0
13394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13395 
  )
13396 
 
13397 
  def __init__(self, success=None, ex=None,):
13398 
    self.success = success
13399 
    self.ex = ex
13400 
 
13401 
  def read(self, iprot):
13402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13404 
      return
13405 
    iprot.readStructBegin()
13406 
    while True:
13407 
      (fname, ftype, fid) = iprot.readFieldBegin()
13408 
      if ftype == TType.STOP:
13409 
        break
13410 
      if fid == 0:
13411 
        if ftype == TType.BOOL:
13412 
          self.success = iprot.readBool();
13413 
        else:
13414 
          iprot.skip(ftype)
13415 
      elif fid == 1:
13416 
        if ftype == TType.STRUCT:
13417 
          self.ex = TransactionServiceException()
13418 
          self.ex.read(iprot)
13419 
        else:
13420 
          iprot.skip(ftype)
13421 
      else:
13422 
        iprot.skip(ftype)
13423 
      iprot.readFieldEnd()
13424 
    iprot.readStructEnd()
13425 
 
13426 
  def write(self, oprot):
13427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13429 
      return
13430 
    oprot.writeStructBegin('addDelayReason_result')
13431 
    if self.success is not None:
13432 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13433 
      oprot.writeBool(self.success)
13434 
      oprot.writeFieldEnd()
13435 
    if self.ex is not None:
13436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13437 
      self.ex.write(oprot)
13438 
      oprot.writeFieldEnd()
13439 
    oprot.writeFieldStop()
13440 
    oprot.writeStructEnd()
13441 
 
13442 
  def validate(self):
13443 
    return
13444 
 
13445 
 
13446 
  def __repr__(self):
13447 
    L = ['%s=%r' % (key, value)
13448 
      for key, value in self.__dict__.iteritems()]
13449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13450 
 
13451 
  def __eq__(self, other):
13452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13453 
 
13454 
  def __ne__(self, other):
13455 
    return not (self == other)
3956 chandransh 13456 
 
13457 
class reconcileCodCollection_args:
13458 
  """
13459 
  Attributes:
13460 
   - collectedAmountMap
13461 
   - xferBy
13462 
   - xferTxnId
13463 
   - xferDate
13464 
  """
13465 
 
13466 
  thrift_spec = (
13467 
    None, # 0
13468 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
13469 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
13470 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
13471 
    (4, TType.I64, 'xferDate', None, None, ), # 4
13472 
  )
13473 
 
13474 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
13475 
    self.collectedAmountMap = collectedAmountMap
13476 
    self.xferBy = xferBy
13477 
    self.xferTxnId = xferTxnId
13478 
    self.xferDate = xferDate
13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
13489 
      if fid == 1:
13490 
        if ftype == TType.MAP:
13491 
          self.collectedAmountMap = {}
4133 chandransh 13492 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
13493 
          for _i217 in xrange(_size213):
13494 
            _key218 = iprot.readString();
13495 
            _val219 = iprot.readDouble();
13496 
            self.collectedAmountMap[_key218] = _val219
3956 chandransh 13497 
          iprot.readMapEnd()
13498 
        else:
13499 
          iprot.skip(ftype)
13500 
      elif fid == 2:
13501 
        if ftype == TType.STRING:
13502 
          self.xferBy = iprot.readString();
13503 
        else:
13504 
          iprot.skip(ftype)
13505 
      elif fid == 3:
13506 
        if ftype == TType.STRING:
13507 
          self.xferTxnId = iprot.readString();
13508 
        else:
13509 
          iprot.skip(ftype)
13510 
      elif fid == 4:
13511 
        if ftype == TType.I64:
13512 
          self.xferDate = iprot.readI64();
13513 
        else:
13514 
          iprot.skip(ftype)
13515 
      else:
13516 
        iprot.skip(ftype)
13517 
      iprot.readFieldEnd()
13518 
    iprot.readStructEnd()
13519 
 
13520 
  def write(self, oprot):
13521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13523 
      return
13524 
    oprot.writeStructBegin('reconcileCodCollection_args')
13525 
    if self.collectedAmountMap is not None:
13526 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
13527 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
4133 chandransh 13528 
      for kiter220,viter221 in self.collectedAmountMap.items():
13529 
        oprot.writeString(kiter220)
13530 
        oprot.writeDouble(viter221)
3956 chandransh 13531 
      oprot.writeMapEnd()
13532 
      oprot.writeFieldEnd()
13533 
    if self.xferBy is not None:
13534 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
13535 
      oprot.writeString(self.xferBy)
13536 
      oprot.writeFieldEnd()
13537 
    if self.xferTxnId is not None:
13538 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
13539 
      oprot.writeString(self.xferTxnId)
13540 
      oprot.writeFieldEnd()
13541 
    if self.xferDate is not None:
13542 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
13543 
      oprot.writeI64(self.xferDate)
13544 
      oprot.writeFieldEnd()
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
13562 
 
13563 
class reconcileCodCollection_result:
13564 
  """
13565 
  Attributes:
13566 
   - success
13567 
   - ex
13568 
  """
13569 
 
13570 
  thrift_spec = (
13571 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
13572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13573 
  )
13574 
 
13575 
  def __init__(self, success=None, ex=None,):
13576 
    self.success = success
13577 
    self.ex = ex
13578 
 
13579 
  def read(self, iprot):
13580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13582 
      return
13583 
    iprot.readStructBegin()
13584 
    while True:
13585 
      (fname, ftype, fid) = iprot.readFieldBegin()
13586 
      if ftype == TType.STOP:
13587 
        break
13588 
      if fid == 0:
13589 
        if ftype == TType.MAP:
13590 
          self.success = {}
4133 chandransh 13591 
          (_ktype223, _vtype224, _size222 ) = iprot.readMapBegin()
13592 
          for _i226 in xrange(_size222):
13593 
            _key227 = iprot.readString();
13594 
            _val228 = iprot.readString();
13595 
            self.success[_key227] = _val228
3956 chandransh 13596 
          iprot.readMapEnd()
13597 
        else:
13598 
          iprot.skip(ftype)
13599 
      elif fid == 1:
13600 
        if ftype == TType.STRUCT:
13601 
          self.ex = TransactionServiceException()
13602 
          self.ex.read(iprot)
13603 
        else:
13604 
          iprot.skip(ftype)
13605 
      else:
13606 
        iprot.skip(ftype)
13607 
      iprot.readFieldEnd()
13608 
    iprot.readStructEnd()
13609 
 
13610 
  def write(self, oprot):
13611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13613 
      return
13614 
    oprot.writeStructBegin('reconcileCodCollection_result')
13615 
    if self.success is not None:
13616 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13617 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4133 chandransh 13618 
      for kiter229,viter230 in self.success.items():
13619 
        oprot.writeString(kiter229)
13620 
        oprot.writeString(viter230)
3956 chandransh 13621 
      oprot.writeMapEnd()
13622 
      oprot.writeFieldEnd()
13623 
    if self.ex is not None:
13624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13625 
      self.ex.write(oprot)
13626 
      oprot.writeFieldEnd()
13627 
    oprot.writeFieldStop()
13628 
    oprot.writeStructEnd()
13629 
 
13630 
  def validate(self):
13631 
    return
13632 
 
13633 
 
13634 
  def __repr__(self):
13635 
    L = ['%s=%r' % (key, value)
13636 
      for key, value in self.__dict__.iteritems()]
13637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13638 
 
13639 
  def __eq__(self, other):
13640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13641 
 
13642 
  def __ne__(self, other):
13643 
    return not (self == other)
4008 mandeep.dh 13644 
 
13645 
class getTransactionsRequiringExtraProcessing_args:
13646 
  """
13647 
  Attributes:
13648 
   - category
13649 
  """
13650 
 
13651 
  thrift_spec = (
13652 
    None, # 0
13653 
    (1, TType.I32, 'category', None, None, ), # 1
13654 
  )
13655 
 
13656 
  def __init__(self, category=None,):
13657 
    self.category = category
13658 
 
13659 
  def read(self, iprot):
13660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13662 
      return
13663 
    iprot.readStructBegin()
13664 
    while True:
13665 
      (fname, ftype, fid) = iprot.readFieldBegin()
13666 
      if ftype == TType.STOP:
13667 
        break
13668 
      if fid == 1:
13669 
        if ftype == TType.I32:
13670 
          self.category = iprot.readI32();
13671 
        else:
13672 
          iprot.skip(ftype)
13673 
      else:
13674 
        iprot.skip(ftype)
13675 
      iprot.readFieldEnd()
13676 
    iprot.readStructEnd()
13677 
 
13678 
  def write(self, oprot):
13679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13681 
      return
13682 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
13683 
    if self.category is not None:
13684 
      oprot.writeFieldBegin('category', TType.I32, 1)
13685 
      oprot.writeI32(self.category)
13686 
      oprot.writeFieldEnd()
13687 
    oprot.writeFieldStop()
13688 
    oprot.writeStructEnd()
13689 
 
13690 
  def validate(self):
13691 
    return
13692 
 
13693 
 
13694 
  def __repr__(self):
13695 
    L = ['%s=%r' % (key, value)
13696 
      for key, value in self.__dict__.iteritems()]
13697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13698 
 
13699 
  def __eq__(self, other):
13700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13701 
 
13702 
  def __ne__(self, other):
13703 
    return not (self == other)
13704 
 
13705 
class getTransactionsRequiringExtraProcessing_result:
13706 
  """
13707 
  Attributes:
13708 
   - success
13709 
  """
13710 
 
13711 
  thrift_spec = (
13712 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13713 
  )
13714 
 
13715 
  def __init__(self, success=None,):
13716 
    self.success = success
13717 
 
13718 
  def read(self, iprot):
13719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13721 
      return
13722 
    iprot.readStructBegin()
13723 
    while True:
13724 
      (fname, ftype, fid) = iprot.readFieldBegin()
13725 
      if ftype == TType.STOP:
13726 
        break
13727 
      if fid == 0:
13728 
        if ftype == TType.LIST:
13729 
          self.success = []
4133 chandransh 13730 
          (_etype234, _size231) = iprot.readListBegin()
13731 
          for _i235 in xrange(_size231):
13732 
            _elem236 = iprot.readI64();
13733 
            self.success.append(_elem236)
4008 mandeep.dh 13734 
          iprot.readListEnd()
13735 
        else:
13736 
          iprot.skip(ftype)
13737 
      else:
13738 
        iprot.skip(ftype)
13739 
      iprot.readFieldEnd()
13740 
    iprot.readStructEnd()
13741 
 
13742 
  def write(self, oprot):
13743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13745 
      return
13746 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
13747 
    if self.success is not None:
13748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13749 
      oprot.writeListBegin(TType.I64, len(self.success))
4133 chandransh 13750 
      for iter237 in self.success:
13751 
        oprot.writeI64(iter237)
4008 mandeep.dh 13752 
      oprot.writeListEnd()
13753 
      oprot.writeFieldEnd()
13754 
    oprot.writeFieldStop()
13755 
    oprot.writeStructEnd()
13756 
 
13757 
  def validate(self):
13758 
    return
13759 
 
13760 
 
13761 
  def __repr__(self):
13762 
    L = ['%s=%r' % (key, value)
13763 
      for key, value in self.__dict__.iteritems()]
13764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13765 
 
13766 
  def __eq__(self, other):
13767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13768 
 
13769 
  def __ne__(self, other):
13770 
    return not (self == other)
13771 
 
13772 
class markTransactionAsProcessed_args:
13773 
  """
13774 
  Attributes:
13775 
   - transactionId
13776 
   - category
13777 
  """
13778 
 
13779 
  thrift_spec = (
13780 
    None, # 0
13781 
    (1, TType.I64, 'transactionId', None, None, ), # 1
13782 
    (2, TType.I32, 'category', None, None, ), # 2
13783 
  )
13784 
 
13785 
  def __init__(self, transactionId=None, category=None,):
13786 
    self.transactionId = transactionId
13787 
    self.category = category
13788 
 
13789 
  def read(self, iprot):
13790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13792 
      return
13793 
    iprot.readStructBegin()
13794 
    while True:
13795 
      (fname, ftype, fid) = iprot.readFieldBegin()
13796 
      if ftype == TType.STOP:
13797 
        break
13798 
      if fid == 1:
13799 
        if ftype == TType.I64:
13800 
          self.transactionId = iprot.readI64();
13801 
        else:
13802 
          iprot.skip(ftype)
13803 
      elif fid == 2:
13804 
        if ftype == TType.I32:
13805 
          self.category = iprot.readI32();
13806 
        else:
13807 
          iprot.skip(ftype)
13808 
      else:
13809 
        iprot.skip(ftype)
13810 
      iprot.readFieldEnd()
13811 
    iprot.readStructEnd()
13812 
 
13813 
  def write(self, oprot):
13814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13816 
      return
13817 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
13818 
    if self.transactionId is not None:
13819 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
13820 
      oprot.writeI64(self.transactionId)
13821 
      oprot.writeFieldEnd()
13822 
    if self.category is not None:
13823 
      oprot.writeFieldBegin('category', TType.I32, 2)
13824 
      oprot.writeI32(self.category)
13825 
      oprot.writeFieldEnd()
13826 
    oprot.writeFieldStop()
13827 
    oprot.writeStructEnd()
13828 
 
13829 
  def validate(self):
13830 
    return
13831 
 
13832 
 
13833 
  def __repr__(self):
13834 
    L = ['%s=%r' % (key, value)
13835 
      for key, value in self.__dict__.iteritems()]
13836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13837 
 
13838 
  def __eq__(self, other):
13839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13840 
 
13841 
  def __ne__(self, other):
13842 
    return not (self == other)
13843 
 
13844 
class markTransactionAsProcessed_result:
13845 
 
13846 
  thrift_spec = (
13847 
  )
13848 
 
13849 
  def read(self, iprot):
13850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13852 
      return
13853 
    iprot.readStructBegin()
13854 
    while True:
13855 
      (fname, ftype, fid) = iprot.readFieldBegin()
13856 
      if ftype == TType.STOP:
13857 
        break
13858 
      else:
13859 
        iprot.skip(ftype)
13860 
      iprot.readFieldEnd()
13861 
    iprot.readStructEnd()
13862 
 
13863 
  def write(self, oprot):
13864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13866 
      return
13867 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
13868 
    oprot.writeFieldStop()
13869 
    oprot.writeStructEnd()
13870 
 
13871 
  def validate(self):
13872 
    return
13873 
 
13874 
 
13875 
  def __repr__(self):
13876 
    L = ['%s=%r' % (key, value)
13877 
      for key, value in self.__dict__.iteritems()]
13878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13879 
 
13880 
  def __eq__(self, other):
13881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13882 
 
13883 
  def __ne__(self, other):
13884 
    return not (self == other)
4018 chandransh 13885 
 
13886 
class getItemWiseRiskyOrdersCount_args:
13887 
 
13888 
  thrift_spec = (
13889 
  )
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      else:
13901 
        iprot.skip(ftype)
13902 
      iprot.readFieldEnd()
13903 
    iprot.readStructEnd()
13904 
 
13905 
  def write(self, oprot):
13906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13908 
      return
13909 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
13910 
    oprot.writeFieldStop()
13911 
    oprot.writeStructEnd()
13912 
 
13913 
  def validate(self):
13914 
    return
13915 
 
13916 
 
13917 
  def __repr__(self):
13918 
    L = ['%s=%r' % (key, value)
13919 
      for key, value in self.__dict__.iteritems()]
13920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13921 
 
13922 
  def __eq__(self, other):
13923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13924 
 
13925 
  def __ne__(self, other):
13926 
    return not (self == other)
13927 
 
13928 
class getItemWiseRiskyOrdersCount_result:
13929 
  """
13930 
  Attributes:
13931 
   - success
13932 
  """
13933 
 
13934 
  thrift_spec = (
13935 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
13936 
  )
13937 
 
13938 
  def __init__(self, success=None,):
13939 
    self.success = success
13940 
 
13941 
  def read(self, iprot):
13942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13944 
      return
13945 
    iprot.readStructBegin()
13946 
    while True:
13947 
      (fname, ftype, fid) = iprot.readFieldBegin()
13948 
      if ftype == TType.STOP:
13949 
        break
13950 
      if fid == 0:
13951 
        if ftype == TType.MAP:
13952 
          self.success = {}
4133 chandransh 13953 
          (_ktype239, _vtype240, _size238 ) = iprot.readMapBegin()
13954 
          for _i242 in xrange(_size238):
13955 
            _key243 = iprot.readI64();
13956 
            _val244 = iprot.readI64();
13957 
            self.success[_key243] = _val244
4018 chandransh 13958 
          iprot.readMapEnd()
13959 
        else:
13960 
          iprot.skip(ftype)
13961 
      else:
13962 
        iprot.skip(ftype)
13963 
      iprot.readFieldEnd()
13964 
    iprot.readStructEnd()
13965 
 
13966 
  def write(self, oprot):
13967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13969 
      return
13970 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
13971 
    if self.success is not None:
13972 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13973 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
4133 chandransh 13974 
      for kiter245,viter246 in self.success.items():
13975 
        oprot.writeI64(kiter245)
13976 
        oprot.writeI64(viter246)
4018 chandransh 13977 
      oprot.writeMapEnd()
13978 
      oprot.writeFieldEnd()
13979 
    oprot.writeFieldStop()
13980 
    oprot.writeStructEnd()
13981 
 
13982 
  def validate(self):
13983 
    return
13984 
 
13985 
 
13986 
  def __repr__(self):
13987 
    L = ['%s=%r' % (key, value)
13988 
      for key, value in self.__dict__.iteritems()]
13989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13990 
 
13991 
  def __eq__(self, other):
13992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13993 
 
13994 
  def __ne__(self, other):
13995 
    return not (self == other)
4247 rajveer 13996 
 
4295 varun.gupt 13997 
class getOrdersForItemIds_args:
13998 
  """
13999 
  Attributes:
14000 
   - itemIds
14001 
  """
14002 
 
14003 
  thrift_spec = (
14004 
    None, # 0
14005 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14006 
  )
14007 
 
14008 
  def __init__(self, itemIds=None,):
14009 
    self.itemIds = itemIds
14010 
 
14011 
  def read(self, iprot):
14012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14014 
      return
14015 
    iprot.readStructBegin()
14016 
    while True:
14017 
      (fname, ftype, fid) = iprot.readFieldBegin()
14018 
      if ftype == TType.STOP:
14019 
        break
14020 
      if fid == 1:
14021 
        if ftype == TType.LIST:
14022 
          self.itemIds = []
14023 
          (_etype250, _size247) = iprot.readListBegin()
14024 
          for _i251 in xrange(_size247):
14025 
            _elem252 = iprot.readI64();
14026 
            self.itemIds.append(_elem252)
14027 
          iprot.readListEnd()
14028 
        else:
14029 
          iprot.skip(ftype)
14030 
      else:
14031 
        iprot.skip(ftype)
14032 
      iprot.readFieldEnd()
14033 
    iprot.readStructEnd()
14034 
 
14035 
  def write(self, oprot):
14036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14038 
      return
14039 
    oprot.writeStructBegin('getOrdersForItemIds_args')
14040 
    if self.itemIds is not None:
14041 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14042 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
14043 
      for iter253 in self.itemIds:
14044 
        oprot.writeI64(iter253)
14045 
      oprot.writeListEnd()
14046 
      oprot.writeFieldEnd()
14047 
    oprot.writeFieldStop()
14048 
    oprot.writeStructEnd()
14049 
 
14050 
  def validate(self):
14051 
    return
14052 
 
14053 
 
14054 
  def __repr__(self):
14055 
    L = ['%s=%r' % (key, value)
14056 
      for key, value in self.__dict__.iteritems()]
14057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14058 
 
14059 
  def __eq__(self, other):
14060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14061 
 
14062 
  def __ne__(self, other):
14063 
    return not (self == other)
14064 
 
14065 
class getOrdersForItemIds_result:
14066 
  """
14067 
  Attributes:
14068 
   - success
14069 
  """
14070 
 
14071 
  thrift_spec = (
14072 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14073 
  )
14074 
 
14075 
  def __init__(self, success=None,):
14076 
    self.success = success
14077 
 
14078 
  def read(self, iprot):
14079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14081 
      return
14082 
    iprot.readStructBegin()
14083 
    while True:
14084 
      (fname, ftype, fid) = iprot.readFieldBegin()
14085 
      if ftype == TType.STOP:
14086 
        break
14087 
      if fid == 0:
14088 
        if ftype == TType.LIST:
14089 
          self.success = []
14090 
          (_etype257, _size254) = iprot.readListBegin()
14091 
          for _i258 in xrange(_size254):
14092 
            _elem259 = Order()
14093 
            _elem259.read(iprot)
14094 
            self.success.append(_elem259)
14095 
          iprot.readListEnd()
14096 
        else:
14097 
          iprot.skip(ftype)
14098 
      else:
14099 
        iprot.skip(ftype)
14100 
      iprot.readFieldEnd()
14101 
    iprot.readStructEnd()
14102 
 
14103 
  def write(self, oprot):
14104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14106 
      return
14107 
    oprot.writeStructBegin('getOrdersForItemIds_result')
14108 
    if self.success is not None:
14109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14111 
      for iter260 in self.success:
14112 
        iter260.write(oprot)
14113 
      oprot.writeListEnd()
14114 
      oprot.writeFieldEnd()
14115 
    oprot.writeFieldStop()
14116 
    oprot.writeStructEnd()
14117 
 
14118 
  def validate(self):
14119 
    return
14120 
 
14121 
 
14122 
  def __repr__(self):
14123 
    L = ['%s=%r' % (key, value)
14124 
      for key, value in self.__dict__.iteritems()]
14125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14126 
 
14127 
  def __eq__(self, other):
14128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14129 
 
14130 
  def __ne__(self, other):
14131 
    return not (self == other)
14132 
 
4247 rajveer 14133 
class markOrderCancellationRequestReceived_args:
14134 
  """
14135 
  Attributes:
14136 
   - orderId
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    None, # 0
14141 
    (1, TType.I64, 'orderId', None, None, ), # 1
14142 
  )
14143 
 
14144 
  def __init__(self, orderId=None,):
14145 
    self.orderId = orderId
14146 
 
14147 
  def read(self, iprot):
14148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14150 
      return
14151 
    iprot.readStructBegin()
14152 
    while True:
14153 
      (fname, ftype, fid) = iprot.readFieldBegin()
14154 
      if ftype == TType.STOP:
14155 
        break
14156 
      if fid == 1:
14157 
        if ftype == TType.I64:
14158 
          self.orderId = iprot.readI64();
14159 
        else:
14160 
          iprot.skip(ftype)
14161 
      else:
14162 
        iprot.skip(ftype)
14163 
      iprot.readFieldEnd()
14164 
    iprot.readStructEnd()
14165 
 
14166 
  def write(self, oprot):
14167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14169 
      return
14170 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
14171 
    if self.orderId is not None:
14172 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14173 
      oprot.writeI64(self.orderId)
14174 
      oprot.writeFieldEnd()
14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
14193 
class markOrderCancellationRequestReceived_result:
14194 
  """
14195 
  Attributes:
14196 
   - ex
14197 
  """
14198 
 
14199 
  thrift_spec = (
14200 
    None, # 0
14201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14202 
  )
14203 
 
14204 
  def __init__(self, ex=None,):
14205 
    self.ex = ex
14206 
 
14207 
  def read(self, iprot):
14208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14210 
      return
14211 
    iprot.readStructBegin()
14212 
    while True:
14213 
      (fname, ftype, fid) = iprot.readFieldBegin()
14214 
      if ftype == TType.STOP:
14215 
        break
14216 
      if fid == 1:
14217 
        if ftype == TType.STRUCT:
14218 
          self.ex = TransactionServiceException()
14219 
          self.ex.read(iprot)
14220 
        else:
14221 
          iprot.skip(ftype)
14222 
      else:
14223 
        iprot.skip(ftype)
14224 
      iprot.readFieldEnd()
14225 
    iprot.readStructEnd()
14226 
 
14227 
  def write(self, oprot):
14228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14230 
      return
14231 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
14232 
    if self.ex is not None:
14233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14234 
      self.ex.write(oprot)
14235 
      oprot.writeFieldEnd()
14236 
    oprot.writeFieldStop()
14237 
    oprot.writeStructEnd()
14238 
 
14239 
  def validate(self):
14240 
    return
14241 
 
14242 
 
14243 
  def __repr__(self):
14244 
    L = ['%s=%r' % (key, value)
14245 
      for key, value in self.__dict__.iteritems()]
14246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14247 
 
14248 
  def __eq__(self, other):
14249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14250 
 
14251 
  def __ne__(self, other):
14252 
    return not (self == other)
14253 
 
14254 
class markOrderCancellationRequestConfirmed_args:
14255 
  """
14256 
  Attributes:
14257 
   - orderId
14258 
  """
14259 
 
14260 
  thrift_spec = (
14261 
    None, # 0
14262 
    (1, TType.I64, 'orderId', None, None, ), # 1
14263 
  )
14264 
 
14265 
  def __init__(self, orderId=None,):
14266 
    self.orderId = orderId
14267 
 
14268 
  def read(self, iprot):
14269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14271 
      return
14272 
    iprot.readStructBegin()
14273 
    while True:
14274 
      (fname, ftype, fid) = iprot.readFieldBegin()
14275 
      if ftype == TType.STOP:
14276 
        break
14277 
      if fid == 1:
14278 
        if ftype == TType.I64:
14279 
          self.orderId = iprot.readI64();
14280 
        else:
14281 
          iprot.skip(ftype)
14282 
      else:
14283 
        iprot.skip(ftype)
14284 
      iprot.readFieldEnd()
14285 
    iprot.readStructEnd()
14286 
 
14287 
  def write(self, oprot):
14288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14290 
      return
14291 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
14292 
    if self.orderId is not None:
14293 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14294 
      oprot.writeI64(self.orderId)
14295 
      oprot.writeFieldEnd()
14296 
    oprot.writeFieldStop()
14297 
    oprot.writeStructEnd()
14298 
 
14299 
  def validate(self):
14300 
    return
14301 
 
14302 
 
14303 
  def __repr__(self):
14304 
    L = ['%s=%r' % (key, value)
14305 
      for key, value in self.__dict__.iteritems()]
14306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14307 
 
14308 
  def __eq__(self, other):
14309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14310 
 
14311 
  def __ne__(self, other):
14312 
    return not (self == other)
14313 
 
14314 
class markOrderCancellationRequestConfirmed_result:
14315 
  """
14316 
  Attributes:
14317 
   - ex
14318 
  """
14319 
 
14320 
  thrift_spec = (
14321 
    None, # 0
14322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14323 
  )
14324 
 
14325 
  def __init__(self, ex=None,):
14326 
    self.ex = ex
14327 
 
14328 
  def read(self, iprot):
14329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14331 
      return
14332 
    iprot.readStructBegin()
14333 
    while True:
14334 
      (fname, ftype, fid) = iprot.readFieldBegin()
14335 
      if ftype == TType.STOP:
14336 
        break
14337 
      if fid == 1:
14338 
        if ftype == TType.STRUCT:
14339 
          self.ex = TransactionServiceException()
14340 
          self.ex.read(iprot)
14341 
        else:
14342 
          iprot.skip(ftype)
14343 
      else:
14344 
        iprot.skip(ftype)
14345 
      iprot.readFieldEnd()
14346 
    iprot.readStructEnd()
14347 
 
14348 
  def write(self, oprot):
14349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14351 
      return
14352 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
14353 
    if self.ex is not None:
14354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14355 
      self.ex.write(oprot)
14356 
      oprot.writeFieldEnd()
14357 
    oprot.writeFieldStop()
14358 
    oprot.writeStructEnd()
14359 
 
14360 
  def validate(self):
14361 
    return
14362 
 
14363 
 
14364 
  def __repr__(self):
14365 
    L = ['%s=%r' % (key, value)
14366 
      for key, value in self.__dict__.iteritems()]
14367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14368 
 
14369 
  def __eq__(self, other):
14370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14371 
 
14372 
  def __ne__(self, other):
14373 
    return not (self == other)
14374 
 
14375 
class markOrderCancellationRequestDenied_args:
14376 
  """
14377 
  Attributes:
14378 
   - orderId
14379 
  """
14380 
 
14381 
  thrift_spec = (
14382 
    None, # 0
14383 
    (1, TType.I64, 'orderId', None, None, ), # 1
14384 
  )
14385 
 
14386 
  def __init__(self, orderId=None,):
14387 
    self.orderId = orderId
14388 
 
14389 
  def read(self, iprot):
14390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14392 
      return
14393 
    iprot.readStructBegin()
14394 
    while True:
14395 
      (fname, ftype, fid) = iprot.readFieldBegin()
14396 
      if ftype == TType.STOP:
14397 
        break
14398 
      if fid == 1:
14399 
        if ftype == TType.I64:
14400 
          self.orderId = iprot.readI64();
14401 
        else:
14402 
          iprot.skip(ftype)
14403 
      else:
14404 
        iprot.skip(ftype)
14405 
      iprot.readFieldEnd()
14406 
    iprot.readStructEnd()
14407 
 
14408 
  def write(self, oprot):
14409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14411 
      return
14412 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
14413 
    if self.orderId is not None:
14414 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14415 
      oprot.writeI64(self.orderId)
14416 
      oprot.writeFieldEnd()
14417 
    oprot.writeFieldStop()
14418 
    oprot.writeStructEnd()
14419 
 
14420 
  def validate(self):
14421 
    return
14422 
 
14423 
 
14424 
  def __repr__(self):
14425 
    L = ['%s=%r' % (key, value)
14426 
      for key, value in self.__dict__.iteritems()]
14427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14428 
 
14429 
  def __eq__(self, other):
14430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14431 
 
14432 
  def __ne__(self, other):
14433 
    return not (self == other)
14434 
 
14435 
class markOrderCancellationRequestDenied_result:
14436 
  """
14437 
  Attributes:
14438 
   - ex
14439 
  """
14440 
 
14441 
  thrift_spec = (
14442 
    None, # 0
14443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14444 
  )
14445 
 
14446 
  def __init__(self, ex=None,):
14447 
    self.ex = ex
14448 
 
14449 
  def read(self, iprot):
14450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14452 
      return
14453 
    iprot.readStructBegin()
14454 
    while True:
14455 
      (fname, ftype, fid) = iprot.readFieldBegin()
14456 
      if ftype == TType.STOP:
14457 
        break
14458 
      if fid == 1:
14459 
        if ftype == TType.STRUCT:
14460 
          self.ex = TransactionServiceException()
14461 
          self.ex.read(iprot)
14462 
        else:
14463 
          iprot.skip(ftype)
14464 
      else:
14465 
        iprot.skip(ftype)
14466 
      iprot.readFieldEnd()
14467 
    iprot.readStructEnd()
14468 
 
14469 
  def write(self, oprot):
14470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14472 
      return
14473 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
14474 
    if self.ex is not None:
14475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14476 
      self.ex.write(oprot)
14477 
      oprot.writeFieldEnd()
14478 
    oprot.writeFieldStop()
14479 
    oprot.writeStructEnd()
14480 
 
14481 
  def validate(self):
14482 
    return
14483 
 
14484 
 
14485 
  def __repr__(self):
14486 
    L = ['%s=%r' % (key, value)
14487 
      for key, value in self.__dict__.iteritems()]
14488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14489 
 
14490 
  def __eq__(self, other):
14491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14492 
 
14493 
  def __ne__(self, other):
14494 
    return not (self == other)
14495 
 
4258 rajveer 14496 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 14497 
  """
14498 
  Attributes:
4258 rajveer 14499 
   - transactionId
4247 rajveer 14500 
  """
14501 
 
14502 
  thrift_spec = (
14503 
    None, # 0
4258 rajveer 14504 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 14505 
  )
14506 
 
4258 rajveer 14507 
  def __init__(self, transactionId=None,):
14508 
    self.transactionId = transactionId
4247 rajveer 14509 
 
14510 
  def read(self, iprot):
14511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14513 
      return
14514 
    iprot.readStructBegin()
14515 
    while True:
14516 
      (fname, ftype, fid) = iprot.readFieldBegin()
14517 
      if ftype == TType.STOP:
14518 
        break
14519 
      if fid == 1:
14520 
        if ftype == TType.I64:
4258 rajveer 14521 
          self.transactionId = iprot.readI64();
4247 rajveer 14522 
        else:
14523 
          iprot.skip(ftype)
14524 
      else:
14525 
        iprot.skip(ftype)
14526 
      iprot.readFieldEnd()
14527 
    iprot.readStructEnd()
14528 
 
14529 
  def write(self, oprot):
14530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14532 
      return
4258 rajveer 14533 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
14534 
    if self.transactionId is not None:
14535 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14536 
      oprot.writeI64(self.transactionId)
4247 rajveer 14537 
      oprot.writeFieldEnd()
14538 
    oprot.writeFieldStop()
14539 
    oprot.writeStructEnd()
14540 
 
14541 
  def validate(self):
14542 
    return
14543 
 
14544 
 
14545 
  def __repr__(self):
14546 
    L = ['%s=%r' % (key, value)
14547 
      for key, value in self.__dict__.iteritems()]
14548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14549 
 
14550 
  def __eq__(self, other):
14551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14552 
 
14553 
  def __ne__(self, other):
14554 
    return not (self == other)
14555 
 
4258 rajveer 14556 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 14557 
  """
14558 
  Attributes:
14559 
   - ex
14560 
  """
14561 
 
14562 
  thrift_spec = (
14563 
    None, # 0
14564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14565 
  )
14566 
 
14567 
  def __init__(self, ex=None,):
14568 
    self.ex = ex
14569 
 
14570 
  def read(self, iprot):
14571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14573 
      return
14574 
    iprot.readStructBegin()
14575 
    while True:
14576 
      (fname, ftype, fid) = iprot.readFieldBegin()
14577 
      if ftype == TType.STOP:
14578 
        break
14579 
      if fid == 1:
14580 
        if ftype == TType.STRUCT:
14581 
          self.ex = TransactionServiceException()
14582 
          self.ex.read(iprot)
14583 
        else:
14584 
          iprot.skip(ftype)
14585 
      else:
14586 
        iprot.skip(ftype)
14587 
      iprot.readFieldEnd()
14588 
    iprot.readStructEnd()
14589 
 
14590 
  def write(self, oprot):
14591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14593 
      return
4258 rajveer 14594 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 14595 
    if self.ex is not None:
14596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14597 
      self.ex.write(oprot)
14598 
      oprot.writeFieldEnd()
14599 
    oprot.writeFieldStop()
14600 
    oprot.writeStructEnd()
14601 
 
14602 
  def validate(self):
14603 
    return
14604 
 
14605 
 
14606 
  def __repr__(self):
14607 
    L = ['%s=%r' % (key, value)
14608 
      for key, value in self.__dict__.iteritems()]
14609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14610 
 
14611 
  def __eq__(self, other):
14612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14613 
 
14614 
  def __ne__(self, other):
14615 
    return not (self == other)
4259 anupam.sin 14616 
 
14617 
class refundTransaction_args:
14618 
  """
14619 
  Attributes:
14620 
   - transactionId
14621 
   - refundedBy
14622 
   - reason
14623 
  """
14624 
 
14625 
  thrift_spec = (
14626 
    None, # 0
14627 
    (1, TType.I64, 'transactionId', None, None, ), # 1
14628 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
14629 
    (3, TType.STRING, 'reason', None, None, ), # 3
14630 
  )
14631 
 
14632 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
14633 
    self.transactionId = transactionId
14634 
    self.refundedBy = refundedBy
14635 
    self.reason = reason
14636 
 
14637 
  def read(self, iprot):
14638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14640 
      return
14641 
    iprot.readStructBegin()
14642 
    while True:
14643 
      (fname, ftype, fid) = iprot.readFieldBegin()
14644 
      if ftype == TType.STOP:
14645 
        break
14646 
      if fid == 1:
14647 
        if ftype == TType.I64:
14648 
          self.transactionId = iprot.readI64();
14649 
        else:
14650 
          iprot.skip(ftype)
14651 
      elif fid == 2:
14652 
        if ftype == TType.STRING:
14653 
          self.refundedBy = iprot.readString();
14654 
        else:
14655 
          iprot.skip(ftype)
14656 
      elif fid == 3:
14657 
        if ftype == TType.STRING:
14658 
          self.reason = iprot.readString();
14659 
        else:
14660 
          iprot.skip(ftype)
14661 
      else:
14662 
        iprot.skip(ftype)
14663 
      iprot.readFieldEnd()
14664 
    iprot.readStructEnd()
14665 
 
14666 
  def write(self, oprot):
14667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14669 
      return
14670 
    oprot.writeStructBegin('refundTransaction_args')
14671 
    if self.transactionId is not None:
14672 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
14673 
      oprot.writeI64(self.transactionId)
14674 
      oprot.writeFieldEnd()
14675 
    if self.refundedBy is not None:
14676 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
14677 
      oprot.writeString(self.refundedBy)
14678 
      oprot.writeFieldEnd()
14679 
    if self.reason is not None:
14680 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14681 
      oprot.writeString(self.reason)
14682 
      oprot.writeFieldEnd()
14683 
    oprot.writeFieldStop()
14684 
    oprot.writeStructEnd()
14685 
 
14686 
  def validate(self):
14687 
    return
14688 
 
14689 
 
14690 
  def __repr__(self):
14691 
    L = ['%s=%r' % (key, value)
14692 
      for key, value in self.__dict__.iteritems()]
14693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14694 
 
14695 
  def __eq__(self, other):
14696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14697 
 
14698 
  def __ne__(self, other):
14699 
    return not (self == other)
14700 
 
14701 
class refundTransaction_result:
14702 
  """
14703 
  Attributes:
14704 
   - ex
14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    None, # 0
14709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14710 
  )
14711 
 
14712 
  def __init__(self, ex=None,):
14713 
    self.ex = ex
14714 
 
14715 
  def read(self, iprot):
14716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14718 
      return
14719 
    iprot.readStructBegin()
14720 
    while True:
14721 
      (fname, ftype, fid) = iprot.readFieldBegin()
14722 
      if ftype == TType.STOP:
14723 
        break
14724 
      if fid == 1:
14725 
        if ftype == TType.STRUCT:
14726 
          self.ex = TransactionServiceException()
14727 
          self.ex.read(iprot)
14728 
        else:
14729 
          iprot.skip(ftype)
14730 
      else:
14731 
        iprot.skip(ftype)
14732 
      iprot.readFieldEnd()
14733 
    iprot.readStructEnd()
14734 
 
14735 
  def write(self, oprot):
14736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14738 
      return
14739 
    oprot.writeStructBegin('refundTransaction_result')
14740 
    if self.ex is not None:
14741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14742 
      self.ex.write(oprot)
14743 
      oprot.writeFieldEnd()
14744 
    oprot.writeFieldStop()
14745 
    oprot.writeStructEnd()
14746 
 
14747 
  def validate(self):
14748 
    return
14749 
 
14750 
 
14751 
  def __repr__(self):
14752 
    L = ['%s=%r' % (key, value)
14753 
      for key, value in self.__dict__.iteritems()]
14754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14755 
 
14756 
  def __eq__(self, other):
14757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14758 
 
14759 
  def __ne__(self, other):
14760 
    return not (self == other)
4285 rajveer 14761 
 
4324 mandeep.dh 14762 
class updateShipmentAddress_args:
14763 
  """
14764 
  Attributes:
14765 
   - orderId
14766 
   - addressId
14767 
  """
14768 
 
14769 
  thrift_spec = (
14770 
    None, # 0
14771 
    (1, TType.I64, 'orderId', None, None, ), # 1
14772 
    (2, TType.I64, 'addressId', None, None, ), # 2
14773 
  )
14774 
 
14775 
  def __init__(self, orderId=None, addressId=None,):
14776 
    self.orderId = orderId
14777 
    self.addressId = addressId
14778 
 
14779 
  def read(self, iprot):
14780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14782 
      return
14783 
    iprot.readStructBegin()
14784 
    while True:
14785 
      (fname, ftype, fid) = iprot.readFieldBegin()
14786 
      if ftype == TType.STOP:
14787 
        break
14788 
      if fid == 1:
14789 
        if ftype == TType.I64:
14790 
          self.orderId = iprot.readI64();
14791 
        else:
14792 
          iprot.skip(ftype)
14793 
      elif fid == 2:
14794 
        if ftype == TType.I64:
14795 
          self.addressId = iprot.readI64();
14796 
        else:
14797 
          iprot.skip(ftype)
14798 
      else:
14799 
        iprot.skip(ftype)
14800 
      iprot.readFieldEnd()
14801 
    iprot.readStructEnd()
14802 
 
14803 
  def write(self, oprot):
14804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14806 
      return
14807 
    oprot.writeStructBegin('updateShipmentAddress_args')
14808 
    if self.orderId is not None:
14809 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14810 
      oprot.writeI64(self.orderId)
14811 
      oprot.writeFieldEnd()
14812 
    if self.addressId is not None:
14813 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
14814 
      oprot.writeI64(self.addressId)
14815 
      oprot.writeFieldEnd()
14816 
    oprot.writeFieldStop()
14817 
    oprot.writeStructEnd()
14818 
 
14819 
  def validate(self):
14820 
    return
14821 
 
14822 
 
14823 
  def __repr__(self):
14824 
    L = ['%s=%r' % (key, value)
14825 
      for key, value in self.__dict__.iteritems()]
14826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14827 
 
14828 
  def __eq__(self, other):
14829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14830 
 
14831 
  def __ne__(self, other):
14832 
    return not (self == other)
14833 
 
14834 
class updateShipmentAddress_result:
14835 
  """
14836 
  Attributes:
14837 
   - ex
14838 
  """
14839 
 
14840 
  thrift_spec = (
14841 
    None, # 0
14842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14843 
  )
14844 
 
14845 
  def __init__(self, ex=None,):
14846 
    self.ex = ex
14847 
 
14848 
  def read(self, iprot):
14849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14851 
      return
14852 
    iprot.readStructBegin()
14853 
    while True:
14854 
      (fname, ftype, fid) = iprot.readFieldBegin()
14855 
      if ftype == TType.STOP:
14856 
        break
14857 
      if fid == 1:
14858 
        if ftype == TType.STRUCT:
14859 
          self.ex = TransactionServiceException()
14860 
          self.ex.read(iprot)
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
14872 
    oprot.writeStructBegin('updateShipmentAddress_result')
14873 
    if self.ex is not None:
14874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14875 
      self.ex.write(oprot)
14876 
      oprot.writeFieldEnd()
14877 
    oprot.writeFieldStop()
14878 
    oprot.writeStructEnd()
14879 
 
14880 
  def validate(self):
14881 
    return
14882 
 
14883 
 
14884 
  def __repr__(self):
14885 
    L = ['%s=%r' % (key, value)
14886 
      for key, value in self.__dict__.iteritems()]
14887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14888 
 
14889 
  def __eq__(self, other):
14890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14891 
 
14892 
  def __ne__(self, other):
14893 
    return not (self == other)
14894 
 
4285 rajveer 14895 
class acceptOrdersForItemId_args:
14896 
  """
14897 
  Attributes:
14898 
   - itemId
14899 
   - inventory
14900 
  """
14901 
 
14902 
  thrift_spec = (
14903 
    None, # 0
14904 
    (1, TType.I64, 'itemId', None, None, ), # 1
14905 
    (2, TType.I64, 'inventory', None, None, ), # 2
14906 
  )
14907 
 
14908 
  def __init__(self, itemId=None, inventory=None,):
14909 
    self.itemId = itemId
14910 
    self.inventory = inventory
14911 
 
14912 
  def read(self, iprot):
14913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14915 
      return
14916 
    iprot.readStructBegin()
14917 
    while True:
14918 
      (fname, ftype, fid) = iprot.readFieldBegin()
14919 
      if ftype == TType.STOP:
14920 
        break
14921 
      if fid == 1:
14922 
        if ftype == TType.I64:
14923 
          self.itemId = iprot.readI64();
14924 
        else:
14925 
          iprot.skip(ftype)
14926 
      elif fid == 2:
14927 
        if ftype == TType.I64:
14928 
          self.inventory = iprot.readI64();
14929 
        else:
14930 
          iprot.skip(ftype)
14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
14940 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
14941 
    if self.itemId is not None:
14942 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14943 
      oprot.writeI64(self.itemId)
14944 
      oprot.writeFieldEnd()
14945 
    if self.inventory is not None:
14946 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
14947 
      oprot.writeI64(self.inventory)
14948 
      oprot.writeFieldEnd()
14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
14966 
 
14967 
class acceptOrdersForItemId_result:
14968 
  """
14969 
  Attributes:
14970 
   - success
14971 
   - ex
14972 
  """
14973 
 
14974 
  thrift_spec = (
14975 
    (0, TType.BOOL, 'success', None, None, ), # 0
14976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14977 
  )
14978 
 
14979 
  def __init__(self, success=None, ex=None,):
14980 
    self.success = success
14981 
    self.ex = ex
14982 
 
14983 
  def read(self, iprot):
14984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14986 
      return
14987 
    iprot.readStructBegin()
14988 
    while True:
14989 
      (fname, ftype, fid) = iprot.readFieldBegin()
14990 
      if ftype == TType.STOP:
14991 
        break
14992 
      if fid == 0:
14993 
        if ftype == TType.BOOL:
14994 
          self.success = iprot.readBool();
14995 
        else:
14996 
          iprot.skip(ftype)
14997 
      elif fid == 1:
14998 
        if ftype == TType.STRUCT:
14999 
          self.ex = TransactionServiceException()
15000 
          self.ex.read(iprot)
15001 
        else:
15002 
          iprot.skip(ftype)
15003 
      else:
15004 
        iprot.skip(ftype)
15005 
      iprot.readFieldEnd()
15006 
    iprot.readStructEnd()
15007 
 
15008 
  def write(self, oprot):
15009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15011 
      return
15012 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
15013 
    if self.success is not None:
15014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15015 
      oprot.writeBool(self.success)
15016 
      oprot.writeFieldEnd()
15017 
    if self.ex is not None:
15018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15019 
      self.ex.write(oprot)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
4303 rajveer 15038 
 
15039 
class markOrdersAsPORaised_args:
15040 
  """
15041 
  Attributes:
15042 
   - vendorId
15043 
   - itemId
15044 
   - quantity
15045 
   - estimate
4369 rajveer 15046 
   - isReminder
4303 rajveer 15047 
  """
15048 
 
15049 
  thrift_spec = (
15050 
    None, # 0
15051 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15052 
    (2, TType.I64, 'itemId', None, None, ), # 2
15053 
    (3, TType.I64, 'quantity', None, None, ), # 3
15054 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15055 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15056 
  )
15057 
 
4369 rajveer 15058 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15059 
    self.vendorId = vendorId
15060 
    self.itemId = itemId
15061 
    self.quantity = quantity
15062 
    self.estimate = estimate
4369 rajveer 15063 
    self.isReminder = isReminder
4303 rajveer 15064 
 
15065 
  def read(self, iprot):
15066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15068 
      return
15069 
    iprot.readStructBegin()
15070 
    while True:
15071 
      (fname, ftype, fid) = iprot.readFieldBegin()
15072 
      if ftype == TType.STOP:
15073 
        break
15074 
      if fid == 1:
15075 
        if ftype == TType.I64:
15076 
          self.vendorId = iprot.readI64();
15077 
        else:
15078 
          iprot.skip(ftype)
15079 
      elif fid == 2:
15080 
        if ftype == TType.I64:
15081 
          self.itemId = iprot.readI64();
15082 
        else:
15083 
          iprot.skip(ftype)
15084 
      elif fid == 3:
15085 
        if ftype == TType.I64:
15086 
          self.quantity = iprot.readI64();
15087 
        else:
15088 
          iprot.skip(ftype)
15089 
      elif fid == 4:
15090 
        if ftype == TType.I64:
15091 
          self.estimate = iprot.readI64();
15092 
        else:
15093 
          iprot.skip(ftype)
4369 rajveer 15094 
      elif fid == 5:
15095 
        if ftype == TType.BOOL:
15096 
          self.isReminder = iprot.readBool();
15097 
        else:
15098 
          iprot.skip(ftype)
4303 rajveer 15099 
      else:
15100 
        iprot.skip(ftype)
15101 
      iprot.readFieldEnd()
15102 
    iprot.readStructEnd()
15103 
 
15104 
  def write(self, oprot):
15105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15107 
      return
15108 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
15109 
    if self.vendorId is not None:
15110 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15111 
      oprot.writeI64(self.vendorId)
15112 
      oprot.writeFieldEnd()
15113 
    if self.itemId is not None:
15114 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15115 
      oprot.writeI64(self.itemId)
15116 
      oprot.writeFieldEnd()
15117 
    if self.quantity is not None:
15118 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15119 
      oprot.writeI64(self.quantity)
15120 
      oprot.writeFieldEnd()
15121 
    if self.estimate is not None:
15122 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15123 
      oprot.writeI64(self.estimate)
15124 
      oprot.writeFieldEnd()
4369 rajveer 15125 
    if self.isReminder is not None:
15126 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15127 
      oprot.writeBool(self.isReminder)
15128 
      oprot.writeFieldEnd()
4303 rajveer 15129 
    oprot.writeFieldStop()
15130 
    oprot.writeStructEnd()
15131 
 
15132 
  def validate(self):
15133 
    return
15134 
 
15135 
 
15136 
  def __repr__(self):
15137 
    L = ['%s=%r' % (key, value)
15138 
      for key, value in self.__dict__.iteritems()]
15139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15140 
 
15141 
  def __eq__(self, other):
15142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15143 
 
15144 
  def __ne__(self, other):
15145 
    return not (self == other)
15146 
 
15147 
class markOrdersAsPORaised_result:
15148 
  """
15149 
  Attributes:
15150 
   - ex
15151 
  """
15152 
 
15153 
  thrift_spec = (
15154 
    None, # 0
15155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15156 
  )
15157 
 
15158 
  def __init__(self, ex=None,):
15159 
    self.ex = ex
15160 
 
15161 
  def read(self, iprot):
15162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15164 
      return
15165 
    iprot.readStructBegin()
15166 
    while True:
15167 
      (fname, ftype, fid) = iprot.readFieldBegin()
15168 
      if ftype == TType.STOP:
15169 
        break
15170 
      if fid == 1:
15171 
        if ftype == TType.STRUCT:
15172 
          self.ex = TransactionServiceException()
15173 
          self.ex.read(iprot)
15174 
        else:
15175 
          iprot.skip(ftype)
15176 
      else:
15177 
        iprot.skip(ftype)
15178 
      iprot.readFieldEnd()
15179 
    iprot.readStructEnd()
15180 
 
15181 
  def write(self, oprot):
15182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15184 
      return
15185 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
15186 
    if self.ex is not None:
15187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15188 
      self.ex.write(oprot)
15189 
      oprot.writeFieldEnd()
15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
15207 
 
15208 
class markOrdersAsReversalInitiated_args:
15209 
  """
15210 
  Attributes:
15211 
   - vendorId
15212 
   - itemId
15213 
   - quantity
15214 
   - estimate
4369 rajveer 15215 
   - isReminder
4303 rajveer 15216 
  """
15217 
 
15218 
  thrift_spec = (
15219 
    None, # 0
15220 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15221 
    (2, TType.I64, 'itemId', None, None, ), # 2
15222 
    (3, TType.I64, 'quantity', None, None, ), # 3
15223 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15224 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15225 
  )
15226 
 
4369 rajveer 15227 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15228 
    self.vendorId = vendorId
15229 
    self.itemId = itemId
15230 
    self.quantity = quantity
15231 
    self.estimate = estimate
4369 rajveer 15232 
    self.isReminder = isReminder
4303 rajveer 15233 
 
15234 
  def read(self, iprot):
15235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15237 
      return
15238 
    iprot.readStructBegin()
15239 
    while True:
15240 
      (fname, ftype, fid) = iprot.readFieldBegin()
15241 
      if ftype == TType.STOP:
15242 
        break
15243 
      if fid == 1:
15244 
        if ftype == TType.I64:
15245 
          self.vendorId = iprot.readI64();
15246 
        else:
15247 
          iprot.skip(ftype)
15248 
      elif fid == 2:
15249 
        if ftype == TType.I64:
15250 
          self.itemId = iprot.readI64();
15251 
        else:
15252 
          iprot.skip(ftype)
15253 
      elif fid == 3:
15254 
        if ftype == TType.I64:
15255 
          self.quantity = iprot.readI64();
15256 
        else:
15257 
          iprot.skip(ftype)
15258 
      elif fid == 4:
15259 
        if ftype == TType.I64:
15260 
          self.estimate = iprot.readI64();
15261 
        else:
15262 
          iprot.skip(ftype)
4369 rajveer 15263 
      elif fid == 5:
15264 
        if ftype == TType.BOOL:
15265 
          self.isReminder = iprot.readBool();
15266 
        else:
15267 
          iprot.skip(ftype)
4303 rajveer 15268 
      else:
15269 
        iprot.skip(ftype)
15270 
      iprot.readFieldEnd()
15271 
    iprot.readStructEnd()
15272 
 
15273 
  def write(self, oprot):
15274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15276 
      return
15277 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
15278 
    if self.vendorId is not None:
15279 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15280 
      oprot.writeI64(self.vendorId)
15281 
      oprot.writeFieldEnd()
15282 
    if self.itemId is not None:
15283 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15284 
      oprot.writeI64(self.itemId)
15285 
      oprot.writeFieldEnd()
15286 
    if self.quantity is not None:
15287 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15288 
      oprot.writeI64(self.quantity)
15289 
      oprot.writeFieldEnd()
15290 
    if self.estimate is not None:
15291 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15292 
      oprot.writeI64(self.estimate)
15293 
      oprot.writeFieldEnd()
4369 rajveer 15294 
    if self.isReminder is not None:
15295 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15296 
      oprot.writeBool(self.isReminder)
15297 
      oprot.writeFieldEnd()
4303 rajveer 15298 
    oprot.writeFieldStop()
15299 
    oprot.writeStructEnd()
15300 
 
15301 
  def validate(self):
15302 
    return
15303 
 
15304 
 
15305 
  def __repr__(self):
15306 
    L = ['%s=%r' % (key, value)
15307 
      for key, value in self.__dict__.iteritems()]
15308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15309 
 
15310 
  def __eq__(self, other):
15311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15312 
 
15313 
  def __ne__(self, other):
15314 
    return not (self == other)
15315 
 
15316 
class markOrdersAsReversalInitiated_result:
15317 
  """
15318 
  Attributes:
15319 
   - ex
15320 
  """
15321 
 
15322 
  thrift_spec = (
15323 
    None, # 0
15324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15325 
  )
15326 
 
15327 
  def __init__(self, ex=None,):
15328 
    self.ex = ex
15329 
 
15330 
  def read(self, iprot):
15331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15333 
      return
15334 
    iprot.readStructBegin()
15335 
    while True:
15336 
      (fname, ftype, fid) = iprot.readFieldBegin()
15337 
      if ftype == TType.STOP:
15338 
        break
15339 
      if fid == 1:
15340 
        if ftype == TType.STRUCT:
15341 
          self.ex = TransactionServiceException()
15342 
          self.ex.read(iprot)
15343 
        else:
15344 
          iprot.skip(ftype)
15345 
      else:
15346 
        iprot.skip(ftype)
15347 
      iprot.readFieldEnd()
15348 
    iprot.readStructEnd()
15349 
 
15350 
  def write(self, oprot):
15351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15353 
      return
15354 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
15355 
    if self.ex is not None:
15356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15357 
      self.ex.write(oprot)
15358 
      oprot.writeFieldEnd()
15359 
    oprot.writeFieldStop()
15360 
    oprot.writeStructEnd()
15361 
 
15362 
  def validate(self):
15363 
    return
15364 
 
15365 
 
15366 
  def __repr__(self):
15367 
    L = ['%s=%r' % (key, value)
15368 
      for key, value in self.__dict__.iteritems()]
15369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15370 
 
15371 
  def __eq__(self, other):
15372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15373 
 
15374 
  def __ne__(self, other):
15375 
    return not (self == other)
15376 
 
15377 
class markOrdersAsNotAvailabke_args:
15378 
  """
15379 
  Attributes:
15380 
   - vendorId
15381 
   - itemId
15382 
   - quantity
15383 
   - estimate
4369 rajveer 15384 
   - isReminder
4303 rajveer 15385 
  """
15386 
 
15387 
  thrift_spec = (
15388 
    None, # 0
15389 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15390 
    (2, TType.I64, 'itemId', None, None, ), # 2
15391 
    (3, TType.I64, 'quantity', None, None, ), # 3
15392 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 15393 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 15394 
  )
15395 
 
4369 rajveer 15396 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 15397 
    self.vendorId = vendorId
15398 
    self.itemId = itemId
15399 
    self.quantity = quantity
15400 
    self.estimate = estimate
4369 rajveer 15401 
    self.isReminder = isReminder
4303 rajveer 15402 
 
15403 
  def read(self, iprot):
15404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15406 
      return
15407 
    iprot.readStructBegin()
15408 
    while True:
15409 
      (fname, ftype, fid) = iprot.readFieldBegin()
15410 
      if ftype == TType.STOP:
15411 
        break
15412 
      if fid == 1:
15413 
        if ftype == TType.I64:
15414 
          self.vendorId = iprot.readI64();
15415 
        else:
15416 
          iprot.skip(ftype)
15417 
      elif fid == 2:
15418 
        if ftype == TType.I64:
15419 
          self.itemId = iprot.readI64();
15420 
        else:
15421 
          iprot.skip(ftype)
15422 
      elif fid == 3:
15423 
        if ftype == TType.I64:
15424 
          self.quantity = iprot.readI64();
15425 
        else:
15426 
          iprot.skip(ftype)
15427 
      elif fid == 4:
15428 
        if ftype == TType.I64:
15429 
          self.estimate = iprot.readI64();
15430 
        else:
15431 
          iprot.skip(ftype)
4369 rajveer 15432 
      elif fid == 5:
15433 
        if ftype == TType.BOOL:
15434 
          self.isReminder = iprot.readBool();
15435 
        else:
15436 
          iprot.skip(ftype)
4303 rajveer 15437 
      else:
15438 
        iprot.skip(ftype)
15439 
      iprot.readFieldEnd()
15440 
    iprot.readStructEnd()
15441 
 
15442 
  def write(self, oprot):
15443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15445 
      return
15446 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
15447 
    if self.vendorId is not None:
15448 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15449 
      oprot.writeI64(self.vendorId)
15450 
      oprot.writeFieldEnd()
15451 
    if self.itemId is not None:
15452 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15453 
      oprot.writeI64(self.itemId)
15454 
      oprot.writeFieldEnd()
15455 
    if self.quantity is not None:
15456 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
15457 
      oprot.writeI64(self.quantity)
15458 
      oprot.writeFieldEnd()
15459 
    if self.estimate is not None:
15460 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
15461 
      oprot.writeI64(self.estimate)
15462 
      oprot.writeFieldEnd()
4369 rajveer 15463 
    if self.isReminder is not None:
15464 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
15465 
      oprot.writeBool(self.isReminder)
15466 
      oprot.writeFieldEnd()
4303 rajveer 15467 
    oprot.writeFieldStop()
15468 
    oprot.writeStructEnd()
15469 
 
15470 
  def validate(self):
15471 
    return
15472 
 
15473 
 
15474 
  def __repr__(self):
15475 
    L = ['%s=%r' % (key, value)
15476 
      for key, value in self.__dict__.iteritems()]
15477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15478 
 
15479 
  def __eq__(self, other):
15480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15481 
 
15482 
  def __ne__(self, other):
15483 
    return not (self == other)
15484 
 
15485 
class markOrdersAsNotAvailabke_result:
15486 
  """
15487 
  Attributes:
15488 
   - ex
15489 
  """
15490 
 
15491 
  thrift_spec = (
15492 
    None, # 0
15493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15494 
  )
15495 
 
15496 
  def __init__(self, ex=None,):
15497 
    self.ex = ex
15498 
 
15499 
  def read(self, iprot):
15500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15502 
      return
15503 
    iprot.readStructBegin()
15504 
    while True:
15505 
      (fname, ftype, fid) = iprot.readFieldBegin()
15506 
      if ftype == TType.STOP:
15507 
        break
15508 
      if fid == 1:
15509 
        if ftype == TType.STRUCT:
15510 
          self.ex = TransactionServiceException()
15511 
          self.ex.read(iprot)
15512 
        else:
15513 
          iprot.skip(ftype)
15514 
      else:
15515 
        iprot.skip(ftype)
15516 
      iprot.readFieldEnd()
15517 
    iprot.readStructEnd()
15518 
 
15519 
  def write(self, oprot):
15520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15522 
      return
15523 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
15524 
    if self.ex is not None:
15525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15526 
      self.ex.write(oprot)
15527 
      oprot.writeFieldEnd()
15528 
    oprot.writeFieldStop()
15529 
    oprot.writeStructEnd()
15530 
 
15531 
  def validate(self):
15532 
    return
15533 
 
15534 
 
15535 
  def __repr__(self):
15536 
    L = ['%s=%r' % (key, value)
15537 
      for key, value in self.__dict__.iteritems()]
15538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15539 
 
15540 
  def __eq__(self, other):
15541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15542 
 
15543 
  def __ne__(self, other):
15544 
    return not (self == other)
4369 rajveer 15545 
 
15546 
class markOrdersAsTimeout_args:
15547 
  """
15548 
  Attributes:
15549 
   - vendorId
15550 
  """
15551 
 
15552 
  thrift_spec = (
15553 
    None, # 0
15554 
    (1, TType.I64, 'vendorId', None, None, ), # 1
15555 
  )
15556 
 
15557 
  def __init__(self, vendorId=None,):
15558 
    self.vendorId = vendorId
15559 
 
15560 
  def read(self, iprot):
15561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15563 
      return
15564 
    iprot.readStructBegin()
15565 
    while True:
15566 
      (fname, ftype, fid) = iprot.readFieldBegin()
15567 
      if ftype == TType.STOP:
15568 
        break
15569 
      if fid == 1:
15570 
        if ftype == TType.I64:
15571 
          self.vendorId = iprot.readI64();
15572 
        else:
15573 
          iprot.skip(ftype)
15574 
      else:
15575 
        iprot.skip(ftype)
15576 
      iprot.readFieldEnd()
15577 
    iprot.readStructEnd()
15578 
 
15579 
  def write(self, oprot):
15580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15582 
      return
15583 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
15584 
    if self.vendorId is not None:
15585 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
15586 
      oprot.writeI64(self.vendorId)
15587 
      oprot.writeFieldEnd()
15588 
    oprot.writeFieldStop()
15589 
    oprot.writeStructEnd()
15590 
 
15591 
  def validate(self):
15592 
    return
15593 
 
15594 
 
15595 
  def __repr__(self):
15596 
    L = ['%s=%r' % (key, value)
15597 
      for key, value in self.__dict__.iteritems()]
15598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15599 
 
15600 
  def __eq__(self, other):
15601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15602 
 
15603 
  def __ne__(self, other):
15604 
    return not (self == other)
15605 
 
15606 
class markOrdersAsTimeout_result:
15607 
  """
15608 
  Attributes:
15609 
   - success
15610 
   - ex
15611 
  """
15612 
 
15613 
  thrift_spec = (
15614 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
15615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15616 
  )
15617 
 
15618 
  def __init__(self, success=None, ex=None,):
15619 
    self.success = success
15620 
    self.ex = ex
15621 
 
15622 
  def read(self, iprot):
15623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15625 
      return
15626 
    iprot.readStructBegin()
15627 
    while True:
15628 
      (fname, ftype, fid) = iprot.readFieldBegin()
15629 
      if ftype == TType.STOP:
15630 
        break
15631 
      if fid == 0:
15632 
        if ftype == TType.MAP:
15633 
          self.success = {}
15634 
          (_ktype262, _vtype263, _size261 ) = iprot.readMapBegin()
15635 
          for _i265 in xrange(_size261):
15636 
            _key266 = iprot.readI32();
15637 
            _val267 = TimeoutSummary()
15638 
            _val267.read(iprot)
15639 
            self.success[_key266] = _val267
15640 
          iprot.readMapEnd()
15641 
        else:
15642 
          iprot.skip(ftype)
15643 
      elif fid == 1:
15644 
        if ftype == TType.STRUCT:
15645 
          self.ex = TransactionServiceException()
15646 
          self.ex.read(iprot)
15647 
        else:
15648 
          iprot.skip(ftype)
15649 
      else:
15650 
        iprot.skip(ftype)
15651 
      iprot.readFieldEnd()
15652 
    iprot.readStructEnd()
15653 
 
15654 
  def write(self, oprot):
15655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15657 
      return
15658 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
15659 
    if self.success is not None:
15660 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15661 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
15662 
      for kiter268,viter269 in self.success.items():
15663 
        oprot.writeI32(kiter268)
15664 
        viter269.write(oprot)
15665 
      oprot.writeMapEnd()
15666 
      oprot.writeFieldEnd()
15667 
    if self.ex is not None:
15668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15669 
      self.ex.write(oprot)
15670 
      oprot.writeFieldEnd()
15671 
    oprot.writeFieldStop()
15672 
    oprot.writeStructEnd()
15673 
 
15674 
  def validate(self):
15675 
    return
15676 
 
15677 
 
15678 
  def __repr__(self):
15679 
    L = ['%s=%r' % (key, value)
15680 
      for key, value in self.__dict__.iteritems()]
15681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15682 
 
15683 
  def __eq__(self, other):
15684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15685 
 
15686 
  def __ne__(self, other):
15687 
    return not (self == other)
4386 anupam.sin 15688 
 
15689 
class getOrderForAwb_args:
15690 
  """
15691 
  Attributes:
15692 
   - awb
15693 
  """
15694 
 
15695 
  thrift_spec = (
15696 
    None, # 0
15697 
    (1, TType.STRING, 'awb', None, None, ), # 1
15698 
  )
15699 
 
15700 
  def __init__(self, awb=None,):
15701 
    self.awb = awb
15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 1:
15713 
        if ftype == TType.STRING:
15714 
          self.awb = iprot.readString();
15715 
        else:
15716 
          iprot.skip(ftype)
15717 
      else:
15718 
        iprot.skip(ftype)
15719 
      iprot.readFieldEnd()
15720 
    iprot.readStructEnd()
15721 
 
15722 
  def write(self, oprot):
15723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15725 
      return
15726 
    oprot.writeStructBegin('getOrderForAwb_args')
15727 
    if self.awb is not None:
15728 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
15729 
      oprot.writeString(self.awb)
15730 
      oprot.writeFieldEnd()
15731 
    oprot.writeFieldStop()
15732 
    oprot.writeStructEnd()
15733 
 
15734 
  def validate(self):
15735 
    return
15736 
 
15737 
 
15738 
  def __repr__(self):
15739 
    L = ['%s=%r' % (key, value)
15740 
      for key, value in self.__dict__.iteritems()]
15741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15742 
 
15743 
  def __eq__(self, other):
15744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15745 
 
15746 
  def __ne__(self, other):
15747 
    return not (self == other)
15748 
 
15749 
class getOrderForAwb_result:
15750 
  """
15751 
  Attributes:
15752 
   - success
15753 
   - ex
15754 
  """
15755 
 
15756 
  thrift_spec = (
15757 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
15758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15759 
  )
15760 
 
15761 
  def __init__(self, success=None, ex=None,):
15762 
    self.success = success
15763 
    self.ex = ex
15764 
 
15765 
  def read(self, iprot):
15766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15768 
      return
15769 
    iprot.readStructBegin()
15770 
    while True:
15771 
      (fname, ftype, fid) = iprot.readFieldBegin()
15772 
      if ftype == TType.STOP:
15773 
        break
15774 
      if fid == 0:
15775 
        if ftype == TType.STRUCT:
15776 
          self.success = Order()
15777 
          self.success.read(iprot)
15778 
        else:
15779 
          iprot.skip(ftype)
15780 
      elif fid == 1:
15781 
        if ftype == TType.STRUCT:
15782 
          self.ex = TransactionServiceException()
15783 
          self.ex.read(iprot)
15784 
        else:
15785 
          iprot.skip(ftype)
15786 
      else:
15787 
        iprot.skip(ftype)
15788 
      iprot.readFieldEnd()
15789 
    iprot.readStructEnd()
15790 
 
15791 
  def write(self, oprot):
15792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15794 
      return
15795 
    oprot.writeStructBegin('getOrderForAwb_result')
15796 
    if self.success is not None:
15797 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15798 
      self.success.write(oprot)
15799 
      oprot.writeFieldEnd()
15800 
    if self.ex is not None:
15801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15802 
      self.ex.write(oprot)
15803 
      oprot.writeFieldEnd()
15804 
    oprot.writeFieldStop()
15805 
    oprot.writeStructEnd()
15806 
 
15807 
  def validate(self):
15808 
    return
15809 
 
15810 
 
15811 
  def __repr__(self):
15812 
    L = ['%s=%r' % (key, value)
15813 
      for key, value in self.__dict__.iteritems()]
15814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15815 
 
15816 
  def __eq__(self, other):
15817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15818 
 
15819 
  def __ne__(self, other):
15820 
    return not (self == other)